LCOV - code coverage report
Current view: top level - svx/source/inc - fmexpl.hxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 2 51 3.9 %
Date: 2015-06-13 12:38:46 Functions: 2 49 4.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : #ifndef INCLUDED_SVX_SOURCE_INC_FMEXPL_HXX
      20             : #define INCLUDED_SVX_SOURCE_INC_FMEXPL_HXX
      21             : 
      22             : #include <svl/lstner.hxx>
      23             : #include <svl/SfxBroadcaster.hxx>
      24             : #include <vcl/window.hxx>
      25             : #include <sfx2/childwin.hxx>
      26             : #include <svl/poolitem.hxx>
      27             : #include <sfx2/bindings.hxx>
      28             : #include <sfx2/dockwin.hxx>
      29             : #include <sfx2/ctrlitem.hxx>
      30             : #include <vcl/image.hxx>
      31             : 
      32             : #include <com/sun/star/container/XNameContainer.hpp>
      33             : #include <com/sun/star/form/XForm.hpp>
      34             : #include <com/sun/star/form/XFormComponent.hpp>
      35             : #include <com/sun/star/beans/PropertyChangeEvent.hpp>
      36             : #include <com/sun/star/container/XContainerListener.hpp>
      37             : #include <com/sun/star/container/XContainer.hpp>
      38             : #include <com/sun/star/beans/XPropertyChangeListener.hpp>
      39             : #include <com/sun/star/container/XIndexContainer.hpp>
      40             : 
      41             : #include <svtools/treelistbox.hxx>
      42             : 
      43             : #include <vcl/dialog.hxx>
      44             : #include <vcl/group.hxx>
      45             : #include <vcl/button.hxx>
      46             : #include <vcl/fixed.hxx>
      47             : #include <vcl/edit.hxx>
      48             : #include <vcl/dockwin.hxx>
      49             : #include <svx/fmview.hxx>
      50             : 
      51             : #include "fmexch.hxx"
      52             : #include <vector>
      53             : #include <set>
      54             : 
      55             : class SdrObjListIter;
      56             : class FmFormShell;
      57             : class SdrObject;
      58             : class FmFormModel;
      59             : class FmFormView;
      60             : class SdrMarkList;
      61             : 
      62             : 
      63             : class FmEntryData;
      64             : class FmNavInsertedHint : public SfxHint
      65             : {
      66             :     FmEntryData* pEntryData;
      67             :     sal_uInt32 nPos;
      68             : 
      69             : public:
      70             :     FmNavInsertedHint( FmEntryData* pInsertedEntryData, sal_uInt32 nRelPos );
      71             :     virtual ~FmNavInsertedHint();
      72             : 
      73           0 :     FmEntryData* GetEntryData() const { return pEntryData; }
      74           0 :     sal_uInt32 GetRelPos() const { return nPos; }
      75             : };
      76             : 
      77             : 
      78             : class FmNavModelReplacedHint : public SfxHint
      79             : {
      80             :     FmEntryData* pEntryData;    // die Daten des Eintrages, der ein neues Model bekommen hat
      81             : 
      82             : public:
      83             :     FmNavModelReplacedHint( FmEntryData* pAffectedEntryData );
      84             :     virtual ~FmNavModelReplacedHint();
      85             : 
      86           0 :     FmEntryData* GetEntryData() const { return pEntryData; }
      87             : };
      88             : 
      89             : 
      90             : class FmNavRemovedHint : public SfxHint
      91             : {
      92             :     FmEntryData* pEntryData;
      93             : 
      94             : public:
      95             :     FmNavRemovedHint( FmEntryData* pInsertedEntryData );
      96             :     virtual ~FmNavRemovedHint();
      97             : 
      98           0 :     FmEntryData* GetEntryData() const { return pEntryData; }
      99             : };
     100             : 
     101             : 
     102             : class FmNavNameChangedHint : public SfxHint
     103             : {
     104             :     FmEntryData*    pEntryData;
     105             :     OUString          aNewName;
     106             : 
     107             : public:
     108             :     FmNavNameChangedHint( FmEntryData* pData, const OUString& rNewName );
     109             :     virtual ~FmNavNameChangedHint();
     110             : 
     111           0 :     FmEntryData*    GetEntryData() const { return pEntryData; }
     112           0 :     OUString          GetNewName() const { return aNewName; }
     113             : };
     114             : 
     115             : 
     116             : class FmNavClearedHint : public SfxHint
     117             : {
     118             : public:
     119             :     FmNavClearedHint();
     120             :     virtual ~FmNavClearedHint();
     121             : };
     122             : 
     123             : 
     124             : class FmNavViewMarksChanged : public SfxHint
     125             : {
     126             :     FmFormView* pView;
     127             : public:
     128         318 :     FmNavViewMarksChanged(FmFormView* pWhichView) { pView = pWhichView; }
     129         318 :     virtual ~FmNavViewMarksChanged() {}
     130             : 
     131           0 :     const FmFormView* GetAffectedView() const { return pView; }
     132             : };
     133             : 
     134             : 
     135             : class FmEntryDataList;
     136             : class FmEntryData
     137             : {
     138             : private:
     139             :     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >       m_xNormalizedIFace;
     140             :     ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >   m_xProperties;
     141             :     ::com::sun::star::uno::Reference< ::com::sun::star::container::XChild >     m_xChild;
     142             : 
     143             : protected:
     144             :     Image               m_aNormalImage;
     145             :     OUString     aText;
     146             : 
     147             :     FmEntryDataList*    pChildList;
     148             :     FmEntryData*        pParent;
     149             : 
     150             : protected:
     151             :     void    newObject( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _rxIFace );
     152             : 
     153             : public:
     154             :     TYPEINFO();
     155             : 
     156             :     FmEntryData( FmEntryData* pParentData, const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _rIFace );
     157             :     FmEntryData( const FmEntryData& rEntryData );
     158             :     virtual ~FmEntryData();
     159             : 
     160             :     void    Clear();
     161           0 :     void    SetText( const OUString& rText ){ aText = rText; }
     162           0 :     void    SetParent( FmEntryData* pParentData ){ pParent = pParentData; }
     163             : 
     164           0 :     const Image&    GetNormalImage() const { return m_aNormalImage; }
     165             : 
     166           0 :     OUString          GetText() const { return aText; }
     167           0 :     FmEntryData*    GetParent() const { return pParent; }
     168           0 :     FmEntryDataList* GetChildList() const { return pChildList; }
     169             : 
     170             :     virtual bool IsEqualWithoutChildren( FmEntryData* pEntryData );
     171             :     virtual FmEntryData* Clone() = 0;
     172             : 
     173             :     // note that the interface returned is normalized, i.e. querying the given XInterface of the object
     174             :     // for XInterface must return the interface itself.
     175           0 :     const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& GetElement() const
     176             :     {
     177           0 :         return m_xNormalizedIFace;
     178             :     }
     179             : 
     180           0 :     const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& GetPropertySet() const
     181             :     {
     182           0 :         return m_xProperties;
     183             :     }
     184             : 
     185           0 :     const ::com::sun::star::uno::Reference< ::com::sun::star::container::XChild >& GetChildIFace() const
     186             :     {
     187           0 :         return m_xChild;
     188             :     }
     189             : };
     190             : 
     191             : 
     192             : typedef ::std::vector< FmEntryData* > FmEntryDataBaseList;
     193             : 
     194             : class FmEntryDataList
     195             : {
     196             : private:
     197             :     FmEntryDataBaseList maEntryDataList;
     198             : 
     199             : public:
     200             :     FmEntryDataList();
     201             :     virtual ~FmEntryDataList();
     202             : 
     203           0 :     FmEntryData*    at( size_t Index )
     204           0 :         { return ( Index < maEntryDataList.size() ) ? maEntryDataList[ Index ] : NULL; }
     205             : 
     206           0 :     size_t          size() const { return maEntryDataList.size(); }
     207             :     FmEntryData*    remove( FmEntryData* pItem );
     208             :     void            insert( FmEntryData* pItem, size_t Index );
     209             :     void            clear();
     210             : };
     211             : 
     212             : 
     213             : // FmNavRequestSelectHint - jemand teilt dem NavigatorTree mit, dass er bestimmte Eintraege selektieren soll
     214             : 
     215             : typedef std::set<FmEntryData*> FmEntryDataArray;
     216             : 
     217             : class FmNavRequestSelectHint : public SfxHint
     218             : {
     219             :     FmEntryDataArray    m_arredToSelect;
     220             :     bool                m_bMixedSelection;
     221             : public:
     222           0 :     FmNavRequestSelectHint()
     223           0 :         : m_bMixedSelection(false)
     224             :     {
     225           0 :     }
     226           0 :     virtual ~FmNavRequestSelectHint() {}
     227             : 
     228           0 :     void SetMixedSelection(bool bMixedSelection) { m_bMixedSelection = bMixedSelection; }
     229           0 :     bool IsMixedSelection() const { return m_bMixedSelection; }
     230           0 :     void AddItem(FmEntryData* pEntry) { m_arredToSelect.insert(pEntry); }
     231           0 :     void ClearItems() { m_arredToSelect.clear(); }
     232           0 :     FmEntryDataArray& GetItems() { return m_arredToSelect; }
     233             : };
     234             : 
     235             : 
     236             : class FmFormData : public FmEntryData
     237             : {
     238             :     ::com::sun::star::uno::Reference< ::com::sun::star::form::XForm >           m_xForm;
     239             :     ::com::sun::star::uno::Reference< ::com::sun::star::container::XContainer > m_xContainer;
     240             : 
     241             : public:
     242             :     TYPEINFO_OVERRIDE();
     243             : 
     244             :     FmFormData(
     245             :         const ::com::sun::star::uno::Reference< ::com::sun::star::form::XForm >& _rxForm,
     246             :         const ImageList& _rNormalImages,
     247             :         FmFormData* _pParent = NULL
     248             :     );
     249             : 
     250             :     FmFormData( const FmFormData& rFormData );
     251             :     virtual ~FmFormData();
     252             : 
     253             :     void SetForm( const ::com::sun::star::uno::Reference< ::com::sun::star::form::XForm >& xForm )
     254             :     {
     255             :         m_xForm = xForm;
     256             :         m_xContainer.set(m_xForm, css::uno::UNO_QUERY);
     257             :         newObject( m_xForm );
     258             :     }
     259             : 
     260           0 :     const ::com::sun::star::uno::Reference< ::com::sun::star::form::XForm >& GetFormIface() const { return m_xForm; }
     261           0 :     const ::com::sun::star::uno::Reference< ::com::sun::star::container::XContainer >& GetContainer() const { return m_xContainer; }
     262             : 
     263             :     virtual bool IsEqualWithoutChildren( FmEntryData* pEntryData ) SAL_OVERRIDE;
     264             :     virtual FmEntryData* Clone() SAL_OVERRIDE;
     265             : };
     266             : 
     267             : 
     268             : 
     269             : class FmControlData : public FmEntryData
     270             : {
     271             :     ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >  m_xFormComponent;
     272             : 
     273             :     Image GetImage(const ImageList& ilNavigatorImages) const;
     274             : 
     275             : public:
     276             :     TYPEINFO_OVERRIDE();
     277             : 
     278             :     FmControlData(
     279             :         const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& _rxComponent,
     280             :         const ImageList& _rNormalImages,
     281             :         FmFormData* _pParent
     282             :     );
     283             :     FmControlData( const FmControlData& rControlData );
     284             :     virtual ~FmControlData();
     285             : 
     286           0 :     const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& GetFormComponent() const { return m_xFormComponent; }
     287             :     virtual bool IsEqualWithoutChildren( FmEntryData* pEntryData ) SAL_OVERRIDE;
     288             :     virtual FmEntryData* Clone() SAL_OVERRIDE;
     289             : 
     290             :     void ModelReplaced(
     291             :         const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& _rxNew,
     292             :         const ImageList& _rNormalImages
     293             :     );
     294             : };
     295             : 
     296             : 
     297             : 
     298             : 
     299             : namespace svxform
     300             : {
     301             : 
     302             : 
     303             :     class NavigatorTreeModel;
     304             : 
     305           0 :     class OFormComponentObserver
     306             :         :public ::cppu::WeakImplHelper2 <   ::com::sun::star::beans::XPropertyChangeListener
     307             :                                         ,   ::com::sun::star::container::XContainerListener
     308             :                                         >
     309             :     {
     310             :         ::svxform::NavigatorTreeModel*  m_pNavModel;
     311             :         sal_uInt32 m_nLocks;
     312             :         bool   m_bCanUndo;
     313             : 
     314             :     public:
     315             :         OFormComponentObserver( ::svxform::NavigatorTreeModel* pModel );
     316             : 
     317             :     // XEventListenerListener
     318             :         virtual void SAL_CALL disposing(const ::com::sun::star::lang::EventObject& Source) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     319             : 
     320             :     // ::com::sun::star::beans::XPropertyChangeListener
     321             :         virtual void SAL_CALL propertyChange(const ::com::sun::star::beans::PropertyChangeEvent& evt) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     322             : 
     323             :     // ::com::sun::star::container::XContainerListener
     324             : 
     325             :         virtual void SAL_CALL elementInserted(const  ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     326             :         virtual void SAL_CALL elementReplaced(const  ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     327             :         virtual void SAL_CALL elementRemoved(const  ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     328             : 
     329           0 :         void Lock() { m_nLocks++; }
     330           0 :         void UnLock() { m_nLocks--; }
     331           0 :         bool IsLocked() const { return m_nLocks != 0; }
     332           0 :         bool CanUndo() const { return m_bCanUndo; }
     333           0 :         void ReleaseModel() { m_pNavModel = NULL; }
     334             :     protected:
     335             :         void Insert(const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xIface, sal_Int32 nIndex);
     336             :         void Remove( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _rxElement );
     337             :     };
     338             : 
     339             :     class NavigatorTreeModel : public SfxBroadcaster
     340             :                            ,public SfxListener
     341             :     {
     342             :         friend class NavigatorTree;
     343             :         friend class OFormComponentObserver;
     344             : 
     345             :         FmEntryDataList*            m_pRootList;
     346             :         FmFormShell*                m_pFormShell;
     347             :         FmFormPage*                 m_pFormPage;
     348             :         FmFormModel*                m_pFormModel;
     349             :         OFormComponentObserver*     m_pPropChangeList;
     350             : 
     351             :         ImageList                   m_aNormalImages;
     352             : 
     353             :         void UpdateContent( const ::com::sun::star::uno::Reference< ::com::sun::star::form::XForms >& xForms );
     354             :         FmControlData* CreateControlData( ::com::sun::star::form::XFormComponent* pFormComponent );
     355             : 
     356             :         void InsertForm(const ::com::sun::star::uno::Reference< ::com::sun::star::form::XForm >& xForm, sal_uInt32 nRelPos);
     357             :         void RemoveForm(FmFormData* pFormData);
     358             : 
     359             :         void InsertFormComponent(const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& xComp, sal_uInt32 nRelPos);
     360             :         void RemoveFormComponent(FmControlData* pControlData);
     361             :         void InsertSdrObj(const SdrObject* pSdrObj);
     362             :         void RemoveSdrObj(const SdrObject* pSdrObj);
     363             : 
     364             :         void ReplaceFormComponent(const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& xOld, const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& xNew);
     365             : 
     366             :         void BroadcastMarkedObjects(const SdrMarkList& mlMarked);
     367             :             // einen RequestSelectHint mit den aktuell markierten Objekten broadcasten
     368             :         bool InsertFormComponent(FmNavRequestSelectHint& rHint, SdrObject* pObject);
     369             :             // ist ein Helper fuer vorherige, managet das Abteigen in SdrObjGroups
     370             :             // Rueckgabe sal_True, wenn das Objekt eine FormComponent ist (oder rekursiv nur aus solchen besteht)
     371             : 
     372             :     public:
     373             :         NavigatorTreeModel( const ImageList& _rNormalImages );
     374             :         virtual ~NavigatorTreeModel();
     375             : 
     376             :         void FillBranch( FmFormData* pParentData );
     377             :         void ClearBranch( FmFormData* pParentData );
     378             :         void UpdateContent( FmFormShell* pNewShell );
     379             : 
     380             :         void Insert( FmEntryData* pEntryData, sal_uLong nRelPos = CONTAINER_APPEND,
     381             :                                               bool bAlterModel = false );
     382             :         void Remove( FmEntryData* pEntryData, bool bAlterModel = false );
     383             : 
     384             :         static bool Rename( FmEntryData* pEntryData, const OUString& rNewText );
     385             : 
     386             :         void Clear();
     387             :         void SetModified( bool bMod=true );
     388             : 
     389             :         ::com::sun::star::uno::Reference< ::com::sun::star::form::XForms >    GetForms() const;
     390           0 :         FmFormShell*        GetFormShell() const { return m_pFormShell; }
     391           0 :         FmFormPage*         GetFormPage() const { return m_pFormPage; }
     392             :         FmEntryData*        FindData( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xElement, FmEntryDataList* pDataList, bool bRecurs=true );
     393             :         FmEntryData*        FindData( const OUString& rText, FmFormData* pParentData, bool bRecurs=true );
     394           0 :         FmEntryDataList*    GetRootList() const { return m_pRootList; }
     395             :         static ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexContainer >   GetFormComponents( FmFormData* pParentFormData );
     396             :         SdrObject*          Search(SdrObjListIter& rIter, const ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent >& xComp);
     397             : 
     398             :         virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) SAL_OVERRIDE;
     399             :     };
     400             : 
     401             : 
     402             :     typedef std::set<SvTreeListEntry*> SvLBoxEntrySortedArray;
     403             : 
     404             :     class NavigatorTree : public SvTreeListBox, public SfxListener
     405             :     {
     406             :         enum DROP_ACTION        { DA_SCROLLUP, DA_SCROLLDOWN, DA_EXPANDNODE };
     407             :         enum SELDATA_ITEMS      { SDI_DIRTY, SDI_ALL, SDI_NORMALIZED, SDI_NORMALIZED_FORMARK };
     408             : 
     409             :         // beim Droppen will ich scrollen und Folder aufklappen koennen, dafuer :
     410             :         AutoTimer           m_aDropActionTimer;
     411             :         Timer               m_aSynchronizeTimer;
     412             :         // die Meta-Daten ueber meine aktuelle Selektion
     413             :         SvLBoxEntrySortedArray  m_arrCurrentSelection;
     414             :         // the entries which, in the view, are currently marked as "cut" (painted semi-transparent)
     415             :         ListBoxEntrySet         m_aCutEntries;
     416             :         // die Images, die ich brauche (und an FormDatas und EntryDatas weiterreiche)
     417             :         ImageList           m_aNavigatorImages;
     418             : 
     419             :         ::svxform::OControlExchangeHelper   m_aControlExchange;
     420             : 
     421             :         NavigatorTreeModel* m_pNavModel;
     422             :         SvTreeListEntry*        m_pRootEntry;
     423             :         SvTreeListEntry*        m_pEditEntry;
     424             : 
     425             :         ImplSVEvent *       nEditEvent;
     426             : 
     427             :         SELDATA_ITEMS       m_sdiState;
     428             :         Point               m_aTimerTriggered;      // die Position, an der der DropTimer angeschaltet wurde
     429             :         DROP_ACTION         m_aDropActionType;
     430             : 
     431             :         sal_uInt16          m_nSelectLock;
     432             :         sal_uInt16          m_nFormsSelected;
     433             :         sal_uInt16          m_nControlsSelected;
     434             :         sal_uInt16          m_nHiddenControls;      // (die Zahl geht in m_nControlsSelected mit ein)
     435             : 
     436             :         unsigned short      m_aTimerCounter;
     437             : 
     438             :         bool            m_bDragDataDirty        : 1;    // dito
     439             :         bool            m_bPrevSelectionMixed   : 1;
     440             :         bool            m_bMarkingObjects       : 1;    // wenn das sal_True ist, brauche ich auf die RequestSelectHints nicht reagieren
     441             :         bool            m_bRootSelected         : 1;
     442             :         bool            m_bInitialUpdate        : 1;   // bin ich das erste Mal im UpdateContent ?
     443             :         bool            m_bKeyboardCut          : 1;
     444             : 
     445             : 
     446             :         void            UpdateContent();
     447             :         FmControlData*  NewControl( const OUString& rServiceName, SvTreeListEntry* pParentEntry, bool bEditName = true );
     448             :         void            NewForm( SvTreeListEntry* pParentEntry );
     449             :         SvTreeListEntry*    Insert( FmEntryData* pEntryData, sal_uLong nRelPos=TREELIST_APPEND );
     450             :         void            Remove( FmEntryData* pEntryData );
     451             : 
     452             : 
     453             :         void CollectSelectionData(SELDATA_ITEMS sdiHow);
     454             :             // sammelt in m_arrCurrentSelection die aktuell selektierten Eintraege, normalisiert die Liste wenn verlangt
     455             :             // SDI_NORMALIZED bedeutet einfach, dass alle Eintraege, die schon einen selektierten Vorfahren haben, nicht mit gesammelt
     456             :             // werden.
     457             :             // SDI_NORMALIZED_FORMARK bedeutet, dass wie bei SDI_NORMALIZED verfahren wird, aber Eintraege, deren direktes Elter nicht
     458             :             // selektiert ist, aufgenommen werden (unabhaengig vom Status weiterer Vorfahren), desgleichen Formulare, die selektiert sind,
     459             :             // unabhaengig vom Status irgendwelcher Vorfahren
     460             :             // Bei beiden Normalized-Modi enthalten die m_nFormsSelected, ... die richtige Anzahl, auch wenn nicht alle dieser Eintraege
     461             :             // in m_arrCurrentSelection landen.
     462             :             // SDI_DIRTY ist natuerlich nicht erlaubt als Parameter
     463             : 
     464             :         // ein einziges Interface fuer alle selektierten Eintraege zusammensetzen
     465             :         void    ShowSelectionProperties(bool bForce = false);
     466             :         // alle selektierten Elemnte loeschen
     467             :         void    DeleteSelection();
     468             : 
     469             :         void SynchronizeSelection(FmEntryDataArray& arredToSelect);
     470             :             // nach dem Aufruf dieser Methode sind genau die Eintraege selektiert, die in dem Array bezeichnet sind
     471             :         void SynchronizeSelection();
     472             :             // macht das selbe, nimmt die MarkList der View
     473             :         void SynchronizeMarkList();
     474             :             // umgekehrte Richtung von SynchronizeMarkList : markiert in der View alle der aktuellen Selektion entsprechenden Controls
     475             : 
     476             :         void CollectObjects(FmFormData* pFormData, bool bDeep, ::std::set< ::com::sun::star::uno::Reference< ::com::sun::star::form::XFormComponent > >& _rObjects);
     477             : 
     478             :         // im Select aktualisiere ich normalerweise die Marklist der zugehoerigen View, mit folgenden Funktionen
     479             :         // kann ich das Locking dieses Verhaltens steuern
     480           0 :         void LockSelectionHandling() { ++m_nSelectLock; }
     481           0 :         void UnlockSelectionHandling() { --m_nSelectLock; }
     482           0 :         bool IsSelectionHandlingLocked() const { return m_nSelectLock>0; }
     483             : 
     484             :         static bool IsHiddenControl(FmEntryData* pEntryData);
     485             : 
     486             :         DECL_LINK( OnEdit, void* );
     487             :         DECL_LINK_TYPED( OnDropActionTimer, Timer*, void );
     488             : 
     489             :         DECL_LINK(OnEntrySelDesel, NavigatorTree*);
     490             :         DECL_LINK_TYPED(OnSynchronizeTimer, Timer*, void);
     491             : 
     492             :         DECL_LINK( OnClipboardAction, void* );
     493             : 
     494             :     protected:
     495             :         virtual void    Command( const CommandEvent& rEvt ) SAL_OVERRIDE;
     496             : 
     497             :         virtual sal_Int8    AcceptDrop( const AcceptDropEvent& rEvt ) SAL_OVERRIDE;
     498             :         virtual sal_Int8    ExecuteDrop( const ExecuteDropEvent& rEvt ) SAL_OVERRIDE;
     499             :         virtual void        StartDrag( sal_Int8 nAction, const Point& rPosPixel ) SAL_OVERRIDE;
     500             : 
     501             :     public:
     502             :         NavigatorTree(vcl::Window* pParent );
     503             :         virtual ~NavigatorTree();
     504             :         virtual void dispose() SAL_OVERRIDE;
     505             : 
     506             :         void Clear();
     507             :         void UpdateContent( FmFormShell* pFormShell );
     508             :         void MarkViewObj( FmFormData* pFormData, bool bMark, bool bDeep = false );
     509             :         void MarkViewObj( FmControlData* pControlData, bool bMarkHandles, bool bMark );
     510             :         void UnmarkAllViewObj();
     511             : 
     512             :         static bool IsFormEntry( SvTreeListEntry* pEntry );
     513             :         static bool IsFormComponentEntry( SvTreeListEntry* pEntry );
     514             : 
     515             :         OUString GenerateName( FmEntryData* pEntryData );
     516             : 
     517           0 :         NavigatorTreeModel*    GetNavModel() const { return m_pNavModel; }
     518             :         SvTreeListEntry*        FindEntry( FmEntryData* pEntryData );
     519             : 
     520             :         virtual bool EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText ) SAL_OVERRIDE;
     521             :         virtual bool Select( SvTreeListEntry* pEntry, bool bSelect=true ) SAL_OVERRIDE;
     522             :         virtual bool EditingEntry( SvTreeListEntry* pEntry, Selection& ) SAL_OVERRIDE;
     523             :         virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) SAL_OVERRIDE;
     524             :         virtual void KeyInput( const KeyEvent& rKEvt ) SAL_OVERRIDE;
     525             : 
     526             :         virtual void ModelHasRemoved( SvTreeListEntry* _pEntry ) SAL_OVERRIDE;
     527             : 
     528             :         using SvTreeListBox::Insert;
     529             :         using SvTreeListBox::ExecuteDrop;
     530             :         using SvTreeListBox::Select;
     531             :         using SvTreeListBox::Notify;
     532             : 
     533             :     private:
     534             :         sal_Int8    implAcceptDataTransfer( const DataFlavorExVector& _rFlavors, sal_Int8 _nAction, const Point& _rDropPos, bool _bDnD );
     535             :         sal_Int8    implAcceptDataTransfer( const DataFlavorExVector& _rFlavors, sal_Int8 _nAction, SvTreeListEntry* _pTargetEntry, bool _bDnD );
     536             : 
     537             :         sal_Int8    implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const Point& _rDropPos, bool _bDnD );
     538             :         sal_Int8    implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, SvTreeListEntry* _pTargetEntry, bool _bDnD );
     539             : 
     540             :         // check if a cut, copy, or drag operation can be started in the current situation
     541             :         bool        implAllowExchange( sal_Int8 _nAction, bool* _pHasNonHidden = NULL );
     542             :         // check if a paste with the current clipboard content can be accepted
     543             :         bool        implAcceptPaste( );
     544             : 
     545             :         // fills m_aControlExchange in preparation of a DnD or clipboard operation
     546             :         bool        implPrepareExchange( sal_Int8 _nAction );
     547             : 
     548             :         void        doPaste();
     549             :         void        doCopy();
     550             :         void        doCut();
     551             : 
     552           0 :         bool    doingKeyboardCut( ) const { return m_bKeyboardCut; }
     553             :     };
     554             : 
     555             : 
     556             :     class NavigatorFrame : public SfxDockingWindow, public SfxControllerItem
     557             :     {
     558             :     private:
     559             :         VclPtr< ::svxform::NavigatorTree> m_pNavigatorTree;
     560             : 
     561             :     protected:
     562             :         virtual void Resize() SAL_OVERRIDE;
     563             :         virtual bool Close() SAL_OVERRIDE;
     564             :         virtual void GetFocus() SAL_OVERRIDE;
     565             :         virtual Size CalcDockingSize( SfxChildAlignment ) SAL_OVERRIDE;
     566             :         virtual SfxChildAlignment CheckAlignment( SfxChildAlignment, SfxChildAlignment ) SAL_OVERRIDE;
     567             : 
     568             :         using SfxDockingWindow::StateChanged;
     569             : 
     570             :     public:
     571             :         NavigatorFrame( SfxBindings *pBindings, SfxChildWindow *pMgr,
     572             :                        vcl::Window* pParent );
     573             :         virtual ~NavigatorFrame();
     574             :         virtual void dispose() SAL_OVERRIDE;
     575             : 
     576             :         void UpdateContent( FmFormShell* pFormShell );
     577             :         void StateChanged( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) SAL_OVERRIDE;
     578             :         void FillInfo( SfxChildWinInfo& rInfo ) const SAL_OVERRIDE;
     579             :     };
     580             : 
     581             : 
     582           0 :     class SVX_DLLPUBLIC NavigatorFrameManager : public SfxChildWindow
     583             :     {
     584             :     public:
     585             :         SVX_DLLPRIVATE NavigatorFrameManager( vcl::Window *pParent, sal_uInt16 nId, SfxBindings *pBindings,
     586             :                           SfxChildWinInfo *pInfo );
     587             :         SFX_DECL_CHILDWINDOW( NavigatorFrameManager );
     588             :     };
     589             : 
     590             : 
     591             : }
     592             : 
     593             : 
     594             : #endif // INCLUDED_SVX_SOURCE_INC_FMEXPL_HXX
     595             : 
     596             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11