svdpage.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include <cppuhelper/weak.hxx>
#include <svl/stylesheetuser.hxx>
#include <vcl/prntypes.hxx>
#include <svl/itemset.hxx>
#include <svx/sdrpageuser.hxx>
#include <svx/sdr/contact/viewobjectcontactredirector.hxx>
#include <svx/sdrmasterpagedescriptor.hxx>
#include <svx/svxdllapi.h>
#include <com/sun/star/container/XIndexAccess.hpp>
#include <com/sun/star/drawing/XDrawPage.hpp>
#include <svx/svdobj.hxx>
#include <unotools/weakref.hxx>
#include <memory>
#include <optional>
#include <vector>
#include <deque>
 
 
// predefines
namespace model { class Theme; }
namespace reportdesign { class OSection; }
namespace sdr::contact { class ViewContact; }
class SdrPage;
class SdrModel;
class SfxItemPool;
class SdrPageView;
class SdrLayerAdmin;
class SdrLayerIDSet;
class Color;
class SfxStyleSheet;
class SvxUnoDrawPagesAccess;
 
//
//  SdrObjList
//      E3dObjList
//      SdrPage -> see continuation there
 
// class SdrObjList
class SVXCORE_DLLPUBLIC SdrObjList
{
friend class SdrObjListIter;
friend class SdrEditView;
 
private:
    SdrObjList(const SdrObjList& rSrcList) = delete;
    SdrObjList &operator=(const SdrObjList& rSrcList) = delete;
 
protected:
    void RecalcRects();
 
private:
    static void impChildInserted(SdrObject const & rChild);
 
    // tdf#116879 Clear SdrObjList, no Undo done. Used from destructor, but also
    // from other places. When used from destructor, suppress broadcasts
    // to not get callbacks to evtl. derived objects already in destruction
    // (e.g. SdrPage)
    void impClearSdrObjList(bool bBroadcast);
 
protected:
    // protected constructor to make clear that this class should only
    // be used as base for derivations, not naked. See getSdrModelFromSdrObjList
    // which is pure virtual to force this, too
    SdrObjList();
    virtual ~SdrObjList();
 
public:
    // SdrModel/SdrPage access on SdrObjList level
    virtual SdrPage* getSdrPageFromSdrObjList() const;
    virtual SdrObject* getSdrObjectFromSdrObjList() const;
 
    void CopyObjects(const SdrObjList& rSrcList);
 
    // tdf#116879 clean up everything (without Undo), plus broadcasting
    // changes. Split to this call and a private one (impClearSdrObjList)
    // that allows cleanup without broadcasting in the destructor
    void    ClearSdrObjList();
 
    void           RecalcObjOrdNums();
    bool           IsObjOrdNumsDirty() const        { return mbObjOrdNumsDirty; }
    virtual void   NbcInsertObject(SdrObject* pObj, size_t nPos=SAL_MAX_SIZE);
    virtual void   InsertObject(SdrObject* pObj, size_t nPos=SAL_MAX_SIZE);
    void           sort( std::vector<sal_Int32>& sortOrder );
 
    void InsertObjectThenMakeNameUnique(SdrObject* pObj);
    void InsertObjectThenMakeNameUnique(SdrObject* pObj, std::unordered_set<rtl::OUString>& rNameSet, size_t nPos=SAL_MAX_SIZE);
 
    virtual rtl::Reference<SdrObject> NbcRemoveObject(size_t nObjNum);
    virtual rtl::Reference<SdrObject> RemoveObject(size_t nObjNum);
 
    virtual rtl::Reference<SdrObject> ReplaceObject(SdrObject* pNewObj, size_t nObjNum);
 
    virtual SdrObject* SetObjectOrdNum(size_t nOldObjNum, size_t nNewObjNum);
 
    void SetExistingObjectOrdNum(SdrObject* pExistingObj, size_t nNewObjNum);
 
    void SetSdrObjListRectsDirty();
 
    const tools::Rectangle& GetAllObjSnapRect() const;
    const tools::Rectangle& GetAllObjBoundRect() const;
 
    void NbcReformatAllTextObjects();
    void ReformatAllTextObjects();
 
    void ReformatAllEdgeObjects();
 
    void BurnInStyleSheetAttributes();
 
    size_t GetObjCount() const;
    SdrObject* GetObj(size_t nNum) const;
    SdrObject* GetObjByName(std::u16string_view sName) const;
 
    virtual bool IsReadOnly() const;
 
    void FlattenGroups();
 
    void UnGroupObj( size_t nObjNum );
 
    bool HasObjectNavigationOrder() const;
 
    void SetObjectNavigationPosition (
        SdrObject& rObject,
        const sal_uInt32 nNewNavigationPosition);
 
    SdrObject* GetObjectForNavigationPosition (const sal_uInt32 nNavigationPosition) const;
 
    void ClearObjectNavigationOrder();
 
    bool RecalcNavigationPositions();
 
    void SetNavigationOrder (const css::uno::Reference<
                             css::container::XIndexAccess>& rxOrder);
 
    virtual void dumpAsXml(xmlTextWriterPtr pWriter) const;
 
private:
    tools::Rectangle    maSdrObjListOutRect;
    tools::Rectangle    maSdrObjListSnapRect;
    std::deque<rtl::Reference<SdrObject>> maList;
    std::optional<std::vector<unotools::WeakReference<SdrObject>>> mxNavigationOrder;
    bool                mbObjOrdNumsDirty;
    bool                mbRectsDirty;
    bool mbIsNavigationOrderDirty;
 
    void InsertObjectIntoContainer (
        SdrObject& rObject,
        const sal_uInt32 nInsertPosition);
 
    void ReplaceObjectInContainer (
        SdrObject& rObject,
        const sal_uInt32 nObjectPosition);
 
    void RemoveObjectFromContainer (
        const sal_uInt32 nObjectPosition);
 
    void ImplReformatAllEdgeObjects(const SdrObjList& );
};
 
// Used for all methods which return a page number
#define SDRPAGE_NOTFOUND 0xFFFF
 
class SdrPageGridFrame
{
    tools::Rectangle aPaper;
    tools::Rectangle aUserArea;
public:
    SdrPageGridFrame(const tools::Rectangle& rPaper, const tools::Rectangle& rUser): aPaper(rPaper), aUserArea(rUser) {}
    const tools::Rectangle& GetPaperRect() const                  { return aPaper; }
    const tools::Rectangle& GetUserArea() const                   { return aUserArea; }
};
 
class SVXCORE_DLLPUBLIC SdrPageGridFrameList final
{
    std::vector<SdrPageGridFrame*> aList;
 
    SdrPageGridFrameList(const SdrPageGridFrameList& rSrcList) = delete;
    void           operator=(const SdrPageGridFrameList& rSrcList) = delete;
    SdrPageGridFrame* GetObject(sal_uInt16 i) const { return aList[i]; }
 
public:
    SdrPageGridFrameList()                                    {}
    ~SdrPageGridFrameList()                                            { Clear(); }
    void           Clear();
    sal_uInt16     GetCount() const                                    { return sal_uInt16(aList.size()); }
    void           Insert(const SdrPageGridFrame& rGF) { aList.push_back(new SdrPageGridFrame(rGF)); }
    SdrPageGridFrame&       operator[](sal_uInt16 nPos)                    { return *GetObject(nPos); }
    const SdrPageGridFrame& operator[](sal_uInt16 nPos) const              { return *GetObject(nPos); }
};
 
// class SdrPageProperties
class SVXCORE_DLLPUBLIC SdrPageProperties final : public SfxListener, public svl::StyleSheetUser
{
private:
    // data
    SdrPage*                mpSdrPage;
    SfxStyleSheet*          mpStyleSheet;
    std::shared_ptr<model::Theme> mpTheme;
    SfxItemSet              maProperties;
 
    // internal helpers
    void ImpRemoveStyleSheet();
    void ImpAddStyleSheet(SfxStyleSheet& rNewStyleSheet);
 
    SdrPageProperties& operator=(const SdrPageProperties& rCandidate) = delete;
 
    void sendLOKitThemeChangedCallback();
public:
    // construct/destruct
    SdrPageProperties(SdrPage& rSdrPage);
    virtual ~SdrPageProperties() override;
 
    // Notify(...) from baseclass SfxListener
    virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override;
 
    virtual bool isUsedByModel() const override;
 
    // data read/write
    const SfxItemSet& GetItemSet() const { return maProperties;}
    void PutItemSet(const SfxItemSet& rSet);
    void PutItem(const SfxPoolItem& rItem);
    void ClearItem(const sal_uInt16 nWhich = 0);
 
    // StyleSheet access
    void SetStyleSheet(SfxStyleSheet* pStyleSheet);
    SfxStyleSheet* GetStyleSheet() const { return mpStyleSheet;}
 
    void SetTheme(std::shared_ptr<model::Theme> const& pTheme);
    std::shared_ptr<model::Theme> const& GetTheme() const;
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const;
};
 
 
//
//  SdrPage
//      DlgEdPage
//      FmFormPage
//          ScDrawPage
//          SdPage
//          SwDPage
//      OReportPage
 
class SVXCORE_DLLPUBLIC SdrPage : public SdrObjList, public cppu::OWeakObject
{
    // #i9076#
    friend class SdrModel;
    friend class SvxUnoDrawPagesAccess;
 
    // this class uses its own UNO wrapper
    // and thus has to set mxUnoPage (it also relies on mxUnoPage not being WeakRef)
    friend class reportdesign::OSection;
 
    SdrPage& operator=(const SdrPage&) = delete;
    SdrPage(const SdrPage&) = delete;
 
    // start PageUser section
private:
    // #111111# PageUser section
    sdr::PageUserVector                                             maPageUsers;
 
    std::unique_ptr<sdr::contact::ViewContact> mpViewContact;
 
public:
    void AddPageUser(sdr::PageUser& rNewUser);
    void RemovePageUser(sdr::PageUser& rOldUser);
 
    // SdrModel access on SdrPage level
    SdrModel& getSdrModelFromSdrPage() const { return mrSdrModelFromSdrPage; }
 
protected:
    std::unique_ptr<sdr::contact::ViewContact> CreateObjectSpecificViewContact();
public:
    const sdr::contact::ViewContact& GetViewContact() const;
    sdr::contact::ViewContact& GetViewContact();
 
    // #110094# DrawContact support: Methods for handling Page changes
    void ActionChanged();
 
private:
    // the SdrModel this page was created with, unchanged during SdrPage lifetime
    SdrModel&                   mrSdrModelFromSdrPage;
 
private:
    tools::Long mnWidth;       // page size
    tools::Long mnHeight;      // page size
    sal_Int32 mnBorderLeft;  // left page margin
    sal_Int32 mnBorderUpper; // top page margin
    sal_Int32 mnBorderRight; // right page margin
    sal_Int32 mnBorderLower; // bottom page margin
    bool mbBackgroundFullSize = false; 
 
    std::unique_ptr<SdrLayerAdmin> mpLayerAdmin;
    std::unique_ptr<SdrPageProperties> mpSdrPageProperties;
    css::uno::Reference< css::uno::XInterface > mxUnoPage;
 
public:
    SdrPageProperties& getSdrPageProperties();
    const SdrPageProperties& getSdrPageProperties() const;
    const SdrPageProperties* getCorrectSdrPageProperties() const;
 
protected:
    // new MasterPageDescriptorVector
    std::unique_ptr<sdr::MasterPageDescriptor> mpMasterPageDescriptor;
 
    sal_uInt16          nPageNum;
 
    bool                mbMaster : 1;               // flag if this is a MasterPage
    bool                mbInserted : 1;
    bool                mbObjectsNotPersistent : 1;
 
    // #i93597#
    bool                mbPageBorderOnlyLeftRight : 1;
 
    void SetUnoPage(css::uno::Reference<css::drawing::XDrawPage> const&);
    virtual css::uno::Reference< css::uno::XInterface > createUnoPage();
 
    // Copying of pages is split into two parts: construction and copying of page objects,
    // because the copying might need access to fully initialized page. CloneSdrPage() is responsible
    // to call lateInit() after copy-construction of a new object. Any initialization in derived
    // classes that needs access to the page objects must be deferred to lateInit. And it must
    // call lateInit() of its parent class.
    void lateInit(const SdrPage& rSrcPage);
 
public:
    explicit SdrPage(SdrModel& rModel, bool bMasterPage=false);
    virtual ~SdrPage() override;
 
    virtual rtl::Reference<SdrPage> CloneSdrPage(SdrModel& rTargetModel) const;
    bool             IsMasterPage() const       { return mbMaster; }
    void             SetInserted(bool bNew = true);
    bool             IsInserted() const         { return mbInserted; }
    void             SetChanged();
 
    // derived from SdrObjList, returns this
    virtual SdrPage* getSdrPageFromSdrObjList() const override;
 
    // #i68775# React on PageNum changes (from Model in most cases)
    void SetPageNum(sal_uInt16 nNew);
    sal_uInt16 GetPageNum() const;
 
    // #i93597# Allow page border definition to not be the full rectangle but to
    // use only the left and right vertical edges (reportdesigner)
    void setPageBorderOnlyLeftRight(bool bNew) { mbPageBorderOnlyLeftRight = bNew; }
    bool getPageBorderOnlyLeftRight() const { return mbPageBorderOnlyLeftRight; }
 
    virtual void SetSize(const Size& aSiz);
    Size GetSize() const;
    virtual void SetOrientation(Orientation eOri);
    virtual Orientation GetOrientation() const;
    tools::Long GetWidth() const;
    tools::Long GetHeight() const;
    virtual void  SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 Lwr);
    virtual void  SetLeftBorder(sal_Int32 nBorder);
    virtual void  SetUpperBorder(sal_Int32 nBorder);
    virtual void  SetRightBorder(sal_Int32 nBorder);
    virtual void  SetLowerBorder(sal_Int32 nBorder);
    sal_Int32 GetLeftBorder() const;
    sal_Int32 GetUpperBorder() const;
    sal_Int32 GetRightBorder() const;
    sal_Int32 GetLowerBorder() const;
    void    SetBackgroundFullSize(bool bIn);
    bool    IsBackgroundFullSize() const;
 
    // New MasterPage interface
    bool TRG_HasMasterPage() const { return (nullptr != mpMasterPageDescriptor); }
    void TRG_SetMasterPage(SdrPage& rNew);
    void TRG_ClearMasterPage();
    SdrPage& TRG_GetMasterPage() const;
    const SdrLayerIDSet& TRG_GetMasterPageVisibleLayers() const;
    void TRG_SetMasterPageVisibleLayers(const SdrLayerIDSet& rNew);
    sdr::contact::ViewContact& TRG_GetMasterPageDescriptorViewContact() const;
 
    void MakePageObjectsNamesUnique();
 
protected:
    void TRG_ImpMasterPageRemoved(const SdrPage& rRemovedPage);
public:
 
    const SdrLayerAdmin& GetLayerAdmin() const;
    SdrLayerAdmin& GetLayerAdmin();
 
    virtual OUString GetLayoutName() const;
 
    virtual const SdrPageGridFrameList* GetGridFrameList(const SdrPageView* pPV, const tools::Rectangle* pRect) const;
 
    css::uno::Reference< css::uno::XInterface > const & getUnoPage();
 
    virtual SfxStyleSheet* GetTextStyleSheetForObject( SdrObject* pObj ) const;
 
    // #i75566# GetBackgroundColor -> GetPageBackgroundColor
    Color GetPageBackgroundColor() const;
 
    // #i75566# GetBackgroundColor -> GetPageBackgroundColor and bScreenDisplay hint value
    Color GetPageBackgroundColor( SdrPageView const * pView, bool bScreenDisplay = true) const;
 
    virtual bool checkVisibility(
        const sdr::contact::ViewObjectContact& rOriginal,
        const sdr::contact::DisplayInfo& rDisplayInfo,
        bool bEdit );
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const override;
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */