svx/source/inc/fmexpl.hxx

   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 <config_options.h>
  23 #include <svl/lstner.hxx>
  24 #include <svl/SfxBroadcaster.hxx>
  25 #include <vcl/window.hxx>
  26 #include <sfx2/childwin.hxx>
  27 #include <svl/poolitem.hxx>
  28 #include <sfx2/bindings.hxx>
  29 #include <sfx2/dockwin.hxx>
  30 #include <sfx2/ctrlitem.hxx>
  31 #include <vcl/image.hxx>
  32
  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/beans/XPropertyChangeListener.hpp>
  38 #include <com/sun/star/container/XIndexContainer.hpp>
  39
  40 #include <svx/fmview.hxx>
  41
  42 #include "fmexch.hxx"
  43 #include <vector>
  44 #include <set>
  45 #include <cppuhelper/implbase.hxx>
  46
  47 class SdrObjListIter;
  48 class FmFormShell;
  49 class SdrObject;
  50 class FmFormModel;
  51 class FmFormView;
  52 class SdrMarkList;
  53
  54
  55 class FmEntryData;
  56 class FmNavInsertedHint : public SfxHint
  57 {
  58     FmEntryData* pEntryData;
  59     sal_uInt32 nPos;
  60
  61 public:
  62     FmNavInsertedHint( FmEntryData* pInsertedEntryData, sal_uInt32 nRelPos );
  63     virtual ~FmNavInsertedHint() override;
  64
  65     FmEntryData* GetEntryData() const { return pEntryData; }
  66     sal_uInt32 GetRelPos() const { return nPos; }
  67 };
  68
  69
  70 class FmNavModelReplacedHint : public SfxHint
  71 {
  72     FmEntryData* pEntryData;    // the data of the entry that has got a new model
  73
  74 public:
  75     FmNavModelReplacedHint( FmEntryData* pAffectedEntryData );
  76     virtual ~FmNavModelReplacedHint() override;
  77
  78     FmEntryData* GetEntryData() const { return pEntryData; }
  79 };
  80
  81
  82 class FmNavRemovedHint : public SfxHint
  83 {
  84     FmEntryData* pEntryData;
  85
  86 public:
  87     FmNavRemovedHint( FmEntryData* pInsertedEntryData );
  88     virtual ~FmNavRemovedHint() override;
  89
  90     FmEntryData* GetEntryData() const { return pEntryData; }
  91 };
  92
  93
  94 class FmNavNameChangedHint : public SfxHint
  95 {
  96     FmEntryData*    pEntryData;
  97     OUString          aNewName;
  98
  99 public:
 100     FmNavNameChangedHint( FmEntryData* pData, const OUString& rNewName );
 101     virtual ~FmNavNameChangedHint() override;
 102
 103     FmEntryData*    GetEntryData() const { return pEntryData; }
 104     const OUString& GetNewName() const { return aNewName; }
 105 };
 106
 107
 108 class FmNavClearedHint : public SfxHint
 109 {
 110 public:
 111     FmNavClearedHint();
 112     virtual ~FmNavClearedHint() override;
 113 };
 114
 115
 116 class FmNavViewMarksChanged : public SfxHint
 117 {
 118     FmFormView* pView;
 119 public:
 120     FmNavViewMarksChanged(FmFormView* pWhichView) { pView = pWhichView; }
 121
 122     const FmFormView* GetAffectedView() const { return pView; }
 123 };
 124
 125
 126 class FmEntryDataList;
 127 class FmEntryData
 128 {
 129 private:
 130     css::uno::Reference< css::uno::XInterface >       m_xNormalizedIFace;
 131     css::uno::Reference< css::beans::XPropertySet >   m_xProperties;
 132     css::uno::Reference< css::container::XChild >     m_xChild;
 133
 134 protected:
 135     OUString            m_aNormalImage;
 136     OUString            aText;
 137
 138     std::unique_ptr<FmEntryDataList>
 139                         pChildList;
 140     FmEntryData*        pParent;
 141
 142 protected:
 143     void    newObject( const css::uno::Reference< css::uno::XInterface >& _rxIFace );
 144
 145 public:
 146
 147     FmEntryData( FmEntryData* pParentData, const css::uno::Reference< css::uno::XInterface >& _rIFace );
 148     FmEntryData( const FmEntryData& rEntryData );
 149     virtual ~FmEntryData();
 150
 151     void    SetText( const OUString& rText ){ aText = rText; }
 152     void    SetParent( FmEntryData* pParentData ){ pParent = pParentData; }
 153
 154     const OUString& GetNormalImage() const { return m_aNormalImage; }
 155
 156     const OUString& GetText() const { return aText; }
 157     FmEntryData*    GetParent() const { return pParent; }
 158     FmEntryDataList* GetChildList() const { return pChildList.get(); }
 159
 160     virtual bool IsEqualWithoutChildren( FmEntryData* pEntryData );
 161     virtual std::unique_ptr<FmEntryData> Clone() = 0;
 162
 163     // note that the interface returned is normalized, i.e. querying the given XInterface of the object
 164     // for XInterface must return the interface itself.
 165     const css::uno::Reference< css::uno::XInterface >& GetElement() const
 166     {
 167         return m_xNormalizedIFace;
 168     }
 169
 170     const css::uno::Reference< css::beans::XPropertySet >& GetPropertySet() const
 171     {
 172         return m_xProperties;
 173     }
 174
 175     const css::uno::Reference< css::container::XChild >& GetChildIFace() const
 176     {
 177         return m_xChild;
 178     }
 179 };
 180
 181
 182 class FmEntryDataList final
 183 {
 184 private:
 185     std::vector< std::unique_ptr<FmEntryData> > maEntryDataList;
 186
 187 public:
 188     FmEntryDataList();
 189     ~FmEntryDataList();
 190
 191     FmEntryData*    at( size_t Index )
 192         { return maEntryDataList.at(Index).get(); }
 193
 194     size_t          size() const { return maEntryDataList.size(); }
 195     void            removeNoDelete( FmEntryData* pItem );
 196     void            insert( std::unique_ptr<FmEntryData> pItem, size_t Index );
 197     void            clear();
 198 };
 199
 200
 201 // FmNavRequestSelectHint - someone tells the NavigatorTree to select certain entries
 202
 203 typedef std::set<FmEntryData*> FmEntryDataArray;
 204
 205 class FmNavRequestSelectHint : public SfxHint
 206 {
 207     FmEntryDataArray    m_arredToSelect;
 208     bool                m_bMixedSelection;
 209 public:
 210     FmNavRequestSelectHint()
 211         : m_bMixedSelection(false)
 212     {
 213     }
 214
 215     void SetMixedSelection(bool bMixedSelection) { m_bMixedSelection = bMixedSelection; }
 216     bool IsMixedSelection() const { return m_bMixedSelection; }
 217     void AddItem(FmEntryData* pEntry) { m_arredToSelect.insert(pEntry); }
 218     void ClearItems() { m_arredToSelect.clear(); }
 219     FmEntryDataArray& GetItems() { return m_arredToSelect; }
 220 };
 221
 222
 223 class FmFormData : public FmEntryData
 224 {
 225     css::uno::Reference< css::form::XForm >           m_xForm;
 226
 227 public:
 228     FmFormData(const css::uno::Reference< css::form::XForm >& _rxForm, FmFormData* _pParent);
 229     FmFormData( const FmFormData& rFormData );
 230     virtual ~FmFormData() override;
 231
 232     const css::uno::Reference< css::form::XForm >& GetFormIface() const { return m_xForm; }
 233
 234     virtual bool IsEqualWithoutChildren( FmEntryData* pEntryData ) override;
 235     virtual std::unique_ptr<FmEntryData> Clone() override;
 236 };
 237
 238
 239 class FmControlData : public FmEntryData
 240 {
 241     css::uno::Reference< css::form::XFormComponent >  m_xFormComponent;
 242
 243     OUString GetImage() const;
 244
 245 public:
 246
 247     FmControlData(
 248         const css::uno::Reference< css::form::XFormComponent >& _rxComponent,
 249         FmFormData* _pParent
 250     );
 251     FmControlData( const FmControlData& rControlData );
 252     virtual ~FmControlData() override;
 253
 254     const css::uno::Reference< css::form::XFormComponent >& GetFormComponent() const { return m_xFormComponent; }
 255     virtual bool IsEqualWithoutChildren( FmEntryData* pEntryData ) override;
 256     virtual std::unique_ptr<FmEntryData> Clone() override;
 257
 258     void ModelReplaced(const css::uno::Reference< css::form::XFormComponent >& _rxNew);
 259 };
 260
 261
 262 namespace svxform
 263 {
 264
 265
 266     class NavigatorTreeModel;
 267
 268     class OFormComponentObserver final
 269         :public ::cppu::WeakImplHelper <   css::beans::XPropertyChangeListener
 270                                         ,   css::container::XContainerListener
 271                                         >
 272     {
 273         ::svxform::NavigatorTreeModel*  m_pNavModel;
 274         sal_uInt32 m_nLocks;
 275         bool   m_bCanUndo;
 276
 277     public:
 278         OFormComponentObserver( ::svxform::NavigatorTreeModel* pModel );
 279
 280     // XEventListenerListener
 281         virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
 282
 283     // css::beans::XPropertyChangeListener
 284         virtual void SAL_CALL propertyChange(const css::beans::PropertyChangeEvent& evt) override;
 285
 286     // css::container::XContainerListener
 287
 288         virtual void SAL_CALL elementInserted(const  css::container::ContainerEvent& rEvent) override;
 289         virtual void SAL_CALL elementReplaced(const  css::container::ContainerEvent& rEvent) override;
 290         virtual void SAL_CALL elementRemoved(const  css::container::ContainerEvent& rEvent) override;
 291
 292         void Lock() { m_nLocks++; }
 293         void UnLock() { m_nLocks--; }
 294         bool IsLocked() const { return m_nLocks != 0; }
 295         bool CanUndo() const { return m_bCanUndo; }
 296         void ReleaseModel() { m_pNavModel = nullptr; }
 297     private:
 298         void Insert(const css::uno::Reference< css::uno::XInterface >& xIface, sal_Int32 nIndex);
 299         void Remove( const css::uno::Reference< css::uno::XInterface >& _rxElement );
 300     };
 301
 302     class NavigatorTreeModel : public SfxBroadcaster
 303                            ,public SfxListener
 304     {
 305         friend class NavigatorTree;
 306         friend class OFormComponentObserver;
 307
 308         std::unique_ptr<FmEntryDataList>
 309                                     m_pRootList;
 310         FmFormShell*                m_pFormShell;
 311         FmFormPage*                 m_pFormPage;
 312         FmFormModel*                m_pFormModel;
 313         rtl::Reference<OFormComponentObserver> m_pPropChangeList;
 314
 315         void UpdateContent( const css::uno::Reference< css::form::XForms >& xForms );
 316
 317         void InsertForm(const css::uno::Reference< css::form::XForm >& xForm, sal_uInt32 nRelPos);
 318         void RemoveForm(FmFormData const * pFormData);
 319
 320         void InsertFormComponent(const css::uno::Reference< css::form::XFormComponent >& xComp, sal_uInt32 nRelPos);
 321         void RemoveFormComponent(FmControlData const * pControlData);
 322         void InsertSdrObj(const SdrObject* pSdrObj);
 323         void RemoveSdrObj(const SdrObject* pSdrObj);
 324
 325         void ReplaceFormComponent(const css::uno::Reference< css::form::XFormComponent >& xOld, const css::uno::Reference< css::form::XFormComponent >& xNew);
 326
 327         void BroadcastMarkedObjects(const SdrMarkList& mlMarked);
 328             // send a RequestSelectHint with the currently selected objects
 329         bool InsertFormComponent(FmNavRequestSelectHint& rHint, SdrObject* pObject);
 330             // is a helper for previous, manages the ... in SdrObjGroups;
 331             // returns sal_True if the object is a FormComponent (or recursively consists only of such)
 332
 333     public:
 334         NavigatorTreeModel();
 335         virtual ~NavigatorTreeModel() override;
 336
 337         void FillBranch( FmFormData* pParentData );
 338         void UpdateContent( FmFormShell* pNewShell );
 339
 340         void Insert(FmEntryData* pEntryData, sal_uInt32 nRelPos = SAL_MAX_UINT32,
 341                                              bool bAlterModel = false);
 342         void Remove(FmEntryData* pEntryData, bool bAlterModel = false);
 343
 344         static bool Rename( FmEntryData* pEntryData, const OUString& rNewText );
 345
 346         void Clear();
 347         void SetModified();
 348
 349         css::uno::Reference< css::form::XForms >    GetForms() const;
 350         FmFormShell*        GetFormShell() const { return m_pFormShell; }
 351         FmFormPage*         GetFormPage() const { return m_pFormPage; }
 352         FmEntryData*        FindData( const css::uno::Reference< css::uno::XInterface >& xElement, FmEntryDataList* pDataList, bool bRecurs=true );
 353         FmEntryData*        FindData( const OUString& rText, FmFormData const * pParentData, bool bRecurs );
 354         FmEntryDataList*    GetRootList() const { return m_pRootList.get(); }
 355         static css::uno::Reference< css::container::XIndexContainer >   GetFormComponents( FmFormData const * pParentFormData );
 356
 357         virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
 358     };
 359
 360     class NavigatorTree;
 361
 362     class NavigatorTreeDropTarget : public DropTargetHelper
 363     {
 364     private:
 365         NavigatorTree& m_rTreeView;
 366
 367         virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override;
 368         virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override;
 369
 370     public:
 371         NavigatorTreeDropTarget(NavigatorTree& rTreeView);
 372     };
 373
 374     typedef std::set<std::unique_ptr<weld::TreeIter>> SvLBoxEntrySortedArray;
 375
 376     class NavigatorTree final : public SfxListener
 377     {
 378         std::unique_ptr<weld::TreeView> m_xTreeView;
 379         NavigatorTreeDropTarget m_aDropTargetHelper;
 380
 381         enum SELDATA_ITEMS      { SDI_DIRTY, SDI_ALL, SDI_NORMALIZED, SDI_NORMALIZED_FORMARK };
 382
 383         Timer               m_aSynchronizeTimer;
 384         // the meta-data about my current selection
 385         SvLBoxEntrySortedArray  m_arrCurrentSelection;
 386         // the entries which, in the view, are currently marked as "cut" (painted semi-transparent)
 387         ListBoxEntrySet         m_aCutEntries;
 388
 389         ::svxform::OControlExchangeHelper m_aControlExchange;
 390
 391         std::unique_ptr<NavigatorTreeModel> m_pNavModel;
 392         std::unique_ptr<weld::TreeIter> m_xRootEntry;
 393         std::unique_ptr<weld::TreeIter> m_xEditEntry;
 394
 395         ImplSVEvent *       nEditEvent;
 396
 397         SELDATA_ITEMS       m_sdiState;
 398
 399         sal_uInt16          m_nSelectLock;
 400         sal_uInt16          m_nFormsSelected;
 401         sal_uInt16          m_nControlsSelected;
 402         sal_uInt16          m_nHiddenControls;      // (the number is included in m_nControlsSelected)
 403
 404         bool            m_bDragDataDirty        : 1;    // ditto
 405         bool            m_bPrevSelectionMixed   : 1;
 406         bool            m_bRootSelected         : 1;
 407         bool            m_bInitialUpdate        : 1;    // am I the first time in the UpdateContent?
 408         bool            m_bKeyboardCut          : 1;
 409         bool            m_bEditing              : 1;
 410
 411         FmControlData*  NewControl(const OUString& rServiceName, const weld::TreeIter& rParentEntry, bool bEditName);
 412         void            NewForm(const weld::TreeIter& rParentEntry);
 413         std::unique_ptr<weld::TreeIter> Insert(FmEntryData* pEntryData, int nRelPos);
 414         void            Remove( FmEntryData* pEntryData );
 415
 416
 417         void CollectSelectionData(SELDATA_ITEMS sdiHow);
 418             // Collects the currently selected entries in m_arrCurrentSelection, normalizes the list if requested.
 419             // - SDI_NORMALIZED simply means that all entries that already have a selected ancestor are not collected.
 420             // - SDI_NORMALIZED_FORMARK means that the procedure is the same as for SDI_NORMALIZED,
 421             //   but entries whose direct parent is not selected are collected (independent of the
 422             //   status of further ancestors). The same applies for forms that are selected,
 423             //   regardless of the status of any ancestors.
 424             // For both normalized modes, the m_nFormsSelected, ... contain the correct number,
 425             // even if not all of these entries end up in m_arrCurrentSelection.
 426             // SDI_DIRTY is of course not allowed as a parameter.
 427
 428         // a single interface for all selected entries
 429         void    ShowSelectionProperties(bool bForce = false);
 430         // delete all selected elements
 431         void    DeleteSelection();
 432
 433         void SynchronizeSelection(FmEntryDataArray& arredToSelect);
 434             // after calling this method, exactly the entries marked in the array are selected
 435         void SynchronizeSelection();
 436             // makes the same, takes the MarkList of the View
 437         void SynchronizeMarkList();
 438             // reverse direction of SynchronizeMarkList: selects in the view all controls corresponding to the current selection
 439
 440         void CollectObjects(FmFormData const * pFormData, bool bDeep, ::std::set< css::uno::Reference< css::form::XFormComponent > >& _rObjects);
 441
 442         // in the Select I usually update the Marklist of the corresponding view,
 443         // with the following functions I can control the locking of this behavior
 444         void LockSelectionHandling() { ++m_nSelectLock; }
 445         void UnlockSelectionHandling() { --m_nSelectLock; }
 446         bool IsSelectionHandlingLocked() const { return m_nSelectLock>0; }
 447
 448         bool IsEditingActive() const { return m_bEditing; }
 449
 450         static bool IsHiddenControl(FmEntryData const * pEntryData);
 451
 452         DECL_LINK( KeyInputHdl, const KeyEvent&, bool );
 453         DECL_LINK( PopupMenuHdl, const CommandEvent&, bool );
 454
 455         DECL_LINK(EditingEntryHdl, const weld::TreeIter&, bool);
 456         typedef std::pair<const weld::TreeIter&, OUString> IterString;
 457         DECL_LINK(EditedEntryHdl, const IterString&, bool);
 458
 459         DECL_LINK( OnEdit, void*, void );
 460
 461         DECL_LINK( OnEntrySelDesel, weld::TreeView&, void );
 462         DECL_LINK( OnSynchronizeTimer, Timer*, void );
 463
 464         DECL_LINK( OnClipboardAction, OLocalExchange&, void );
 465
 466         DECL_LINK( DragBeginHdl, bool&, bool );
 467
 468     public:
 469         NavigatorTree(std::unique_ptr<weld::TreeView> xTreeView);
 470         virtual ~NavigatorTree() override;
 471
 472         void Clear();
 473         void UpdateContent( FmFormShell* pFormShell );
 474         void MarkViewObj( FmFormData const * pFormData, bool bDeep );
 475         void MarkViewObj( FmControlData const * pControlData );
 476         void UnmarkAllViewObj();
 477
 478         void GrabFocus() { m_xTreeView->grab_focus(); }
 479
 480         bool IsFormEntry(const weld::TreeIter& rEntry);
 481         bool IsFormComponentEntry(const weld::TreeIter& rEntry);
 482
 483         OUString GenerateName( FmEntryData const * pEntryData );
 484
 485         NavigatorTreeModel*    GetNavModel() const { return m_pNavModel.get(); }
 486         std::unique_ptr<weld::TreeIter> FindEntry(FmEntryData* pEntryData);
 487
 488         virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
 489
 490         weld::TreeView& get_widget() { return *m_xTreeView; }
 491
 492         sal_Int8    AcceptDrop(const AcceptDropEvent& rEvt);
 493         sal_Int8    ExecuteDrop(const ExecuteDropEvent& rEvt);
 494
 495     private:
 496         sal_Int8    implAcceptDataTransfer( const DataFlavorExVector& _rFlavors, sal_Int8 _nAction, const weld::TreeIter* _pTargetEntry, bool _bDnD );
 497
 498         sal_Int8    implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const Point& _rDropPos, bool _bDnD );
 499         sal_Int8    implExecuteDataTransfer( const OControlTransferData& _rData, sal_Int8 _nAction, const weld::TreeIter* _pTargetEntry, bool _bDnD );
 500
 501         // check if a cut, copy, or drag operation can be started in the current situation
 502         bool        implAllowExchange( sal_Int8 _nAction, bool* _pHasNonHidden = nullptr );
 503         // check if a paste with the current clipboard content can be accepted
 504         bool        implAcceptPaste( );
 505
 506         // fills m_aControlExchange in preparation of a DnD or clipboard operation
 507         bool        implPrepareExchange( sal_Int8 _nAction );
 508
 509         void        ModelHasRemoved(const weld::TreeIter* _pEntry);
 510
 511         void        doPaste();
 512         void        doCopy();
 513         void        doCut();
 514
 515         bool    doingKeyboardCut( ) const { return m_bKeyboardCut; }
 516     };
 517
 518     class NavigatorFrame : public SfxDockingWindow, public SfxControllerItem
 519     {
 520     private:
 521         std::unique_ptr<NavigatorTree> m_xNavigatorTree;
 522
 523     protected:
 524         virtual bool Close() override;
 525         virtual void GetFocus() override;
 526         virtual Size CalcDockingSize( SfxChildAlignment ) override;
 527         virtual SfxChildAlignment CheckAlignment( SfxChildAlignment, SfxChildAlignment ) override;
 528
 529         using SfxDockingWindow::StateChanged;
 530
 531     public:
 532         NavigatorFrame( SfxBindings *pBindings, SfxChildWindow *pMgr,
 533                        vcl::Window* pParent );
 534         virtual ~NavigatorFrame() override;
 535         virtual void dispose() override;
 536
 537         void UpdateContent( FmFormShell* pFormShell );
 538         void StateChanged( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) override;
 539         void FillInfo( SfxChildWinInfo& rInfo ) const override;
 540     };
 541
 542     class UNLESS_MERGELIBS(SVXCORE_DLLPUBLIC) NavigatorFrameManager : public SfxChildWindow
 543     {
 544     public:
 545         SVX_DLLPRIVATE NavigatorFrameManager( vcl::Window *pParent, sal_uInt16 nId, SfxBindings *pBindings,
 546                           SfxChildWinInfo *pInfo );
 547         SFX_DECL_CHILDWINDOW( NavigatorFrameManager );
 548     };
 549 }
 550
 551 #endif // INCLUDED_SVX_SOURCE_INC_FMEXPL_HXX
 552
 553 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */