| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_dbui.hxx" | |
| #define ITEMID_HORJUSTIFY SID_ATTR_ALIGN_HOR_JUSTIFY | |
| #define ITEMID_VERJUSTIFY SID_ATTR_ALIGN_VER_JUSTIFY | |
| //#define ITEMID_ORIENTATION SID_ATTR_ALIGN_ORIENTATION | |
| #define ITEMID_LINEBREAK SID_ATTR_ALIGN_LINEBREAK | |
| #define ITEMID_MARGIN SID_ATTR_ALIGN_MARGIN | |
| #include "FieldDescControl.hxx" | |
| #include "FieldControls.hxx" | |
| #include <tools/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include "TableDesignHelpBar.hxx" | |
| #include <vcl/scrbar.hxx> | |
| #include <vcl/button.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <vcl/fixed.hxx> | |
| #include <vcl/msgbox.hxx> | |
| #include <vector> | |
| #include "FieldDescriptions.hxx" | |
| #include "dlgattr.hxx" | |
| #include <svx/numfmtsh.hxx> | |
| #include <svx/svxids.hrc> | |
| #include <svx/algitem.hxx> | |
| #include <svl/itempool.hxx> | |
| #define _ZFORLIST_DECLARE_TABLE // ohne das bekomme ich einen Compiler-Fehler in <svl/zforlist.hxx> | |
| #include <svl/zforlist.hxx> | |
| #include <svl/rngitem.hxx> | |
| #include <svl/intitem.hxx> | |
| #include <svl/numuno.hxx> | |
| #include <svtools/transfer.hxx> | |
| #include <com/sun/star/lang/XUnoTunnel.hpp> | |
| #include <com/sun/star/util/NumberFormat.hpp> | |
| #include <com/sun/star/util/XNumberFormatPreviewer.hpp> | |
| #include <com/sun/star/util/XNumberFormatTypes.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include "QEnumTypes.hxx" | |
| #include "dbaccess_helpid.hrc" | |
| #include <connectivity/dbtools.hxx> | |
| #include <connectivity/dbconversion.hxx> | |
| #include <comphelper/numbers.hxx> | |
| #include "UITools.hxx" | |
| #include <memory> | |
| #include "dbu_control.hrc" | |
| #include "dbu_tbl.hrc" | |
| using namespace dbaui; | |
| using namespace dbtools; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::sdbc; | |
| using namespace ::com::sun::star::util; | |
| //================================================================== | |
| // fuer die Controls auf der OFieldDescGenPage | |
| #define CONTROL_SPACING_X 18 // 6 | |
| #define CONTROL_SPACING_Y 4 | |
| #define CONTROL_WIDTH_1 160 // 100 | |
| #define CONTROL_WIDTH_2 100 // 60 | |
| #define CONTROL_WIDTH_3 250 | |
| #define CONTROL_WIDTH_4 (CONTROL_WIDTH_3 - 20 - 5) | |
| #define SBA_DEF_RANGEFORMAT (100 + 143) // RangeItem | |
| #define SBA_DEF_FMTVALUE (100 + 144) // SfxULONG, Format | |
| #define SBA_ATTR_ALIGN_HOR_JUSTIFY (100 + 145) // SvxHorJustifyItem | |
| #define HSCROLL_STEP 20 | |
| namespace | |
| { | |
| // ----------------------------------------------------------------------------- | |
| double checkDoubleForDateFormat(double _nValue,sal_Int32 _nFormatKey,const Reference< ::com::sun::star::util::XNumberFormatter>& _xNumberFormatter) | |
| { | |
| double nValue = _nValue; | |
| sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(_xNumberFormatter,_nFormatKey); | |
| if( (nNumberFormat & ::com::sun::star::util::NumberFormat::DATE) == ::com::sun::star::util::NumberFormat::DATE | |
| || (nNumberFormat & ::com::sun::star::util::NumberFormat::DATETIME) == ::com::sun::star::util::NumberFormat::DATETIME ) | |
| { | |
| nValue = DBTypeConversion::toStandardDbDate(DBTypeConversion::getNULLDate(_xNumberFormatter->getNumberFormatsSupplier()),nValue); | |
| } | |
| return nValue; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| template< typename T1, typename T2> void lcl_HideAndDeleteControl(short& _nPos,T1** _pControl,T2** _pControlText) | |
| { | |
| if ( *_pControl ) | |
| { | |
| --_nPos; | |
| (*_pControl)->Hide(); | |
| (*_pControlText)->Hide(); | |
| delete *_pControl; | |
| delete *_pControlText; | |
| (*_pControl) = NULL; | |
| (*_pControlText) = NULL; | |
| } | |
| } | |
| } | |
| //================================================================== | |
| // class OFieldDescControl | |
| //================================================================== | |
| DBG_NAME(OFieldDescControl) | |
| //================================================================== | |
| OFieldDescControl::OFieldDescControl( Window* pParent, const ResId& rResId, OTableDesignHelpBar* pHelpBar) | |
| :TabPage( pParent, rResId ) | |
| ,pHelp( pHelpBar ) | |
| ,pLastFocusWindow(NULL) | |
| ,m_pActFocusWindow(NULL) | |
| ,pDefaultText(NULL) | |
| ,pRequiredText(NULL) | |
| ,pAutoIncrementText(NULL) | |
| ,pTextLenText(NULL) | |
| ,pNumTypeText(NULL) | |
| ,pLengthText(NULL) | |
| ,pScaleText(NULL) | |
| ,pFormatText(NULL) | |
| ,pBoolDefaultText(NULL) | |
| ,m_pColumnNameText(NULL) | |
| ,m_pTypeText(NULL) | |
| ,m_pAutoIncrementValueText(NULL) | |
| ,pRequired(NULL) | |
| ,pNumType(NULL) | |
| ,pAutoIncrement(NULL) | |
| ,pDefault(NULL) | |
| ,pTextLen(NULL) | |
| ,pLength(NULL) | |
| ,pScale(NULL) | |
| ,pFormatSample(NULL) | |
| ,pBoolDefault(NULL) | |
| ,m_pColumnName(NULL) | |
| ,m_pType(NULL) | |
| ,m_pAutoIncrementValue(NULL) | |
| ,pFormat(NULL) | |
| ,m_pVertScroll( NULL ) | |
| ,m_pHorzScroll( NULL ) | |
| ,m_pPreviousType() | |
| ,nCurChildId(1) | |
| ,m_nPos(-1) | |
| ,aYes(ModuleRes(STR_VALUE_YES)) | |
| ,aNo(ModuleRes(STR_VALUE_NO)) | |
| ,m_nOldVThumb( 0 ) | |
| ,m_nOldHThumb( 0 ) | |
| ,m_nWidth(50) | |
| ,nDelayedGrabFocusEvent(0) | |
| ,m_bAdded(sal_False) | |
| ,m_bRightAligned(false) | |
| ,pActFieldDescr(NULL) | |
| { | |
| DBG_CTOR(OFieldDescControl,NULL); | |
| Contruct(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| OFieldDescControl::OFieldDescControl( Window* pParent, OTableDesignHelpBar* pHelpBar ) | |
| :TabPage( pParent, WB_3DLOOK | WB_DIALOGCONTROL ) | |
| ,pHelp( pHelpBar ) | |
| ,pLastFocusWindow(NULL) | |
| ,m_pActFocusWindow(NULL) | |
| ,pDefaultText(NULL) | |
| ,pRequiredText(NULL) | |
| ,pAutoIncrementText(NULL) | |
| ,pTextLenText(NULL) | |
| ,pNumTypeText(NULL) | |
| ,pLengthText(NULL) | |
| ,pScaleText(NULL) | |
| ,pFormatText(NULL) | |
| ,pBoolDefaultText(NULL) | |
| ,m_pColumnNameText(NULL) | |
| ,m_pTypeText(NULL) | |
| ,m_pAutoIncrementValueText(NULL) | |
| ,pRequired(NULL) | |
| ,pNumType(NULL) | |
| ,pAutoIncrement(NULL) | |
| ,pDefault(NULL) | |
| ,pTextLen(NULL) | |
| ,pLength(NULL) | |
| ,pScale(NULL) | |
| ,pFormatSample(NULL) | |
| ,pBoolDefault(NULL) | |
| ,m_pColumnName(NULL) | |
| ,m_pType(NULL) | |
| ,m_pAutoIncrementValue(NULL) | |
| ,pFormat(NULL) | |
| ,m_pVertScroll( NULL ) | |
| ,m_pHorzScroll( NULL ) | |
| ,m_pPreviousType() | |
| ,nCurChildId(1) | |
| ,m_nPos(-1) | |
| ,aYes(ModuleRes(STR_VALUE_YES)) | |
| ,aNo(ModuleRes(STR_VALUE_NO)) | |
| ,m_nOldVThumb( 0 ) | |
| ,m_nOldHThumb( 0 ) | |
| ,m_nWidth(50) | |
| ,nDelayedGrabFocusEvent(0) | |
| ,m_bAdded(sal_False) | |
| ,m_bRightAligned(false) | |
| ,pActFieldDescr(NULL) | |
| { | |
| DBG_CTOR(OFieldDescControl,NULL); | |
| Contruct(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OFieldDescControl::Contruct() | |
| { | |
| m_pVertScroll = new ScrollBar(this, WB_VSCROLL | WB_REPEAT | WB_DRAG); | |
| m_pHorzScroll = new ScrollBar(this, WB_HSCROLL | WB_REPEAT | WB_DRAG); | |
| m_pVertScroll->SetScrollHdl(LINK(this, OFieldDescControl, OnScroll)); | |
| m_pHorzScroll->SetScrollHdl(LINK(this, OFieldDescControl, OnScroll)); | |
| m_pVertScroll->Show(); | |
| m_pHorzScroll->Show(); | |
| m_pVertScroll->EnableClipSiblings(); | |
| m_pHorzScroll->EnableClipSiblings(); | |
| m_pVertScroll->SetLineSize(1); | |
| m_pVertScroll->SetPageSize(1); | |
| m_pHorzScroll->SetLineSize(1); | |
| m_pHorzScroll->SetPageSize(1); | |
| m_nOldVThumb = m_nOldHThumb = 0; | |
| } | |
| //------------------------------------------------------------------------------ | |
| OFieldDescControl::~OFieldDescControl() | |
| { | |
| DBG_DTOR(OFieldDescControl,NULL); | |
| { | |
| ::std::auto_ptr<Window> aTemp(m_pVertScroll); | |
| m_pVertScroll = NULL; | |
| } | |
| { | |
| ::std::auto_ptr<Window> aTemp(m_pHorzScroll); | |
| m_pHorzScroll = NULL; | |
| } | |
| if ( m_bAdded ) | |
| ::dbaui::notifySystemWindow(this,this,::comphelper::mem_fun(&TaskPaneList::RemoveWindow)); | |
| pLastFocusWindow = NULL; | |
| ////////////////////////////////////////////////////////////////////// | |
| // Childs zerstoeren | |
| DeactivateAggregate( tpDefault ); | |
| DeactivateAggregate( tpRequired ); | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpNumType ); | |
| DeactivateAggregate( tpScale ); | |
| DeactivateAggregate( tpLength ); | |
| DeactivateAggregate( tpFormat ); | |
| DeactivateAggregate( tpAutoIncrement ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| DeactivateAggregate( tpColumnName ); | |
| DeactivateAggregate( tpType ); | |
| DeactivateAggregate( tpAutoIncrementValue ); | |
| if(nDelayedGrabFocusEvent) | |
| Application::RemoveUserEvent(nDelayedGrabFocusEvent); | |
| } | |
| //------------------------------------------------------------------------------ | |
| String OFieldDescControl::BoolStringPersistent(const String& rUIString) const | |
| { | |
| static String aZero('0'); | |
| static String aOne('1'); | |
| if (rUIString == aNo) | |
| return aZero; | |
| if (rUIString == aYes) | |
| return aOne; | |
| return String(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| String OFieldDescControl::BoolStringUI(const String& rPersistentString) const | |
| { | |
| static String aZero('0'); | |
| static String aOne('1'); | |
| static String aNone(ModuleRes(STR_VALUE_NONE)); | |
| // FS - 66161 - 14.05.1999 - aeltere Versionen haben eventuell einen sprachabhaengigen String als Default gespeichert | |
| if (rPersistentString.Equals(aYes) || rPersistentString.Equals(aNo)) | |
| return rPersistentString; | |
| if (rPersistentString == aZero) | |
| return aNo; | |
| if (rPersistentString == aOne) | |
| return aYes; | |
| return aNone; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::Init() | |
| { | |
| Reference< ::com::sun::star::util::XNumberFormatter > xFormatter = GetFormatter(); | |
| ::dbaui::setEvalDateFormatForFormatter(xFormatter); | |
| } | |
| //------------------------------------------------------------------------------ | |
| IMPL_LINK(OFieldDescControl, OnScroll, ScrollBar*, /*pBar*/) | |
| { | |
| ScrollAllAggregates(); | |
| return 0; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| namespace | |
| { | |
| void getMaxXPosition(Window* _pWindow,long& _rnMaxXPosition) | |
| { | |
| if (_pWindow) | |
| { | |
| long nTemp = _pWindow->GetSizePixel().Width() + _pWindow->GetPosPixel().X(); | |
| _rnMaxXPosition = ::std::max(_rnMaxXPosition, nTemp); | |
| } | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::CheckScrollBars() | |
| { | |
| // ein paar Berechnungen zur neuen Position der ScrollBars | |
| Size szOverallSize = GetSizePixel(); | |
| long nHScrollHeight = m_pHorzScroll->GetSizePixel().Height(); | |
| long nVScrollWidth = m_pVertScroll->GetSizePixel().Width(); | |
| long nNewHWidth = szOverallSize.Width() - nVScrollWidth; | |
| long nNewVHeight = szOverallSize.Height() - nHScrollHeight; | |
| sal_Bool bNeedHScrollBar(sal_False), bNeedVScrollBar(sal_False); | |
| // die Bereiche anpassen | |
| // brauche ich ScrollBars eigentlich ? | |
| // horizontal : | |
| long lMaxXPosition = 0; | |
| Control* ppAggregates[] = { pRequired, pNumType, pAutoIncrement, pDefault, pTextLen, pLength, pScale, pFormat, m_pColumnName, m_pType,m_pAutoIncrementValue}; | |
| for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i) | |
| getMaxXPosition(ppAggregates[i],lMaxXPosition); | |
| if (m_pHorzScroll) | |
| lMaxXPosition += m_pHorzScroll->GetThumbPos() * HSCROLL_STEP; | |
| long lMaxXAvailable = szOverallSize.Width(); | |
| bNeedHScrollBar = lMaxXPosition > lMaxXAvailable; | |
| // aendert sich vielleicht noch | |
| // vertikal | |
| // wieviel Controls habe ich | |
| sal_uInt16 nActive = CountActiveAggregates(); | |
| // welches ist das letzte, was ganz drauf passt ? | |
| sal_uInt16 nLastVisible; | |
| const sal_Int32 nControlHeight = GetMaxControlHeight(); | |
| const sal_Int32 nControl_Spacing_y = LogicToPixel(Size(0, CONTROL_SPACING_Y),MAP_APPFONT).Height(); | |
| if (bNeedHScrollBar) | |
| nLastVisible = static_cast<sal_uInt16>((szOverallSize.Height() - nControl_Spacing_y - nHScrollHeight) / (nControl_Spacing_y + nControlHeight)); | |
| else | |
| nLastVisible = static_cast<sal_uInt16>((szOverallSize.Height() - nControl_Spacing_y) / (nControl_Spacing_y + nControlHeight)); | |
| bNeedVScrollBar = nActive>nLastVisible; | |
| if (bNeedVScrollBar) | |
| { | |
| // in die urspruengliche Berechnung von lMaxXAvailable ist nicht mit eingegangen, dass ich eine VScrollBar habe, also muss ich | |
| // das nachholen | |
| lMaxXAvailable -= nVScrollWidth; | |
| if (!bNeedHScrollBar && (lMaxXPosition > lMaxXAvailable)) | |
| { | |
| // durch die vertikale brauche ich jetzt ploetzlich doch eine horizontale | |
| bNeedHScrollBar = sal_True; | |
| // nLastVisible anpassen | |
| nLastVisible = static_cast<sal_uInt16>((szOverallSize.Height() - nControl_Spacing_y - nHScrollHeight) / (nControl_Spacing_y + nControlHeight)); | |
| // bNeedVScrollBar aendert sich nicht : es ist schon auf sal_True und nLastVisible wird hoechstens kleiner | |
| } | |
| } | |
| // jetzt kann ich sie wirklich positionieren und ihre Parameter setzen | |
| if (bNeedVScrollBar) | |
| { | |
| m_pVertScroll->Show(); | |
| m_pVertScroll->SetRangeMax(nActive - nLastVisible); | |
| // m_pVertScroll->SetThumbPos(0); | |
| m_pVertScroll->SetPosSizePixel( Point(nNewHWidth, 0), Size(nVScrollWidth, szOverallSize.Height()) ); | |
| } | |
| else | |
| { | |
| m_pVertScroll->Hide(); | |
| m_pVertScroll->SetRangeMax(0); | |
| m_pVertScroll->SetThumbPos(0); | |
| } | |
| if (bNeedHScrollBar) | |
| { | |
| m_pHorzScroll->Show(); | |
| m_pHorzScroll->SetRangeMax((lMaxXPosition - lMaxXAvailable + HSCROLL_STEP - 1 )/HSCROLL_STEP); | |
| // m_pHorzScroll->SetThumbPos(0); | |
| m_pHorzScroll->SetPosSizePixel( Point(0, nNewVHeight), Size(bNeedVScrollBar ? nNewHWidth : szOverallSize.Width(), nHScrollHeight) ); | |
| } | |
| else | |
| { | |
| m_pHorzScroll->Hide(); | |
| m_pHorzScroll->SetRangeMax(0); | |
| m_pHorzScroll->SetThumbPos(0); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::Resize() | |
| { | |
| CheckScrollBars(); | |
| ScrollAllAggregates(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| inline void OFieldDescControl::ScrollAggregate(Control* pText, Control* pInput, Control* pButton, long nDeltaX, long nDeltaY) | |
| { | |
| if (!pText) | |
| return; | |
| pText->SetPosPixel(pText->GetPosPixel() + Point(nDeltaX, nDeltaY)); | |
| pInput->SetPosPixel(pInput->GetPosPixel() + Point(nDeltaX, nDeltaY)); | |
| if (pButton) | |
| pButton->SetPosPixel(pButton->GetPosPixel() + Point(nDeltaX, nDeltaY)); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::ScrollAllAggregates() | |
| { | |
| long nDeltaX = 0, nDeltaY = 0; | |
| if (m_nOldHThumb != m_pHorzScroll->GetThumbPos()) | |
| { | |
| nDeltaX = (m_nOldHThumb - m_pHorzScroll->GetThumbPos()) * HSCROLL_STEP; | |
| m_nOldHThumb = m_pHorzScroll->GetThumbPos(); | |
| } | |
| if (m_nOldVThumb != m_pVertScroll->GetThumbPos()) | |
| { | |
| const sal_Int32 nControlHeight = GetMaxControlHeight(); | |
| const sal_Int32 nControl_Spacing_y = LogicToPixel(Size(0, CONTROL_SPACING_Y),MAP_APPFONT).Height(); | |
| nDeltaY = (m_nOldVThumb - m_pVertScroll->GetThumbPos()) * (nControl_Spacing_y + nControlHeight); | |
| m_nOldVThumb = m_pVertScroll->GetThumbPos(); | |
| } | |
| if (nDeltaX || nDeltaY) | |
| { | |
| Control* ppAggregates[] = { pRequired, pNumType | |
| , pAutoIncrement, pDefault | |
| , pTextLen, pLength | |
| , pScale, m_pColumnName | |
| , m_pType, m_pAutoIncrementValue}; | |
| Control* ppAggregatesText[] = { pRequiredText, pNumTypeText | |
| , pAutoIncrementText, pDefaultText | |
| , pTextLenText, pLengthText | |
| , pScaleText, m_pColumnNameText | |
| , m_pTypeText, m_pAutoIncrementValueText}; | |
| OSL_ENSURE(sizeof(ppAggregates)/sizeof(ppAggregates[0]) == sizeof(ppAggregatesText)/sizeof(ppAggregatesText[0]),"Lists are not identical!"); | |
| for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i) | |
| ScrollAggregate(ppAggregatesText[i],ppAggregates[i],NULL,nDeltaX, nDeltaY); | |
| ScrollAggregate(pFormatText,pFormatSample,pFormat,nDeltaX, nDeltaY); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| sal_uInt16 OFieldDescControl::CountActiveAggregates() const | |
| { | |
| Control* ppAggregates[] = { pRequired, pNumType, pAutoIncrement, pDefault, pTextLen, pLength, pScale, pFormat, m_pColumnName, m_pType,m_pAutoIncrementValue}; | |
| sal_uInt16 nVisibleAggregates = 0; | |
| for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i) | |
| if (ppAggregates[i]) | |
| ++nVisibleAggregates; | |
| return nVisibleAggregates; | |
| } | |
| //------------------------------------------------------------------------------ | |
| sal_Int32 OFieldDescControl::GetMaxControlHeight() const | |
| { | |
| Size aHeight; | |
| Control* ppAggregates[] = { pRequired, pNumType, pAutoIncrement, pDefault, pTextLen, pLength, pScale, pFormat, m_pColumnName, m_pType,m_pAutoIncrementValue}; | |
| for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i) | |
| { | |
| if ( ppAggregates[i] ) | |
| { | |
| const Size aTemp( ppAggregates[i]->GetOptimalSize(WINDOWSIZE_PREFERRED) ); | |
| if ( aTemp.Height() > aHeight.Height() ) | |
| aHeight.Height() = aTemp.Height(); | |
| } // if ( ppAggregates[i] ) | |
| } | |
| return aHeight.Height(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::SetReadOnly( sal_Bool bReadOnly ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls enablen/disablen | |
| Control* ppAggregates[] = { pRequired, pNumType | |
| , pAutoIncrement, pDefault | |
| , pTextLen, pLength | |
| , pScale, m_pColumnName | |
| , m_pType, m_pAutoIncrementValue | |
| , pFormat}; | |
| Control* ppAggregatesText[] = { pRequiredText, pNumTypeText | |
| , pAutoIncrementText, pDefaultText | |
| , pTextLenText, pLengthText | |
| , pScaleText, m_pColumnNameText | |
| , m_pTypeText, m_pAutoIncrementValueText | |
| , pFormatText}; | |
| OSL_ENSURE(sizeof(ppAggregates)/sizeof(ppAggregates[0]) == sizeof(ppAggregatesText)/sizeof(ppAggregatesText[0]),"Lists are not identical!"); | |
| for (sal_uInt16 i=0; i<sizeof(ppAggregates)/sizeof(ppAggregates[0]); ++i) | |
| { | |
| if ( ppAggregatesText[i] ) | |
| ppAggregatesText[i]->Enable( !bReadOnly ); | |
| if ( ppAggregates[i] ) | |
| ppAggregates[i]->Enable( !bReadOnly ); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| String OFieldDescControl::GetControlText( sal_uInt16 nControlId ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Texte der Controls auslesen | |
| switch( nControlId ) | |
| { | |
| case FIELD_PROPERTY_BOOL_DEFAULT: | |
| if (pBoolDefault) | |
| return pBoolDefault->GetSelectEntry(); | |
| break; | |
| case FIELD_PROPERTY_DEFAULT: | |
| if (pDefault) | |
| return pDefault->GetText(); | |
| break; | |
| case FIELD_PROPERTY_REQUIRED: | |
| if (pRequired) | |
| return pRequired->GetSelectEntry(); | |
| break; | |
| case FIELD_PROPERTY_TEXTLEN: | |
| if (pTextLen) | |
| return String::CreateFromInt64(pTextLen->GetValue()); | |
| case FIELD_PROPERTY_NUMTYPE: | |
| if (pNumType) | |
| return pNumType->GetSelectEntry(); | |
| break; | |
| case FIELD_PROPERTY_AUTOINC: | |
| if (pAutoIncrement) | |
| return pAutoIncrement->GetSelectEntry(); | |
| break; | |
| case FIELD_PROPERTY_LENGTH: | |
| if (pLength) | |
| return pLength->GetText(); | |
| break; | |
| case FIELD_PROPERTY_SCALE: | |
| if (pScale) | |
| return pScale->GetText(); | |
| break; | |
| case FIELD_PROPERTY_FORMAT: | |
| if (pFormatSample) | |
| return pFormatSample->GetText(); | |
| break; | |
| case FIELD_PRPOERTY_COLUMNNAME: | |
| if(m_pColumnName) | |
| return m_pColumnName->GetText(); | |
| case FIELD_PRPOERTY_TYPE: | |
| if(m_pType) | |
| return m_pType->GetSelectEntry(); | |
| break; | |
| case FIELD_PRPOERTY_AUTOINCREMENT: | |
| if(m_pAutoIncrementValue) | |
| return m_pAutoIncrementValue->GetText(); | |
| } | |
| return String(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::SetControlText( sal_uInt16 nControlId, const String& rText ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Texte der Controls setzen | |
| switch( nControlId ) | |
| { | |
| case FIELD_PROPERTY_BOOL_DEFAULT: | |
| if (pBoolDefault) | |
| { | |
| String sOld = pBoolDefault->GetSelectEntry(); | |
| pBoolDefault->SelectEntry(rText); | |
| if (!sOld.Equals(rText)) | |
| LINK(this, OFieldDescControl, ChangeHdl).Call(pBoolDefault); | |
| } | |
| break; | |
| case FIELD_PROPERTY_DEFAULT: | |
| if (pDefault) | |
| { | |
| pDefault->SetText(rText); | |
| UpdateFormatSample(pActFieldDescr); | |
| } | |
| break; | |
| case FIELD_PROPERTY_REQUIRED: | |
| if (pRequired) | |
| pRequired->SelectEntry(rText); | |
| break; | |
| case FIELD_PROPERTY_TEXTLEN: | |
| if (pTextLen) | |
| pTextLen->SetText(rText); | |
| break; | |
| case FIELD_PROPERTY_NUMTYPE: | |
| if (pNumType) | |
| pNumType->SelectEntry(rText); | |
| break; | |
| case FIELD_PROPERTY_AUTOINC: | |
| if (pAutoIncrement) | |
| { | |
| String sOld = pAutoIncrement->GetSelectEntry(); | |
| pAutoIncrement->SelectEntry(rText); | |
| if (!sOld.Equals(rText)) | |
| LINK(this, OFieldDescControl, ChangeHdl).Call(pAutoIncrement); | |
| } | |
| break; | |
| case FIELD_PROPERTY_LENGTH: | |
| if (pLength) | |
| pLength->SetText(rText); | |
| break; | |
| case FIELD_PROPERTY_SCALE: | |
| if (pScale) | |
| pScale->SetText(rText); | |
| break; | |
| case FIELD_PROPERTY_FORMAT: | |
| if (pActFieldDescr) | |
| UpdateFormatSample(pActFieldDescr); | |
| break; | |
| case FIELD_PRPOERTY_COLUMNNAME: | |
| if(m_pColumnName) | |
| m_pColumnName->SetText(rText); | |
| break; | |
| case FIELD_PRPOERTY_TYPE: | |
| if(m_pType) | |
| m_pType->SelectEntry(rText); | |
| break; | |
| case FIELD_PRPOERTY_AUTOINCREMENT: | |
| if(m_pAutoIncrementValue) | |
| m_pAutoIncrementValue->SetText(rText); | |
| break; | |
| } | |
| } | |
| //------------------------------------------------------------------------ | |
| IMPL_LINK( OFieldDescControl, FormatClickHdl, Button *, /*pButton*/ ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Temporaere Column erzeugen, mit der Datenaustausch mit Dialog erfolgt | |
| if( !pActFieldDescr ) | |
| return 0; | |
| sal_Int32 nOldFormatKey(pActFieldDescr->GetFormatKey()); | |
| SvxCellHorJustify rOldJustify = pActFieldDescr->GetHorJustify(); | |
| Reference< XNumberFormatsSupplier > xSupplier = GetFormatter()->getNumberFormatsSupplier(); | |
| SvNumberFormatsSupplierObj* pSupplierImpl = SvNumberFormatsSupplierObj::getImplementation( xSupplier ); | |
| SvNumberFormatter* pFormatter = pSupplierImpl->GetNumberFormatter(); | |
| sal_uInt16 nFlags; | |
| if(::dbaui::callColumnFormatDialog(this,pFormatter,pActFieldDescr->GetType(),nOldFormatKey,rOldJustify,nFlags,sal_True)) | |
| { | |
| sal_Bool bModified = sal_False; | |
| if(nOldFormatKey != pActFieldDescr->GetFormatKey()) | |
| { | |
| pActFieldDescr->SetFormatKey( nOldFormatKey ); | |
| bModified = sal_True; | |
| } | |
| if(rOldJustify != pActFieldDescr->GetHorJustify()) | |
| { | |
| pActFieldDescr->SetHorJustify( rOldJustify ); | |
| bModified = sal_True; | |
| } | |
| if(bModified) | |
| { | |
| SetModified(sal_True); | |
| UpdateFormatSample(pActFieldDescr); | |
| } | |
| } | |
| return 0; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void OFieldDescControl::SetModified(sal_Bool /*bModified*/) | |
| { | |
| } | |
| //------------------------------------------------------------------------ | |
| IMPL_LINK( OFieldDescControl, ChangeHdl, ListBox *, pListBox ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| if ( !pActFieldDescr ) | |
| return 0; | |
| if ( pListBox->GetSavedValue() != pListBox->GetSelectEntryPos() ) | |
| SetModified(sal_True); | |
| // Sonderbehandlund f"ur Bool Felder | |
| if(pListBox == pRequired && pBoolDefault ) | |
| { | |
| // wenn pRequired auf sal_True gesetzt ist, dann darf das sal_Bool Feld nicht den Eintrag <<keiner>> besitzen | |
| String sDef = BoolStringUI(::comphelper::getString(pActFieldDescr->GetControlDefault())); | |
| if(pRequired->GetSelectEntryPos() == 0) // JA | |
| { | |
| pBoolDefault->RemoveEntry(String(ModuleRes(STR_VALUE_NONE))); | |
| if (!sDef.Equals(aYes) && !sDef.Equals(aNo)) | |
| pBoolDefault->SelectEntryPos(1); // nein als Default | |
| else | |
| pBoolDefault->SelectEntry(sDef); | |
| } | |
| else if(pBoolDefault->GetEntryCount() < 3) | |
| { | |
| pBoolDefault->InsertEntry(String(ModuleRes(STR_VALUE_NONE))); | |
| pBoolDefault->SelectEntry(sDef); | |
| } | |
| } | |
| // nur fuer AutoIncrement eine Sonderbehandlung | |
| if (pListBox == pAutoIncrement) | |
| { | |
| if(pListBox->GetSelectEntryPos() == 1) | |
| { // no | |
| DeactivateAggregate( tpAutoIncrementValue ); | |
| if(pActFieldDescr->IsPrimaryKey()) | |
| DeactivateAggregate( tpRequired ); | |
| else if( pActFieldDescr->getTypeInfo()->bNullable ) | |
| { | |
| ActivateAggregate( tpRequired ); | |
| if(pRequired) | |
| { | |
| if( pActFieldDescr->IsNullable() ) | |
| pRequired->SelectEntryPos( 1 ); // no | |
| else | |
| pRequired->SelectEntryPos( 0 ); // yes | |
| } | |
| } | |
| ActivateAggregate( tpDefault ); | |
| } | |
| else | |
| { | |
| DeactivateAggregate( tpRequired ); | |
| DeactivateAggregate( tpDefault ); | |
| ActivateAggregate( tpAutoIncrementValue ); | |
| } | |
| // und jetzt alle nach oben schieben | |
| ArrangeAggregates(); | |
| } | |
| if(pListBox == m_pType) | |
| { | |
| TOTypeInfoSP pTypeInfo = getTypeInfo(m_pType->GetSelectEntryPos()); | |
| pActFieldDescr->FillFromTypeInfo(pTypeInfo,sal_True,sal_False); // SetType(pTypeInfo); | |
| DisplayData(pActFieldDescr); | |
| CellModified(-1, m_pType->GetPos()); | |
| } | |
| return 0; | |
| } | |
| //------------------------------------------------------------------------------ | |
| // alle Control neu anordnen, so dass sie in fester Reihenfolge und wirklich | |
| // OBEN auf der DescriptionPage stehen | |
| void OFieldDescControl::ArrangeAggregates() | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| // die Beschreibung eines Controls | |
| struct AGGREGATE_DESCRIPTION | |
| { | |
| Control* pctrlInputControl; // das eigentliche Control zur Eingabe | |
| Control* pctrlTextControl; // das Label dazu | |
| sal_uInt16 nPosSizeArgument; // das zweite Argument fuer SetPosSize | |
| }; | |
| AGGREGATE_DESCRIPTION adAggregates[] = { | |
| { m_pColumnName, m_pColumnNameText, 1}, | |
| { m_pType, m_pTypeText, 1}, | |
| { pAutoIncrement, pAutoIncrementText, 1 }, | |
| { m_pAutoIncrementValue, m_pAutoIncrementValueText, 3 }, | |
| { pNumType, pNumTypeText, 1 }, | |
| { pRequired, pRequiredText, 1 }, | |
| { pTextLen, pTextLenText, 1 }, | |
| { pLength, pLengthText, 1 }, | |
| { pScale, pScaleText, 1 }, | |
| { pDefault, pDefaultText, 3 }, | |
| { pFormatSample, pFormatText, 4 }, | |
| { pBoolDefault, pBoolDefaultText, 1 }, | |
| }; | |
| long nMaxWidth = 0; | |
| for (size_t i=0; i<sizeof(adAggregates)/sizeof(adAggregates[0]); i++) | |
| { | |
| if (adAggregates[i].pctrlTextControl) | |
| { | |
| nMaxWidth = ::std::max<long>(OutputDevice::GetTextWidth(adAggregates[i].pctrlTextControl->GetText()),nMaxWidth); | |
| } | |
| } | |
| OSL_ENSURE(nMaxWidth != 0,"Invalid width!"); | |
| // und los ... | |
| int nCurrentControlPos = 0; | |
| Control* pZOrderPredecessor = NULL; | |
| for (size_t i=0; i<sizeof(adAggregates)/sizeof(adAggregates[0]); i++) | |
| { | |
| if (adAggregates[i].pctrlInputControl) | |
| { | |
| SetPosSize(&adAggregates[i].pctrlTextControl, nCurrentControlPos, 0); | |
| SetPosSize(&adAggregates[i].pctrlInputControl, nCurrentControlPos, adAggregates[i].nPosSizeArgument); | |
| // die Z-Order so, dass die Controls auch wirklich in derselben Reihenfolge durchwandert werden koennen, in der sie | |
| // hier angeordnet wurden | |
| adAggregates[i].pctrlTextControl->SetZOrder(pZOrderPredecessor, pZOrderPredecessor ? WINDOW_ZORDER_BEHIND : WINDOW_ZORDER_FIRST); | |
| adAggregates[i].pctrlInputControl->SetZOrder(adAggregates[i].pctrlTextControl, WINDOW_ZORDER_BEHIND ); | |
| pZOrderPredecessor = adAggregates[i].pctrlInputControl; | |
| if (adAggregates[i].pctrlInputControl == pFormatSample) | |
| { | |
| pFormat->SetZOrder(pZOrderPredecessor, WINDOW_ZORDER_BEHIND); | |
| pZOrderPredecessor = pFormat; | |
| } | |
| ++nCurrentControlPos; | |
| } | |
| } | |
| // eine Sonderbehandlung fuer die Format-Controls | |
| if (pFormat) | |
| { | |
| Point ptSamplePos(pFormatSample->GetPosPixel()); | |
| Size szSampleSize(pFormatSample->GetSizePixel()); | |
| pFormat->SetPosPixel(Point(ptSamplePos.X() + szSampleSize.Width() + 5, ptSamplePos.Y())); | |
| } | |
| // als letztes noch die ScrollBars in der ZOrder ganz nach oben | |
| m_pVertScroll->SetZOrder(NULL, WINDOW_ZORDER_FIRST); | |
| m_pHorzScroll->SetZOrder(NULL, WINDOW_ZORDER_FIRST); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::ActivateAggregate( EControlType eType ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls erzeugen | |
| switch( eType ) | |
| { | |
| case tpDefault: | |
| if( pDefault ) | |
| return; | |
| m_nPos++; | |
| pDefaultText = CreateText(STR_DEFAULT_VALUE); | |
| pDefault = new OPropEditCtrl( this, STR_HELP_DEFAULT_VALUE, FIELD_PROPERTY_DEFAULT, WB_BORDER ); | |
| InitializeControl(pDefault,HID_TAB_ENT_DEFAULT,false); | |
| break; | |
| case tpAutoIncrementValue: | |
| if( m_pAutoIncrementValue || !isAutoIncrementValueEnabled() ) | |
| return; | |
| m_nPos++; | |
| m_pAutoIncrementValueText = CreateText(STR_AUTOINCREMENT_VALUE); | |
| m_pAutoIncrementValue = new OPropEditCtrl( this, STR_HELP_AUTOINCREMENT_VALUE, FIELD_PRPOERTY_AUTOINCREMENT, WB_BORDER ); | |
| m_pAutoIncrementValue->SetText( getAutoIncrementValue() ); | |
| InitializeControl(m_pAutoIncrementValue,HID_TAB_AUTOINCREMENTVALUE,false); | |
| break; | |
| case tpRequired: | |
| { | |
| if( pRequired ) | |
| return; | |
| Reference< XDatabaseMetaData> xMetaData = getMetaData(); | |
| if(xMetaData.is() && xMetaData->supportsNonNullableColumns()) | |
| { | |
| m_nPos++; | |
| pRequiredText = CreateText(STR_FIELD_REQUIRED); | |
| pRequired = new OPropListBoxCtrl( this, STR_HELP_FIELD_REQUIRED, FIELD_PROPERTY_REQUIRED, WB_DROPDOWN); | |
| pRequired->InsertEntry( aYes ); | |
| pRequired->InsertEntry( aNo ); | |
| pRequired->SelectEntryPos(1); | |
| InitializeControl(pRequired,HID_TAB_ENT_REQUIRED,true); | |
| } | |
| } | |
| break; | |
| case tpAutoIncrement: | |
| { | |
| if( pAutoIncrement ) | |
| return; | |
| m_nPos++; | |
| pAutoIncrementText = CreateText(STR_FIELD_AUTOINCREMENT); | |
| pAutoIncrement = new OPropListBoxCtrl( this, STR_HELP_AUTOINCREMENT, FIELD_PROPERTY_AUTOINC, WB_DROPDOWN ); | |
| pAutoIncrement->InsertEntry( aYes ); | |
| pAutoIncrement->InsertEntry( aNo ); | |
| pAutoIncrement->SelectEntryPos(0); | |
| InitializeControl(pAutoIncrement,HID_TAB_ENT_AUTOINCREMENT,true); | |
| } | |
| break; | |
| case tpTextLen: | |
| if( pTextLen ) | |
| return; | |
| m_nPos++; | |
| pTextLenText = CreateText(STR_TEXT_LENGTH); | |
| pTextLen = CreateNumericControl(STR_HELP_TEXT_LENGTH, FIELD_PROPERTY_TEXTLEN,HID_TAB_ENT_TEXT_LEN); | |
| break; | |
| case tpType: | |
| if( m_pType) | |
| return; | |
| m_nPos++; | |
| m_pTypeText = CreateText(STR_TAB_FIELD_DATATYPE); | |
| m_pType = new OPropListBoxCtrl( this, STR_HELP_AUTOINCREMENT, FIELD_PRPOERTY_TYPE, WB_DROPDOWN ); | |
| m_pType->SetDropDownLineCount(20); | |
| { | |
| const OTypeInfoMap* pTypeInfo = getTypeInfo(); | |
| OTypeInfoMap::const_iterator aIter = pTypeInfo->begin(); | |
| OTypeInfoMap::const_iterator aEnd = pTypeInfo->end(); | |
| for(;aIter != aEnd;++aIter) | |
| m_pType->InsertEntry( aIter->second->aUIName ); | |
| } | |
| m_pType->SelectEntryPos(0); | |
| InitializeControl(m_pType,HID_TAB_ENT_TYPE,true); | |
| break; | |
| case tpColumnName: | |
| if( m_pColumnName ) | |
| return; | |
| m_nPos++; | |
| { | |
| sal_uInt32 nMax = EDIT_NOLIMIT; | |
| ::rtl::OUString aTmpString; | |
| try | |
| { | |
| Reference< XDatabaseMetaData> xMetaData = getMetaData(); | |
| if ( xMetaData.is() ) | |
| { | |
| nMax = xMetaData->getMaxColumnNameLength(); | |
| aTmpString = xMetaData->getExtraNameCharacters(); | |
| } | |
| } | |
| catch(Exception&) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| m_pColumnNameText = CreateText(STR_TAB_FIELD_NAME); | |
| m_pColumnName = new OPropColumnEditCtrl( this, | |
| aTmpString, | |
| STR_HELP_DEFAULT_VALUE, | |
| FIELD_PRPOERTY_COLUMNNAME, | |
| WB_BORDER ); | |
| m_pColumnName->SetMaxTextLen(xub_StrLen( nMax ? nMax : EDIT_NOLIMIT)); | |
| m_pColumnName->setCheck( isSQL92CheckEnabled(getConnection()) ); | |
| } | |
| InitializeControl(m_pColumnName,HID_TAB_ENT_COLUMNNAME,false); | |
| break; | |
| case tpNumType: | |
| if( pNumType ) | |
| return; | |
| m_nPos++; | |
| pNumTypeText = CreateText(STR_NUMERIC_TYPE); | |
| pNumType = new OPropListBoxCtrl( this, STR_HELP_NUMERIC_TYPE, FIELD_PROPERTY_NUMTYPE, WB_DROPDOWN ); | |
| pNumType->SetDropDownLineCount(5); | |
| pNumType->InsertEntry( String::CreateFromAscii("Byte") ); | |
| pNumType->InsertEntry( String::CreateFromAscii("SmallInt") ); | |
| pNumType->InsertEntry( String::CreateFromAscii("Integer") ); | |
| pNumType->InsertEntry( String::CreateFromAscii("Single") ); | |
| pNumType->InsertEntry( String::CreateFromAscii("Double") ); | |
| pNumType->SelectEntryPos(2); | |
| InitializeControl(pNumType,HID_TAB_ENT_NUMTYP,true); | |
| break; | |
| case tpLength: | |
| if( pLength ) | |
| return; | |
| m_nPos++; | |
| pLengthText = CreateText(STR_LENGTH); | |
| pLength = CreateNumericControl(STR_HELP_LENGTH, FIELD_PROPERTY_LENGTH,HID_TAB_ENT_LEN); | |
| break; | |
| case tpScale: | |
| if( pScale ) | |
| return; | |
| m_nPos++; | |
| pScaleText = CreateText(STR_SCALE); | |
| pScale = CreateNumericControl(STR_HELP_SCALE, FIELD_PROPERTY_SCALE,HID_TAB_ENT_SCALE); | |
| break; | |
| case tpFormat: | |
| if (!pFormat) | |
| { | |
| m_nPos++; | |
| pFormatText = CreateText(STR_FORMAT); | |
| pFormatSample = new OPropEditCtrl( this, STR_HELP_FORMAT_CODE, -1, WB_BORDER ); | |
| pFormatSample->SetReadOnly(sal_True); | |
| pFormatSample->Enable(sal_False); | |
| InitializeControl(pFormatSample,HID_TAB_ENT_FORMAT_SAMPLE,false); | |
| pFormat = new PushButton( this, ModuleRes(PB_FORMAT) ); | |
| const sal_Int32 nControlHeight = GetMaxControlHeight(); | |
| pFormat->SetSizePixel(Size(nControlHeight, nControlHeight)); | |
| pFormat->SetClickHdl( LINK( this, OFieldDescControl, FormatClickHdl ) ); | |
| InitializeControl(pFormat,HID_TAB_ENT_FORMAT,false); | |
| } | |
| UpdateFormatSample(pActFieldDescr); | |
| break; | |
| case tpBoolDefault: | |
| if (pBoolDefault) | |
| return; | |
| m_nPos++; | |
| pBoolDefaultText = CreateText(STR_DEFAULT_VALUE); | |
| pBoolDefault = new OPropListBoxCtrl( this, STR_HELP_BOOL_DEFAULT, FIELD_PROPERTY_BOOL_DEFAULT, WB_DROPDOWN ); | |
| pBoolDefault->SetDropDownLineCount(3); | |
| pBoolDefault->InsertEntry(String(ModuleRes(STR_VALUE_NONE))); | |
| pBoolDefault->InsertEntry(aYes); | |
| pBoolDefault->InsertEntry(aNo); | |
| InitializeControl(pBoolDefault,HID_TAB_ENT_BOOL_DEFAULT,false); | |
| break; | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OFieldDescControl::InitializeControl(Control* _pControl,const ::rtl::OString& _sHelpId,bool _bAddChangeHandler) | |
| { | |
| _pControl->SetHelpId(_sHelpId); | |
| if ( _bAddChangeHandler ) | |
| ((OPropListBoxCtrl*)_pControl)->SetSelectHdl(LINK(this,OFieldDescControl,ChangeHdl)); | |
| _pControl->SetGetFocusHdl(LINK(this, OFieldDescControl, OnControlFocusGot)); | |
| _pControl->SetLoseFocusHdl(LINK(this, OFieldDescControl, OnControlFocusLost)); | |
| _pControl->EnableClipSiblings(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| FixedText* OFieldDescControl::CreateText(sal_uInt16 _nTextRes) | |
| { | |
| FixedText* pFixedText = new FixedText( this ); | |
| pFixedText->SetText( ModuleRes(_nTextRes) ); | |
| pFixedText->EnableClipSiblings(); | |
| return pFixedText; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| OPropNumericEditCtrl* OFieldDescControl::CreateNumericControl(sal_uInt16 _nHelpStr,short _nProperty,const rtl::OString& _sHelpId) | |
| { | |
| OPropNumericEditCtrl* pControl = new OPropNumericEditCtrl( this, _nHelpStr, _nProperty, WB_BORDER ); | |
| pControl->SetDecimalDigits(0); | |
| pControl->SetMin(0); | |
| pControl->SetMax(0x7FFFFFFF); // soll draussen geaendert werden, wenn noetig | |
| pControl->SetStrictFormat(sal_True); | |
| InitializeControl(pControl,_sHelpId,false); | |
| return pControl; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::DeactivateAggregate( EControlType eType ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| pLastFocusWindow = NULL; | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls zerstoeren | |
| switch( eType ) | |
| { | |
| case tpDefault: | |
| lcl_HideAndDeleteControl(m_nPos,&pDefault,&pDefaultText); | |
| break; | |
| case tpAutoIncrementValue: | |
| lcl_HideAndDeleteControl(m_nPos,&m_pAutoIncrementValue,&m_pAutoIncrementValueText); | |
| break; | |
| case tpColumnName: | |
| lcl_HideAndDeleteControl(m_nPos,&m_pColumnName,&m_pColumnNameText); | |
| break; | |
| case tpType: | |
| lcl_HideAndDeleteControl(m_nPos,&m_pType,&m_pTypeText); | |
| break; | |
| case tpAutoIncrement: | |
| lcl_HideAndDeleteControl(m_nPos,&pAutoIncrement,&pAutoIncrementText); | |
| break; | |
| case tpRequired: | |
| lcl_HideAndDeleteControl(m_nPos,&pRequired,&pRequiredText); | |
| break; | |
| case tpTextLen: | |
| lcl_HideAndDeleteControl(m_nPos,&pTextLen,&pTextLenText); | |
| break; | |
| case tpNumType: | |
| lcl_HideAndDeleteControl(m_nPos,&pNumType,&pNumTypeText); | |
| break; | |
| case tpLength: | |
| lcl_HideAndDeleteControl(m_nPos,&pLength,&pLengthText); | |
| break; | |
| case tpScale: | |
| lcl_HideAndDeleteControl(m_nPos,&pScale,&pScaleText); | |
| break; | |
| case tpFormat: | |
| // TODO: we have to check if we have to increment m_nPos again | |
| lcl_HideAndDeleteControl(m_nPos,&pFormat,&pFormatText); | |
| if ( pFormatSample ) | |
| { | |
| pFormatSample->Hide(); | |
| delete pFormatSample; | |
| pFormatSample = NULL; | |
| } | |
| break; | |
| case tpBoolDefault: | |
| lcl_HideAndDeleteControl(m_nPos,&pBoolDefault,&pBoolDefaultText); | |
| break; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::SetPosSize( Control** ppControl, long nRow, sal_uInt16 nCol ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Groesse ermitteln | |
| const sal_Int32 nControlHeight = GetMaxControlHeight(); | |
| Size aSize(0,nControlHeight); | |
| if ( isRightAligned() && nCol ) | |
| aSize.Width() = LogicToPixel(Size(m_nWidth, 0),MAP_APPFONT).Width(); | |
| else | |
| { | |
| switch( nCol ) | |
| { | |
| case 0: | |
| default: | |
| aSize.Width() = CONTROL_WIDTH_1; | |
| break; | |
| case 1: | |
| aSize.Width() = CONTROL_WIDTH_2; | |
| break; | |
| case 3: | |
| aSize.Width() = CONTROL_WIDTH_3; | |
| break; | |
| case 4: | |
| aSize.Width() = CONTROL_WIDTH_4; | |
| break; | |
| } // switch( nCol ) | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // Position ermitteln | |
| Point aPosition; | |
| switch( nCol ) | |
| { | |
| case 0: | |
| aPosition.X() = 0; | |
| aPosition.Y() = 1; | |
| break; | |
| case 1: | |
| case 3: | |
| case 4: | |
| if ( isRightAligned() ) | |
| { | |
| Size aOwnSize = GetSizePixel(); | |
| aPosition.X() = aOwnSize.Width() - aSize.Width(); | |
| } | |
| else | |
| aPosition.X() = CONTROL_WIDTH_1 + CONTROL_SPACING_X; | |
| break; | |
| default: | |
| aPosition.X() = 0; | |
| } | |
| (*ppControl)->SetSizePixel( aSize ); | |
| aSize = (*ppControl)->GetSizePixel( ); | |
| const sal_Int32 nControl_Spacing_y = LogicToPixel(Size(0, CONTROL_SPACING_Y),MAP_APPFONT).Height(); | |
| aPosition.Y() += ((nRow+1)*nControl_Spacing_y) + | |
| (nRow*nControlHeight); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Control anzeigen | |
| (*ppControl)->SetPosSizePixel( aPosition, aSize ); | |
| aSize = (*ppControl)->GetSizePixel(); | |
| (*ppControl)->Show(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::DisplayData(OFieldDescription* pFieldDescr ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| pActFieldDescr = pFieldDescr; | |
| if(!pFieldDescr) | |
| { | |
| DeactivateAggregate( tpDefault ); | |
| DeactivateAggregate( tpRequired ); | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpNumType ); | |
| DeactivateAggregate( tpScale ); | |
| DeactivateAggregate( tpLength ); | |
| DeactivateAggregate( tpFormat ); | |
| DeactivateAggregate( tpAutoIncrement ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| DeactivateAggregate( tpColumnName ); | |
| DeactivateAggregate( tpType ); | |
| DeactivateAggregate( tpAutoIncrementValue ); | |
| m_pPreviousType = TOTypeInfoSP(); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Zeiger des gespeicherten Focus zuruecksetzen | |
| pLastFocusWindow = NULL; | |
| if ( m_bAdded ) | |
| { | |
| ::dbaui::notifySystemWindow(this,this,::comphelper::mem_fun(&TaskPaneList::RemoveWindow)); | |
| m_bAdded = sal_False; | |
| } | |
| return; | |
| } | |
| if ( !m_bAdded ) | |
| { | |
| ::dbaui::notifySystemWindow(this,this,::comphelper::mem_fun(&TaskPaneList::AddWindow)); | |
| m_bAdded = sal_True; | |
| } | |
| TOTypeInfoSP pFieldType; | |
| if( pFieldDescr ) | |
| pFieldType = pFieldDescr->getTypeInfo(); | |
| ActivateAggregate( tpColumnName ); | |
| ActivateAggregate( tpType ); | |
| OSL_ENSURE(pFieldType.get(),"We need a type information here!"); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Wenn sich der Typ geaendert hat, Controls austauschen | |
| if( m_pPreviousType != pFieldType ) | |
| { | |
| ////////////////////////////////////////////////////////////////////// | |
| // Zeiger des gespeicherten Focus zuruecksetzen | |
| pLastFocusWindow = NULL; | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls, die nicht mehr angezeigt werden duerfen | |
| DeactivateAggregate( tpNumType ); | |
| ////////////////////////////////////////////////////////////////////// | |
| // determine which controls we should show and which not | |
| // 1. the required control | |
| if ( pFieldType->bNullable ) | |
| ActivateAggregate( tpRequired ); | |
| else | |
| DeactivateAggregate( tpRequired ); | |
| // 2. the autoincrement | |
| if ( pFieldType->bAutoIncrement ) | |
| { | |
| DeactivateAggregate( tpRequired ); | |
| DeactivateAggregate( tpDefault ); | |
| ActivateAggregate( tpAutoIncrement ); | |
| ActivateAggregate( tpAutoIncrementValue ); | |
| } | |
| else | |
| { | |
| DeactivateAggregate( tpAutoIncrement ); | |
| DeactivateAggregate( tpAutoIncrementValue ); | |
| if(pFieldType->bNullable) | |
| ActivateAggregate( tpRequired ); | |
| else | |
| DeactivateAggregate( tpRequired ); | |
| ActivateAggregate( tpDefault ); | |
| } | |
| // 3. the scale and precision | |
| if (pFieldType->nPrecision) | |
| { | |
| ActivateAggregate( tpLength ); | |
| pLength->SetMax(::std::max<sal_Int32>(pFieldType->nPrecision,pFieldDescr->GetPrecision())); | |
| pLength->SetSpecialReadOnly(pFieldType->aCreateParams.getLength()==0); | |
| } | |
| else | |
| DeactivateAggregate( tpLength ); | |
| if (pFieldType->nMaximumScale) | |
| { | |
| ActivateAggregate( tpScale ); | |
| pScale->SetMax(::std::max<sal_Int32>(pFieldType->nMaximumScale,pFieldDescr->GetScale())); | |
| pScale->SetMin(pFieldType->nMinimumScale); | |
| static const ::rtl::OUString s_sPRECISION(RTL_CONSTASCII_USTRINGPARAM("PRECISION")); | |
| pScale->SetSpecialReadOnly(pFieldType->aCreateParams.getLength() == 0 || pFieldType->aCreateParams == s_sPRECISION); | |
| } | |
| else | |
| DeactivateAggregate( tpScale ); | |
| // and now look for type specific things | |
| switch( pFieldType->nType ) | |
| { | |
| case DataType::CHAR: | |
| case DataType::VARCHAR: | |
| case DataType::LONGVARCHAR: | |
| DeactivateAggregate( tpLength ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| ActivateAggregate( tpDefault ); | |
| ActivateAggregate( tpFormat ); | |
| if (pFieldType->nPrecision) | |
| { | |
| ActivateAggregate( tpTextLen ); | |
| pTextLen->SetMax(::std::max<sal_Int32>(pFieldType->nPrecision,pFieldDescr->GetPrecision())); | |
| pTextLen->SetSpecialReadOnly(pFieldType->aCreateParams.getLength()==0); | |
| } | |
| else | |
| DeactivateAggregate( tpTextLen ); | |
| break; | |
| case DataType::DATE: | |
| case DataType::TIME: | |
| case DataType::TIMESTAMP: | |
| DeactivateAggregate( tpLength ); // we don't need a length for date types | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| ActivateAggregate( tpDefault ); | |
| ActivateAggregate( tpFormat ); | |
| break; | |
| case DataType::BIT: | |
| if ( pFieldType->aCreateParams.getLength() ) | |
| { | |
| DeactivateAggregate( tpFormat ); | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| break; | |
| } | |
| // run through | |
| case DataType::BOOLEAN: | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpFormat ); | |
| DeactivateAggregate( tpDefault ); | |
| ActivateAggregate( tpBoolDefault ); | |
| break; | |
| case DataType::DECIMAL: | |
| case DataType::NUMERIC: | |
| case DataType::BIGINT: | |
| case DataType::FLOAT: | |
| case DataType::DOUBLE: | |
| case DataType::TINYINT: | |
| case DataType::SMALLINT: | |
| case DataType::INTEGER: | |
| case DataType::REAL: | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| ActivateAggregate( tpFormat ); | |
| break; | |
| case DataType::BINARY: | |
| case DataType::VARBINARY: | |
| DeactivateAggregate( tpDefault ); | |
| DeactivateAggregate( tpRequired ); | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| ActivateAggregate( tpFormat ); | |
| break; | |
| case DataType::LONGVARBINARY: | |
| case DataType::SQLNULL: | |
| case DataType::OBJECT: | |
| case DataType::DISTINCT: | |
| case DataType::STRUCT: | |
| case DataType::ARRAY: | |
| case DataType::BLOB: | |
| case DataType::CLOB: | |
| case DataType::REF: | |
| case DataType::OTHER: | |
| DeactivateAggregate( tpFormat ); | |
| DeactivateAggregate( tpTextLen ); | |
| DeactivateAggregate( tpBoolDefault ); | |
| break; | |
| default: | |
| OSL_ENSURE(0,"Unknown type"); | |
| } | |
| m_pPreviousType = pFieldType; | |
| } | |
| if(pFieldDescr) | |
| { | |
| if(pFieldDescr->IsPrimaryKey()) | |
| { | |
| DeactivateAggregate( tpRequired ); | |
| } | |
| else if ( !pAutoIncrement && pFieldType.get() ) | |
| { | |
| if ( pFieldType->bNullable ) | |
| ActivateAggregate( tpRequired ); | |
| else | |
| DeactivateAggregate( tpRequired ); | |
| } | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls initialisieren | |
| if( pAutoIncrement ) | |
| { | |
| if ( pFieldDescr->IsAutoIncrement() ) | |
| { | |
| pAutoIncrement->SelectEntryPos( 0 ); // yes | |
| ActivateAggregate( tpAutoIncrementValue ); | |
| if ( m_pAutoIncrementValue ) | |
| m_pAutoIncrementValue->SetText(pFieldDescr->GetAutoIncrementValue()); | |
| DeactivateAggregate( tpRequired ); | |
| DeactivateAggregate( tpDefault ); | |
| } | |
| else | |
| { | |
| // disable autoincrement value because it should only be visible when autoincrement is to true | |
| DeactivateAggregate( tpAutoIncrementValue ); | |
| pAutoIncrement->SelectEntryPos( 1 ); // no | |
| ActivateAggregate( tpDefault ); | |
| // hat Auswirkungen auf pRequired | |
| if(!pFieldDescr->IsPrimaryKey()) | |
| ActivateAggregate( tpRequired ); | |
| } | |
| } | |
| if( pDefault ) | |
| { | |
| pDefault->SetText( getControlDefault(pFieldDescr) ); | |
| pDefault->ClearModifyFlag(); | |
| } | |
| if( pBoolDefault ) | |
| { | |
| // wenn pRequired auf sal_True gesetzt ist, dann darf das sal_Bool Feld nicht den Eintrag <<keiner>> besitzen | |
| ::rtl::OUString sValue; | |
| pFieldDescr->GetControlDefault() >>= sValue; | |
| String sDef = BoolStringUI(sValue); | |
| // sicher stellen das <<keiner>> nur vorhanden ist, wenn das Feld NULL sein darf | |
| if ( ( pFieldType.get() && !pFieldType->bNullable ) || !pFieldDescr->IsNullable() ) | |
| { | |
| pFieldDescr->SetIsNullable(ColumnValue::NO_NULLS); // der Typ sagt das | |
| pBoolDefault->RemoveEntry(String(ModuleRes(STR_VALUE_NONE))); | |
| if ( !sDef.Equals(aYes) && !sDef.Equals(aNo) ) | |
| pBoolDefault->SelectEntryPos(1); // nein als Default | |
| else | |
| pBoolDefault->SelectEntry(sDef); | |
| pFieldDescr->SetControlDefault(makeAny(::rtl::OUString(BoolStringPersistent(pBoolDefault->GetSelectEntry())))); | |
| } | |
| else if(pBoolDefault->GetEntryCount() < 3) | |
| { | |
| pBoolDefault->InsertEntry(String(ModuleRes(STR_VALUE_NONE))); | |
| pBoolDefault->SelectEntry(sDef); | |
| } | |
| else | |
| pBoolDefault->SelectEntry(sDef); | |
| } | |
| if( pRequired ) | |
| { | |
| if( pFieldDescr->IsNullable() ) | |
| pRequired->SelectEntryPos( 1 ); // no | |
| else | |
| pRequired->SelectEntryPos( 0 ); // yes | |
| } | |
| if( pTextLen ) | |
| { | |
| pTextLen->SetText( String::CreateFromInt32(pFieldDescr->GetPrecision()) ); | |
| pTextLen->ClearModifyFlag(); | |
| } | |
| if( pNumType ) | |
| { | |
| OSL_ENSURE(sal_False, "OFieldDescControl::DisplayData: invalid num type!"); | |
| } | |
| if( pLength ) | |
| pLength->SetText( String::CreateFromInt32(pFieldDescr->GetPrecision()) ); | |
| if( pScale ) | |
| pScale->SetText( String::CreateFromInt32(pFieldDescr->GetScale()) ); | |
| if( pFormat ) | |
| UpdateFormatSample(pFieldDescr); | |
| if(m_pColumnName) | |
| m_pColumnName->SetText(pFieldDescr->GetName()); | |
| if(m_pType) | |
| { | |
| sal_uInt16 nPos = pFieldType.get() ? m_pType->GetEntryPos(String(pFieldDescr->getTypeInfo()->aUIName)) : LISTBOX_ENTRY_NOTFOUND; | |
| if(nPos == LISTBOX_ENTRY_NOTFOUND) | |
| { | |
| const OTypeInfoMap* pMap = getTypeInfo(); | |
| OTypeInfoMap::const_iterator aIter = pMap->find(pFieldType.get() ? pFieldDescr->getTypeInfo()->nType : pFieldDescr->GetType()); | |
| if(aIter == pMap->end() && !pMap->empty()) | |
| { | |
| aIter = pMap->begin(); | |
| if(pFieldDescr->GetPrecision() > aIter->second->nPrecision) | |
| pFieldDescr->SetPrecision(aIter->second->nPrecision); | |
| if(pFieldDescr->GetScale() > aIter->second->nMaximumScale) | |
| pFieldDescr->SetScale(0); | |
| if(!aIter->second->bNullable && pFieldDescr->IsNullable()) | |
| pFieldDescr->SetIsNullable(ColumnValue::NO_NULLS); | |
| if(!aIter->second->bAutoIncrement && pFieldDescr->IsAutoIncrement()) | |
| pFieldDescr->SetAutoIncrement(sal_False); | |
| } | |
| if ( aIter != pMap->end() ) | |
| { | |
| pFieldDescr->SetType(aIter->second); | |
| } | |
| } | |
| m_pType->SelectEntry(pFieldDescr->getTypeInfo()->aUIName); | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls Enablen/Disablen | |
| sal_Bool bRead(IsReadOnly()); | |
| ArrangeAggregates(); | |
| CheckScrollBars(); | |
| ScrollAllAggregates(); | |
| SetReadOnly( bRead ); | |
| } | |
| //------------------------------------------------------------------------ | |
| IMPL_LINK(OFieldDescControl, DelayedGrabFocus, Control**, ppControl) | |
| { | |
| nDelayedGrabFocusEvent = 0; | |
| if (*ppControl) | |
| (*ppControl)->GrabFocus(); | |
| return 0L; | |
| } | |
| //------------------------------------------------------------------------------ | |
| IMPL_LINK(OFieldDescControl, OnControlFocusGot, Control*, pControl ) | |
| { | |
| String strHelpText; | |
| OPropNumericEditCtrl* pNumeric = dynamic_cast< OPropNumericEditCtrl* >( pControl ); | |
| if ( pNumeric ) | |
| { | |
| pNumeric->SaveValue(); | |
| strHelpText = pNumeric->GetHelp(); | |
| } | |
| OPropColumnEditCtrl* pColumn = dynamic_cast< OPropColumnEditCtrl* >( pControl ); | |
| if ( pColumn ) | |
| { | |
| pColumn->SaveValue(); | |
| strHelpText = pColumn->GetHelp(); | |
| } | |
| OPropEditCtrl* pEdit = dynamic_cast< OPropEditCtrl* >( pControl ); | |
| if ( pEdit ) | |
| { | |
| pEdit->SaveValue(); | |
| strHelpText = pEdit->GetHelp(); | |
| } | |
| OPropListBoxCtrl* pListBox = dynamic_cast< OPropListBoxCtrl* >( pControl ); | |
| if ( pListBox ) | |
| { | |
| pListBox->SaveValue(); | |
| strHelpText = pListBox->GetHelp(); | |
| } | |
| if (pControl == pFormat) | |
| strHelpText =String(ModuleRes(STR_HELP_FORMAT_BUTTON)); | |
| if (strHelpText.Len() && (pHelp != NULL)) | |
| pHelp->SetHelpText(strHelpText); | |
| m_pActFocusWindow = pControl; | |
| return 0L; | |
| } | |
| //------------------------------------------------------------------------------ | |
| IMPL_LINK(OFieldDescControl, OnControlFocusLost, Control*, pControl ) | |
| { | |
| if ((pControl == pLength) || (pControl == pTextLen) || (pControl == pScale)) | |
| { | |
| OPropNumericEditCtrl* pConverted = (OPropNumericEditCtrl*)pControl; | |
| if (pConverted->IsModified()) | |
| CellModified(-1, pConverted->GetPos()); | |
| } | |
| if(pControl == m_pColumnName) | |
| { | |
| OPropColumnEditCtrl* pConverted = (OPropColumnEditCtrl*)pControl; | |
| if (pConverted->IsModified()) | |
| CellModified(-1, pConverted->GetPos()); | |
| } | |
| else if ((pControl == pDefault) || (pControl == pFormatSample) || (pControl == m_pAutoIncrementValue) ) | |
| { | |
| OPropEditCtrl* pConverted = (OPropEditCtrl*)pControl; | |
| if (pConverted->IsModified()) | |
| CellModified(-1, pConverted->GetPos()); | |
| } | |
| else if ((pControl == pRequired) || (pControl == pNumType) || (pControl == pAutoIncrement) || (pControl == pBoolDefault) || (pControl == m_pType)) | |
| { | |
| OPropListBoxCtrl* pConverted = (OPropListBoxCtrl*)pControl; | |
| if (pConverted->IsModified()) | |
| CellModified(-1, pConverted->GetPos()); | |
| } | |
| if (pControl == pDefault) | |
| UpdateFormatSample(pActFieldDescr); | |
| implFocusLost(pControl); | |
| return 0L; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::SaveData( OFieldDescription* pFieldDescr ) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| if( !pFieldDescr ) | |
| return; | |
| ////////////////////////////////////////////////////////////////////// | |
| // Controls auslesen | |
| ::rtl::OUString sDefault; | |
| if (pDefault) | |
| { | |
| sDefault = pDefault->GetText(); | |
| } | |
| else if (pBoolDefault) | |
| { | |
| sDefault = BoolStringPersistent(pBoolDefault->GetSelectEntry()); | |
| } | |
| if ( sDefault.getLength() ) | |
| pFieldDescr->SetControlDefault(makeAny(sDefault)); | |
| else | |
| pFieldDescr->SetControlDefault(Any()); | |
| if((pRequired && pRequired->GetSelectEntryPos() == 0) || pFieldDescr->IsPrimaryKey() || (pBoolDefault && pBoolDefault->GetEntryCount() == 2)) // yes | |
| pFieldDescr->SetIsNullable( ColumnValue::NO_NULLS ); | |
| else | |
| pFieldDescr->SetIsNullable( ColumnValue::NULLABLE ); | |
| if ( pAutoIncrement ) | |
| pFieldDescr->SetAutoIncrement( pAutoIncrement->GetSelectEntryPos() == 0 ); | |
| if( pTextLen ) | |
| pFieldDescr->SetPrecision( static_cast<sal_Int32>(pTextLen->GetValue()) ); | |
| else if( pLength ) | |
| pFieldDescr->SetPrecision( static_cast<sal_Int32>(pLength->GetValue()) ); | |
| if( pScale ) | |
| pFieldDescr->SetScale( static_cast<sal_Int32>(pScale->GetValue()) ); | |
| if(m_pColumnName) | |
| pFieldDescr->SetName(m_pColumnName->GetText()); | |
| if ( m_pAutoIncrementValue && isAutoIncrementValueEnabled() ) | |
| pFieldDescr->SetAutoIncrementValue(m_pAutoIncrementValue->GetText()); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::UpdateFormatSample(OFieldDescription* pFieldDescr) | |
| { | |
| if ( pFieldDescr && pFormatSample ) | |
| pFormatSample->SetText(getControlDefault(pFieldDescr,sal_False)); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::GetFocus() | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Setzt den Focus auf das zuletzt aktive Control | |
| TabPage::GetFocus(); | |
| if( pLastFocusWindow ) | |
| { | |
| pLastFocusWindow->GrabFocus(); | |
| pLastFocusWindow = NULL; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::implFocusLost(Window* _pWhich) | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| DBG_ASSERT(!_pWhich || IsChild(_pWhich), "OFieldDescControl::implFocusLost : invalid window !"); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Das aktive Control merken | |
| if (!pLastFocusWindow) | |
| pLastFocusWindow = _pWhich; | |
| ////////////////////////////////////////////////////////////////////// | |
| // HelpText zuruecksetzen | |
| if (pHelp && !pHelp->HasChildPathFocus()) | |
| pHelp->SetHelpText( String() ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OFieldDescControl::LoseFocus() | |
| { | |
| DBG_CHKTHIS(OFieldDescControl,NULL); | |
| implFocusLost(NULL); | |
| TabPage::LoseFocus(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OFieldDescControl::isCopyAllowed() | |
| { | |
| sal_Bool bAllowed = (m_pActFocusWindow != NULL) && | |
| (m_pActFocusWindow == pDefault || m_pActFocusWindow == pFormatSample || | |
| m_pActFocusWindow == pTextLen || m_pActFocusWindow == pLength || | |
| m_pActFocusWindow == pScale || m_pActFocusWindow == m_pColumnName || | |
| m_pActFocusWindow == m_pAutoIncrementValue) && | |
| static_cast<Edit*>(m_pActFocusWindow)->GetSelected().Len() != 0; | |
| return bAllowed; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OFieldDescControl::isCutAllowed() | |
| { | |
| sal_Bool bAllowed = (m_pActFocusWindow != NULL) && | |
| (m_pActFocusWindow == pDefault || m_pActFocusWindow == pFormatSample || | |
| m_pActFocusWindow == pTextLen || m_pActFocusWindow == pLength || | |
| m_pActFocusWindow == pScale || m_pActFocusWindow == m_pColumnName || | |
| m_pActFocusWindow == m_pAutoIncrementValue) && | |
| static_cast<Edit*>(m_pActFocusWindow)->GetSelected().Len() != 0; | |
| return bAllowed; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OFieldDescControl::isPasteAllowed() | |
| { | |
| sal_Bool bAllowed = (m_pActFocusWindow != NULL) && | |
| (m_pActFocusWindow == pDefault || m_pActFocusWindow == pFormatSample || | |
| m_pActFocusWindow == pTextLen || m_pActFocusWindow == pLength || | |
| m_pActFocusWindow == pScale || m_pActFocusWindow == m_pColumnName || | |
| m_pActFocusWindow == m_pAutoIncrementValue); | |
| if ( bAllowed ) | |
| { | |
| TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent())); | |
| bAllowed = aTransferData.HasFormat(SOT_FORMAT_STRING); | |
| } | |
| return bAllowed; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OFieldDescControl::cut() | |
| { | |
| if(isCutAllowed()) | |
| static_cast<Edit*>(m_pActFocusWindow)->Cut(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OFieldDescControl::copy() | |
| { | |
| if(isCopyAllowed()) // this only checks if the focus window is valid | |
| static_cast<Edit*>(m_pActFocusWindow)->Copy(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OFieldDescControl::paste() | |
| { | |
| if(m_pActFocusWindow) // this only checks if the focus window is valid | |
| static_cast<Edit*>(m_pActFocusWindow)->Paste(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OFieldDescControl::isTextFormat(const OFieldDescription* _pFieldDescr,sal_uInt32& _nFormatKey) const | |
| { | |
| _nFormatKey = _pFieldDescr->GetFormatKey(); | |
| sal_Bool bTextFormat = sal_True; | |
| try | |
| { | |
| if (!_nFormatKey) | |
| { | |
| Reference< ::com::sun::star::util::XNumberFormatTypes> xNumberTypes(GetFormatter()->getNumberFormatsSupplier()->getNumberFormats(),UNO_QUERY); | |
| OSL_ENSURE(xNumberTypes.is(),"XNumberFormatTypes is null!"); | |
| _nFormatKey = ::dbtools::getDefaultNumberFormat( _pFieldDescr->GetType(), | |
| _pFieldDescr->GetScale(), | |
| _pFieldDescr->IsCurrency(), | |
| xNumberTypes, | |
| GetLocale()); | |
| } | |
| sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(GetFormatter(),_nFormatKey); | |
| bTextFormat = (nNumberFormat == ::com::sun::star::util::NumberFormat::TEXT); | |
| } | |
| catch(const Exception&) | |
| { | |
| } | |
| return bTextFormat; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| String OFieldDescControl::getControlDefault( const OFieldDescription* _pFieldDescr ,sal_Bool _bCheck) const | |
| { | |
| ::rtl::OUString sDefault; | |
| sal_Bool bCheck = !_bCheck || _pFieldDescr->GetControlDefault().hasValue(); | |
| if ( bCheck ) | |
| { | |
| sal_uInt32 nFormatKey; | |
| sal_Bool bTextFormat = sal_False; | |
| double nValue = 0.0; | |
| try | |
| { | |
| bTextFormat = isTextFormat(_pFieldDescr,nFormatKey); | |
| if ( _pFieldDescr->GetControlDefault() >>= sDefault ) | |
| { | |
| if ( !bTextFormat ) | |
| { | |
| if ( sDefault.getLength() ) | |
| { | |
| try | |
| { | |
| nValue = GetFormatter()->convertStringToNumber(nFormatKey,sDefault); | |
| } | |
| catch(const Exception&) | |
| { | |
| return ::rtl::OUString(); // return empty string for format example | |
| } | |
| } | |
| } | |
| } | |
| else | |
| _pFieldDescr->GetControlDefault() >>= nValue; | |
| Reference< ::com::sun::star::util::XNumberFormatter> xNumberFormatter = GetFormatter(); | |
| Reference<XPropertySet> xFormSet = xNumberFormatter->getNumberFormatsSupplier()->getNumberFormats()->getByKey(nFormatKey); | |
| OSL_ENSURE(xFormSet.is(),"XPropertySet is null!"); | |
| ::rtl::OUString sFormat; | |
| xFormSet->getPropertyValue(::rtl::OUString::createFromAscii("FormatString")) >>= sFormat; | |
| if ( !bTextFormat ) | |
| { | |
| Locale aLocale; | |
| ::comphelper::getNumberFormatProperty(xNumberFormatter,nFormatKey,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Locale"))) >>= aLocale; | |
| sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(xNumberFormatter,nFormatKey); | |
| if( (nNumberFormat & ::com::sun::star::util::NumberFormat::DATE) == ::com::sun::star::util::NumberFormat::DATE | |
| || (nNumberFormat & ::com::sun::star::util::NumberFormat::DATETIME) == ::com::sun::star::util::NumberFormat::DATETIME ) | |
| { | |
| nValue = DBTypeConversion::toNullDate(DBTypeConversion::getNULLDate(xNumberFormatter->getNumberFormatsSupplier()),nValue); | |
| } | |
| Reference< ::com::sun::star::util::XNumberFormatPreviewer> xPreViewer(xNumberFormatter,UNO_QUERY); | |
| OSL_ENSURE(xPreViewer.is(),"XNumberFormatPreviewer is null!"); | |
| sDefault = xPreViewer->convertNumberToPreviewString(sFormat,nValue,aLocale,sal_True); | |
| } | |
| else if ( !_bCheck || (sDefault.getLength() != 0) ) | |
| sDefault = xNumberFormatter->formatString(nFormatKey,(sDefault.getLength() != 0 )? sDefault : sFormat); | |
| } | |
| catch(const Exception&) | |
| { | |
| } | |
| } | |
| return sDefault; | |
| } | |
| // ----------------------------------------------------------------------------- |