| /************************************************************** |
| * |
| * 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_svx.hxx" |
| #include "fmvwimp.hxx" |
| #include <svx/fmshell.hxx> |
| #include "svx/fmtools.hxx" |
| #include "fmservs.hxx" |
| #ifndef _SVX_FMPROP_HRC |
| #include "fmprop.hrc" |
| #endif |
| #include "fmpgeimp.hxx" |
| #include "fmitems.hxx" |
| #include "fmundo.hxx" |
| #include <vcl/waitobj.hxx> |
| #include <com/sun/star/form/XLoadable.hpp> |
| #include <com/sun/star/container/XNamed.hpp> |
| #ifndef _COM_SUN_STAR_SDDB_PRIVILEGE_HPP_ |
| #include <com/sun/star/sdbcx/Privilege.hpp> |
| #endif |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/beans/XMultiPropertySet.hpp> |
| #include <com/sun/star/beans/XFastPropertySet.hpp> |
| #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/container/XNameContainer.hpp> |
| #include <com/sun/star/awt/XTabControllerModel.hpp> |
| #include <sfx2/viewfrm.hxx> |
| #include <vcl/wrkwin.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svl/whiter.hxx> |
| #include <sfx2/app.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/visitem.hxx> |
| #include <unotools/moduleoptions.hxx> |
| #include <sfx2/objface.hxx> |
| #include <sfx2/request.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/objsh.hxx> |
| #include <svx/svdobj.hxx> |
| #include <svx/fmpage.hxx> |
| #include "svx/svditer.hxx" |
| #include "fmobj.hxx" |
| |
| #ifndef _SVX_SVXIDS_HRC |
| #include <svx/svxids.hrc> |
| #endif |
| |
| #ifndef _SVX_FMRESIDS_HRC |
| #include "svx/fmresids.hrc" |
| #endif |
| #include "fmexch.hxx" |
| #include <svx/fmglob.hxx> |
| #include <svl/eitem.hxx> |
| #include <tools/shl.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <svx/svdpage.hxx> |
| #include <svx/fmmodel.hxx> |
| #include <svx/dialmgr.hxx> |
| #include "fmshimp.hxx" |
| #include <svx/svdpagv.hxx> |
| #include <sfx2/objitem.hxx> |
| #include <sfx2/viewsh.hxx> |
| #include <vcl/sound.hxx> |
| #include "fmexpl.hxx" |
| #include "formcontrolling.hxx" |
| #include <svl/numuno.hxx> |
| #include <connectivity/dbtools.hxx> |
| #include <comphelper/types.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include "fmdocumentclassification.hxx" |
| #include "formtoolbars.hxx" |
| |
| #include <svx/svxdlg.hxx> //CHINA001 |
| #include <svx/dialogs.hrc> //CHINA001 |
| |
| #include "svx/sdrobjectfilter.hxx" |
| |
| #define HANDLE_SQL_ERRORS( action, successflag, context, message ) \ |
| try \ |
| { \ |
| successflag = sal_False; \ |
| action; \ |
| successflag = sal_True; \ |
| } \ |
| catch(::com::sun::star::sdbc::SQLException& e) \ |
| { \ |
| ::com::sun::star::sdb::SQLContext eExtendedInfo = \ |
| GetImpl()->prependContextInfo(e, Reference< XInterface > (), context, ::rtl::OUString()); \ |
| displayException(eExtendedInfo); \ |
| } \ |
| catch(Exception&) \ |
| { \ |
| DBG_ERROR(message); \ |
| } \ |
| |
| |
| #define DO_SAFE_WITH_ERROR( action, message ) try { action; } catch(Exception&) { DBG_ERROR(message); } |
| |
| #define FmFormShell |
| #include "svxslots.hxx" |
| |
| #ifndef _SVX_SVXIDS_HRC |
| #include <svx/svxids.hrc> |
| #endif |
| #include "tbxform.hxx" |
| #include <comphelper/property.hxx> |
| #include <com/sun/star/beans/PropertyValue.hpp> |
| |
| // wird fuer Invalidate verwendet -> mitpflegen |
| // aufsteigend sortieren !!!!!! |
| sal_uInt16 ControllerSlotMap[] = // slots des Controllers |
| { |
| SID_FM_CONFIG, |
| SID_FM_PUSHBUTTON, |
| SID_FM_RADIOBUTTON, |
| SID_FM_CHECKBOX, |
| SID_FM_FIXEDTEXT, |
| SID_FM_GROUPBOX, |
| SID_FM_EDIT, |
| SID_FM_LISTBOX, |
| SID_FM_COMBOBOX, |
| SID_FM_DBGRID, |
| SID_FM_IMAGEBUTTON, |
| SID_FM_FILECONTROL, |
| SID_FM_NAVIGATIONBAR, |
| SID_FM_CTL_PROPERTIES, |
| SID_FM_PROPERTIES, |
| SID_FM_TAB_DIALOG, |
| SID_FM_ADD_FIELD, |
| SID_FM_DESIGN_MODE, |
| SID_FM_SHOW_FMEXPLORER, |
| SID_FM_SHOW_PROPERTIES, |
| SID_FM_FMEXPLORER_CONTROL, |
| SID_FM_DATEFIELD, |
| SID_FM_TIMEFIELD, |
| SID_FM_NUMERICFIELD, |
| SID_FM_CURRENCYFIELD, |
| SID_FM_PATTERNFIELD, |
| SID_FM_OPEN_READONLY, |
| SID_FM_IMAGECONTROL, |
| SID_FM_USE_WIZARDS, |
| SID_FM_FORMATTEDFIELD, |
| SID_FM_FILTER_NAVIGATOR, |
| SID_FM_AUTOCONTROLFOCUS, |
| SID_FM_SCROLLBAR, |
| SID_FM_SPINBUTTON, |
| SID_FM_SHOW_DATANAVIGATOR, |
| SID_FM_DATANAVIGATOR_CONTROL, |
| |
| 0 |
| }; |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::awt; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::sdbcx; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::form; |
| using namespace ::com::sun::star::form::runtime; |
| using namespace ::com::sun::star::frame; |
| using namespace ::svxform; |
| |
| //======================================================================== |
| // class FmDesignModeChangedHint |
| //======================================================================== |
| TYPEINIT1( FmDesignModeChangedHint, SfxHint ); |
| |
| //------------------------------------------------------------------------ |
| FmDesignModeChangedHint::FmDesignModeChangedHint( sal_Bool bDesMode ) |
| :m_bDesignMode( bDesMode ) |
| { |
| } |
| |
| //------------------------------------------------------------------------ |
| FmDesignModeChangedHint::~FmDesignModeChangedHint() |
| { |
| } |
| |
| //======================================================================== |
| const sal_uInt32 FM_UI_FEATURE_SHOW_DATABASEBAR = 0x00000001; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_FIELD = 0x00000002; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_PROPERTIES = 0x00000004; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_EXPLORER = 0x00000008; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_FILTERBAR = 0x00000010; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_FILTERNAVIGATOR = 0x00000020; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR = 0x00000040; |
| const sal_uInt32 FM_UI_FEATURE_TB_CONTROLS = 0x00000080; |
| const sal_uInt32 FM_UI_FEATURE_TB_MORECONTROLS = 0x00000100; |
| const sal_uInt32 FM_UI_FEATURE_TB_FORMDESIGN = 0x00000200; |
| const sal_uInt32 FM_UI_FEATURE_SHOW_DATANAVIGATOR = 0x00000400; |
| |
| SFX_IMPL_INTERFACE(FmFormShell, SfxShell, SVX_RES(RID_STR_FORMSHELL)) |
| { |
| SFX_FEATURED_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_NAVIGATION|SFX_VISIBILITY_STANDARD|SFX_VISIBILITY_READONLYDOC, |
| SVX_RES(RID_SVXTBX_FORM_NAVIGATION), |
| FM_UI_FEATURE_SHOW_DATABASEBAR ); |
| |
| SFX_FEATURED_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_NAVIGATION|SFX_VISIBILITY_STANDARD|SFX_VISIBILITY_READONLYDOC, |
| SVX_RES(RID_SVXTBX_FORM_FILTER), |
| FM_UI_FEATURE_SHOW_FILTERBAR ); |
| |
| SFX_FEATURED_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_READONLYDOC, |
| SVX_RES( RID_SVXTBX_TEXT_CONTROL_ATTRIBUTES ), |
| FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR ); |
| |
| SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_FM_ADD_FIELD, FM_UI_FEATURE_SHOW_FIELD); |
| SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_FM_SHOW_PROPERTIES, FM_UI_FEATURE_SHOW_PROPERTIES); |
| SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_FM_SHOW_FMEXPLORER, FM_UI_FEATURE_SHOW_EXPLORER); |
| SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_FM_FILTER_NAVIGATOR, FM_UI_FEATURE_SHOW_FILTERNAVIGATOR); |
| SFX_FEATURED_CHILDWINDOW_REGISTRATION(SID_FM_SHOW_DATANAVIGATOR, FM_UI_FEATURE_SHOW_DATANAVIGATOR); |
| |
| SFX_FEATURED_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD, |
| SVX_RES( RID_SVXTBX_CONTROLS ), |
| FM_UI_FEATURE_TB_CONTROLS ); |
| |
| SFX_FEATURED_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD, |
| SVX_RES( RID_SVXTBX_MORECONTROLS ), |
| FM_UI_FEATURE_TB_MORECONTROLS ); |
| |
| SFX_FEATURED_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD, |
| SVX_RES( RID_SVXTBX_FORMDESIGN ), |
| FM_UI_FEATURE_TB_FORMDESIGN ); |
| } |
| |
| //======================================================================== |
| TYPEINIT1(FmFormShell,SfxShell) |
| |
| //------------------------------------------------------------------------ |
| FmFormShell::FmFormShell( SfxViewShell* _pParent, FmFormView* pView ) |
| :SfxShell(_pParent) |
| ,m_pImpl(new FmXFormShell(*this, _pParent->GetViewFrame())) |
| ,m_pFormView( pView ) |
| ,m_pFormModel( NULL ) |
| ,m_pParentShell(_pParent) |
| ,m_nLastSlot( 0 ) |
| ,m_bDesignMode( sal_True ) |
| ,m_bHasForms(sal_False) |
| { |
| m_pImpl->acquire(); |
| SetPool( &SFX_APP()->GetPool() ); |
| SetName( String::CreateFromAscii( "Form" ) ); |
| |
| SetView(m_pFormView); |
| } |
| |
| //------------------------------------------------------------------------ |
| FmFormShell::~FmFormShell() |
| { |
| if ( m_pFormView ) |
| SetView( NULL ); |
| |
| m_pImpl->dispose(); |
| m_pImpl->release(); |
| m_pImpl = NULL; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::NotifyMarkListChanged(FmFormView* pWhichView) |
| { |
| FmNavViewMarksChanged aChangeNotification(pWhichView); |
| Broadcast(aChangeNotification); |
| } |
| |
| //------------------------------------------------------------------------ |
| sal_uInt16 FmFormShell::PrepareClose(sal_Bool bUI, sal_Bool /*bForBrowsing*/) |
| { |
| if ( GetImpl()->didPrepareClose() ) |
| // we already did a PrepareClose for the current modifications of the current form |
| // 2002-11-12 #104702# - fs@openoffice.org |
| return sal_True; |
| |
| sal_Bool bResult = sal_True; |
| // Save the data records, not in DesignMode and FilterMode |
| if (!m_bDesignMode && !GetImpl()->isInFilterMode() && |
| m_pFormView && m_pFormView->GetActualOutDev() && |
| m_pFormView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW) |
| { |
| SdrPageView* pCurPageView = m_pFormView->GetSdrPageView(); |
| |
| // sal_uInt16 nPos = pCurPageView ? pCurPageView->GetWinList().Find((OutputDevice*)m_pFormView->GetActualOutDev()) : SDRPAGEVIEWWIN_NOTFOUND; |
| SdrPageWindow* pWindow = pCurPageView ? pCurPageView->FindPageWindow(*((OutputDevice*)m_pFormView->GetActualOutDev())) : 0L; |
| |
| if(pWindow) |
| { |
| // Zunaechst werden die aktuellen Inhalte der Controls gespeichert |
| // Wenn alles glatt gelaufen ist, werden die modifizierten Datensaetze gespeichert |
| if ( GetImpl()->getActiveController().is() ) |
| { |
| const ::svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures(); |
| if ( rController->commitCurrentControl() ) |
| { |
| sal_Bool bModified = rController->isModifiedRow(); |
| |
| if ( bModified && bUI ) |
| { |
| QueryBox aQry(NULL, SVX_RES(RID_QRY_SAVEMODIFIED)); |
| switch (aQry.Execute()) |
| { |
| case RET_NO: |
| bModified = sal_False; |
| GetImpl()->didPrepareClose( sal_True ); |
| break; |
| |
| case RET_CANCEL: |
| return sal_False; |
| |
| case RET_NEWTASK: |
| return RET_NEWTASK; |
| } |
| |
| if ( bModified ) |
| bResult = rController->commitCurrentRecord( ); |
| } |
| } |
| } |
| } |
| } |
| return bResult; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::impl_setDesignMode(sal_Bool bDesign) |
| { |
| if (m_pFormView) |
| { |
| if (!bDesign) |
| m_nLastSlot = SID_FM_DESIGN_MODE; |
| |
| GetImpl()->SetDesignMode(bDesign); |
| // mein m_bDesignMode wird auch von der Impl gesetzt ... |
| } |
| else |
| { |
| m_bHasForms = sal_False; |
| m_bDesignMode = bDesign; |
| UIFeatureChanged(); |
| } |
| |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate(ControllerSlotMap); |
| } |
| |
| //------------------------------------------------------------------------ |
| sal_Bool FmFormShell::HasUIFeature( sal_uInt32 nFeature ) |
| { |
| sal_Bool bResult = sal_False; |
| if ((nFeature & FM_UI_FEATURE_SHOW_DATABASEBAR) == FM_UI_FEATURE_SHOW_DATABASEBAR) |
| { |
| // nur wenn auch formulare verfuegbar |
| bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar() && !GetImpl()->isInFilterMode(); |
| } |
| else if ((nFeature & FM_UI_FEATURE_SHOW_FILTERBAR) == FM_UI_FEATURE_SHOW_FILTERBAR) |
| { |
| // nur wenn auch formulare verfuegbar |
| bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar() && GetImpl()->isInFilterMode(); |
| } |
| else if ((nFeature & FM_UI_FEATURE_SHOW_FILTERNAVIGATOR) == FM_UI_FEATURE_SHOW_FILTERNAVIGATOR) |
| { |
| bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar() && GetImpl()->isInFilterMode(); |
| } |
| else if ((nFeature & FM_UI_FEATURE_SHOW_FIELD) == FM_UI_FEATURE_SHOW_FIELD) |
| { |
| bResult = m_bDesignMode && m_pFormView && m_bHasForms; |
| } |
| else if ((nFeature & FM_UI_FEATURE_SHOW_PROPERTIES) == FM_UI_FEATURE_SHOW_PROPERTIES) |
| { |
| bResult = m_bDesignMode && m_pFormView && m_bHasForms; |
| } |
| else if ((nFeature & FM_UI_FEATURE_SHOW_EXPLORER) == FM_UI_FEATURE_SHOW_EXPLORER) |
| { |
| bResult = m_bDesignMode; // OJ #101593# && m_pFormView && m_bHasForms; |
| } |
| else if ( ( nFeature & FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR ) == FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR ) |
| { |
| bResult = !GetImpl()->IsReadonlyDoc() && m_pImpl->IsActiveControl( true ); |
| } |
| else if ((nFeature & FM_UI_FEATURE_SHOW_DATANAVIGATOR) == FM_UI_FEATURE_SHOW_DATANAVIGATOR) |
| { |
| bResult = GetImpl()->isEnhancedForm(); |
| } |
| else if ( ( ( nFeature & FM_UI_FEATURE_TB_CONTROLS ) == FM_UI_FEATURE_TB_CONTROLS ) |
| || ( ( nFeature & FM_UI_FEATURE_TB_MORECONTROLS ) == FM_UI_FEATURE_TB_MORECONTROLS ) |
| || ( ( nFeature & FM_UI_FEATURE_TB_FORMDESIGN ) == FM_UI_FEATURE_TB_FORMDESIGN ) |
| ) |
| { |
| bResult = sal_True; |
| } |
| |
| return bResult; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::Execute(SfxRequest &rReq) |
| { |
| sal_uInt16 nSlot = rReq.GetSlot(); |
| |
| ////////////////////////////////////////////////////////////////////// |
| // MasterSlot setzen |
| switch( nSlot ) |
| { |
| case SID_FM_PUSHBUTTON: |
| case SID_FM_RADIOBUTTON: |
| case SID_FM_CHECKBOX: |
| case SID_FM_FIXEDTEXT: |
| case SID_FM_GROUPBOX: |
| case SID_FM_LISTBOX: |
| case SID_FM_COMBOBOX: |
| case SID_FM_NAVIGATIONBAR: |
| case SID_FM_EDIT: |
| case SID_FM_DBGRID: |
| case SID_FM_IMAGEBUTTON: |
| case SID_FM_IMAGECONTROL: |
| case SID_FM_FILECONTROL: |
| case SID_FM_DATEFIELD: |
| case SID_FM_TIMEFIELD: |
| case SID_FM_NUMERICFIELD: |
| case SID_FM_CURRENCYFIELD: |
| case SID_FM_PATTERNFIELD: |
| case SID_FM_FORMATTEDFIELD: |
| case SID_FM_SCROLLBAR: |
| case SID_FM_SPINBUTTON: |
| m_nLastSlot = nSlot; |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_FM_CONFIG ); |
| break; |
| } |
| |
| ////////////////////////////////////////////////////////////////////// |
| // Identifier und Inventor des Uno-Controls setzen |
| sal_uInt16 nIdentifier = 0; |
| switch( nSlot ) |
| { |
| case SID_FM_CHECKBOX: |
| nIdentifier = OBJ_FM_CHECKBOX; |
| break; |
| case SID_FM_PUSHBUTTON: |
| nIdentifier = OBJ_FM_BUTTON; |
| break; |
| case SID_FM_FIXEDTEXT: |
| nIdentifier = OBJ_FM_FIXEDTEXT; |
| break; |
| case SID_FM_LISTBOX: |
| nIdentifier = OBJ_FM_LISTBOX; |
| break; |
| case SID_FM_EDIT: |
| nIdentifier = OBJ_FM_EDIT; |
| break; |
| case SID_FM_RADIOBUTTON: |
| nIdentifier = OBJ_FM_RADIOBUTTON; |
| break; |
| case SID_FM_GROUPBOX: |
| nIdentifier = OBJ_FM_GROUPBOX; |
| break; |
| case SID_FM_COMBOBOX: |
| nIdentifier = OBJ_FM_COMBOBOX; |
| break; |
| case SID_FM_NAVIGATIONBAR: |
| nIdentifier = OBJ_FM_NAVIGATIONBAR; |
| break; |
| case SID_FM_DBGRID: |
| nIdentifier = OBJ_FM_GRID; |
| break; |
| case SID_FM_IMAGEBUTTON: |
| nIdentifier = OBJ_FM_IMAGEBUTTON; |
| break; |
| case SID_FM_IMAGECONTROL: |
| nIdentifier = OBJ_FM_IMAGECONTROL; |
| break; |
| case SID_FM_FILECONTROL: |
| nIdentifier = OBJ_FM_FILECONTROL; |
| break; |
| case SID_FM_DATEFIELD: |
| nIdentifier = OBJ_FM_DATEFIELD; |
| break; |
| case SID_FM_TIMEFIELD: |
| nIdentifier = OBJ_FM_TIMEFIELD; |
| break; |
| case SID_FM_NUMERICFIELD: |
| nIdentifier = OBJ_FM_NUMERICFIELD; |
| break; |
| case SID_FM_CURRENCYFIELD: |
| nIdentifier = OBJ_FM_CURRENCYFIELD; |
| break; |
| case SID_FM_PATTERNFIELD: |
| nIdentifier = OBJ_FM_PATTERNFIELD; |
| break; |
| case SID_FM_FORMATTEDFIELD: |
| nIdentifier = OBJ_FM_FORMATTEDFIELD; |
| break; |
| case SID_FM_SCROLLBAR: |
| nIdentifier = OBJ_FM_SCROLLBAR; |
| break; |
| case SID_FM_SPINBUTTON: |
| nIdentifier = OBJ_FM_SPINBUTTON; |
| break; |
| } |
| |
| switch ( nSlot ) |
| { |
| case SID_FM_CHECKBOX: |
| case SID_FM_PUSHBUTTON: |
| case SID_FM_FIXEDTEXT: |
| case SID_FM_LISTBOX: |
| case SID_FM_EDIT: |
| case SID_FM_RADIOBUTTON: |
| case SID_FM_COMBOBOX: |
| case SID_FM_NAVIGATIONBAR: |
| case SID_FM_GROUPBOX: |
| case SID_FM_DBGRID: |
| case SID_FM_IMAGEBUTTON: |
| case SID_FM_IMAGECONTROL: |
| case SID_FM_FILECONTROL: |
| case SID_FM_DATEFIELD: |
| case SID_FM_TIMEFIELD: |
| case SID_FM_NUMERICFIELD: |
| case SID_FM_CURRENCYFIELD: |
| case SID_FM_PATTERNFIELD: |
| case SID_FM_FORMATTEDFIELD: |
| case SID_FM_SCROLLBAR: |
| case SID_FM_SPINBUTTON: |
| { |
| SFX_REQUEST_ARG( rReq, pGrabFocusItem, SfxBoolItem, SID_FM_TOGGLECONTROLFOCUS, sal_False ); |
| if ( pGrabFocusItem && pGrabFocusItem->GetValue() ) |
| { // see below |
| SfxViewShell* pShell = GetViewShell(); |
| Window* pShellWnd = pShell ? pShell->GetWindow() : NULL; |
| if ( pShellWnd ) |
| pShellWnd->GrabFocus(); |
| break; |
| } |
| |
| SfxUInt16Item aIdentifierItem( SID_FM_CONTROL_IDENTIFIER, nIdentifier ); |
| SfxUInt32Item aInventorItem( SID_FM_CONTROL_INVENTOR, FmFormInventor ); |
| const SfxPoolItem* pArgs[] = |
| { |
| &aIdentifierItem, &aInventorItem, NULL |
| }; |
| const SfxPoolItem* pInternalArgs[] = |
| { |
| NULL |
| }; |
| |
| GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_CREATE_CONTROL, SFX_CALLMODE_ASYNCHRON, |
| pArgs, rReq.GetModifier(), pInternalArgs ); |
| |
| if ( rReq.GetModifier() & KEY_MOD1 ) |
| { |
| // #99013# if selected with control key, return focus to current view |
| // do this asynchron, so that the creation can be finished first |
| // reusing the SID_FM_TOGGLECONTROLFOCUS is somewhat hacky ... which it wouldn't if it would have another |
| // name, so I do not really have a big problem with this .... |
| SfxBoolItem aGrabFocusIndicatorItem( SID_FM_TOGGLECONTROLFOCUS, sal_True ); |
| GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( nSlot, SFX_CALLMODE_ASYNCHRON, |
| &aGrabFocusIndicatorItem, NULL ); |
| } |
| |
| rReq.Done(); |
| } break; |
| } |
| |
| // Individuelle Aktionen |
| switch( nSlot ) |
| { |
| case SID_FM_MORE_CONTROLS: |
| case SID_FM_FORM_DESIGN_TOOLS: |
| { |
| FormToolboxes aToolboxAccess( GetImpl()->getHostFrame() ); |
| aToolboxAccess.toggleToolbox( nSlot ); |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_FM_TOGGLECONTROLFOCUS: |
| { |
| FmFormView* pFormView = GetFormView(); |
| if ( !pFormView ) |
| break; |
| |
| // if we execute this ourself, then either the application does not implement an own handling for this, |
| // of we're on the top of the dispatcher stack, which means a control has the focus. |
| // In the latter case, we put the focus to the document window, otherwise, we focus the first control |
| const bool bHasControlFocus = GetImpl()->HasControlFocus(); |
| if ( bHasControlFocus ) |
| { |
| const OutputDevice* pDevice = GetCurrentViewDevice(); |
| Window* pWindow = dynamic_cast< Window* >( const_cast< OutputDevice* >( pDevice ) ); |
| if ( pWindow ) |
| pWindow->GrabFocus(); |
| } |
| else |
| { |
| pFormView->GrabFirstControlFocus( ); |
| } |
| } |
| break; |
| |
| case SID_FM_VIEW_AS_GRID: |
| GetImpl()->CreateExternalView(); |
| break; |
| case SID_FM_CONVERTTO_EDIT : |
| case SID_FM_CONVERTTO_BUTTON : |
| case SID_FM_CONVERTTO_FIXEDTEXT : |
| case SID_FM_CONVERTTO_LISTBOX : |
| case SID_FM_CONVERTTO_CHECKBOX : |
| case SID_FM_CONVERTTO_RADIOBUTTON : |
| case SID_FM_CONVERTTO_GROUPBOX : |
| case SID_FM_CONVERTTO_COMBOBOX : |
| case SID_FM_CONVERTTO_IMAGEBUTTON : |
| case SID_FM_CONVERTTO_FILECONTROL : |
| case SID_FM_CONVERTTO_DATE : |
| case SID_FM_CONVERTTO_TIME : |
| case SID_FM_CONVERTTO_NUMERIC : |
| case SID_FM_CONVERTTO_CURRENCY : |
| case SID_FM_CONVERTTO_PATTERN : |
| case SID_FM_CONVERTTO_IMAGECONTROL : |
| case SID_FM_CONVERTTO_FORMATTED : |
| case SID_FM_CONVERTTO_SCROLLBAR : |
| case SID_FM_CONVERTTO_SPINBUTTON : |
| case SID_FM_CONVERTTO_NAVIGATIONBAR : |
| GetImpl()->executeControlConversionSlot( nSlot ); |
| // nach dem Konvertieren die Selektion neu bestimmern, da sich ja das selektierte Objekt |
| // geaendert hat |
| GetImpl()->SetSelection(GetFormView()->GetMarkedObjectList()); |
| break; |
| case SID_FM_LEAVE_CREATE: |
| m_nLastSlot = 0; |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_FM_CONFIG ); |
| rReq.Done(); |
| break; |
| case SID_FM_SHOW_PROPERTY_BROWSER: |
| { |
| SFX_REQUEST_ARG( rReq, pShowItem, SfxBoolItem, SID_FM_SHOW_PROPERTIES, sal_False ); |
| sal_Bool bShow = sal_True; |
| if ( pShowItem ) |
| bShow = pShowItem->GetValue(); |
| GetImpl()->ShowSelectionProperties( bShow ); |
| |
| rReq.Done(); |
| } break; |
| |
| case SID_FM_PROPERTIES: |
| { |
| // PropertyBrowser anzeigen |
| SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, nSlot, sal_False); |
| sal_Bool bShow = pShowItem ? pShowItem->GetValue() : sal_True; |
| |
| InterfaceBag aOnlyTheForm; |
| aOnlyTheForm.insert( Reference< XInterface >( GetImpl()->getCurrentForm(), UNO_QUERY ) ); |
| GetImpl()->setCurrentSelection( aOnlyTheForm ); |
| |
| GetImpl()->ShowSelectionProperties( bShow ); |
| |
| rReq.Done(); |
| } break; |
| |
| case SID_FM_CTL_PROPERTIES: |
| { |
| SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, nSlot, sal_False); |
| sal_Bool bShow = pShowItem ? pShowItem->GetValue() : sal_True; |
| |
| OSL_ENSURE( GetImpl()->onlyControlsAreMarked(), "FmFormShell::Execute: ControlProperties should be disabled!" ); |
| if ( bShow ) |
| GetImpl()->selectLastMarkedControls(); |
| GetImpl()->ShowSelectionProperties( bShow ); |
| |
| rReq.Done(); |
| } break; |
| case SID_FM_SHOW_PROPERTIES: |
| case SID_FM_ADD_FIELD: |
| case SID_FM_FILTER_NAVIGATOR: |
| case SID_FM_SHOW_DATANAVIGATOR : |
| { |
| GetViewShell()->GetViewFrame()->ChildWindowExecute( rReq ); |
| rReq.Done(); |
| } break; |
| case SID_FM_SHOW_FMEXPLORER: |
| { |
| if (!m_pFormView) // setzen der ::com::sun::star::sdbcx::View Forcieren |
| GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_CREATE_SW_DRAWVIEW); |
| |
| GetViewShell()->GetViewFrame()->ChildWindowExecute(rReq); |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_FM_TAB_DIALOG: |
| { |
| GetImpl()->ExecuteTabOrderDialog( Reference< XTabControllerModel >( GetImpl()->getCurrentForm(), UNO_QUERY ) ); |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_FM_DESIGN_MODE: |
| { |
| SFX_REQUEST_ARG(rReq, pDesignItem, SfxBoolItem, nSlot, sal_False); |
| sal_Bool bDesignMode = pDesignItem ? pDesignItem->GetValue() : !m_bDesignMode; |
| SetDesignMode( bDesignMode ); |
| if ( m_bDesignMode == bDesignMode ) |
| rReq.Done(); |
| |
| m_nLastSlot = SID_FM_DESIGN_MODE; |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_FM_CONFIG ); |
| } |
| break; |
| |
| case SID_FM_AUTOCONTROLFOCUS: |
| { |
| FmFormModel* pModel = GetFormModel(); |
| DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !"); |
| // should have been disabled in GetState if we don't have a FormModel |
| pModel->SetAutoControlFocus( !pModel->GetAutoControlFocus() ); |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS); |
| } |
| break; |
| case SID_FM_OPEN_READONLY: |
| { |
| FmFormModel* pModel = GetFormModel(); |
| DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !"); |
| // should have been disabled in GetState if we don't have a FormModel |
| pModel->SetOpenInDesignMode( !pModel->GetOpenInDesignMode() ); |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_OPEN_READONLY); |
| } |
| break; |
| case SID_FM_USE_WIZARDS: |
| { |
| GetImpl()->SetWizardUsing(!GetImpl()->GetWizardUsing()); |
| GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_USE_WIZARDS); |
| } |
| break; |
| case SID_FM_SEARCH: |
| { |
| const ::svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures(); |
| if ( rController->commitCurrentControl() && rController->commitCurrentRecord() ) |
| GetImpl()->ExecuteSearch(); |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_FM_RECORD_FIRST: |
| case SID_FM_RECORD_PREV: |
| case SID_FM_RECORD_NEXT: |
| case SID_FM_RECORD_LAST: |
| case SID_FM_RECORD_NEW: |
| case SID_FM_REFRESH: |
| case SID_FM_REFRESH_FORM_CONTROL: |
| case SID_FM_RECORD_DELETE: |
| case SID_FM_RECORD_UNDO: |
| case SID_FM_RECORD_SAVE: |
| case SID_FM_REMOVE_FILTER_SORT: |
| case SID_FM_SORTDOWN: |
| case SID_FM_SORTUP: |
| case SID_FM_AUTOFILTER: |
| case SID_FM_ORDERCRIT: |
| case SID_FM_FORM_FILTERED: |
| { |
| GetImpl()->ExecuteFormSlot( nSlot ); |
| rReq.Done(); |
| } |
| break; |
| |
| case SID_FM_RECORD_ABSOLUTE: |
| { |
| const ::svx::ControllerFeatures& rController = GetImpl()->getNavControllerFeatures(); |
| sal_Int32 nRecord = -1; |
| |
| const SfxItemSet* pArgs = rReq.GetArgs(); |
| if ( pArgs ) |
| { |
| const SfxPoolItem* pItem; |
| if ( ( pArgs->GetItemState( FN_PARAM_1, sal_True, &pItem ) ) == SFX_ITEM_SET ) |
| { |
| const SfxInt32Item* pTypedItem = PTR_CAST( SfxInt32Item, pItem ); |
| if ( pTypedItem ) |
| nRecord = Max( pTypedItem->GetValue(), sal_Int32(0) ); |
| } |
| } |
| else |
| { |
| SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); |
| DBG_ASSERT( pFact, "no dialog factory!" ); |
| if ( pFact ) |
| { |
| ::std::auto_ptr< AbstractFmInputRecordNoDialog > dlg( pFact->CreateFmInputRecordNoDialog( NULL ) ); |
| DBG_ASSERT( dlg.get(), "Dialogdiet fail!" ); |
| dlg->SetValue( rController->getCursor()->getRow() ); |
| if ( dlg->Execute() == RET_OK ) |
| nRecord = dlg->GetValue(); |
| |
| rReq.AppendItem( SfxInt32Item( FN_PARAM_1, nRecord ) ); |
| } |
| } |
| |
| if ( nRecord != -1 ) |
| rController->execute( nSlot, ::rtl::OUString::createFromAscii( "Position" ), makeAny( (sal_Int32)nRecord ) ); |
| |
| rReq.Done(); |
| } break; |
| case SID_FM_FILTER_EXECUTE: |
| case SID_FM_FILTER_EXIT: |
| { |
| sal_Bool bCancelled = ( SID_FM_FILTER_EXIT == nSlot ); |
| sal_Bool bReopenNavigator = sal_False; |
| |
| if ( !bCancelled ) |
| { |
| // if the filter navigator is still open, we need to close it, so it can possibly |
| // commit it's most recent changes |
| if ( GetViewShell() && GetViewShell()->GetViewFrame() ) |
| if ( GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR ) ) |
| { |
| GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR ); |
| bReopenNavigator = sal_True; |
| } |
| |
| Reference< runtime::XFormController > xController( GetImpl()->getActiveController() ); |
| |
| if ( GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR ) |
| // closing the window was denied, for instance because of a invalid criterion |
| |
| || ( xController.is() |
| && !GetImpl()->getActiveControllerFeatures()->commitCurrentControl( ) |
| ) |
| // committing the controller was denied |
| ) |
| { |
| rReq.Done(); |
| break; |
| } |
| } |
| |
| GetImpl()->stopFiltering( !bCancelled ); |
| rReq.Done(); |
| |
| if ( bReopenNavigator ) |
| // we closed the navigator only to implicitly commit it (as we do not have another |
| // direct wire to it), but to the user, it should look it it was always open |
| GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR ); |
| } |
| break; |
| |
| case SID_FM_FILTER_START: |
| { |
| GetImpl()->startFiltering(); |
| rReq.Done(); |
| |
| // initially open the filter navigator, the whole form based filter is pretty useless without it |
| SfxBoolItem aIdentifierItem( SID_FM_FILTER_NAVIGATOR, sal_True ); |
| GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_FILTER_NAVIGATOR, SFX_CALLMODE_ASYNCHRON, |
| &aIdentifierItem, NULL ); |
| } break; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::GetState(SfxItemSet &rSet) |
| { |
| SfxWhichIter aIter( rSet ); |
| sal_uInt16 nWhich = aIter.FirstWhich(); |
| while ( nWhich ) |
| { |
| switch( nWhich ) |
| { |
| case SID_FM_MORE_CONTROLS: |
| case SID_FM_FORM_DESIGN_TOOLS: |
| { |
| FormToolboxes aToolboxAccess( GetImpl()->getHostFrame() ); |
| rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible( nWhich ) ) ); |
| } |
| break; |
| |
| case SID_FM_FILTER_EXECUTE: |
| case SID_FM_FILTER_EXIT: |
| if (!GetImpl()->isInFilterMode()) |
| rSet.DisableItem( nWhich ); |
| break; |
| |
| case SID_FM_USE_WIZARDS: |
| if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) ) |
| rSet.Put( SfxVisibilityItem( nWhich, sal_False ) ); |
| else if (!GetFormModel()) |
| rSet.DisableItem( nWhich ); |
| else |
| rSet.Put( SfxBoolItem(nWhich, GetImpl()->GetWizardUsing() ) ); |
| break; |
| case SID_FM_AUTOCONTROLFOCUS: |
| if (!GetFormModel()) |
| rSet.DisableItem( nWhich ); |
| else |
| rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetAutoControlFocus() ) ); |
| break; |
| case SID_FM_OPEN_READONLY: |
| if (!GetFormModel()) |
| rSet.DisableItem( nWhich ); |
| else |
| rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetOpenInDesignMode() ) ); |
| break; |
| |
| case SID_FM_NAVIGATIONBAR: |
| case SID_FM_DBGRID: |
| if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) ) |
| { |
| rSet.Put( SfxVisibilityItem( nWhich, sal_False ) ); |
| break; |
| } |
| // NO break! |
| |
| case SID_FM_SCROLLBAR: |
| case SID_FM_IMAGECONTROL: |
| case SID_FM_FILECONTROL: |
| case SID_FM_CURRENCYFIELD: |
| case SID_FM_PATTERNFIELD: |
| case SID_FM_IMAGEBUTTON: |
| case SID_FM_RADIOBUTTON: |
| case SID_FM_COMBOBOX: |
| case SID_FM_GROUPBOX: |
| case SID_FM_CHECKBOX: |
| case SID_FM_PUSHBUTTON: |
| case SID_FM_FIXEDTEXT: |
| case SID_FM_LISTBOX: |
| case SID_FM_EDIT: |
| case SID_FM_DATEFIELD: |
| case SID_FM_TIMEFIELD: |
| case SID_FM_NUMERICFIELD: |
| case SID_FM_FORMATTEDFIELD: |
| case SID_FM_SPINBUTTON: |
| if (!m_bDesignMode) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| sal_Bool bLayerLocked = sal_False; |
| if (m_pFormView) |
| { |
| // Ist der ::com::sun::star::drawing::Layer gelocked, so m???ssen die Slots disabled werden. #36897 |
| SdrPageView* pPV = m_pFormView->GetSdrPageView(); |
| if (pPV != NULL) |
| bLayerLocked = pPV->IsLayerLocked(m_pFormView->GetActiveLayer()); |
| } |
| if (bLayerLocked) |
| rSet.DisableItem( nWhich ); |
| else |
| rSet.Put( SfxBoolItem(nWhich, (nWhich==m_nLastSlot)) ); |
| } |
| break; |
| case SID_FM_FILTER_NAVIGATOR_CONTROL: |
| { |
| if (GetImpl()->isInFilterMode()) |
| rSet.Put(SfxObjectItem(nWhich, this)); |
| else |
| rSet.Put(SfxObjectItem(nWhich)); |
| } break; |
| case SID_FM_FIELDS_CONTROL: |
| case SID_FM_PROPERTY_CONTROL: |
| { |
| if (!m_bDesignMode || !m_pFormView || !m_bHasForms) |
| rSet.Put(SfxObjectItem(nWhich)); |
| else |
| rSet.Put(SfxObjectItem(nWhich, this)); |
| |
| } break; |
| case SID_FM_FMEXPLORER_CONTROL: |
| case SID_FM_DATANAVIGATOR_CONTROL : |
| { |
| if (!m_bDesignMode || !m_pFormView) |
| rSet.Put(SfxObjectItem(nWhich)); |
| else |
| rSet.Put(SfxObjectItem(nWhich, this)); |
| |
| } break; |
| case SID_FM_ADD_FIELD: |
| case SID_FM_SHOW_FMEXPLORER: |
| case SID_FM_SHOW_PROPERTIES: |
| case SID_FM_FILTER_NAVIGATOR: |
| case SID_FM_SHOW_DATANAVIGATOR: |
| { |
| if ( GetViewShell()->GetViewFrame()->KnowsChildWindow(nWhich) ) |
| rSet.Put( SfxBoolItem( nWhich, GetViewShell()->GetViewFrame()->HasChildWindow(nWhich)) ); |
| else |
| rSet.DisableItem(nWhich); |
| } break; |
| |
| case SID_FM_SHOW_PROPERTY_BROWSER: |
| { |
| rSet.Put(SfxBoolItem(GetImpl()->IsPropBrwOpen())); |
| } |
| break; |
| |
| case SID_FM_CTL_PROPERTIES: |
| { |
| // der Impl eventuell die Moeglichjkeit geben, ihre an der aktuellen MarkList ausgerichteten Objekte |
| // auf den neuesten Stand zu bringen |
| if (GetImpl()->IsSelectionUpdatePending()) |
| GetImpl()->ForceUpdateSelection(sal_False); |
| |
| if ( !m_pFormView || !m_bDesignMode || !GetImpl()->onlyControlsAreMarked() ) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| sal_Bool bChecked = GetImpl()->IsPropBrwOpen() && !GetImpl()->isSolelySelected( GetImpl()->getCurrentForm() ); |
| // if the property browser is open, and only controls are marked, and the current selection |
| // does not consist of only the current form, then the current selection is the (composition of) |
| // the currently marked controls |
| rSet.Put( SfxBoolItem( nWhich, bChecked ) ); |
| } |
| } break; |
| |
| case SID_FM_PROPERTIES: |
| { |
| // der Impl eventuell die Moeglichjkeit geben, ihre an der aktuellen MarkList ausgerichteten Objekte |
| // auf den neuesten Stand zu bringen |
| if (GetImpl()->IsSelectionUpdatePending()) |
| GetImpl()->ForceUpdateSelection(sal_False); |
| |
| if ( !m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm().is() ) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| sal_Bool bChecked = GetImpl()->IsPropBrwOpen() && GetImpl()->isSolelySelected( GetImpl()->getCurrentForm() ); |
| rSet.Put(SfxBoolItem(nWhich, bChecked)); |
| } |
| } break; |
| case SID_FM_TAB_DIALOG: |
| // der Impl eventuell die Moeglichjkeit geben, ihre an der aktuellen MarkList ausgerichteten Objekte |
| // auf den neuesten Stand zu bringen |
| if (GetImpl()->IsSelectionUpdatePending()) |
| GetImpl()->ForceUpdateSelection(sal_False); |
| |
| if (!m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm().is() ) |
| rSet.DisableItem( nWhich ); |
| break; |
| case SID_FM_CONFIG: |
| rSet.Put(SfxUInt16Item(nWhich, m_nLastSlot)); |
| break; |
| case SID_FM_DESIGN_MODE: |
| if (!m_pFormView || GetImpl()->IsReadonlyDoc() ) |
| rSet.DisableItem( nWhich ); |
| else |
| rSet.Put( SfxBoolItem(nWhich, m_bDesignMode) ); |
| break; |
| case SID_FM_SEARCH: |
| case SID_FM_RECORD_FIRST: |
| case SID_FM_RECORD_NEXT: |
| case SID_FM_RECORD_PREV: |
| case SID_FM_RECORD_LAST: |
| case SID_FM_RECORD_NEW: |
| case SID_FM_RECORD_DELETE: |
| case SID_FM_RECORD_ABSOLUTE: |
| case SID_FM_RECORD_TOTAL: |
| case SID_FM_RECORD_SAVE: |
| case SID_FM_RECORD_UNDO: |
| case SID_FM_FORM_FILTERED: |
| case SID_FM_REMOVE_FILTER_SORT: |
| case SID_FM_SORTUP: |
| case SID_FM_SORTDOWN: |
| case SID_FM_ORDERCRIT: |
| case SID_FM_FILTER_START: |
| case SID_FM_AUTOFILTER: |
| case SID_FM_REFRESH: |
| case SID_FM_REFRESH_FORM_CONTROL: |
| case SID_FM_VIEW_AS_GRID: |
| GetFormState(rSet,nWhich); |
| break; |
| |
| case SID_FM_CHANGECONTROLTYPE: |
| { |
| if ( !m_pFormView || !m_bDesignMode ) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| if ( !GetImpl()->canConvertCurrentSelectionToControl( OBJ_FM_FIXEDTEXT ) ) |
| // if it cannot be converted to a fixed text, it is no single control |
| rSet.DisableItem( nWhich ); |
| } |
| } break; |
| |
| case SID_FM_CONVERTTO_FILECONTROL : |
| case SID_FM_CONVERTTO_CURRENCY : |
| case SID_FM_CONVERTTO_PATTERN : |
| case SID_FM_CONVERTTO_IMAGECONTROL : |
| case SID_FM_CONVERTTO_SCROLLBAR : |
| case SID_FM_CONVERTTO_NAVIGATIONBAR : |
| case SID_FM_CONVERTTO_IMAGEBUTTON : |
| case SID_FM_CONVERTTO_EDIT : |
| case SID_FM_CONVERTTO_BUTTON : |
| case SID_FM_CONVERTTO_FIXEDTEXT : |
| case SID_FM_CONVERTTO_LISTBOX : |
| case SID_FM_CONVERTTO_CHECKBOX : |
| case SID_FM_CONVERTTO_RADIOBUTTON : |
| case SID_FM_CONVERTTO_GROUPBOX : |
| case SID_FM_CONVERTTO_COMBOBOX : |
| case SID_FM_CONVERTTO_DATE : |
| case SID_FM_CONVERTTO_TIME : |
| case SID_FM_CONVERTTO_NUMERIC : |
| case SID_FM_CONVERTTO_FORMATTED : |
| case SID_FM_CONVERTTO_SPINBUTTON : |
| { |
| if ( !m_pFormView || !m_bDesignMode || !GetImpl()->canConvertCurrentSelectionToControl( nWhich ) ) |
| rSet.DisableItem( nWhich ); |
| else |
| { |
| rSet.Put( SfxBoolItem( nWhich, sal_False ) ); |
| // just to have a defined state (available and not checked) |
| } |
| } |
| break; |
| } |
| nWhich = aIter.NextWhich(); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::GetFormState(SfxItemSet &rSet, sal_uInt16 nWhich) |
| { |
| if ( !GetImpl()->getNavController().is() |
| || !isRowSetAlive(GetImpl()->getNavController()->getModel()) |
| || !m_pFormView |
| || m_bDesignMode |
| || !GetImpl()->getActiveForm().is() |
| || GetImpl()->isInFilterMode() |
| ) |
| rSet.DisableItem(nWhich); |
| else |
| { |
| sal_Bool bEnable = sal_False; |
| try |
| { |
| switch (nWhich) |
| { |
| case SID_FM_VIEW_AS_GRID: |
| if (GetImpl()->getHostFrame().is() && GetImpl()->getNavController().is()) |
| { |
| bEnable = sal_True; |
| sal_Bool bDisplayingCurrent = |
| GetImpl()->getInternalForm( |
| Reference< XForm >( GetImpl()->getNavController()->getModel(), UNO_QUERY ) |
| ) == GetImpl()->getExternallyDisplayedForm(); |
| rSet.Put(SfxBoolItem(nWhich, bDisplayingCurrent)); |
| } |
| break; |
| |
| case SID_FM_SEARCH: |
| { |
| Reference< ::com::sun::star::beans::XPropertySet > xNavSet(GetImpl()->getActiveForm(), UNO_QUERY); |
| sal_Int32 nCount = ::comphelper::getINT32(xNavSet->getPropertyValue(FM_PROP_ROWCOUNT)); |
| bEnable = nCount != 0; |
| } break; |
| case SID_FM_RECORD_ABSOLUTE: |
| case SID_FM_RECORD_TOTAL: |
| { |
| FeatureState aState; |
| GetImpl()->getNavControllerFeatures()->getState( nWhich, aState ); |
| if ( SID_FM_RECORD_ABSOLUTE == nWhich ) |
| { |
| sal_Int32 nPosition = 0; |
| aState.State >>= nPosition; |
| rSet.Put( SfxInt32Item( nWhich, nPosition ) ); |
| } |
| else if ( SID_FM_RECORD_TOTAL == nWhich ) |
| { |
| ::rtl::OUString sTotalCount; |
| aState.State >>= sTotalCount; |
| rSet.Put( SfxStringItem( nWhich, sTotalCount ) ); |
| } |
| bEnable = aState.Enabled; |
| } |
| break; |
| |
| // first, prev, next, last, and absolute affect the nav controller, not the |
| // active controller |
| case SID_FM_RECORD_FIRST: |
| case SID_FM_RECORD_PREV: |
| case SID_FM_RECORD_NEXT: |
| case SID_FM_RECORD_LAST: |
| case SID_FM_RECORD_NEW: |
| case SID_FM_RECORD_SAVE: |
| case SID_FM_RECORD_UNDO: |
| case SID_FM_RECORD_DELETE: |
| case SID_FM_REFRESH: |
| case SID_FM_REFRESH_FORM_CONTROL: |
| case SID_FM_REMOVE_FILTER_SORT: |
| case SID_FM_SORTUP: |
| case SID_FM_SORTDOWN: |
| case SID_FM_AUTOFILTER: |
| case SID_FM_ORDERCRIT: |
| bEnable = GetImpl()->IsFormSlotEnabled( nWhich ); |
| break; |
| |
| case SID_FM_FORM_FILTERED: |
| { |
| FeatureState aState; |
| bEnable = GetImpl()->IsFormSlotEnabled( nWhich, &aState ); |
| |
| rSet.Put( SfxBoolItem( nWhich, ::comphelper::getBOOL( aState.State ) ) ); |
| } |
| break; |
| |
| case SID_FM_FILTER_START: |
| bEnable = GetImpl()->getActiveControllerFeatures()->canDoFormFilter(); |
| break; |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_ERROR( "FmFormShell::GetFormState: caught an exception while determining the state!" ); |
| } |
| if (!bEnable) |
| rSet.DisableItem(nWhich); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| FmFormPage* FmFormShell::GetCurPage() const |
| { |
| FmFormPage* pP = NULL; |
| if (m_pFormView && m_pFormView->GetSdrPageView()) |
| pP = PTR_CAST(FmFormPage,m_pFormView->GetSdrPageView()->GetPage()); |
| return pP; |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::SetView( FmFormView* _pView ) |
| { |
| if ( m_pFormView ) |
| { |
| if ( IsActive() ) |
| GetImpl()->viewDeactivated( *m_pFormView ); |
| |
| m_pFormView->SetFormShell( NULL, FmFormView::FormShellAccess() ); |
| m_pFormView = NULL; |
| m_pFormModel = NULL; |
| } |
| |
| if ( !_pView ) |
| return; |
| |
| m_pFormView = _pView; |
| m_pFormView->SetFormShell( this, FmFormView::FormShellAccess() ); |
| m_pFormModel = (FmFormModel*)m_pFormView->GetModel(); |
| |
| impl_setDesignMode( m_pFormView->IsDesignMode() ); |
| |
| // We activate our view if we are activated ourself, but sometimes the Activate precedes the SetView. |
| // But here we know both the view and our activation state so we at least are able to pass the latter |
| // to the former. |
| // FS - 30.06.99 - 67308 |
| if ( IsActive() ) |
| GetImpl()->viewActivated( *m_pFormView ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::DetermineForms(sal_Bool bInvalidate) |
| { |
| // Existieren Formulare auf der aktuellen Page |
| sal_Bool bForms = GetImpl()->hasForms(); |
| if (bForms != m_bHasForms) |
| { |
| m_bHasForms = bForms; |
| if (bInvalidate) |
| UIFeatureChanged(); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| sal_Bool FmFormShell::GetY2KState(sal_uInt16& nReturn) |
| { |
| return GetImpl()->GetY2KState(nReturn); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::SetY2KState(sal_uInt16 n) |
| { |
| GetImpl()->SetY2KState(n); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::Activate(sal_Bool bMDI) |
| { |
| SfxShell::Activate(bMDI); |
| |
| if ( m_pFormView ) |
| GetImpl()->viewActivated( *m_pFormView, sal_True ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::Deactivate(sal_Bool bMDI) |
| { |
| SfxShell::Deactivate(bMDI); |
| |
| if ( m_pFormView ) |
| GetImpl()->viewDeactivated( *m_pFormView, sal_False ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::ExecuteTextAttribute( SfxRequest& _rReq ) |
| { |
| m_pImpl->ExecuteTextAttribute( _rReq ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::GetTextAttributeState( SfxItemSet& _rSet ) |
| { |
| m_pImpl->GetTextAttributeState( _rSet ); |
| } |
| |
| //------------------------------------------------------------------------ |
| bool FmFormShell::IsActiveControl() const |
| { |
| return m_pImpl->IsActiveControl(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::ForgetActiveControl() |
| { |
| m_pImpl->ForgetActiveControl(); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::SetControlActivationHandler( const Link& _rHdl ) |
| { |
| m_pImpl->SetControlActivationHandler( _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------ |
| namespace |
| { |
| SdrUnoObj* lcl_findUnoObject( const SdrObjList& _rObjList, const Reference< XControlModel >& _rxModel ) |
| { |
| SdrObjListIter aIter( _rObjList ); |
| while ( aIter.IsMore() ) |
| { |
| SdrObject* pObject = aIter.Next(); |
| SdrUnoObj* pUnoObject = pObject ? PTR_CAST( SdrUnoObj, pObject ) : NULL; |
| if ( !pUnoObject ) |
| continue; |
| |
| Reference< XControlModel > xControlModel = pUnoObject->GetUnoControlModel(); |
| if ( !xControlModel.is() ) |
| continue; |
| |
| if ( _rxModel == xControlModel ) |
| return pUnoObject; |
| } |
| return NULL; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::ToggleControlFocus( const SdrUnoObj& i_rUnoObject, const SdrView& i_rView, OutputDevice& i_rDevice ) const |
| { |
| try |
| { |
| // check if the focus currently is in a control |
| // Well, okay, do it the other way 'round: Check whether the current control of the active controller |
| // actually has the focus. This should be equivalent. |
| const bool bHasControlFocus = GetImpl()->HasControlFocus(); |
| |
| if ( bHasControlFocus ) |
| { |
| Window* pWindow( dynamic_cast< Window* >( &i_rDevice ) ); |
| OSL_ENSURE( pWindow, "FmFormShell::ToggleControlFocus: I need a Window, really!" ); |
| if ( pWindow ) |
| pWindow->GrabFocus(); |
| } |
| else |
| { |
| Reference< XControl > xControl; |
| GetFormControl( i_rUnoObject.GetUnoControlModel(), i_rView, i_rDevice, xControl ); |
| Reference< XWindow > xControlWindow( xControl, UNO_QUERY ); |
| if ( xControlWindow.is() ) |
| xControlWindow->setFocus(); |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| namespace |
| { |
| class FocusableControlsFilter : public ::svx::ISdrObjectFilter |
| { |
| public: |
| FocusableControlsFilter( const SdrView& i_rView, const OutputDevice& i_rDevice ) |
| :m_rView( i_rView ) |
| ,m_rDevice( i_rDevice ) |
| { |
| } |
| |
| public: |
| virtual bool includeObject( const SdrObject& i_rObject ) const |
| { |
| const SdrUnoObj* pUnoObj = dynamic_cast< const SdrUnoObj* >( &i_rObject ); |
| if ( !pUnoObj ) |
| return false; |
| |
| Reference< XControl > xControl = pUnoObj->GetUnoControl( m_rView, m_rDevice ); |
| return FmXFormView::isFocusable( xControl ); |
| } |
| |
| private: |
| const SdrView& m_rView; |
| const OutputDevice& m_rDevice; |
| }; |
| } |
| |
| //------------------------------------------------------------------------ |
| ::std::auto_ptr< ::svx::ISdrObjectFilter > FmFormShell::CreateFocusableControlFilter( const SdrView& i_rView, const OutputDevice& i_rDevice ) const |
| { |
| ::std::auto_ptr< ::svx::ISdrObjectFilter > pFilter; |
| |
| if ( !i_rView.IsDesignMode() ) |
| pFilter.reset( new FocusableControlsFilter( i_rView, i_rDevice ) ); |
| |
| return pFilter; |
| } |
| |
| //------------------------------------------------------------------------ |
| SdrUnoObj* FmFormShell::GetFormControl( const Reference< XControlModel >& _rxModel, const SdrView& _rView, const OutputDevice& _rDevice, Reference< XControl >& _out_rxControl ) const |
| { |
| if ( !_rxModel.is() ) |
| return NULL; |
| |
| // we can only retrieve controls for SdrObjects which belong to page which is actually displayed in the given view |
| SdrPageView* pPageView = _rView.GetSdrPageView(); |
| SdrPage* pPage = pPageView ? pPageView->GetPage() : NULL; |
| OSL_ENSURE( pPage, "FmFormShell::GetFormControl: no page displayed in the given view!" ); |
| if ( !pPage ) |
| return NULL; |
| |
| SdrUnoObj* pUnoObject = lcl_findUnoObject( *pPage, _rxModel ); |
| if ( pUnoObject ) |
| { |
| _out_rxControl = pUnoObject->GetUnoControl( _rView, _rDevice ); |
| return pUnoObject; |
| } |
| |
| #if OSL_DEBUG_LEVEL > 0 |
| // perhaps we are fed with a control model which lives on a page other than the one displayed |
| // in the given view. This is worth being reported as error, in non-product builds. |
| FmFormModel* pModel = GetFormModel(); |
| if ( pModel ) |
| { |
| sal_uInt16 pageCount = pModel->GetPageCount(); |
| for ( sal_uInt16 page = 0; page < pageCount; ++page ) |
| { |
| pPage = pModel->GetPage( page ); |
| OSL_ENSURE( pPage, "FmFormShell::GetFormControl: NULL page encountered!" ); |
| if ( !pPage ) |
| continue; |
| |
| pUnoObject = lcl_findUnoObject( *pPage, _rxModel ); |
| OSL_ENSURE( !pUnoObject, "FmFormShell::GetFormControl: the given control model belongs to a wrong page (displayed elsewhere)!" ); |
| } |
| } |
| #endif |
| |
| return NULL; |
| } |
| |
| //------------------------------------------------------------------------ |
| Reference< runtime::XFormController > FmFormShell::GetFormController( const Reference< XForm >& _rxForm, const SdrView& _rView, const OutputDevice& _rDevice ) const |
| { |
| const FmFormView* pFormView = dynamic_cast< const FmFormView* >( &_rView ); |
| if ( !pFormView ) |
| return NULL; |
| |
| return pFormView->GetFormController( _rxForm, _rDevice ); |
| } |
| |
| //------------------------------------------------------------------------ |
| void FmFormShell::SetDesignMode( sal_Bool _bDesignMode ) |
| { |
| if ( _bDesignMode == m_bDesignMode ) |
| return; |
| |
| FmFormModel* pModel = GetFormModel(); |
| if (pModel) |
| // fuer die Zeit des Uebergangs das Undo-Environment ausschalten, das sichert, dass man dort auch nicht-transiente |
| // Properties mal eben aendern kann (sollte allerdings mit Vorsicht genossen und beim Rueckschalten des Modes |
| // auch immer wieder rueckgaegig gemacht werden. Ein Beispiel ist das Setzen der maximalen Text-Laenge durch das |
| // OEditModel an seinem Control.) |
| pModel->GetUndoEnv().Lock(); |
| |
| // dann die eigentliche Umschaltung |
| if ( m_bDesignMode || PrepareClose( sal_True ) ) |
| impl_setDesignMode(!m_bDesignMode ); |
| |
| // und mein Undo-Environment wieder an |
| if ( pModel ) |
| pModel->GetUndoEnv().UnLock(); |
| } |