| /************************************************************** |
| * |
| * 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_dbaccess.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; |
| } |
| // ----------------------------------------------------------------------------- |