diff options
Diffstat (limited to 'svx/source/inc/fmshimp.hxx')
| -rw-r--r-- | svx/source/inc/fmshimp.hxx | 562 |
1 files changed, 562 insertions, 0 deletions
diff --git a/svx/source/inc/fmshimp.hxx b/svx/source/inc/fmshimp.hxx new file mode 100644 index 000000000..a468bc030 --- /dev/null +++ b/svx/source/inc/fmshimp.hxx @@ -0,0 +1,562 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_INC_FMSHIMP_HXX +#define INCLUDED_SVX_SOURCE_INC_FMSHIMP_HXX + +#include <config_options.h> +#include <com/sun/star/sdbc/XResultSet.hpp> +#include <com/sun/star/container/ContainerEvent.hpp> +#include <com/sun/star/container/XContainerListener.hpp> +#include <com/sun/star/awt/XControl.hpp> +#include <com/sun/star/awt/XControlContainer.hpp> +#include <com/sun/star/form/XForm.hpp> +#include <com/sun/star/form/runtime/XFormController.hpp> +#include <com/sun/star/form/XFormComponent.hpp> +#include <com/sun/star/form/NavigationBarMode.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/view/XSelectionChangeListener.hpp> +#include <com/sun/star/beans/XPropertyChangeListener.hpp> +#include <com/sun/star/beans/PropertyChangeEvent.hpp> +#include <com/sun/star/form/runtime/FeatureState.hpp> +#include <tools/diagnose_ex.h> +#include <vcl/timer.hxx> +#include <sfx2/shell.hxx> +#include <svx/svdmark.hxx> +#include <svx/fmsearch.hxx> + +#include <svx/fmtools.hxx> +#include <osl/mutex.hxx> +#include <comphelper/container.hxx> +#include <cppuhelper/basemutex.hxx> +#include <cppuhelper/compbase.hxx> +#include <unotools/configitem.hxx> +#include "formcontrolling.hxx" +#include "fmdocumentclassification.hxx" +#include <o3tl/typed_flags_set.hxx> + +#include <queue> +#include <string_view> +#include <vector> +#include <memory> + +struct ImplSVEvent; + +typedef std::vector< css::uno::Reference< css::form::XForm > > FmFormArray; + +// catch database exceptions if they occur +#define DO_SAFE(statement) try { statement; } catch( const Exception& ) { TOOLS_WARN_EXCEPTION("svx", "unhandled exception (I tried to move a cursor (or something like that).)"); } + +enum class LoopGridsSync { + DISABLE_SYNC = 1, + FORCE_SYNC = 2, + ENABLE_SYNC = 3 +}; +enum class LoopGridsFlags +{ + NONE = 0, + DISABLE_ROCTRLR = 4 +}; +namespace o3tl +{ + template<> struct typed_flags<LoopGridsFlags> : is_typed_flags<LoopGridsFlags, 0x04> {}; +} + + +// flags for controlling the behaviour when calling loadForms +enum class LoadFormsFlags { + Load = 0x0000, // default: simply load + Sync = 0x0000, // default: do in synchronous + Unload = 0x0001, // unload + Async = 0x0002 // do this async +}; +namespace o3tl { + template<> struct typed_flags<LoadFormsFlags> : is_typed_flags<LoadFormsFlags, 0x0003> {}; +} + +namespace weld { + class Menu; +} + +// a class iterating through all fields of a form which are bound to a field +// sub forms are ignored, grid columns (where the grid is a direct child of the form) are included +class FmXBoundFormFieldIterator final : public ::comphelper::IndexAccessIterator +{ +public: + FmXBoundFormFieldIterator(const css::uno::Reference< css::uno::XInterface>& _rStartingPoint) : ::comphelper::IndexAccessIterator(_rStartingPoint) { } + +private: + virtual bool ShouldHandleElement(const css::uno::Reference< css::uno::XInterface>& _rElement) override; + virtual bool ShouldStepInto(const css::uno::Reference< css::uno::XInterface>& _rContainer) const override; +}; + +class FmFormPage; +class FmFormPageImpl; + +struct FmLoadAction +{ + FmFormPage* pPage; + ImplSVEvent * nEventId; + LoadFormsFlags nFlags; + + FmLoadAction( FmFormPage* _pPage, LoadFormsFlags _nFlags, ImplSVEvent * _nEventId ) + :pPage( _pPage ), nEventId( _nEventId ), nFlags( _nFlags ) + { + } +}; + + +class SfxViewFrame; +typedef ::cppu::WeakComponentImplHelper< css::beans::XPropertyChangeListener + , css::container::XContainerListener + , css::view::XSelectionChangeListener + , css::form::XFormControllerListener + > FmXFormShell_BD_BASE; + + +class FmXFormShell_Base_Disambiguation : public FmXFormShell_BD_BASE +{ + using css::beans::XPropertyChangeListener::disposing; +protected: + FmXFormShell_Base_Disambiguation( ::osl::Mutex& _rMutex ); + using WeakComponentImplHelperBase::disposing; +}; + + +namespace svx +{ + class FmTextControlShell; +} + + +typedef FmXFormShell_Base_Disambiguation FmXFormShell_BASE; +typedef ::utl::ConfigItem FmXFormShell_CFGBASE; + +struct SdrViewEvent; +class FmFormShell; +class FmFormView; +class FmFormObj; +class UNLESS_MERGELIBS(SVXCORE_DLLPUBLIC) FmXFormShell final : private cppu::BaseMutex + ,public FmXFormShell_BASE + ,public FmXFormShell_CFGBASE + ,public svx::IControllerFeatureInvalidation +{ + friend class FmFormView; + friend class FmXFormView; + + class SuspendPropertyTracking; + friend class SuspendPropertyTracking; + + // timer for delayed mark + Timer m_aMarkTimer; + std::vector<SdrObject*> m_arrSearchedControls; + // We enable a permanent cursor for the grid we found a searched text, it's disabled in the next "found" event. + FmFormArray m_aSearchForms; + + struct SAL_DLLPRIVATE InvalidSlotInfo { + sal_uInt16 id; + sal_uInt8 flags; + InvalidSlotInfo(sal_uInt16 slotId, sal_uInt8 flgs) : id(slotId), flags(flgs) {}; + }; + std::vector<InvalidSlotInfo> m_arrInvalidSlots; + // we explicitly switch off the propbrw before leaving the design mode + // this flag tells us if we have to switch it on again when reentering + + css::form::NavigationBarMode m_eNavigate; // kind of navigation + + // since I want to mark an SdrObject when searching for the treatment of the "found", + // I get all relevant objects before yanking up of the search dialog + // (the array is thus only valid during the search process) + std::vector<sal_Int16> m_arrRelativeGridColumn; + + ImplSVEvent * m_nInvalidationEvent; + ImplSVEvent * m_nActivationEvent; + ::std::queue< FmLoadAction > + m_aLoadingPages; + + FmFormShell* m_pShell; + std::unique_ptr<svx::FmTextControlShell> m_pTextShell; + + svx::ControllerFeatures m_aActiveControllerFeatures; + svx::ControllerFeatures m_aNavControllerFeatures; + + // current form, controller + // only available in the alive mode + css::uno::Reference< css::form::runtime::XFormController > m_xActiveController; + css::uno::Reference< css::form::runtime::XFormController > m_xNavigationController; + css::uno::Reference< css::form::XForm > m_xActiveForm; + + // current container of a page + // only available in the design mode + css::uno::Reference< css::container::XIndexAccess> m_xForms; + + // the currently selected objects, as to be displayed in the property browser + InterfaceBag m_aCurrentSelection; + /// the currently selected form, or the form which all currently selected controls belong to, or <NULL/> + css::uno::Reference< css::form::XForm > m_xCurrentForm; + /// the last selection/marking of controls only. Necessary to implement the "Control properties" slot + InterfaceBag m_aLastKnownMarkedControls; + + + // And this is also for the 'found': When I find in GridControls, I need the column, + // but only get the number of the field corresponding to the number of the + // column + <offset>, where the offset depends on the position of the GridControl + // in the form. So here is a conversion. + css::uno::Reference< css::awt::XControlModel> m_xLastGridFound; + // the frame we live in + css::uno::Reference< css::frame::XFrame> m_xAttachedFrame; + // Administration of external form views (see the SID_FM_VIEW_AS_GRID-slot) + css::uno::Reference< css::frame::XController > m_xExternalViewController; // the controller for the external form view + css::uno::Reference< css::form::runtime::XFormController > m_xExtViewTriggerController; // the nav controller at the time the external display was triggered + css::uno::Reference< css::sdbc::XResultSet > m_xExternalDisplayedForm; // the form which the external view is based on + + mutable ::svxform::DocumentType + m_eDocumentType; /// the type of document we're living in + sal_Int16 m_nLockSlotInvalidation; + bool m_bHadPropertyBrowserInDesignMode : 1; + + bool m_bTrackProperties : 1; + // should I (or the owner of this impl class) take car of the update of the css::beans::Property-Browser? + + bool m_bUseWizards : 1; + + bool m_bDatabaseBar : 1; // is there a database bar + bool m_bInActivate : 1; // is a controller activated + bool m_bSetFocus : 1; // may the focus be changed over + bool m_bFilterMode : 1; // is a filter currently set to the controls + bool m_bChangingDesignMode:1; // sal_True within SetDesignMode + bool m_bPreparedClose : 1; // for the current modification state of the current form + // PrepareClose had been called and the user denied to save changes + bool m_bFirstActivation : 1; // has the shell ever been activated? + +public: + // attribute access + SAL_DLLPRIVATE const css::uno::Reference< css::frame::XFrame >& + getHostFrame_Lock() const { return m_xAttachedFrame; } + SAL_DLLPRIVATE const css::uno::Reference< css::sdbc::XResultSet >& + getExternallyDisplayedForm_Lock() const { return m_xExternalDisplayedForm; } + + SAL_DLLPRIVATE bool + didPrepareClose_Lock() const { return m_bPreparedClose; } + SAL_DLLPRIVATE void + didPrepareClose_Lock(bool bDid) { m_bPreparedClose = bDid; } + + SAL_DLLPRIVATE FmXFormShell(FmFormShell& _rShell, SfxViewFrame* _pViewFrame); + +private: + SAL_DLLPRIVATE virtual ~FmXFormShell() override; + +// EventListener + SAL_DLLPRIVATE virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override; + +// css::container::XContainerListener + SAL_DLLPRIVATE virtual void SAL_CALL elementInserted(const css::container::ContainerEvent& rEvent) override; + SAL_DLLPRIVATE virtual void SAL_CALL elementReplaced(const css::container::ContainerEvent& rEvent) override; + SAL_DLLPRIVATE virtual void SAL_CALL elementRemoved(const css::container::ContainerEvent& rEvent) override; + +// XSelectionChangeListener + SAL_DLLPRIVATE virtual void SAL_CALL selectionChanged(const css::lang::EventObject& rEvent) override; + +// css::beans::XPropertyChangeListener + SAL_DLLPRIVATE virtual void SAL_CALL propertyChange(const css::beans::PropertyChangeEvent& evt) override; + +// css::form::XFormControllerListener + SAL_DLLPRIVATE virtual void SAL_CALL formActivated(const css::lang::EventObject& rEvent) override; + SAL_DLLPRIVATE virtual void SAL_CALL formDeactivated(const css::lang::EventObject& rEvent) override; + +// OComponentHelper + SAL_DLLPRIVATE virtual void SAL_CALL disposing() override; + +public: + SAL_DLLPRIVATE void EnableTrackProperties_Lock(bool bEnable) { m_bTrackProperties = bEnable; } + SAL_DLLPRIVATE bool IsTrackPropertiesEnabled_Lock() const { return m_bTrackProperties; } + + // activation handling + SAL_DLLPRIVATE void viewActivated_Lock(FmFormView& _rCurrentView, bool _bSyncAction = false); + SAL_DLLPRIVATE void viewDeactivated_Lock(FmFormView& _rCurrentView, bool _bDeactivateController = true); + + // IControllerFeatureInvalidation + SAL_DLLPRIVATE virtual void invalidateFeatures/*_NoLock*/( const ::std::vector< sal_Int32 >& _rFeatures ) override; + + SAL_DLLPRIVATE void ExecuteTabOrderDialog_Lock( // execute SID_FM_TAB_DIALOG + const css::uno::Reference< css::awt::XTabControllerModel >& _rxForForm + ); + + // stuff + SAL_DLLPRIVATE void AddElement_Lock(const css::uno::Reference< css::uno::XInterface>& Element); + SAL_DLLPRIVATE void RemoveElement_Lock(const css::uno::Reference< css::uno::XInterface>& Element); + + /** updates m_xForms, to be either <NULL/>, if we're in alive mode, or our current page's forms collection, + if in design mode + */ + SAL_DLLPRIVATE void UpdateForms_Lock(bool bInvalidate); + + SAL_DLLPRIVATE void ExecuteSearch_Lock(); // execute SID_FM_SEARCH + SAL_DLLPRIVATE void CreateExternalView_Lock(); // execute SID_FM_VIEW_AS_GRID + + SAL_DLLPRIVATE bool GetY2KState_Lock(sal_uInt16 & n); + SAL_DLLPRIVATE void SetY2KState_Lock(sal_uInt16 n); + +private: + // form handling + /// load or unload the forms on a page + SAL_DLLPRIVATE void loadForms_Lock( FmFormPage* _pPage, const LoadFormsFlags _nBehaviour ); + SAL_DLLPRIVATE void smartControlReset( const css::uno::Reference< css::container::XIndexAccess >& _rxModels ); + + + SAL_DLLPRIVATE void startListening_Lock(); + SAL_DLLPRIVATE void stopListening_Lock(); + + SAL_DLLPRIVATE css::uno::Reference< css::awt::XControl > + impl_getControl_Lock( + const css::uno::Reference< css::awt::XControlModel>& i_rxModel, + const FmFormObj& i_rKnownFormObj + ); + + // collects in strNames the names of all forms + SAL_DLLPRIVATE static void impl_collectFormSearchContexts_nothrow_Lock( + const css::uno::Reference< css::uno::XInterface>& _rxStartingPoint, + std::u16string_view _rCurrentLevelPrefix, + FmFormArray& _out_rForms, + ::std::vector< OUString >& _out_rNames ); + + /** checks whenever the instance is already disposed, if so, this is reported as assertion error (debug + builds only) and <TRUE/> is returned. + */ + SAL_DLLPRIVATE bool impl_checkDisposed_Lock() const; + +public: + // method for non design mode (alive mode) + SAL_DLLPRIVATE void setActiveController_Lock(const css::uno::Reference< css::form::runtime::XFormController>& _xController, bool _bNoSaveOldContent = false); + SAL_DLLPRIVATE const css::uno::Reference< css::form::runtime::XFormController>& getActiveController_Lock() const { return m_xActiveController; } + SAL_DLLPRIVATE const css::uno::Reference< css::form::runtime::XFormController>& getActiveInternalController_Lock() const { return m_xActiveController == m_xExternalViewController ? m_xExtViewTriggerController : m_xActiveController; } + SAL_DLLPRIVATE const css::uno::Reference< css::form::XForm>& getActiveForm_Lock() const { return m_xActiveForm; } + SAL_DLLPRIVATE const css::uno::Reference< css::form::runtime::XFormController>& getNavController_Lock() const { return m_xNavigationController; } + + SAL_DLLPRIVATE const svx::ControllerFeatures& getActiveControllerFeatures_Lock() const + { return m_aActiveControllerFeatures; } + SAL_DLLPRIVATE const svx::ControllerFeatures& getNavControllerFeatures_Lock() const + { return m_aNavControllerFeatures.isAssigned() ? m_aNavControllerFeatures : m_aActiveControllerFeatures; } + + /** announces a new "current selection" + @return + <TRUE/> if and only if the to-bet-set selection was different from the previous selection + */ + SAL_DLLPRIVATE bool setCurrentSelection_Lock(InterfaceBag&& rSelection); + + /** sets the new selection to the last known marked controls + */ + SAL_DLLPRIVATE bool selectLastMarkedControls_Lock(); + + /** retrieves the current selection + */ + void getCurrentSelection_Lock(InterfaceBag& /* [out] */ _rSelection) const; + + /** sets a new current selection as indicated by a mark list + @return + <TRUE/> if and only if the to-bet-set selection was different from the previous selection + */ + SAL_DLLPRIVATE bool setCurrentSelectionFromMark_Lock(const SdrMarkList& rMarkList); + + /// returns the currently selected form, or the form which all currently selected controls belong to, or <NULL/> + SAL_DLLPRIVATE const css::uno::Reference< css::form::XForm >& + getCurrentForm_Lock() const { return m_xCurrentForm; } + SAL_DLLPRIVATE void forgetCurrentForm_Lock(); + /// returns whether the last known marking contained only controls + SAL_DLLPRIVATE bool onlyControlsAreMarked_Lock() const { return !m_aLastKnownMarkedControls.empty(); } + + /// determines whether the current selection consists of exactly the given object + SAL_DLLPRIVATE bool isSolelySelected_Lock( + const css::uno::Reference< css::uno::XInterface >& _rxObject + ); + + /// handles a MouseButtonDown event of the FmFormView + SAL_DLLPRIVATE void handleMouseButtonDown_Lock( const SdrViewEvent& _rViewEvent ); + /// handles the request for showing the "Properties" + SAL_DLLPRIVATE void handleShowPropertiesRequest_Lock(); + + SAL_DLLPRIVATE bool hasForms_Lock() const { return m_xForms.is() && m_xForms->getCount() != 0; } + SAL_DLLPRIVATE bool hasDatabaseBar_Lock() const { return m_bDatabaseBar; } + + SAL_DLLPRIVATE void ShowSelectionProperties_Lock(bool bShow); + SAL_DLLPRIVATE bool IsPropBrwOpen_Lock() const; + + SAL_DLLPRIVATE void DetermineSelection_Lock(const SdrMarkList& rMarkList); + SAL_DLLPRIVATE void SetSelection_Lock(const SdrMarkList& rMarkList); + SAL_DLLPRIVATE void SetSelectionDelayed_Lock(); + + SAL_DLLPRIVATE void SetDesignMode_Lock(bool bDesign); + + SAL_DLLPRIVATE bool GetWizardUsing_Lock() const { return m_bUseWizards; } + SAL_DLLPRIVATE void SetWizardUsing_Lock(bool _bUseThem); + + // setting the filter mode + SAL_DLLPRIVATE bool isInFilterMode_Lock() const { return m_bFilterMode; } + SAL_DLLPRIVATE void startFiltering_Lock(); + SAL_DLLPRIVATE void stopFiltering_Lock(bool bSave); + + // fills rMenu to be a menu that contains all ControlConversion entries + SAL_DLLPRIVATE static void GetConversionMenu_Lock(weld::Menu& rMenu); + + /// checks whether a given control conversion slot can be applied to the current selection + SAL_DLLPRIVATE bool canConvertCurrentSelectionToControl_Lock(std::string_view rIdent); + /// enables or disables all conversion slots in a menu, according to the current selection + SAL_DLLPRIVATE void checkControlConversionSlotsForCurrentSelection_Lock(weld::Menu& rMenu); + /// executes a control conversion slot for a given object + SAL_DLLPRIVATE bool executeControlConversionSlot_Lock(const css::uno::Reference< css::form::XFormComponent >& _rxObject, std::string_view rIdent); + /** executes a control conversion slot for the current selection + @precond canConvertCurrentSelectionToControl( <arg>_nSlotId</arg> ) must return <TRUE/> + */ + SAL_DLLPRIVATE void executeControlConversionSlot_Lock(std::string_view rIdent); + /// checks whether the given slot id denotes a control conversion slot + SAL_DLLPRIVATE static bool isControlConversionSlot(std::string_view rIdent); + + SAL_DLLPRIVATE void ExecuteTextAttribute_Lock(SfxRequest& _rReq); + SAL_DLLPRIVATE void GetTextAttributeState_Lock(SfxItemSet& _rSet); + SAL_DLLPRIVATE bool IsActiveControl_Lock(bool _bCountRichTextOnly) const; + SAL_DLLPRIVATE void ForgetActiveControl_Lock(); + SAL_DLLPRIVATE void SetControlActivationHandler_Lock(const Link<LinkParamNone*,void>& _rHdl); + + /// classifies our host document + SAL_DLLPRIVATE ::svxform::DocumentType getDocumentType_Lock() const; + SAL_DLLPRIVATE bool isEnhancedForm_Lock() const; + + /// determines whether our host document is currently read-only + SAL_DLLPRIVATE bool IsReadonlyDoc_Lock() const; + + // Setting the curObject/selObject/curForm is delayed (SetSelectionDelayed). With the + // following functions this can be inquired/enforced. + SAL_DLLPRIVATE inline bool IsSelectionUpdatePending_Lock() const; + SAL_DLLPRIVATE void ForceUpdateSelection_Lock(); + + SAL_DLLPRIVATE css::uno::Reference< css::frame::XModel> getContextDocument_Lock() const; + SAL_DLLPRIVATE css::uno::Reference< css::form::XForm> getInternalForm_Lock(const css::uno::Reference< css::form::XForm>& _xForm) const; + SAL_DLLPRIVATE css::uno::Reference< css::sdbc::XResultSet> getInternalForm_Lock(const css::uno::Reference< css::sdbc::XResultSet>& _xForm) const; + // if the form belongs to the controller (extern) displaying a grid, the according internal form will + // be displayed, _xForm else + + // check if the current control of the active controller has the focus + SAL_DLLPRIVATE bool HasControlFocus_Lock() const; + +private: + DECL_DLLPRIVATE_LINK(OnFoundData_Lock, FmFoundRecordInformation&, void); + DECL_DLLPRIVATE_LINK(OnCanceledNotFound_Lock, FmFoundRecordInformation&, void); + DECL_DLLPRIVATE_LINK(OnSearchContextRequest_Lock, FmSearchContext&, sal_uInt32); + DECL_DLLPRIVATE_LINK(OnTimeOut_Lock, Timer*, void); + DECL_DLLPRIVATE_LINK(OnFirstTimeActivation_Lock, void*, void); + DECL_DLLPRIVATE_LINK(OnFormsCreated_Lock, FmFormPageImpl&, void); + + SAL_DLLPRIVATE void LoopGrids_Lock(LoopGridsSync nSync, LoopGridsFlags nWhat = LoopGridsFlags::NONE); + + // invalidation of slots + SAL_DLLPRIVATE void InvalidateSlot_Lock(sal_Int16 nId, bool bWithId); + SAL_DLLPRIVATE void UpdateSlot_Lock(sal_Int16 nId); + // locking the invalidation - if the internal locking counter goes to 0, all accumulated slots + // are invalidated (asynchronously) + SAL_DLLPRIVATE void LockSlotInvalidation_Lock(bool bLock); + + DECL_DLLPRIVATE_LINK(OnInvalidateSlots_Lock, void*, void); + + SAL_DLLPRIVATE void CloseExternalFormViewer_Lock(); + // closes the task-local beamer displaying a grid view for a form + + // ConfigItem related stuff + SAL_DLLPRIVATE virtual void Notify( const css::uno::Sequence< OUString >& _rPropertyNames) override; + SAL_DLLPRIVATE void implAdjustConfigCache_Lock(); + + SAL_DLLPRIVATE css::uno::Reference< css::awt::XControlContainer > + getControlContainerForView_Lock() const; + + /** finds and sets a default for m_xCurrentForm, if it is currently NULL + */ + SAL_DLLPRIVATE void impl_defaultCurrentForm_nothrow_Lock(); + + /** sets m_xCurrentForm to the provided form, and updates everything which + depends on the current form + */ + SAL_DLLPRIVATE void impl_updateCurrentForm_Lock( const css::uno::Reference< css::form::XForm >& _rxNewCurForm ); + + /** adds or removes ourself as XEventListener at m_xActiveController + */ + SAL_DLLPRIVATE void impl_switchActiveControllerListening_Lock(const bool _bListen); + + /** add an element + */ + SAL_DLLPRIVATE void impl_AddElement_nothrow(const css::uno::Reference< css::uno::XInterface>& Element); + + /** remove an element + */ + SAL_DLLPRIVATE void impl_RemoveElement_nothrow_Lock(const css::uno::Reference< css::uno::XInterface>& Element); + + SAL_DLLPRIVATE virtual void ImplCommit() override; + + // asynchronous cursor actions/navigation slot handling + +public: + /** execute the given form slot + <p>Warning. Only a small set of slots implemented currently.</p> + @param _nSlot + the slot to execute + */ + SAL_DLLPRIVATE void ExecuteFormSlot_Lock(sal_Int32 _nSlot); + + /** determines whether the current form slot is currently enabled + */ + SAL_DLLPRIVATE bool IsFormSlotEnabled( sal_Int32 _nSlot, css::form::runtime::FeatureState* _pCompleteState ) const; + + SAL_DLLPRIVATE static OString SlotToIdent(sal_uInt16 nSlot); + +private: + DECL_DLLPRIVATE_LINK( OnLoadForms_Lock, void*, void ); +}; + + +inline bool FmXFormShell::IsSelectionUpdatePending_Lock() const +{ + return m_aMarkTimer.IsActive(); +} + + +// = An iterator that, emanating from an interface, looks for an object whose +// = css::beans::Property-Set has a ControlSource and a BoundField property, the +// = latter having a non-NULL value. If the interface itself does not meet this +// = condition, it is tested whether it is a container (that is, has a +// = css::container::XIndexAccess), then it is descended there and the same tried +// = for each element of the container (again possibly with descent). If any +// = object thereby has the required property, the part with the container test +// = for that object is omitted. +// = + +class SearchableControlIterator final : public ::comphelper::IndexAccessIterator +{ + OUString m_sCurrentValue; + // the current value of the ControlSource css::beans::Property + +public: + const OUString& getCurrentValue() const { return m_sCurrentValue; } + + SearchableControlIterator(css::uno::Reference< css::uno::XInterface> const & xStartingPoint); + + virtual bool ShouldHandleElement(const css::uno::Reference< css::uno::XInterface>& rElement) override; + virtual bool ShouldStepInto(const css::uno::Reference< css::uno::XInterface>& xContainer) const override; + virtual void Invalidate() override { IndexAccessIterator::Invalidate(); m_sCurrentValue.clear(); } +}; + +#endif // INCLUDED_SVX_SOURCE_INC_FMSHIMP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |