execute move of global headers

see https://gerrit.libreoffice.org/#/c/3367/
and Change-Id: I00c96fa77d04b33a6f8c8cd3490dfcd9bdc9e84a for details

Change-Id: I199a75bc4042af20817265d5ef85b1134a96ff5a

1 files changed, 605 insertions, 0 deletions

diff --git a/include/svx/svdpage.hxx b/include/svx/svdpage.hxx
new file mode 100644
index 000000000000..c8dd083019a4
--- /dev/null
+++ b/include/svx/svdpage.hxx
@@ -0,0 +1,605 @@
+/* -*- 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 _SVDPAGE_HXX
+#define _SVDPAGE_HXX
+
+#include <svl/stylesheetuser.hxx>
+#include <vcl/bitmap.hxx>
+#include <vcl/print.hxx>
+#include <vcl/gdimtf.hxx>
+#include <tools/weakbase.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <svx/svdtypes.hxx>
+#include <svx/svdlayer.hxx>
+#include <vector>
+#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 <boost/scoped_ptr.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+namespace reportdesign { class OSection; }
+namespace sdr { namespace contact { class ViewContact; }}
+class SdrPage;
+class SdrModel;
+class SfxItemPool;
+class SdrPageView;
+class SdrLayerAdmin;
+class SetOfByte;
+class Color;
+class SfxStyleSheet;
+class SvxUnoDrawPagesAccess;
+
+enum SdrInsertReasonKind {SDRREASON_UNKNOWN,    // unbekannt
+                          SDRREASON_STREAMING,  // einlesen eines Doks
+                          SDRREASON_UNDO,       // kommt aus dem Undo
+                          SDRREASON_COPY,       // irgendjemand kopiert...
+                          SDRREASON_VIEWCREATE, // vom Anwender interaktiv erzeugt
+                          SDRREASON_VIEWCALL};  // Durch SdrView::Group(), ...
+
+class SdrInsertReason {
+    const SdrObject* pRefObj;
+    SdrInsertReasonKind eReason;
+public:
+    SdrInsertReason(): pRefObj(NULL),eReason(SDRREASON_UNKNOWN) {}
+    SdrInsertReason(SdrInsertReasonKind eR,const SdrObject* pO=NULL): pRefObj(pO),eReason(eR) {}
+    void SetReferenceObject(const SdrObject* pO)  { pRefObj=pO; }
+    const SdrObject* GetReferenceObject() const   { return pRefObj; }
+    void SetReason(SdrInsertReasonKind eR)        { eReason=eR; }
+    SdrInsertReasonKind GetReason() const         { return eReason; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// class SdrObjList
+
+class SVX_DLLPUBLIC SdrObjList
+{
+private:
+    typedef ::std::vector<SdrObject*> SdrObjectContainerType;
+    SdrObjectContainerType maList;
+
+protected:
+friend class SdrObjListIter;
+friend class SdrEditView;
+    SdrObjList* pUpList;   // Vaterliste
+    SdrModel*   pModel;    // Diese Liste gehoert zu diesem Model (Layer,ItemPool,Storage).
+    SdrPage*    pPage;     // Page, in die Liste haengt. Kann auch this sein.
+    SdrObject*  pOwnerObj; // OwnerObject, falls Liste eines GruppenObjekts.
+    Rectangle   aOutRect;
+    Rectangle   aSnapRect;
+    SdrObjListKind eListKind;
+    bool    bObjOrdNumsDirty;
+    bool    bRectsDirty;
+protected:
+    virtual void RecalcRects();
+
+private:
+    /// simple ActionChildInserted forwarder to have it on a central place
+    void impChildInserted(SdrObject& rChild) const;
+public:
+    TYPEINFO();
+    SdrObjList(SdrModel* pNewModel, SdrPage* pNewPage, SdrObjList* pNewUpList=NULL);
+    SdrObjList(const SdrObjList& rSrcList);
+    virtual ~SdrObjList();
+    // !!! Diese Methode nur fuer Leute, die ganz genau wissen was sie tun !!!
+
+    // #110094# This should not be needed (!)
+    void SetObjOrdNumsDirty()                           { bObjOrdNumsDirty=sal_True; }
+    // pModel, pPage, pUpList und pOwnerObj werden Zuweisungeoperator nicht veraendert!
+    void operator=(const SdrObjList& rSrcList);
+    void CopyObjects(const SdrObjList& rSrcList);
+    // alles Aufraeumen (ohne Undo)
+    void    Clear();
+    SdrObjListKind GetListKind() const                  { return eListKind; }
+    void           SetListKind(SdrObjListKind eNewKind) { eListKind=eNewKind; }
+    SdrObjList*    GetUpList() const                    { return pUpList; }
+    void           SetUpList(SdrObjList* pNewUpList)    { pUpList=pNewUpList; }
+    SdrObject*     GetOwnerObj() const                  { return pOwnerObj; }
+    void           SetOwnerObj(SdrObject* pNewOwner)    { pOwnerObj=pNewOwner; }
+    virtual SdrPage* GetPage() const;
+    virtual void     SetPage(SdrPage* pNewPage);
+    virtual SdrModel* GetModel() const;
+    virtual void      SetModel(SdrModel* pNewModel);
+    // Neuberechnung der Objekt-Ordnungsnummern
+    void     RecalcObjOrdNums();
+    bool IsObjOrdNumsDirty() const        { return bObjOrdNumsDirty; }
+    virtual void NbcInsertObject(SdrObject* pObj, sal_uIntPtr nPos=0xFFFF
+                                 , const SdrInsertReason* pReason=NULL
+                                                                      );
+    virtual void InsertObject(SdrObject* pObj, sal_uIntPtr nPos=0xFFFF
+                              , const SdrInsertReason* pReason=NULL
+                                                                     );
+    // aus Liste entfernen ohne delete
+    virtual SdrObject* NbcRemoveObject(sal_uIntPtr nObjNum);
+    virtual SdrObject* RemoveObject(sal_uIntPtr nObjNum);
+    // Vorhandenes Objekt durch ein anderes ersetzen.
+    // Wie Remove&Insert jedoch performanter, da die Ordnungsnummern
+    // nicht Dirty gesetzt werden muessen.
+    virtual SdrObject* NbcReplaceObject(SdrObject* pNewObj, sal_uIntPtr nObjNum);
+    virtual SdrObject* ReplaceObject(SdrObject* pNewObj, sal_uIntPtr nObjNum);
+    // Die Z-Order eines Objekts veraendern
+    virtual SdrObject* NbcSetObjectOrdNum(sal_uIntPtr nOldObjNum, sal_uIntPtr nNewObjNum);
+    virtual SdrObject* SetObjectOrdNum(sal_uIntPtr nOldObjNum, sal_uIntPtr nNewObjNum);
+
+    virtual void SetRectsDirty();
+
+    const Rectangle& GetAllObjSnapRect() const;
+    const Rectangle& GetAllObjBoundRect() const;
+
+    // Alle Textobjekte neu formatieren, z.B. bei Druckerwechsel
+    void NbcReformatAllTextObjects();
+    void ReformatAllTextObjects();
+
+    /** #103122# reformats all edge objects that are connected to other objects */
+    void ReformatAllEdgeObjects();
+
+    // Die Vorlagenattribute der Zeichenobjekte in harte Attribute verwandeln.
+    void BurnInStyleSheetAttributes();
+
+    sal_uIntPtr      GetObjCount() const;
+    SdrObject* GetObj(sal_uIntPtr nNum) const;
+
+    // Gelinkte Seite oder gelinktes Gruppenobjekt
+    virtual bool IsReadOnly() const;
+
+    // Zaehlt alle Objekte inkl. Objekte in Objektgruppen, ...
+    sal_uIntPtr   CountAllObjects() const;
+
+    // Alle aufgelagerten Teile (z.B. Grafiken) der Liste in den
+    // Speicher laden.
+    void    ForceSwapInObjects() const;
+    void    ForceSwapOutObjects() const;
+
+    void    SwapInAll() const { ForceSwapInObjects(); }
+    void    SwapOutAll() const { ForceSwapOutObjects(); }
+
+    /** Makes the object list flat, i.e. the object list content are
+        then tree leaves
+
+        This method travels recursively over all group objects in this
+        list, extracts the content, inserts it flat to the list and
+        removes the group object afterwards.
+     */
+    virtual void FlattenGroups();
+    /** Ungroup the object at the given index
+
+        This method ungroups the content of the group object at the
+        given index, i.e. the content is put flat into the object list
+        (if the object at the given index is no group, this method is
+        a no-op). If the group itself contains group objects, the
+        operation is performed recursively, such that the content of
+        the given object contains no groups afterwards.
+     */
+    virtual void UnGroupObj( sal_uIntPtr nObjNum );
+
+    /** Return whether there is an explicit, user defined, object navigation
+        order.  When there is one this method returns <TRUE/> and the
+        GetObjectForNavigationPosition() and
+        SdrObject::GetNavigationPosition() methods will return values
+        different from those returne by SdrObject::GetOrdNum() and
+        GetObj().
+    */
+    bool HasObjectNavigationOrder (void) const;
+
+    /** Set the navigation position of the given object to the specified
+        value.  Note that this changes the navigation position for all
+        objects on or following the old or new position.
+    */
+    void SetObjectNavigationPosition (
+        SdrObject& rObject,
+        const sal_uInt32 nNewNavigationPosition);
+
+    /** Return the object for the given navigation position.  When there is
+        a user defined navigation order, i.e. mpNavigationOrder is not NULL,
+        then that is used to look up the object.  Otherwise the z-order is
+        used by looking up the object in maList.
+        @param nNavigationPosition
+            Valid values include 0 and are smaller than the number of
+            objects as returned by GetObjCount().
+        @return
+            The returned pointer is NULL for invalid positions.
+    */
+    SdrObject* GetObjectForNavigationPosition (const sal_uInt32 nNavigationPosition) const;
+
+    /** Restore the navigation order to that defined by the z-order.
+    */
+    void ClearObjectNavigationOrder (void);
+
+    /** Set the navigation position of all SdrObjects to their position in
+        the mpNavigationOrder list.  This method returns immediately when no
+        update is necessary.
+        @return
+            This method returns <TRUE/> when the navigation positions stored
+            in SdrObjects are up to date.
+            It returns <FALSE/> when the navigation positions are not valid,
+            for example because no explicit navigation order has been
+            defined, i.e. HasObjectNavigationOrder() would return <FALSE/>.
+    */
+    bool RecalcNavigationPositions (void);
+
+    /** Set the navigation order to the one defined by the given list of
+        XShape objects.
+        @param rxOrder
+            When this is an empty reference then the navigation order is
+            reset to the z-order. The preferred way to do this, however, is
+            to call ClearObjectNavigationOrder().
+            Otherwise this list is expected to contain all the shapes in the
+            called SdrObjList.
+    */
+    void SetNavigationOrder (const ::com::sun::star::uno::Reference<
+        ::com::sun::star::container::XIndexAccess>& rxOrder);
+
+private:
+    class WeakSdrObjectContainerType;
+    /// This list, if it exists, defines the navigation order.  It it does
+    /// not exist then maList defines the navigation order.
+    ::boost::scoped_ptr<WeakSdrObjectContainerType> mpNavigationOrder;
+
+    /// This flag is <TRUE/> when the mpNavigation list has been changed but
+    /// the indices of the referenced SdrObjects still have their old values.
+    bool mbIsNavigationOrderDirty;
+
+    /** Insert an SdrObject into maList.  Do not modify the maList member
+        directly.
+        @param rObject
+            The object to insert into the object list.
+        @param nInsertPosition
+            The given object is inserted before the object at this
+            position.  Valid values include 0 (the object is inserted at the
+            head of the list) and the number of objects in the list as
+            returned by GetObjCount() (the object is inserted at the end of
+            the list.)
+    */
+    void InsertObjectIntoContainer (
+        SdrObject& rObject,
+        const sal_uInt32 nInsertPosition);
+
+    /** Replace an object in the object list.
+        @param rObject
+            The new object that replaces the one in the list at the
+            specified position.
+        @param nObjectPosition
+            The object at this position in the object list is replaced by
+            the given object.  Valid values include 0 and are smaller than
+            the number of objects in the list.
+    */
+    void ReplaceObjectInContainer (
+        SdrObject& rObject,
+        const sal_uInt32 nObjectPosition);
+
+    /** Remove an object from the object list.
+        The object list has to contain at least one element.
+        @param nObjectPosition
+            The object at this position is removed from the object list.
+            Valid values include 0 and are smaller than the number of
+            objects in the list.
+    */
+    void RemoveObjectFromContainer (
+        const sal_uInt32 nObjectPosition);
+};
+
+/*
+Eine Sdraw-Seite enthaelt genau eine Objektliste sowie eine Beschreibung
+der physikalischen Seitendimensionen (Groesse/Raender). Letzteres wird
+lediglich zum Fangen von Objekten beim Draggen benoetigt.
+An der Seite lassen sich (ueber SdrObjList) Objekte einfuegen und loeschen,
+nach vorn und nach hinten stellen. Ausserdem kann die Ordnungszahl eines
+Objektes abgefragt sowie direkt gesetzt werden.
+*/
+
+// Used for all methods which return a page number
+#define SDRPAGE_NOTFOUND 0xFFFF
+
+//////////////////////////////////////////////////////////////////////////////
+// class SdrPageGridFrame
+
+// Fuer das Fangraster/Punkgitter im Writer
+class SdrPageGridFrame
+{
+    Rectangle aPaper;
+    Rectangle aUserArea;
+public:
+    SdrPageGridFrame(const Rectangle& rPaper): aPaper(rPaper), aUserArea(rPaper) {}
+    SdrPageGridFrame(const Rectangle& rPaper, const Rectangle& rUser): aPaper(rPaper), aUserArea(rUser) {}
+    void             SetPaperRect(const Rectangle& rPaper) { aPaper=rPaper; }
+    void             SetUserArea(const Rectangle& rUser)   { aUserArea=rUser; }
+    const Rectangle& GetPaperRect() const                  { return aPaper; }
+    const Rectangle& GetUserArea() const                   { return aUserArea; }
+};
+
+class SVX_DLLPUBLIC SdrPageGridFrameList {
+    std::vector<SdrPageGridFrame*> aList;
+private:
+    SVX_DLLPRIVATE SdrPageGridFrameList(const SdrPageGridFrameList& rSrcList);      // never implemented
+    SVX_DLLPRIVATE void           operator=(const SdrPageGridFrameList& rSrcList);  // never implemented
+protected:
+    SdrPageGridFrame* GetObject(sal_uInt16 i) const { return aList[i]; }
+public:
+    SdrPageGridFrameList(): aList()                                    {}
+    ~SdrPageGridFrameList()                                            { Clear(); }
+    void           Clear();
+    sal_uInt16         GetCount() const                                    { return sal_uInt16(aList.size()); }
+    void           Insert(const SdrPageGridFrame& rGF) { aList.push_back(new SdrPageGridFrame(rGF)); }
+    void           Insert(const SdrPageGridFrame& rGF, sal_uInt16 nPos)
+    {
+        if(nPos==0xFFFF)
+            aList.push_back(new SdrPageGridFrame(rGF));
+        else
+            aList.insert(aList.begin()+nPos,new SdrPageGridFrame(rGF));
+    }
+    void           Delete(sal_uInt16 nPos)
+    {
+        SdrPageGridFrame* p = aList[nPos];
+        aList.erase(aList.begin()+nPos);
+        delete p;
+    }
+    void           Move(sal_uInt16 nPos, sal_uInt16 nNewPos)
+    {
+        SdrPageGridFrame* p = aList[nPos];
+        aList.erase(aList.begin()+nPos);
+        aList.insert(aList.begin()+nNewPos,p);
+    }
+    SdrPageGridFrame&       operator[](sal_uInt16 nPos)                    { return *GetObject(nPos); }
+    const SdrPageGridFrame& operator[](sal_uInt16 nPos) const              { return *GetObject(nPos); }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// class SdrPageProperties
+
+class SVX_DLLPUBLIC SdrPageProperties : public SfxListener, public svl::StyleSheetUser
+{
+private:
+    // data
+    SdrPage*                mpSdrPage;
+    SfxStyleSheet*          mpStyleSheet;
+    SfxItemSet*             mpProperties;
+
+    // internal helpers
+    void ImpRemoveStyleSheet();
+    void ImpAddStyleSheet(SfxStyleSheet& rNewStyleSheet);
+
+    // not implemented
+    SdrPageProperties& operator=(const SdrPageProperties& rCandidate);
+
+public:
+    // construct/destruct
+    SdrPageProperties(SdrPage& rSdrPage);
+    virtual ~SdrPageProperties();
+
+    // Notify(...) from baseclass SfxListener
+    virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint);
+
+    virtual bool isUsedByModel() const;
+
+    // data read/write
+    const SfxItemSet& GetItemSet() const;
+    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;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// class SdrPage
+
+class SVX_DLLPUBLIC SdrPage : public SdrObjList, public tools::WeakBase< SdrPage >
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    // start PageUser section
+private:
+    // #111111# PageUser section
+    sdr::PageUserVector                                             maPageUsers;
+
+public:
+    void AddPageUser(sdr::PageUser& rNewUser);
+    void RemovePageUser(sdr::PageUser& rOldUser);
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // end PageUser section
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // #110094# DrawContact section
+private:
+    sdr::contact::ViewContact*                                      mpViewContact;
+protected:
+    virtual sdr::contact::ViewContact* CreateObjectSpecificViewContact();
+public:
+    sdr::contact::ViewContact& GetViewContact() const;
+
+    // #110094# DrawContact support: Methods for handling Page changes
+    void ActionChanged() const;
+
+    // #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;
+
+    sal_Int32 nWdt;     // Seitengroesse
+    sal_Int32 nHgt;     // Seitengroesse
+    sal_Int32 nBordLft; // Seitenrand links
+    sal_Int32 nBordUpp; // Seitenrand oben
+    sal_Int32 nBordRgt; // Seitenrand rechts
+    sal_Int32 nBordLwr; // Seitenrand unten
+
+protected:
+    SdrLayerAdmin*      pLayerAdmin;
+private:
+    SdrPageProperties*  mpSdrPageProperties;
+    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > mxUnoPage;
+
+public:
+    SdrPageProperties& getSdrPageProperties() { return *mpSdrPageProperties; }
+    const SdrPageProperties& getSdrPageProperties() const { return *mpSdrPageProperties; }
+    const SdrPageProperties* getCorrectSdrPageProperties() const;
+
+protected:
+    // new MasterPageDescriptorVector
+    ::sdr::MasterPageDescriptor*                    mpMasterPageDescriptor;
+
+    SetOfByte  aPrefVisiLayers;
+    sal_uInt16     nPageNum;
+
+    // bitfield
+    unsigned            mbMaster : 1;               // flag if this is a MasterPage
+    unsigned            mbInserted : 1;
+    unsigned            mbObjectsNotPersistent : 1;
+    unsigned            mbSwappingLocked : 1;
+
+    // #i93597#
+    unsigned            mbPageBorderOnlyLeftRight : 1;
+
+    void SetUnoPage(::com::sun::star::uno::Reference<
+                        ::com::sun::star::drawing::XDrawPage> const&);
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > createUnoPage();
+
+public:
+    TYPEINFO();
+    SdrPage(SdrModel& rNewModel, bool bMasterPage=false);
+    // Copy-Ctor und Zuweisungeoperator sind nicht getestet!
+    SdrPage(const SdrPage& rSrcPage);
+    virtual ~SdrPage();
+    // pModel, pPage, pUpList, pOwnerObj und mbInserted werden Zuweisungeoperator nicht veraendert!
+    SdrPage& operator=(const SdrPage& rSrcPage);
+    virtual SdrPage* Clone() const;
+    virtual SdrPage* Clone(SdrModel* pNewModel) const;
+    bool IsMasterPage() const       { return mbMaster; }
+    void SetInserted(bool bNew = true);
+    bool IsInserted() const         { return mbInserted; }
+    virtual void SetChanged();
+
+    // #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);
+    virtual Size GetSize() const;
+    virtual void SetOrientation(Orientation eOri);
+    virtual Orientation GetOrientation() const;
+    virtual sal_Int32 GetWdt() const;
+    virtual sal_Int32 GetHgt() const;
+    virtual void  SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 Lwr);
+    virtual void  SetLftBorder(sal_Int32 nBorder);
+    virtual void  SetUppBorder(sal_Int32 nBorder);
+    virtual void  SetRgtBorder(sal_Int32 nBorder);
+    virtual void  SetLwrBorder(sal_Int32 nBorder);
+    virtual sal_Int32 GetLftBorder() const;
+    virtual sal_Int32 GetUppBorder() const;
+    virtual sal_Int32 GetRgtBorder() const;
+    virtual sal_Int32 GetLwrBorder() const;
+
+    virtual void SetModel(SdrModel* pNewModel);
+
+    // New MasterPage interface
+    sal_Bool TRG_HasMasterPage() const { return (0L != mpMasterPageDescriptor); }
+    void TRG_SetMasterPage(SdrPage& rNew);
+    void TRG_ClearMasterPage();
+    SdrPage& TRG_GetMasterPage() const;
+    const SetOfByte& TRG_GetMasterPageVisibleLayers() const;
+    void TRG_SetMasterPageVisibleLayers(const SetOfByte& rNew);
+    sdr::contact::ViewContact& TRG_GetMasterPageDescriptorViewContact() const;
+
+protected:
+    void TRG_ImpMasterPageRemoved(const SdrPage& rRemovedPage);
+public:
+
+    // Aenderungen an den Layern setzen nicht das Modified-Flag !
+    const         SdrLayerAdmin& GetLayerAdmin() const                  { return *pLayerAdmin; }
+                  SdrLayerAdmin& GetLayerAdmin()                        { return *pLayerAdmin; }
+
+    virtual OUString GetLayoutName() const;
+
+    // fuer's Raster im Writer, auch fuer AlignObjects wenn 1 Objekt markiert ist
+    // wenn pRect!=NULL, dann die Seiten, die von diesem Rect intersected werden
+    // ansonsten die sichtbaren Seiten.
+    virtual const SdrPageGridFrameList* GetGridFrameList(const SdrPageView* pPV, const Rectangle* pRect) const;
+    bool IsObjectsNotPersistent() const          { return mbObjectsNotPersistent; }
+    void SetObjectsNotPersistent(bool b)     { mbObjectsNotPersistent = b; }
+    // Durch Setzen dieses Flags, kann das Auslagern (Swappen) von
+    // Teilen der Page (z.B. Grafiken) unterbunden werden.
+    // Es werden hierdurch jedoch nicht automatisch alle ausgelagerten
+    // Teile nachgeladen, dies geschieht erst bei konkretem Bedarf oder
+    // durch Aufruf von SwapInAll().
+    // Fuer die MasterPage(s) der Page muss dies ggf. separat gemacht werden.
+    bool IsSwappingLocked() const { return mbSwappingLocked; }
+    void SetSwappingLocked(bool bLock) { mbSwappingLocked = bLock; }
+
+    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > getUnoPage();
+
+    virtual SfxStyleSheet* GetTextStyleSheetForObject( SdrObject* pObj ) const;
+
+    /** *deprecated* returns an averaged background color of this page */
+    // #i75566# GetBackgroundColor -> GetPageBackgroundColor
+    Color GetPageBackgroundColor() const;
+
+    /** *deprecated* returns an averaged background color of this page */
+    // #i75566# GetBackgroundColor -> GetPageBackgroundColor and bScreenDisplay hint value
+    Color GetPageBackgroundColor( SdrPageView* pView, bool bScreenDisplay = true) const;
+
+    /** this method returns true if the object from the ViewObjectContact should
+        be visible on this page while rendering.
+        bEdit selects if visibility test is for an editing view or a final render,
+        like printing.
+    */
+    virtual bool checkVisibility(
+        const sdr::contact::ViewObjectContact& rOriginal,
+        const sdr::contact::DisplayInfo& rDisplayInfo,
+        bool bEdit );
+};
+
+typedef tools::WeakReference< SdrPage > SdrPageWeakRef;
+
+//////////////////////////////////////////////////////////////////////////////
+// use new redirector instead of pPaintProc
+
+class SVX_DLLPUBLIC StandardCheckVisisbilityRedirector : public ::sdr::contact::ViewObjectContactRedirector
+{
+public:
+    StandardCheckVisisbilityRedirector();
+    virtual ~StandardCheckVisisbilityRedirector();
+
+    // all default implementations just call the same methods at the original. To do something
+    // different, overload the method and at least do what the method does.
+    virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
+        const sdr::contact::ViewObjectContact& rOriginal,
+        const sdr::contact::DisplayInfo& rDisplayInfo);
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_SVDPAGE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */