sd/inc/drawdoc.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 #ifndef _DRAWDOC_HXX
  29 #define _DRAWDOC_HXX
  30
  31 #include <com/sun/star/lang/Locale.hpp>
  32 #include <com/sun/star/text/WritingMode.hpp>
  33 #include <com/sun/star/frame/XModel.hdl>
  34 #include <vcl/print.hxx>
  35 #include <svx/fmmodel.hxx>
  36 #include "pres.hxx"
  37 #include <svx/pageitem.hxx>
  38 #include <unotools/charclass.hxx>
  39 #include <sot/storage.hxx>
  40 #include <rsc/rscsfx.hxx>
  41 #include <com/sun/star/lang/Locale.hpp>
  42 #include <com/sun/star/text/WritingMode.hpp>
  43
  44 // #107844#
  45 #include <svx/svdundo.hxx>
  46
  47 #include <vector>
  48
  49 #ifndef INCLUDED_MEMORY
  50 #include <memory>
  51 #define INCLUDED_MEMORY
  52 #endif
  53 #include "sddllapi.h"
  54 #include "sdpage.hxx"
  55
  56 namespace com
  57 {
  58     namespace sun
  59     {
  60         namespace star
  61         {
  62             namespace embed
  63             {
  64                 class XStorage;
  65             }
  66             namespace io
  67             {
  68                 class XStream;
  69             }
  70             namespace presentation
  71             {
  72                 class XPresentation2;
  73             }
  74         }
  75     }
  76 }
  77
  78 namespace sd
  79 {
  80     class FrameView;
  81     class Outliner;
  82 }
  83
  84
  85 class Timer;
  86 class SfxObjectShell;
  87 class SdDrawDocShell;
  88 class SdPage;
  89 class SdAnimationInfo;
  90 class SdIMapInfo;
  91 class IMapObject;
  92 class SdStyleSheetPool;
  93 class SfxMedium;
  94 class SvxSearchItem;
  95 class SdrOle2Obj;
  96 class EditStatus;
  97 class Graphic;
  98 class Point;
  99 class Window;
 100 class SdTransferable;
 101 struct SpellCallbackInfo;
 102 struct StyleRequestData;
 103 class SdDrawDocument;
 104
 105 namespace sd
 106 {
 107 #ifndef SV_DECL_DRAW_DOC_SHELL_DEFINED
 108 #define SV_DECL_DRAW_DOC_SHELL_DEFINED
 109 SV_DECL_REF(DrawDocShell)
 110 #endif
 111 class DrawDocShell;
 112 class UndoManager;
 113 class ShapeList;
 114 }
 115
 116 class ImpDrawPageListWatcher;
 117 class ImpMasterPageListWatcher;
 118
 119 struct StyleReplaceData
 120 {
 121     SfxStyleFamily  nFamily;
 122     SfxStyleFamily  nNewFamily;
 123     String          aName;
 124     String          aNewName;
 125 };
 126
 127 enum DocCreationMode
 128 {
 129     NEW_DOC,
 130     DOC_LOADED
 131 };
 132
 133 namespace sd
 134 {
 135     struct PresentationSettings
 136     {
 137         rtl::OUString maPresPage;
 138         sal_Bool mbAll;
 139         sal_Bool mbEndless;
 140         sal_Bool mbCustomShow;
 141         sal_Bool mbManual;
 142         sal_Bool mbMouseVisible;
 143         sal_Bool mbMouseAsPen;
 144         sal_Bool mbLockedPages;
 145         sal_Bool mbAlwaysOnTop;
 146         sal_Bool mbFullScreen;
 147         sal_Bool mbAnimationAllowed;
 148         sal_Int32 mnPauseTimeout;
 149         sal_Bool mbShowPauseLogo;
 150         sal_Bool mbStartWithNavigator;
 151
 152         PresentationSettings();
 153         PresentationSettings( const PresentationSettings& r );
 154     };
 155 }
 156
 157 // ------------------
 158 // - SdDrawDocument -
 159 // ------------------
 160
 161 class SdDrawDocument : public FmFormModel
 162 {
 163 private:
 164     ::sd::Outliner*     mpOutliner;         // local outliner for outline mode
 165     ::sd::Outliner*     mpInternalOutliner;  // internal outliner for creation of text objects
 166     Timer*              mpWorkStartupTimer;
 167     Timer*              mpOnlineSpellingTimer;
 168     sd::ShapeList*      mpOnlineSpellingList;
 169     SvxSearchItem*      mpOnlineSearchItem;
 170     List*               mpFrameViewList;
 171     List*               mpCustomShowList;
 172     ::sd::DrawDocShell* mpDocSh;
 173     SdTransferable *    mpCreatingTransferable;
 174     sal_Bool                mbHasOnlineSpellErrors;
 175     sal_Bool                mbInitialOnlineSpellingEnabled;
 176     String              maBookmarkFile;
 177     ::sd::DrawDocShellRef   mxBookmarkDocShRef;
 178
 179     sd::PresentationSettings maPresentationSettings;
 180
 181     ::com::sun::star::uno::Reference< ::com::sun::star::presentation::XPresentation2 > mxPresentation;
 182
 183     sal_Bool                mbNewOrLoadCompleted;
 184
 185     sal_Bool                mbOnlineSpell;
 186     sal_Bool                mbSummationOfParagraphs;
 187     bool                mbStartWithPresentation;        // is set to true when starting with command line parameter -start
 188     LanguageType        meLanguage;
 189     LanguageType        meLanguageCJK;
 190     LanguageType        meLanguageCTL;
 191     SvxNumType          mePageNumType;
 192     ::sd::DrawDocShellRef   mxAllocedDocShRef;   // => AllocModel()
 193     sal_Bool                mbAllocDocSh;       // => AllocModel()
 194     DocumentType        meDocType;
 195     CharClass*          mpCharClass;
 196     ::com::sun::star::lang::Locale* mpLocale;
 197
 198     // #109538#
 199     ::std::auto_ptr<ImpDrawPageListWatcher> mpDrawPageListWatcher;
 200     ::std::auto_ptr<ImpMasterPageListWatcher> mpMasterPageListWatcher;
 201
 202     void                UpdatePageObjectsInNotes(sal_uInt16 nStartPos);
 203     void                UpdatePageRelativeURLs(SdPage* pPage, sal_uInt16 nPos, sal_Int32 nIncrement);
 204     void                FillOnlineSpellingList(SdPage* pPage);
 205     void                SpellObject(SdrTextObj* pObj);
 206
 207                         DECL_LINK(WorkStartupHdl, Timer*);
 208                         DECL_LINK(OnlineSpellingHdl, Timer*);
 209                         DECL_LINK(OnlineSpellEventHdl, EditStatus*);
 210
 211     std::vector< rtl::OUString > maAnnotationAuthors;
 212
 213 protected:
 214
 215     virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > createUnoModel();
 216
 217 public:
 218
 219     class InsertBookmarkAsPage_PageFunctorBase;
 220
 221                         TYPEINFO();
 222
 223                         SdDrawDocument(DocumentType eType, SfxObjectShell* pDocSh);
 224                         ~SdDrawDocument();
 225
 226     virtual SdrModel*   AllocModel() const;
 227     virtual SdrPage*    AllocPage(FASTBOOL bMasterPage);
 228     virtual const SdrModel* LoadModel(const String& rFileName);
 229     virtual void        DisposeLoadedModels();
 230     virtual FASTBOOL    IsReadOnly() const;
 231     virtual void        SetChanged(sal_Bool bFlag = sal_True);
 232     virtual SvStream*   GetDocumentStream(SdrDocumentStreamInfo& rStreamInfo) const;
 233
 234     SfxItemPool&        GetPool() { return( *pItemPool ); }
 235
 236     ::sd::Outliner* GetOutliner(sal_Bool bCreateOutliner=sal_True);
 237     SD_DLLPUBLIC ::sd::Outliner* GetInternalOutliner(sal_Bool bCreateOutliner=sal_True);
 238
 239     ::sd::DrawDocShell*     GetDocSh() const { return mpDocSh; }
 240
 241     LanguageType        GetLanguage( const sal_uInt16 nId ) const;
 242     void                SetLanguage( const LanguageType eLang, const sal_uInt16 nId );
 243
 244     SvxNumType          GetPageNumType() const;
 245     void                SetPageNumType(SvxNumType eType) { mePageNumType = eType; }
 246     SD_DLLPUBLIC String              CreatePageNumValue(sal_uInt16 nNum) const;
 247
 248     DocumentType        GetDocumentType() const { return meDocType; }
 249
 250     void                SetAllocDocSh(sal_Bool bAlloc);
 251
 252     void                CreatingDataObj( SdTransferable* pTransferable ) { mpCreatingTransferable = pTransferable; }
 253
 254     /** if the document does not contain at least one handout, one slide and one notes page with
 255         at least one master each this methods creates them.
 256         If a reference document is given, the sizes and border settings of that document are used
 257         for newly created slides.
 258     */
 259     SD_DLLPUBLIC void   CreateFirstPages( SdDrawDocument* pRefDocument = 0 );
 260     SD_DLLPUBLIC sal_Bool                CreateMissingNotesAndHandoutPages();
 261
 262     void                MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos);
 263     void                InsertPage(SdrPage* pPage, sal_uInt16 nPos=0xFFFF);
 264     void                DeletePage(sal_uInt16 nPgNum);
 265     SdrPage*            RemovePage(sal_uInt16 nPgNum);
 266
 267     virtual void     InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos=0xFFFF);
 268     virtual SdrPage* RemoveMasterPage(sal_uInt16 nPgNum);
 269
 270     void                RemoveUnnecessaryMasterPages( SdPage* pMaster=NULL, sal_Bool bOnlyDuplicatePages=sal_False, sal_Bool bUndo=sal_True );
 271     SD_DLLPUBLIC void   SetMasterPage(sal_uInt16 nSdPageNum, const String& rLayoutName,
 272                                       SdDrawDocument* pSourceDoc, sal_Bool bMaster, sal_Bool bCheckMasters);
 273
 274     SD_DLLPUBLIC SdDrawDocument* OpenBookmarkDoc(const String& rBookmarkFile);
 275     SdDrawDocument*     OpenBookmarkDoc(SfxMedium& rMedium);
 276     sal_Bool                InsertBookmark(List* pBookmarkList, List* pExchangeList, sal_Bool bLink,
 277                                         sal_Bool bReplace, sal_uInt16 nPgPos, sal_Bool bNoDialogs,
 278                                         ::sd::DrawDocShell* pBookmarkDocSh, sal_Bool bCopy,
 279                                         Point* pObjPos);
 280
 281     bool IsStartWithPresentation() const;
 282     void SetStartWithPresentation( bool bStartWithPresentation );
 283
 284     /** Insert pages into this document
 285
 286         This method inserts whole pages into this document, either
 287         selected ones (specified via pBookmarkList/pExchangeList), or
 288         all from the source document.
 289
 290         @attention Beware! This method in it's current state does not
 291         handle all combinations of their input parameters
 292         correctly. For example, for pBookmarkList=NULL, bReplace=sal_True
 293         is ignored (no replace happens).
 294
 295         @param pBookmarkList
 296         A list of strings, denoting the names of the pages to be copied
 297
 298         @param pExchangeList
 299         A list of strings, denoting the names of the pages to be renamed
 300
 301         @param bLink
 302         Whether the inserted pages should be links to the bookmark document
 303
 304         @param bReplace
 305         Whether the pages should not be inserted, but replace the pages in
 306         the destination document
 307
 308         @param nPgPos
 309         Insertion point/start of replacement
 310
 311         @param bNoDialogs
 312         Whether query dialogs are allowed (e.g. for page scaling)
 313
 314         @param pBookmarkDocSh
 315         DocShell of the source document (used e.g. to extract the filename
 316         for linked pages)
 317
 318         @param bCopy
 319         Whether the source document should be treated as immutable (i.e.
 320         inserted pages are not removed from it, but cloned)
 321
 322         @param bMergeMasterPages
 323         Whether the source document's master pages should be copied, too.
 324
 325         @param bPreservePageNames
 326         Whether the replace operation should take the name from the new
 327         page, or preserve the old name
 328      */
 329     sal_Bool                InsertBookmarkAsPage(List* pBookmarkList, List* pExchangeList,
 330                                               sal_Bool bLink, sal_Bool bReplace, sal_uInt16 nPgPos,
 331                                               sal_Bool bNoDialogs, ::sd::DrawDocShell* pBookmarkDocSh,
 332                                               sal_Bool bCopy, sal_Bool bMergeMasterPages,
 333                                               sal_Bool bPreservePageNames);
 334     sal_Bool                InsertBookmarkAsObject(List* pBookmarkList, List* pExchangeListL,
 335                                                 sal_Bool bLink, ::sd::DrawDocShell* pBookmarkDocSh,
 336                                                 Point* pObjPos);
 337     void                IterateBookmarkPages( SdDrawDocument* pBookmarkDoc, List* pBookmarkList,
 338                                               sal_uInt16 nBMSdPageCount,
 339                                               InsertBookmarkAsPage_PageFunctorBase& rPageIterator );
 340     SD_DLLPUBLIC void   CloseBookmarkDoc();
 341
 342     SdrObject*          GetObj(const String& rObjName) const;
 343
 344     /** Return the first page that has the given name.  Regular pages and
 345         notes pages are searched first.  When not found then the master
 346         pages are searched.
 347         @param rPgName
 348             Name of the page to return.
 349         @param rbIsMasterPage
 350             Is set by the method to indicate whether the returned index
 351             belongs to a master page (<TRUE/>) or a regular or notes page
 352             (<FALSE/>). The given value is ignored.
 353         @return
 354             Returns the index of the page with the given name or
 355             SDRPAGE_NOTFOUND (=0xffff) when such a page does not exist.
 356     */
 357     sal_uInt16 GetPageByName(const String& rPgName, sal_Bool& rbIsMasterPage ) const;
 358     SD_DLLPUBLIC SdPage*GetSdPage(sal_uInt16 nPgNum, PageKind ePgKind) const;
 359     SD_DLLPUBLIC sal_uInt16 GetSdPageCount(PageKind ePgKind) const;
 360
 361     void                SetSelected(SdPage* pPage, sal_Bool bSelect);
 362     sal_Bool                MovePages(sal_uInt16 nTargetPage);
 363
 364     SD_DLLPUBLIC SdPage*GetMasterSdPage(sal_uInt16 nPgNum, PageKind ePgKind);
 365     SD_DLLPUBLIC sal_uInt16 GetMasterSdPageCount(PageKind ePgKind) const;
 366
 367     sal_uInt16              GetMasterPageUserCount(SdrPage* pMaster) const;
 368
 369     const sd::PresentationSettings& getPresentationSettings() const { return maPresentationSettings; }
 370     sd::PresentationSettings& getPresentationSettings() { return maPresentationSettings; }
 371
 372     const ::com::sun::star::uno::Reference< ::com::sun::star::presentation::XPresentation2 >& getPresentation() const;
 373
 374        void                SetSummationOfParagraphs( sal_Bool bOn = sal_True ) { mbSummationOfParagraphs = bOn; }
 375     sal_Bool            IsSummationOfParagraphs() const { return mbSummationOfParagraphs; }
 376
 377     /** Set the mode that controls whether (and later how) the formatting of the document
 378         depends on the current printer metrics.
 379         @param nMode
 380             Use <const
 381             scope="com::sun::star::document::PrinterIndependentLayout">ENABLED</const>
 382             to make formatting printer-independent and <const
 383             scope="com::sun::star::document::PrinterIndependentLayout">DISABLED</const>
 384             to make formatting depend on the current printer metrics.
 385     */
 386     void SetPrinterIndependentLayout (sal_Int32 nMode);
 387
 388     /** Get the flag that controls whether the formatting of the document
 389         depends on the current printer metrics.
 390         @return
 391             Use <const
 392             scope="com::sun::star::document::PrinterIndependentLayout">ENABLED</const>
 393             when formatting is printer-independent and <const
 394             scope="com::sun::star::document::PrinterIndependentLayout">DISABLED</const>
 395             when formatting depends on the current printer metrics.
 396     */
 397     sal_Int32 GetPrinterIndependentLayout (void);
 398
 399     void                SetOnlineSpell( sal_Bool bIn );
 400     sal_Bool                GetOnlineSpell() const { return mbOnlineSpell; }
 401     void                StopOnlineSpelling();
 402     void                StartOnlineSpelling(sal_Bool bForceSpelling=sal_True);
 403
 404     void                ImpOnlineSpellCallback(SpellCallbackInfo* pInfo, SdrObject* pObj, SdrOutliner* pOutl);
 405
 406     void                InsertObject(SdrObject* pObj, SdPage* pPage);
 407     void                RemoveObject(SdrObject* pObj, SdPage* pPage);
 408
 409     sal_uLong               GetLinkCount();
 410
 411     List*               GetFrameViewList() const { return mpFrameViewList; }
 412     SD_DLLPUBLIC List*  GetCustomShowList(sal_Bool bCreate = sal_False);
 413
 414     void                NbcSetChanged(sal_Bool bFlag = sal_True);
 415
 416     void                SetTextDefaults() const;
 417
 418     void                CreateLayoutTemplates();
 419     void                RenameLayoutTemplate(const String& rOldLayoutName, const String& rNewName);
 420
 421     void                CreateDefaultCellStyles();
 422
 423     SD_DLLPUBLIC void   StopWorkStartupDelay();
 424
 425     void                NewOrLoadCompleted(DocCreationMode eMode);
 426     void                NewOrLoadCompleted( SdPage* pPage, SdStyleSheetPool* pSPool );
 427     sal_Bool                IsNewOrLoadCompleted() const {return mbNewOrLoadCompleted; }
 428
 429     ::sd::FrameView* GetFrameView(sal_uLong nPos) {
 430         return static_cast< ::sd::FrameView*>(
 431             mpFrameViewList->GetObject(nPos));}
 432
 433     /** deprecated*/
 434     SdAnimationInfo*    GetAnimationInfo(SdrObject* pObject) const;
 435
 436     SD_DLLPUBLIC static     SdAnimationInfo* GetShapeUserData(SdrObject& rObject, bool bCreate = false );
 437
 438     SdIMapInfo*         GetIMapInfo( SdrObject* pObject ) const;
 439     IMapObject*         GetHitIMapObject( SdrObject* pObject, const Point& rWinPoint, const ::Window& rCmpWnd );
 440
 441     CharClass*          GetCharClass() const { return mpCharClass; }
 442
 443     void                RestoreLayerNames();
 444
 445     void                UpdateAllLinks();
 446
 447     void                CheckMasterPages();
 448
 449     void                Merge(SdrModel& rSourceModel,
 450                                 sal_uInt16 nFirstPageNum=0, sal_uInt16 nLastPageNum=0xFFFF,
 451                                 sal_uInt16 nDestPos=0xFFFF,
 452                                 FASTBOOL bMergeMasterPages=sal_False, FASTBOOL bAllMasterPages=sal_False,
 453                                 FASTBOOL bUndo=sal_True, FASTBOOL bTreadSourceAsConst=sal_False);
 454
 455     SD_DLLPUBLIC ::com::sun::star::text::WritingMode GetDefaultWritingMode() const;
 456     void SetDefaultWritingMode( ::com::sun::star::text::WritingMode eMode );
 457
 458     /** replacespOldPage from all custom shows with pNewPage or removes pOldPage from
 459         all custom shows if pNewPage is 0.
 460     */
 461     void ReplacePageInCustomShows( const SdPage* pOldPage, const SdPage* pNewPage );
 462
 463 public:
 464
 465     static SdDrawDocument* pDocLockedInsertingLinks;  // static to prevent recursions while resolving links
 466
 467     /** Create and insert a set of two new pages: a standard (draw) page and
 468         the associated notes page.  The new pages are inserted direclty
 469         after the specified page set.
 470         @param pCurrentPage
 471             This page is used to retrieve the layout for the page to
 472             create.
 473         @param ePageKind
 474             This specifies whether <argument>pCurrentPage</argument> is a
 475             standard (draw) page or a notes page.
 476         @param sStandardPageName
 477             Name of the standard page.  An empty string leads to using an
 478             automatically created name.
 479         @param sNotesPageName
 480             Name of the standard page.  An empty string leads to using an
 481             automatically created name.
 482         @param eStandardLayout
 483             Layout to use for the new standard page.  Note that this layout
 484             is not used when the given <argument>pCurrentPage</argument> is
 485             not a standard page.  In this case the layout is taken from the
 486             standard page associated with <argument>pCurrentPage</argument>.
 487         @param eNotesLayout
 488             Layout to use for the new notes page.  Note that this layout
 489             is not used when the given <argument>pCurrentPage</argument> is
 490             not a notes page.  In this case the layout is taken from the
 491             notes page associated with <argument>pCurrentPage</argument>.
 492         @param bIsPageBack
 493             This flag indicates whether to show the background shape.
 494         @param bIsPageObj
 495             This flag indicates whether to show the shapes on the master page.
 496         @param nInsertPosition
 497             Position where to insert the standard page.  When -1 then the
 498             new page set is inserted after the current page.
 499
 500         @return
 501             Returns an index of the inserted pages that can be used with the
 502             <member>GetSdPage()</member> method.
 503     */
 504     sal_uInt16 CreatePage (
 505         SdPage* pCurrentPage,
 506         PageKind ePageKind,
 507         const String& sStandardPageName,
 508         const String& sNotesPageName,
 509         AutoLayout eStandardLayout,
 510         AutoLayout eNotesLayout,
 511         sal_Bool bIsPageBack,
 512         sal_Bool bIsPageObj,
 513         const sal_Int32 nInsertPosition = -1);
 514
 515     /** This method acts as a simplified front end for the more complex
 516         <member>DuplicatePage()</member> method.
 517         @param nPageNum
 518             The page number as passed to the <member>GetSdPage()</member>
 519             method for which the standard page and the notes page are to be
 520             copied.
 521         @return
 522             Returns an index of the inserted pages that can be used with the
 523             <member>GetSdPage()</member> method.
 524     */
 525     sal_uInt16 DuplicatePage (sal_uInt16 nPageNum);
 526
 527     /** Create and insert a set of two new pages that are copies of the
 528         given <argument>pCurrentPage</argument> and its associated notes
 529         resp. standard page.  The copies are inserted directly after the
 530         specified page set.
 531         @param pCurrentPage
 532             This page and its associated notes/standard page is copied.
 533         @param ePageKind
 534             This specifies whether <argument>pCurrentPage</argument> is a
 535             standard (draw) page or a notes page.
 536         @param sStandardPageName
 537             Name of the standard page.  An empty string leads to using an
 538             automatically created name.
 539         @param sNotesPageName
 540             Name of the standard page.  An empty string leads to using an
 541             automatically created name.
 542         @param eStandardLayout
 543             Layout to use for the new standard page.  Note that this layout
 544             is not used when the given <argument>pCurrentPage</argument> is
 545             not a standard page.  In this case the layout is taken from the
 546             standard page associated with <argument>pCurrentPage</argument>.
 547         @param eNotesLayout
 548             Layout to use for the new notes page.  Note that this layout
 549             is not used when the given <argument>pCurrentPage</argument> is
 550             not a notes page.  In this case the layout is taken from the
 551             notes page associated with <argument>pCurrentPage</argument>.
 552         @param bIsPageBack
 553             This flag indicates whether to show the background shape.
 554         @param bIsPageObj
 555             This flag indicates whether to show the shapes on the master page.
 556         @param nInsertPosition
 557             Position where to insert the standard page.  When -1 then the
 558             new page set is inserted after the current page.
 559
 560         @return
 561             Returns an index of the inserted pages that can be used with the
 562             <member>GetSdPage()</member> method.
 563     */
 564     sal_uInt16 DuplicatePage (
 565         SdPage* pCurrentPage,
 566         PageKind ePageKind,
 567         const String& sStandardPageName,
 568         const String& sNotesPageName,
 569         AutoLayout eStandardLayout,
 570         AutoLayout eNotesLayout,
 571         sal_Bool bIsPageBack,
 572         sal_Bool bIsPageObj,
 573         const sal_Int32 nInsertPosition = -1);
 574
 575     /** return the document fonts for latin, cjk and ctl according to the current
 576         languages set at this document */
 577     void getDefaultFonts( Font& rLatinFont, Font& rCJKFont, Font& rCTLFont );
 578
 579     sd::UndoManager* GetUndoManager() const;
 580
 581     /* converts the given western font height to a corresponding ctl font height, deppending on the system language */
 582     static sal_uInt32 convertFontHeightToCTL( sal_uInt32 nWesternFontHeight );
 583
 584     /** Get the style sheet pool if it was a SdStyleSheetPool.
 585      */
 586     SD_DLLPUBLIC SdStyleSheetPool* GetSdStyleSheetPool() const;
 587
 588        void UpdatePageRelativeURLs(const String& rOldName, const String& rNewName);
 589
 590     void SetCalcFieldValueHdl( ::Outliner* pOutliner);
 591
 592     sal_uInt16 GetAnnotationAuthorIndex( const rtl::OUString& rAuthor );
 593
 594 private:
 595     /** This member stores the printer independent layout mode.  Please
 596         refer to <member>SetPrinterIndependentLayout()</member> for its
 597         values.
 598     */
 599     sal_Int32 mnPrinterIndependentLayout;
 600
 601     /** Insert a given set of standard and notes page after the given <argument>pCurrentPage</argument>.
 602         @param pCurrentPage
 603             This page and its associated notes/standard page is copied.
 604         @param ePageKind
 605             This specifies whether <argument>pCurrentPage</argument> is a
 606             standard (draw) page or a notes page.
 607         @param sStandardPageName
 608             Name of the standard page.  An empty string leads to using an
 609             automatically created name.
 610         @param sNotesPageName
 611             Name of the standard page.  An empty string leads to using an
 612             automatically created name.
 613         @param eStandardLayout
 614             Layout to use for the new standard page.  Note that this layout
 615             is not used when the given <argument>pCurrentPage</argument> is
 616             not a standard page.  In this case the layout is taken from the
 617             standard page associated with <argument>pCurrentPage</argument>.
 618         @param eNotesLayout
 619             Layout to use for the new notes page.  Note that this layout
 620             is not used when the given <argument>pCurrentPage</argument> is
 621             not a notes page.  In this case the layout is taken from the
 622             notes page associated with <argument>pCurrentPage</argument>.
 623         @param bIsPageBack
 624             This flag indicates whether to show the background shape.
 625         @param bIsPageObj
 626             This flag indicates whether to show the shapes on the master page.
 627         @param pStandardPage
 628             The standard page to insert.
 629         @param pNotesPage
 630             The notes page to insert.
 631         @param nInsertPosition
 632             Position where to insert the standard page.  When -1 then the
 633             new page set is inserted after the current page.
 634
 635         @return
 636             Returns an index of the inserted pages that can be used with the
 637             <member>GetSdPage()</member> method.
 638     */
 639     sal_uInt16 InsertPageSet (
 640         SdPage* pCurrentPage,
 641         PageKind ePageKind,
 642         const String& sStandardPageName,
 643         const String& sNotesPageName,
 644         AutoLayout eStandardLayout,
 645         AutoLayout eNotesLayout,
 646         sal_Bool bIsPageBack,
 647         sal_Bool bIsPageObj,
 648         SdPage* pStandardPage,
 649         SdPage* pNotesPage,
 650         sal_Int32 nInsertPosition = -1);
 651
 652     /** Set up a newly created page and insert it into the list of pages.
 653         @param pPreviousPage
 654             A page to take the size and border geometry from.
 655         @param pPage
 656             This is the page to set up and insert.
 657         @param sPageName
 658             The name of the new page.
 659         @param nInsertionPoint
 660             Index of the page before which the new page will be inserted.
 661         @param bIsPageBack
 662             This flag indicates whether to show the background shape.
 663         @param bIsPageObj
 664             This flag indicates whether to show the shapes on the master
 665             page.
 666     */
 667     void SetupNewPage (
 668         SdPage* pPreviousPage,
 669         SdPage* pPage,
 670         const String& sPageName,
 671         sal_uInt16 nInsertionPoint,
 672         sal_Bool bIsPageBack,
 673         sal_Bool bIsPageObj);
 674
 675     // #109538#
 676     virtual void PageListChanged();
 677     virtual void MasterPageListChanged();
 678 };
 679
 680 namespace sd
 681 {
 682
 683 // an instance of this guard disables modification of a document
 684 // during its lifetime
 685 class ModifyGuard
 686 {
 687 public:
 688     ModifyGuard( SdDrawDocument* pDoc );
 689     ~ModifyGuard();
 690
 691 private:
 692     void init();
 693
 694     DrawDocShell* mpDocShell;
 695     SdDrawDocument* mpDoc;
 696     sal_Bool mbIsEnableSetModified;
 697     sal_Bool mbIsDocumentChanged;
 698 };
 699
 700 }
 701
 702 #endif // _DRAWDOC_HXX