sd/source/core/drawdoc3.cxx

   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
  20
  21 #include <memory>
  22 #include <string_view>
  23
  24 #include <sfx2/docfile.hxx>
  25 #include <sfx2/docfilt.hxx>
  26 #include <sfx2/app.hxx>
  27 #include <svl/itemset.hxx>
  28 #include <tools/debug.hxx>
  29
  30 #include <sfx2/fcontnr.hxx>
  31 #include <svl/style.hxx>
  32 #include <svx/svdpagv.hxx>
  33 #include <svx/svdundo.hxx>
  34 #include <vcl/stdtext.hxx>
  35 #include <vcl/svapp.hxx>
  36 #include <vcl/weld.hxx>
  37 #include <xmloff/autolayout.hxx>
  38
  39 #include <strings.hrc>
  40 #include <drawdoc.hxx>
  41 #include <sdmod.hxx>
  42 #include <sdpage.hxx>
  43 #include <stlpool.hxx>
  44 #include <sdresid.hxx>
  45 #include <customshowlist.hxx>
  46 #include <sdxfer.hxx>
  47
  48 #include <unmovss.hxx>
  49 #include <unchss.hxx>
  50 #include <unprlout.hxx>
  51 #include <DrawDocShell.hxx>
  52 #include <GraphicDocShell.hxx>
  53 #include <ViewShell.hxx>
  54 #include <View.hxx>
  55 #include <ViewShellBase.hxx>
  56 #include <strings.hxx>
  57
  58 using namespace ::com::sun::star;
  59
  60 /** Concrete incarnations get called by lcl_IterateBookmarkPages, for
  61     every page in the bookmark document/list
  62  */
  63
  64 namespace {
  65
  66 class InsertBookmarkAsPage_FindDuplicateLayouts
  67 {
  68 public:
  69     explicit InsertBookmarkAsPage_FindDuplicateLayouts( std::vector<OUString> &rLayoutsToTransfer )
  70         : mrLayoutsToTransfer(rLayoutsToTransfer) {}
  71     void operator()( SdDrawDocument&, SdPage const *, bool, SdDrawDocument* );
  72 private:
  73     std::vector<OUString> &mrLayoutsToTransfer;
  74 };
  75
  76 }
  77
  78 void InsertBookmarkAsPage_FindDuplicateLayouts::operator()( SdDrawDocument& rDoc, SdPage const * pBMMPage, bool bRenameDuplicates, SdDrawDocument* pBookmarkDoc )
  79 {
  80     // now check for duplicate masterpage and layout names
  81
  82     OUString aLayout( pBMMPage->GetLayoutName() );
  83     sal_Int32 nIndex = aLayout.indexOf( SD_LT_SEPARATOR );
  84     if( nIndex != -1 )
  85         aLayout = aLayout.copy(0, nIndex);
  86
  87     std::vector<OUString>::const_iterator pIter =
  88             find(mrLayoutsToTransfer.begin(),mrLayoutsToTransfer.end(),aLayout);
  89
  90     bool bFound = pIter != mrLayoutsToTransfer.end();
  91
  92     const sal_uInt16 nMPageCount = rDoc.GetMasterPageCount();
  93     for (sal_uInt16 nMPage = 0; nMPage < nMPageCount && !bFound; nMPage++)
  94     {
  95         // Do the layouts already exist within the document?
  96         SdPage* pTestPage = static_cast<SdPage*>( rDoc.GetMasterPage(nMPage) );
  97         OUString aTest(pTestPage->GetLayoutName());
  98         sal_Int32 nIndex2 = aTest.indexOf( SD_LT_SEPARATOR );
  99         if( nIndex2 != -1 )
 100             aTest = aTest.copy(0, nIndex2);
 101
 102         if (aTest == aLayout && pBMMPage->GetPageKind() == pTestPage->GetPageKind())
 103         {
 104             // Ignore Layouts with "Default" these seem to be special - in the sense that there are lot of assumption all over Impress
 105             // about this
 106             if( bRenameDuplicates && aTest != SdResId( STR_LAYOUT_DEFAULT_NAME ) && !(pTestPage->Equals(*pBMMPage)) )
 107             {
 108                 pBookmarkDoc->RenameLayoutTemplate(
 109                     pBMMPage->GetLayoutName(), pBMMPage->GetName() + "_");
 110                 aLayout = pBMMPage->GetName();
 111
 112                 break;
 113             }
 114             else
 115                 bFound = true;
 116         }
 117     }
 118
 119     if (!bFound)
 120         mrLayoutsToTransfer.push_back(aLayout);
 121 }
 122
 123 // Inserts a bookmark as a page
 124 static void lcl_IterateBookmarkPages( SdDrawDocument &rDoc, SdDrawDocument* pBookmarkDoc,
 125                                const std::vector<OUString> &rBookmarkList, sal_uInt16 nBMSdPageCount,
 126                                InsertBookmarkAsPage_FindDuplicateLayouts& rPageIterator, bool bRenameDuplicates )
 127 {
 128
 129     // Refactored copy'n'pasted layout name collection from InsertBookmarkAsPage
 130
 131     int nPos, nEndPos;
 132
 133     if( rBookmarkList.empty() )
 134     {
 135         // no list? whole source document
 136         nEndPos = nBMSdPageCount;
 137     }
 138     else
 139     {
 140         // bookmark list? number of entries
 141         nEndPos = rBookmarkList.size();
 142     }
 143
 144     SdPage* pBMPage;
 145
 146     // iterate over number of pages to insert
 147     for (nPos = 0; nPos < nEndPos; ++nPos)
 148     {
 149         // the master page associated to the nPos'th page to insert
 150         SdPage* pBMMPage = nullptr;
 151
 152         if( rBookmarkList.empty() )
 153         {
 154             // simply take master page of nPos'th page in source document
 155             pBMMPage = static_cast<SdPage*>(&(pBookmarkDoc->GetSdPage(static_cast<sal_uInt16>(nPos), PageKind::Standard)->TRG_GetMasterPage()));
 156         }
 157         else
 158         {
 159             // fetch nPos'th entry from bookmark list, and determine master page
 160             OUString aBMPgName(rBookmarkList[nPos]);
 161             bool  bIsMasterPage;
 162
 163             sal_uInt16 nBMPage = pBookmarkDoc->GetPageByName( aBMPgName, bIsMasterPage );
 164
 165             if (nBMPage != SDRPAGE_NOTFOUND)
 166             {
 167                 pBMPage = static_cast<SdPage*>( pBookmarkDoc->GetPage(nBMPage) );
 168             }
 169             else
 170             {
 171                 pBMPage = nullptr;
 172             }
 173
 174             // enforce that bookmarked page is a standard page and not already a master page
 175             if (pBMPage && pBMPage->GetPageKind()==PageKind::Standard && !pBMPage->IsMasterPage())
 176             {
 177                 const sal_uInt16 nBMSdPage = (nBMPage - 1) / 2;
 178                 pBMMPage = static_cast<SdPage*> (&(pBookmarkDoc->GetSdPage(nBMSdPage, PageKind::Standard)->TRG_GetMasterPage()));
 179             }
 180         }
 181
 182         // successfully determined valid (bookmarked) page?
 183         if( pBMMPage )
 184         {
 185             // yes, call functor
 186             rPageIterator( rDoc, pBMMPage, bRenameDuplicates, pBookmarkDoc );
 187         }
 188     }
 189 }
 190
 191 // Opens a bookmark document
 192 SdDrawDocument* SdDrawDocument::OpenBookmarkDoc(SfxMedium* pMedium)
 193 {
 194     bool bOK = true;
 195     SdDrawDocument* pBookmarkDoc = nullptr;
 196     OUString aBookmarkName = pMedium->GetName();
 197     std::shared_ptr<const SfxFilter> pFilter = pMedium->GetFilter();
 198     if ( !pFilter )
 199     {
 200         pMedium->UseInteractionHandler( true );
 201         SfxGetpApp()->GetFilterMatcher().GuessFilter(*pMedium, pFilter);
 202     }
 203
 204     if ( !pFilter )
 205     {
 206         bOK = false;
 207     }
 208     else if ( !aBookmarkName.isEmpty() && maBookmarkFile != aBookmarkName )
 209     {
 210         bool bCreateGraphicShell = pFilter->GetServiceName() == "com.sun.star.drawing.DrawingDocument";
 211         bool bCreateImpressShell = pFilter->GetServiceName() == "com.sun.star.presentation.PresentationDocument";
 212         if ( bCreateGraphicShell || bCreateImpressShell )
 213         {
 214             CloseBookmarkDoc();
 215
 216             // Create a DocShell, as OLE objects might be contained in the
 217             // document. (Persist)
 218             // If that wasn't the case, we could load the model directly.
 219             if ( bCreateGraphicShell )
 220                 // Draw
 221                 mxBookmarkDocShRef = new ::sd::GraphicDocShell(SfxObjectCreateMode::STANDARD);
 222             else
 223                 // Impress
 224                 mxBookmarkDocShRef = new ::sd::DrawDocShell(SfxObjectCreateMode::STANDARD, true, DocumentType::Impress);
 225
 226             bOK = mxBookmarkDocShRef->DoLoad(pMedium);
 227             if( bOK )
 228             {
 229                 maBookmarkFile = aBookmarkName;
 230                 pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 231             }
 232         }
 233     }
 234
 235     DBG_ASSERT(!aBookmarkName.isEmpty(), "Empty document name!");
 236
 237     if (!bOK)
 238     {
 239         std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(nullptr,
 240                                                        VclMessageType::Warning, VclButtonsType::Ok, SdResId(STR_READ_DATA_ERROR)));
 241         xErrorBox->run();
 242
 243         CloseBookmarkDoc();
 244         pBookmarkDoc = nullptr;
 245     }
 246     else if (mxBookmarkDocShRef.is())
 247     {
 248         pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 249     }
 250
 251     return pBookmarkDoc;
 252 }
 253
 254 // Opens a bookmark document
 255 SdDrawDocument* SdDrawDocument::OpenBookmarkDoc(const OUString& rBookmarkFile)
 256 {
 257     SdDrawDocument* pBookmarkDoc = nullptr;
 258
 259     if (!rBookmarkFile.isEmpty() && maBookmarkFile != rBookmarkFile)
 260     {
 261         std::unique_ptr<SfxMedium> xMedium(new SfxMedium(rBookmarkFile, StreamMode::READ));
 262         pBookmarkDoc = OpenBookmarkDoc(xMedium.release());
 263     }
 264     else if (mxBookmarkDocShRef.is())
 265     {
 266         pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 267     }
 268
 269     return pBookmarkDoc;
 270 }
 271
 272 // Inserts a bookmark (page or object)
 273 void SdDrawDocument::InsertBookmark(
 274     const std::vector<OUString> &rBookmarkList,     // List of names of the bookmarks to be inserted
 275     std::vector<OUString> &rExchangeList,           // List of the names to be used
 276     bool bLink,                                     // Insert bookmarks as links?
 277     sal_uInt16 nInsertPos,                          // Insertion position of pages
 278     ::sd::DrawDocShell* pBookmarkDocSh,             // If set, this is the source document
 279     Point const * pObjPos)                                 // Insertion position of objects
 280 {
 281     bool bOK = true;
 282     bool bInsertPages = false;
 283
 284     if (rBookmarkList.empty())
 285     {
 286         // Insert all pages
 287         bInsertPages = true;
 288     }
 289     else
 290     {
 291         SdDrawDocument* pBookmarkDoc = nullptr;
 292
 293         if (pBookmarkDocSh)
 294         {
 295             pBookmarkDoc = pBookmarkDocSh->GetDoc();
 296         }
 297         else if ( mxBookmarkDocShRef.is() )
 298         {
 299             pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 300         }
 301         else
 302             bOK = false;
 303
 304         bInsertPages = bOK && std::any_of(rBookmarkList.begin(), rBookmarkList.end(),
 305             [&pBookmarkDoc](const OUString& rBookmark) {
 306                 // Is there a page name in the bookmark list?
 307                 bool    bIsMasterPage;
 308                 return pBookmarkDoc->GetPageByName(rBookmark, bIsMasterPage) != SDRPAGE_NOTFOUND;
 309             });
 310     }
 311
 312     bool bCalcObjCount = !rExchangeList.empty();
 313
 314     if ( bOK && bInsertPages )
 315     {
 316         // Insert all page bookmarks
 317         bOK = InsertBookmarkAsPage(rBookmarkList, &rExchangeList, bLink, false/*bReplace*/,
 318                                    nInsertPos, false/*bNoDialogs*/, pBookmarkDocSh, true/*bCopy*/, true, false);
 319     }
 320
 321     if ( bOK && !rBookmarkList.empty() )
 322     {
 323         // Insert all object bookmarks
 324         InsertBookmarkAsObject(rBookmarkList, rExchangeList,
 325                                      pBookmarkDocSh, pObjPos, bCalcObjCount);
 326     }
 327 }
 328
 329 namespace
 330 {
 331
 332 void
 333 lcl_removeUnusedStyles(SfxStyleSheetBasePool* const pStyleSheetPool, StyleSheetCopyResultVector& rStyles)
 334 {
 335     StyleSheetCopyResultVector aUsedStyles;
 336     aUsedStyles.reserve(rStyles.size());
 337     for (const auto& a : rStyles)
 338     {
 339         if (a.m_xStyleSheet->IsUsed())
 340             aUsedStyles.push_back(a);
 341         else
 342             pStyleSheetPool->Remove(a.m_xStyleSheet.get());
 343     }
 344     rStyles = aUsedStyles;
 345 }
 346
 347 SfxStyleSheet *lcl_findStyle(StyleSheetCopyResultVector& rStyles, std::u16string_view aStyleName)
 348 {
 349     for (const auto& a : rStyles)
 350     {
 351         if (a.m_xStyleSheet->GetName().startsWith(aStyleName))
 352             return a.m_xStyleSheet.get();
 353     }
 354     return nullptr;
 355 }
 356
 357 }
 358
 359 bool SdDrawDocument::InsertBookmarkAsPage(
 360     const std::vector<OUString> &rBookmarkList,
 361     std::vector<OUString> *pExchangeList,            // List of names to be used
 362     bool bLink,
 363     bool bReplace,
 364     sal_uInt16 nInsertPos,
 365     bool bNoDialogs,
 366     ::sd::DrawDocShell* pBookmarkDocSh,
 367     bool bCopy,
 368     bool bMergeMasterPages,
 369     bool bPreservePageNames)
 370 {
 371     bool bContinue = true;
 372     bool bScaleObjects = false;
 373     sal_uInt16 nReplacedStandardPages = 0;
 374
 375     SdDrawDocument* pBookmarkDoc = nullptr;
 376     OUString aBookmarkName;
 377
 378     if (pBookmarkDocSh)
 379     {
 380         pBookmarkDoc = pBookmarkDocSh->GetDoc();
 381
 382         if (pBookmarkDocSh->GetMedium())
 383         {
 384             aBookmarkName = pBookmarkDocSh->GetMedium()->GetName();
 385         }
 386     }
 387     else if ( mxBookmarkDocShRef.is() )
 388     {
 389         pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 390         aBookmarkName = maBookmarkFile;
 391     }
 392     else
 393     {
 394         return false;
 395     }
 396
 397     const sal_uInt16 nSdPageCount = GetSdPageCount(PageKind::Standard);
 398     const sal_uInt16 nBMSdPageCount = pBookmarkDoc->GetSdPageCount(PageKind::Standard);
 399     const sal_uInt16 nMPageCount = GetMasterPageCount();
 400
 401     if (nSdPageCount==0 || nBMSdPageCount==0 || nMPageCount==0)
 402     {
 403         return false;
 404     }
 405
 406     // Store the size and some other properties of the first page and notes
 407     // page so that inserted pages can be properly scaled even when inserted
 408     // before the first page.
 409     // Note that the pointers are used later on as general page pointers.
 410     SdPage* pRefPage = GetSdPage(0, PageKind::Standard);
 411     Size  aSize(pRefPage->GetSize());
 412     sal_Int32 nLeft  = pRefPage->GetLeftBorder();
 413     sal_Int32 nRight = pRefPage->GetRightBorder();
 414     sal_Int32 nUpper = pRefPage->GetUpperBorder();
 415     sal_Int32 nLower = pRefPage->GetLowerBorder();
 416     Orientation eOrient = pRefPage->GetOrientation();
 417
 418     SdPage* pNPage = GetSdPage(0, PageKind::Notes);
 419     Size aNSize(pNPage->GetSize());
 420     sal_Int32 nNLeft  = pNPage->GetLeftBorder();
 421     sal_Int32 nNRight = pNPage->GetRightBorder();
 422     sal_Int32 nNUpper = pNPage->GetUpperBorder();
 423     sal_Int32 nNLower = pNPage->GetLowerBorder();
 424     Orientation eNOrient = pNPage->GetOrientation();
 425
 426     // Adapt page size and margins to those of the later pages?
 427     pRefPage = GetSdPage(nSdPageCount - 1, PageKind::Standard);
 428
 429     if( bNoDialogs )
 430     {
 431         // If this is clipboard, then no need to scale objects:
 432         // this will make copied masters to differ from the originals,
 433         // and thus InsertBookmarkAsPage_FindDuplicateLayouts will
 434         // duplicate masters on insert to same document
 435         m_bTransportContainer = (SD_MOD()->pTransferClip &&
 436                                SD_MOD()->pTransferClip->GetWorkDocument() == this);
 437         if (!m_bTransportContainer)
 438         {
 439             if (rBookmarkList.empty())
 440                 bScaleObjects = pRefPage->IsScaleObjects();
 441             else
 442                 bScaleObjects = true;
 443         }
 444     }
 445     else
 446     {
 447         SdPage* pBMPage = pBookmarkDoc->GetSdPage(0,PageKind::Standard);
 448
 449         if (pBMPage->GetSize()        != pRefPage->GetSize()         ||
 450             pBMPage->GetLeftBorder()   != pRefPage->GetLeftBorder()    ||
 451             pBMPage->GetRightBorder()   != pRefPage->GetRightBorder()    ||
 452             pBMPage->GetUpperBorder()   != pRefPage->GetUpperBorder()    ||
 453             pBMPage->GetLowerBorder()   != pRefPage->GetLowerBorder())
 454         {
 455             OUString aStr(SdResId(STR_SCALE_OBJECTS));
 456             std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(nullptr,
 457                                                            VclMessageType::Question, VclButtonsType::YesNo,
 458                                                            aStr));
 459             xQueryBox->add_button(GetStandardText(StandardButtonType::Cancel), RET_CANCEL);
 460             sal_uInt16 nBut = xQueryBox->run();
 461
 462             bScaleObjects = nBut == RET_YES;
 463             bContinue     = nBut != RET_CANCEL;
 464
 465             if (!bContinue)
 466             {
 467                 return bContinue;
 468             }
 469         }
 470     }
 471
 472     // Get the necessary presentation stylesheets and transfer them before
 473     // the pages, else, the text objects won't reference their styles anymore.
 474     SfxUndoManager* pUndoMgr = nullptr;
 475     if( mpDocSh )
 476     {
 477         pUndoMgr = mpDocSh->GetUndoManager();
 478         ViewShellId nViewShellId(-1);
 479         if (sd::ViewShell* pViewShell = mpDocSh->GetViewShell())
 480             nViewShellId = pViewShell->GetViewShellBase().GetViewShellId();
 481         pUndoMgr->EnterListAction(SdResId(STR_UNDO_INSERTPAGES), "", 0, nViewShellId);
 482     }
 483
 484     // Refactored copy'n'pasted layout name collection into IterateBookmarkPages
 485
 486     std::vector<OUString> aLayoutsToTransfer;
 487     InsertBookmarkAsPage_FindDuplicateLayouts aSearchFunctor( aLayoutsToTransfer );
 488     lcl_IterateBookmarkPages( *this, pBookmarkDoc, rBookmarkList, nBMSdPageCount, aSearchFunctor, ( rBookmarkList.empty() && pBookmarkDoc != this ) );
 489
 490     // Copy the style that we actually need.
 491     SdStyleSheetPool& rBookmarkStyleSheetPool = dynamic_cast<SdStyleSheetPool&>(*pBookmarkDoc->GetStyleSheetPool());
 492     SdStyleSheetPool& rStyleSheetPool = dynamic_cast<SdStyleSheetPool&>(*GetStyleSheetPool());
 493
 494     // When copying styles, also copy the master pages!
 495     if( !aLayoutsToTransfer.empty() )
 496         bMergeMasterPages = true;
 497
 498     for ( const OUString& layoutName : aLayoutsToTransfer )
 499     {
 500         StyleSheetCopyResultVector aCreatedStyles;
 501
 502         rStyleSheetPool.CopyLayoutSheets(layoutName, rBookmarkStyleSheetPool,aCreatedStyles);
 503
 504         if(!aCreatedStyles.empty())
 505         {
 506             if( pUndoMgr )
 507             {
 508                 pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aCreatedStyles, true));
 509             }
 510         }
 511     }
 512
 513     // Copy styles. This unconditionally copies all styles, even those
 514     // that are not used in any of the inserted pages. The unused styles
 515     // are then removed at the end of the function, where we also create
 516     // undo records for the inserted styles.
 517     StyleSheetCopyResultVector aNewGraphicStyles;
 518     OUString aRenameStr;
 519     if(!bReplace && !bNoDialogs)
 520         aRenameStr = "_";
 521     rStyleSheetPool.RenameAndCopyGraphicSheets(rBookmarkStyleSheetPool, aNewGraphicStyles, aRenameStr);
 522     StyleSheetCopyResultVector aNewCellStyles;
 523     rStyleSheetPool.CopyCellSheets(rBookmarkStyleSheetPool, aNewCellStyles);
 524
 525     // TODO handle undo of table styles too
 526     rStyleSheetPool.CopyTableStyles(rBookmarkStyleSheetPool);
 527
 528     // Insert document
 529
 530     const bool bUndo = IsUndoEnabled();
 531
 532     if( bUndo )
 533         BegUndo(SdResId(STR_UNDO_INSERTPAGES));
 534
 535     if (rBookmarkList.empty())
 536     {
 537         if (nInsertPos >= GetPageCount())
 538         {
 539             // Add pages to the end
 540             nInsertPos = GetPageCount();
 541         }
 542
 543         sal_uInt16 nActualInsertPos = nInsertPos;
 544
 545         sal_uInt16 nBMSdPage;
 546         std::set<sal_uInt16> aRenameSet;
 547         std::map<sal_uInt16,OUString> aNameMap;
 548
 549         for (nBMSdPage=0; nBMSdPage < nBMSdPageCount; nBMSdPage++)
 550         {
 551             SdPage* pBMPage = pBookmarkDoc->GetSdPage(nBMSdPage, PageKind::Standard);
 552             OUString sName(pBMPage->GetName());
 553             bool    bIsMasterPage;
 554
 555             if (bLink)
 556             {
 557                 // Remember the names of all pages
 558                 aNameMap.insert(std::make_pair(nBMSdPage,sName));
 559             }
 560
 561             // Have to check for duplicate names here, too
 562             // don't change name if source and dest model are the same!
 563             if( pBookmarkDoc != this &&
 564                 GetPageByName(sName, bIsMasterPage ) != SDRPAGE_NOTFOUND )
 565             {
 566                 // delay renaming *after* pages are copied (might destroy source otherwise)
 567                 aRenameSet.insert(nBMSdPage);
 568             }
 569         }
 570
 571         Merge(*pBookmarkDoc,
 572               1,                 // Not the handout page
 573               0xFFFF,            // But all others
 574               nActualInsertPos,  // Insert at position ...
 575               bMergeMasterPages, // Move master pages?
 576               false,             // But only the master pages used
 577               true,              // Create an undo action
 578               bCopy);            // Copy (or merge) pages?
 579
 580         for (nBMSdPage=0; nBMSdPage < nBMSdPageCount; nBMSdPage++)
 581         {
 582             SdPage* pPage       = static_cast<SdPage*>( GetPage(nActualInsertPos) );
 583             SdPage* pNotesPage  = static_cast<SdPage*>( GetPage(nActualInsertPos+1) );
 584
 585             // delay renaming *after* pages are copied (might destroy source otherwise)
 586             if( aRenameSet.find(nBMSdPage) != aRenameSet.end() )
 587             {
 588                 // Page name already in use -> Use default name for default and
 589                 // notes page
 590                 pPage->SetName(OUString());
 591                 pNotesPage->SetName(OUString());
 592             }
 593
 594             if (bLink)
 595             {
 596                 OUString aName(aNameMap[nBMSdPage]);
 597
 598                 // Assemble all link names
 599                 pPage->SetFileName(aBookmarkName);
 600                 pPage->SetBookmarkName(aName);
 601             }
 602
 603             nActualInsertPos += 2;
 604         }
 605     }
 606     else
 607     {
 608         // Insert selected pages
 609         SdPage* pBMPage;
 610
 611         if (nInsertPos >= GetPageCount())
 612         {
 613             // Add pages to the end
 614             bReplace = false;
 615             nInsertPos = GetPageCount();
 616         }
 617
 618         sal_uInt16 nActualInsertPos = nInsertPos;
 619
 620         // Collect the bookmarked pages
 621         ::std::vector<SdPage*> aBookmarkedPages (rBookmarkList.size(), nullptr);
 622         for ( size_t nPos = 0, n = rBookmarkList.size(); nPos < n; ++nPos)
 623         {
 624             OUString aPgName(rBookmarkList[nPos]);
 625             bool    bIsMasterPage;
 626             sal_uInt16  nBMPage = pBookmarkDoc->GetPageByName( aPgName, bIsMasterPage );
 627
 628             if (nBMPage != SDRPAGE_NOTFOUND)
 629             {
 630                 aBookmarkedPages[nPos] =  dynamic_cast<SdPage*>(pBookmarkDoc->GetPage(nBMPage));
 631             }
 632         }
 633
 634         for ( size_t nPos = 0, n = rBookmarkList.size(); nPos < n; ++nPos)
 635         {
 636             pBMPage = aBookmarkedPages[nPos];
 637             sal_uInt16 nBMPage = pBMPage!=nullptr ? pBMPage->GetPageNum() : SDRPAGE_NOTFOUND;
 638
 639             if (pBMPage && pBMPage->GetPageKind()==PageKind::Standard && !pBMPage->IsMasterPage())
 640             {
 641                 // It has to be a default page
 642                 bool bMustRename = false;
 643
 644                 // delay renaming *after* pages are copied (might destroy source otherwise)
 645                 // don't change name if source and dest model are the same!
 646                 // avoid renaming if replacing the same page
 647                 OUString aPgName(rBookmarkList[nPos]);
 648                 bool    bIsMasterPage;
 649                 sal_uInt16 nPageSameName = GetPageByName(aPgName, bIsMasterPage);
 650                 if( pBookmarkDoc != this &&
 651                     nPageSameName != SDRPAGE_NOTFOUND &&
 652                     ( !bReplace ||
 653                       nPageSameName != nActualInsertPos ) )
 654                 {
 655                     bMustRename = true;
 656                 }
 657
 658                 SdPage* pBookmarkPage = pBMPage;
 659                 if (bReplace )
 660                 {
 661                     ReplacePageInCustomShows( dynamic_cast< SdPage* >( GetPage( nActualInsertPos ) ), pBookmarkPage );
 662                 }
 663
 664                 Merge(*pBookmarkDoc,
 665                       nBMPage,           // From page (default page)
 666                       nBMPage+1,         // To page (notes page)
 667                       nActualInsertPos,  // Insert at position
 668                       bMergeMasterPages, // Move master pages?
 669                       false,             // But only the master pages used
 670                       true,              // Create undo action
 671                       bCopy);            // Copy (or merge) pages?
 672
 673                 if( bReplace )
 674                 {
 675                     if( GetPage( nActualInsertPos ) != pBookmarkPage )
 676                     {
 677                         // bookmark page was not moved but cloned, so update custom shows again
 678                         ReplacePageInCustomShows( pBookmarkPage, dynamic_cast< SdPage* >( GetPage( nActualInsertPos ) ) );
 679                     }
 680                 }
 681
 682                 if( bMustRename )
 683                 {
 684                     // Page name already in use -> use default name for default and
 685                     // notes page
 686                     SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) );
 687                     pPage->SetName(OUString());
 688                     SdPage* pNotesPage = static_cast<SdPage*>( GetPage(nActualInsertPos+1) );
 689                     pNotesPage->SetName(OUString());
 690                 }
 691
 692                 if (bLink)
 693                 {
 694                     SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) );
 695                     pPage->SetFileName(aBookmarkName);
 696                     pPage->SetBookmarkName(aPgName);
 697                 }
 698
 699                 if (bReplace)
 700                 {
 701                     // Remove page and notes page.
 702                     const sal_uInt16 nDestPageNum(nActualInsertPos + 2);
 703                     SdPage* pStandardPage = nullptr;
 704
 705                     if(nDestPageNum < GetPageCount())
 706                     {
 707                         pStandardPage = static_cast<SdPage*>(GetPage(nDestPageNum));
 708                     }
 709
 710                     if (pStandardPage)
 711                     {
 712                         if( bPreservePageNames )
 713                         {
 714                             // Take old slide names for inserted pages
 715                             SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) );
 716                             pPage->SetName( pStandardPage->GetRealName() );
 717                         }
 718
 719                         if( bUndo )
 720                             AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pStandardPage));
 721
 722                         RemovePage(nDestPageNum);
 723
 724                         if( !bUndo )
 725                             delete pStandardPage;
 726                     }
 727
 728                     SdPage* pNotesPage = nullptr;
 729
 730                     if(nDestPageNum < GetPageCount())
 731                     {
 732                         pNotesPage = static_cast<SdPage*>(GetPage(nDestPageNum));
 733                     }
 734
 735                     if (pNotesPage)
 736                     {
 737                         if( bPreservePageNames )
 738                         {
 739                             // Take old slide names for inserted pages
 740                             SdPage* pNewNotesPage = static_cast<SdPage*>( GetPage(nActualInsertPos+1));
 741                             if( pNewNotesPage )
 742                                 pNewNotesPage->SetName( pStandardPage->GetRealName() );
 743                         }
 744
 745                         if( bUndo )
 746                             AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
 747
 748                         RemovePage(nDestPageNum);
 749
 750                         if( !bUndo )
 751                             delete pNotesPage;
 752                     }
 753
 754                     nReplacedStandardPages++;
 755                 }
 756
 757                 nActualInsertPos += 2;
 758             }
 759         }
 760     }
 761
 762     // We might have duplicate master pages now, as the drawing engine does not
 763     // recognize duplicates. Remove these now.
 764     sal_uInt16 nNewMPageCount = GetMasterPageCount();
 765
 766     // Go backwards, so the numbers don't become messed up
 767     for (sal_uInt16 nPage = nNewMPageCount - 1; nPage >= nMPageCount; nPage--)
 768     {
 769         pRefPage = static_cast<SdPage*>( GetMasterPage(nPage) );
 770         OUString aMPLayout(pRefPage->GetLayoutName());
 771         PageKind eKind = pRefPage->GetPageKind();
 772
 773         // Does this already exist?
 774         for (sal_uInt16 nTest = 0; nTest < nMPageCount; nTest++)
 775         {
 776             SdPage* pTest = static_cast<SdPage*>( GetMasterPage(nTest) );
 777             OUString aTest(pTest->GetLayoutName());
 778
 779             // nInsertPos > 2 is always true when inserting into non-empty models
 780             if ( nInsertPos > 2 &&
 781                  aTest == aMPLayout &&
 782                  eKind == pTest->GetPageKind() )
 783             {
 784                 if( bUndo )
 785                     AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pRefPage));
 786
 787                 RemoveMasterPage(nPage);
 788
 789                 if( !bUndo )
 790                     delete pRefPage;
 791                 nNewMPageCount--;
 792                 break;
 793             }
 794         }
 795     }
 796
 797     // nInsertPos > 2 is always true when inserting into non-empty models
 798     if (nInsertPos > 0)
 799     {
 800         sal_uInt16 nSdPageStart = (nInsertPos - 1) / 2;
 801         sal_uInt16 nSdPageEnd = bReplace
 802             ? nSdPageStart + nReplacedStandardPages - 1
 803             : GetSdPageCount(PageKind::Standard) - nSdPageCount + nSdPageStart - 1;
 804         const bool bRemoveEmptyPresObj =
 805                 (pBookmarkDoc->GetDocumentType() == DocumentType::Impress) &&
 806                 (GetDocumentType() == DocumentType::Draw);
 807
 808         std::vector<OUString>::iterator pExchangeIter;
 809
 810         if (pExchangeList)
 811             pExchangeIter = pExchangeList->begin();
 812
 813         for (sal_uInt16 nSdPage = nSdPageStart; nSdPage <= nSdPageEnd; nSdPage++)
 814         {
 815             pRefPage = GetSdPage(nSdPage, PageKind::Standard);
 816
 817             if (pExchangeList && pExchangeIter != pExchangeList->end())
 818             {
 819                 // Get the name to use from Exchange list
 820                 OUString aExchangeName(*pExchangeIter);
 821                 pRefPage->SetName(aExchangeName);
 822                 Broadcast(SdrHint(SdrHintKind::PageOrderChange, pRefPage));
 823
 824                 SdPage* pNewNotesPage = GetSdPage(nSdPage, PageKind::Notes);
 825                 pNewNotesPage->SetName(aExchangeName);
 826                 Broadcast(SdrHint(SdrHintKind::PageOrderChange, pNewNotesPage));
 827
 828                 ++pExchangeIter;
 829             }
 830
 831             OUString aLayout(pRefPage->GetLayoutName());
 832             sal_Int32 nIndex = aLayout.indexOf( SD_LT_SEPARATOR );
 833             if( nIndex != -1 )
 834                 aLayout = aLayout.copy(0, nIndex);
 835
 836             // update layout and referred master page
 837             pRefPage->SetPresentationLayout(aLayout);
 838             if( bUndo )
 839                 AddUndo( GetSdrUndoFactory().CreateUndoPageChangeMasterPage( *pRefPage ) );
 840
 841             if (bScaleObjects)
 842             {
 843                 ::tools::Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
 844                 pRefPage->ScaleObjects(aSize, aBorderRect, true);
 845             }
 846             pRefPage->SetSize(aSize);
 847             pRefPage->SetBorder(nLeft, nUpper, nRight, nLower);
 848             pRefPage->SetOrientation( eOrient );
 849
 850             if( bRemoveEmptyPresObj )
 851                 pRefPage->RemoveEmptyPresentationObjects();
 852
 853             pRefPage = GetSdPage(nSdPage, PageKind::Notes);
 854
 855             // update layout and referred master page
 856             pRefPage->SetPresentationLayout(aLayout);
 857             if( bUndo )
 858                 AddUndo( GetSdrUndoFactory().CreateUndoPageChangeMasterPage( *pRefPage ) );
 859
 860             if (bScaleObjects)
 861             {
 862                 ::tools::Rectangle aBorderRect(nNLeft, nNUpper, nNRight, nNLower);
 863                 pRefPage->ScaleObjects(aNSize, aBorderRect, true);
 864             }
 865
 866             pRefPage->SetSize(aNSize);
 867             pRefPage->SetBorder(nNLeft, nNUpper, nNRight, nNLower);
 868             pRefPage->SetOrientation( eNOrient );
 869
 870             if( bRemoveEmptyPresObj )
 871                 pRefPage->RemoveEmptyPresentationObjects();
 872         }
 873
 874         ///Remove processed elements, to avoid doing hacks in InsertBookmarkAsObject
 875         if ( pExchangeList )
 876             pExchangeList->erase(pExchangeList->begin(),pExchangeIter);
 877
 878         for (sal_uInt16 nPage = nMPageCount; nPage < nNewMPageCount; nPage++)
 879         {
 880             pRefPage = static_cast<SdPage*>( GetMasterPage(nPage) );
 881             if (pRefPage->GetPageKind() == PageKind::Standard)
 882             {
 883                 if (bScaleObjects)
 884                 {
 885                     ::tools::Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
 886                     pRefPage->ScaleObjects(aSize, aBorderRect, true);
 887                 }
 888                 pRefPage->SetSize(aSize);
 889                 pRefPage->SetBorder(nLeft, nUpper, nRight, nLower);
 890                 pRefPage->SetOrientation( eOrient );
 891             }
 892             else        // Can only be notes
 893             {
 894                 if (bScaleObjects)
 895                 {
 896                     ::tools::Rectangle aBorderRect(nNLeft, nNUpper, nNRight, nNLower);
 897                     pRefPage->ScaleObjects(aNSize, aBorderRect, true);
 898                 }
 899                 pRefPage->SetSize(aNSize);
 900                 pRefPage->SetBorder(nNLeft, nNUpper, nNRight, nNLower);
 901                 pRefPage->SetOrientation( eNOrient );
 902             }
 903
 904             if( bRemoveEmptyPresObj )
 905                 pRefPage->RemoveEmptyPresentationObjects();
 906         }
 907     }
 908
 909     // Make absolutely sure no double masterpages are there
 910     RemoveUnnecessaryMasterPages(nullptr, true);
 911
 912     // Rename object styles if necessary
 913     if(!aRenameStr.isEmpty())
 914     {
 915         try
 916         {
 917             for(sal_uInt32 p = nInsertPos; p < sal_uInt32(nInsertPos) + sal_uInt32(nBMSdPageCount); p++)
 918             {
 919                 SdPage *pPg = static_cast<SdPage *>( GetPage(p) );
 920                 for(size_t i = 0; pPg && (i < pPg->GetObjCount()); ++i)
 921                 {
 922                     if(pPg->GetObj(i)->GetStyleSheet())
 923                     {
 924                         OUString aStyleName = pPg->GetObj(i)->GetStyleSheet()->GetName();
 925                         SfxStyleSheet *pSheet = lcl_findStyle(aNewGraphicStyles, OUString(aStyleName + aRenameStr));
 926                         if(pSheet != nullptr)
 927                             pPg->GetObj(i)->SetStyleSheet(pSheet, true);
 928                     }
 929                 }
 930             }
 931         }
 932         catch(...)
 933         {
 934             OSL_FAIL("Exception while renaming styles @ SdDrawDocument::InsertBookmarkAsPage");
 935         }
 936     }
 937     // remove copied styles not used on any inserted page and create
 938     // undo records
 939     // WARNING: SdMoveStyleSheetsUndoAction clears the passed list of
 940     // styles, so it cannot be used after this point
 941     lcl_removeUnusedStyles(GetStyleSheetPool(), aNewGraphicStyles);
 942     if (!aNewGraphicStyles.empty() && pUndoMgr)
 943         pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aNewGraphicStyles, true));
 944     lcl_removeUnusedStyles(GetStyleSheetPool(), aNewCellStyles);
 945     if (!aNewCellStyles.empty() && pUndoMgr)
 946         pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aNewCellStyles, true));
 947
 948     if( bUndo )
 949         EndUndo();
 950
 951     if (pUndoMgr)
 952         pUndoMgr->LeaveListAction();
 953
 954     return bContinue;
 955 }
 956
 957 // Inserts a bookmark as an object
 958 bool SdDrawDocument::InsertBookmarkAsObject(
 959     const std::vector<OUString> &rBookmarkList,
 960     const std::vector<OUString> &rExchangeList,            // List of names to use
 961     ::sd::DrawDocShell* pBookmarkDocSh,
 962     Point const * pObjPos,
 963     bool bCalcObjCount)
 964 {
 965     bool bOK = true;
 966     bool bOLEObjFound = false;
 967     std::unique_ptr<::sd::View> pBMView;
 968
 969     SdDrawDocument* pBookmarkDoc = nullptr;
 970
 971     if (pBookmarkDocSh)
 972     {
 973         pBookmarkDoc = pBookmarkDocSh->GetDoc();
 974     }
 975     else if ( mxBookmarkDocShRef.is() )
 976     {
 977         pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 978     }
 979     else
 980     {
 981         return false;
 982     }
 983
 984     if (rBookmarkList.empty())
 985     {
 986         pBMView.reset(new ::sd::View(*pBookmarkDoc, nullptr));
 987         pBMView->EndListening(*pBookmarkDoc);
 988         pBMView->MarkAll();
 989     }
 990     else
 991     {
 992         SdrPage* pPage;
 993         SdrPageView* pPV;
 994
 995         for ( const auto& rBookmark : rBookmarkList )
 996         {
 997             // Get names of bookmarks from the list
 998             SdrObject* pObj = pBookmarkDoc->GetObj(rBookmark);
 999
1000             if (pObj)
1001             {
1002                 // Found an object
1003                 if (pObj->GetObjInventor() == SdrInventor::Default &&
1004                     pObj->GetObjIdentifier() == OBJ_OLE2)
1005                 {
1006                     bOLEObjFound = true;
1007                 }
1008
1009                 if (!pBMView)
1010                 {
1011                     // Create View for the first time
1012                     pBMView.reset(new ::sd::View(*pBookmarkDoc, nullptr));
1013                     pBMView->EndListening(*pBookmarkDoc);
1014                 }
1015
1016                 pPage = pObj->getSdrPageFromSdrObject();
1017
1018                 if (pPage->IsMasterPage())
1019                 {
1020                     pPV = pBMView->ShowSdrPage(pBMView->GetModel()->GetMasterPage(pPage->GetPageNum()));
1021                 }
1022                 else
1023                 {
1024                     pPV = pBMView->GetSdrPageView();
1025                     if( !pPV || (pPV->GetPage() != pPage))
1026                         pPV = pBMView->ShowSdrPage(pPage);
1027                 }
1028
1029                 pBMView->MarkObj(pObj, pPV);
1030             }
1031         }
1032     }
1033
1034     if (pBMView)
1035     {
1036         // Insert selected objects
1037         std::unique_ptr<::sd::View> pView(new ::sd::View(*this, nullptr));
1038         pView->EndListening(*this);
1039
1040         // Look for the page into which the objects are supposed to be inserted
1041         SdrPage* pPage = GetSdPage(0, PageKind::Standard);
1042
1043         if (mpDocSh)
1044         {
1045             ::sd::ViewShell* pViewSh = mpDocSh->GetViewShell();
1046
1047             if (pViewSh)
1048             {
1049                 // Which page is currently in view?
1050                 SdrPageView* pPV = pViewSh->GetView()->GetSdrPageView();
1051
1052                 if (pPV)
1053                 {
1054                     pPage = pPV->GetPage();
1055                 }
1056                 else if (pViewSh->GetActualPage())
1057                 {
1058                     pPage = pViewSh->GetActualPage();
1059                 }
1060             }
1061         }
1062
1063         Point aObjPos;
1064
1065         if (pObjPos)
1066         {
1067             aObjPos = *pObjPos;
1068         }
1069         else
1070         {
1071             aObjPos = ::tools::Rectangle(Point(), pPage->GetSize()).Center();
1072         }
1073
1074         size_t nCountBefore = 0;
1075
1076         if (!rExchangeList.empty() || bCalcObjCount)
1077         {
1078             // Sort OrdNums and get the number of objects before inserting
1079             pPage->RecalcObjOrdNums();
1080             nCountBefore = pPage->GetObjCount();
1081         }
1082
1083         if (bOLEObjFound)
1084             pBMView->GetDoc().SetAllocDocSh(true);
1085
1086         SdDrawDocument* pTmpDoc = static_cast<SdDrawDocument*>( pBMView->CreateMarkedObjModel().release() );
1087         bOK = pView->Paste(*pTmpDoc, aObjPos, pPage, SdrInsertFlags::NONE);
1088
1089         if (bOLEObjFound)
1090             pBMView->GetDoc().SetAllocDocSh(false);
1091
1092         if (!bOLEObjFound)
1093             delete pTmpDoc;         // Would otherwise be destroyed by DocShell
1094
1095         pView.reset();
1096
1097         // Get number of objects after inserting.
1098         const size_t nCount = pPage->GetObjCount();
1099         if (nCountBefore < nCount)
1100         {
1101             size_t nObj = nCountBefore;
1102             for (const auto& rExchange : rExchangeList)
1103             {
1104                 // Get the name to use from the Exchange list
1105                 if (pPage->GetObj(nObj))
1106                 {
1107                     pPage->GetObj(nObj)->SetName(rExchange);
1108                 }
1109
1110                 ++nObj;
1111                 if (nObj >= nCount)
1112                     break;
1113             }
1114         }
1115     }
1116
1117     return bOK;
1118 }
1119
1120 // Stops the bookmark insertion
1121 void SdDrawDocument::CloseBookmarkDoc()
1122 {
1123     if (mxBookmarkDocShRef.is())
1124     {
1125         mxBookmarkDocShRef->DoClose();
1126     }
1127
1128     mxBookmarkDocShRef.clear();
1129     maBookmarkFile.clear();
1130 }
1131
1132 // Is this document read-only?
1133 bool SdDrawDocument::IsReadOnly() const
1134 {
1135     return false;
1136 }
1137
1138 // In the subsequent AllocModel() a DocShell (xAllocedDocShRef) is created.
1139 // Any pre-existing DocShell is deleted
1140 void SdDrawDocument::SetAllocDocSh(bool bAlloc)
1141 {
1142     mbAllocDocSh = bAlloc;
1143
1144     if(mxAllocedDocShRef.is())
1145     {
1146         mxAllocedDocShRef->DoClose();
1147     }
1148
1149     mxAllocedDocShRef.clear();
1150 }
1151
1152 // Return list of CustomShows (create it, too, if necessary)
1153 SdCustomShowList* SdDrawDocument::GetCustomShowList(bool bCreate)
1154 {
1155     if (!mpCustomShowList && bCreate)
1156     {
1157         mpCustomShowList.reset(new SdCustomShowList);
1158     }
1159
1160     return mpCustomShowList.get();
1161 }
1162
1163 // Remove unused master pages and layouts
1164 void SdDrawDocument::RemoveUnnecessaryMasterPages(SdPage* pMasterPage, bool bOnlyDuplicatePages, bool bUndo)
1165 {
1166     ::sd::View* pView = nullptr;
1167     SfxUndoManager* pUndoMgr = nullptr;
1168
1169     if( bUndo && !IsUndoEnabled() )
1170         bUndo = false;
1171
1172     if (mpDocSh)
1173     {
1174         pUndoMgr = mpDocSh->GetUndoManager();
1175
1176         if (mpDocSh->GetViewShell())
1177             pView = mpDocSh->GetViewShell()->GetView();
1178     }
1179
1180     // Check all master pages
1181     sal_uInt16 nSdMasterPageCount = GetMasterSdPageCount( PageKind::Standard );
1182     for (sal_Int32 nMPage = nSdMasterPageCount - 1; nMPage >= 0; nMPage--)
1183     {
1184         SdPage* pMaster = pMasterPage;
1185         SdPage* pNotesMaster = nullptr;
1186
1187         if (!pMaster)
1188         {
1189             pMaster = GetMasterSdPage( static_cast<sal_uInt16>(nMPage), PageKind::Standard );
1190             pNotesMaster = GetMasterSdPage( static_cast<sal_uInt16>(nMPage), PageKind::Notes );
1191         }
1192         else
1193         {
1194             for ( sal_uInt16 nMPg = 0; nMPg < GetMasterPageCount(); nMPg++ )
1195             {
1196                 if ( pMaster == GetMasterPage( nMPg ) )
1197                 {
1198                     pNotesMaster = static_cast<SdPage*>( GetMasterPage( ++nMPg ) );
1199                     break;
1200                 }
1201             }
1202         }
1203
1204         DBG_ASSERT( pMaster->GetPageKind() == PageKind::Standard, "wrong page kind" );
1205
1206         if ( pMaster->GetPageKind() == PageKind::Standard &&
1207              GetMasterPageUserCount( pMaster ) == 0 &&
1208              pNotesMaster )
1209         {
1210             // Do not delete master pages that have their precious flag set
1211             bool bDeleteMaster = !pMaster->IsPrecious();
1212             OUString aLayoutName = pMaster->GetLayoutName();
1213
1214             if(bOnlyDuplicatePages )
1215             {
1216                 // remove only duplicate pages
1217                 bDeleteMaster = false;
1218                 for (sal_uInt16 i = 0; i < GetMasterSdPageCount( PageKind::Standard ); i++)
1219                 {
1220                     SdPage* pMPg = GetMasterSdPage( i, PageKind::Standard );
1221                     if( pMPg != pMaster &&
1222                         pMPg->GetLayoutName() == aLayoutName )
1223                     {
1224                         // duplicate page found -> remove it
1225                         bDeleteMaster = true;
1226                     }
1227                 }
1228             }
1229
1230             if( bDeleteMaster )
1231             {
1232                 if (pView)
1233                 {
1234                     // if MasterPage is visible hide on pageview
1235                     SdrPageView* pPgView = pView->GetSdrPageView();
1236                     if (pPgView)
1237                     {
1238                         SdrPage* pShownPage = pPgView->GetPage();
1239                         if( (pShownPage == pMaster) || (pShownPage == pNotesMaster) )
1240                         {
1241                             pView->HideSdrPage();
1242                             pView->ShowSdrPage( GetSdPage( 0, PageKind::Standard ) );
1243                         }
1244                     }
1245                 }
1246
1247                 if( bUndo )
1248                 {
1249                     BegUndo();
1250                     AddUndo( GetSdrUndoFactory().CreateUndoDeletePage( *pNotesMaster ) );
1251                 }
1252
1253                 RemoveMasterPage( pNotesMaster->GetPageNum() );
1254
1255                 if( !bUndo )
1256                     delete pNotesMaster;
1257
1258                 if( bUndo )
1259                     AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pMaster));
1260
1261                 RemoveMasterPage( pMaster->GetPageNum() );
1262
1263                 if( !bUndo )
1264                     delete pMaster;
1265
1266                 if( bUndo )
1267                     EndUndo();  // do this here already, so Joe's actions happen _between_ our own
1268
1269                 // Delete old, unused layout stylesheets
1270                 bool bDeleteOldStyleSheets = true;
1271                 for ( sal_uInt16 nMPg = 0;
1272                           nMPg < GetMasterPageCount() && bDeleteOldStyleSheets;
1273                        nMPg++ )
1274                 {
1275                     SdPage* pMPg = static_cast<SdPage*>( GetMasterPage(nMPg) );
1276                     if (pMPg->GetLayoutName() == aLayoutName)
1277                     {
1278                         bDeleteOldStyleSheets = false;
1279                     }
1280                 }
1281
1282                 if (bDeleteOldStyleSheets)
1283                 {
1284                     SdStyleSheetVector aRemove;
1285                     static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutSheetList( aLayoutName, aRemove );
1286
1287                     if( bUndo )
1288                     {
1289                         StyleSheetCopyResultVector aUndoRemove;
1290                         aUndoRemove.reserve(aRemove.size());
1291                         for (const auto& a : aRemove)
1292                             aUndoRemove.emplace_back(a.get(), true);
1293
1294                         if (pUndoMgr)
1295                             pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aUndoRemove, false));
1296                     }
1297
1298                     for( const auto& a : aRemove )
1299                         static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->Remove(a.get());
1300                 }
1301             }
1302         }
1303
1304         if (pMasterPage)
1305             break;                      // Just this one master page!
1306     }
1307 }
1308
1309 /** Exchange master page
1310   *
1311   * Either the nSdPageNum gets a new, own master page or the master page is
1312   * exchanged completely (which then applies to all pages).
1313   *
1314   * nSdPageNum   : page number that the new master page should get.
1315   * rLayoutName  : LayoutName of the new master page
1316   * pSourceDoc   : document (template) to get the master page from
1317   * bMaster      : exchange the master page of nSdPageNum
1318   * bCheckMasters: remove unused master pages
1319   *
1320   * If pSourceDoc == NULL, an empty master page is applied.
1321   * If rLayoutName is empty, the first master page is used.
1322   */
1323 // #i121863# factored out functionality
1324 static bool isMasterPageLayoutNameUnique(const SdDrawDocument& rDoc, const OUString& rCandidate)
1325 {
1326     if (rCandidate.isEmpty())
1327     {
1328         return false;
1329     }
1330
1331     const sal_uInt16 nPageCount(rDoc.GetMasterPageCount());
1332
1333     for(sal_uInt16 a(0); a < nPageCount; a++)
1334     {
1335         const SdrPage* pCandidate = rDoc.GetMasterPage(a);
1336         OUString aPageLayoutName(pCandidate->GetLayoutName());
1337         sal_Int32 nIndex = aPageLayoutName.indexOf(SD_LT_SEPARATOR);
1338         if( nIndex != -1 )
1339             aPageLayoutName = aPageLayoutName.copy(0, nIndex);
1340
1341         if(aPageLayoutName == rCandidate)
1342         {
1343             return false;
1344         }
1345     }
1346
1347     return true;
1348 }
1349
1350 // #i121863# factored out functionality
1351 static OUString createNewMasterPageLayoutName(const SdDrawDocument& rDoc)
1352 {
1353     const OUString aBaseName(SdResId(STR_LAYOUT_DEFAULT_NAME));
1354     sal_uInt16 nCount(0);
1355     for (;;)
1356     {
1357         OUString aRetval = aBaseName;
1358         if(nCount)
1359         {
1360             aRetval += OUString::number(nCount);
1361         }
1362         if (isMasterPageLayoutNameUnique(rDoc, aRetval))
1363             return aRetval;
1364         nCount++;
1365     }
1366 }
1367
1368 void SdDrawDocument::SetMasterPage(sal_uInt16 nSdPageNum,
1369                                    const OUString& rLayoutName,
1370                                    SdDrawDocument* pSourceDoc,
1371                                    bool bMaster,
1372                                    bool bCheckMasters)
1373 {
1374     SfxUndoManager* pUndoMgr = nullptr;
1375
1376     if( mpDocSh )
1377     {
1378         mpDocSh->SetWaitCursor( true );
1379         pUndoMgr = mpDocSh->GetUndoManager();
1380     }
1381
1382     const bool bUndo = pUndoMgr && IsUndoEnabled();
1383
1384     if (bUndo)
1385     {
1386         ViewShellId nViewShellId(-1);
1387         if (sd::ViewShell* pViewShell = mpDocSh->GetViewShell())
1388             nViewShellId = pViewShell->GetViewShellBase().GetViewShellId();
1389         pUndoMgr->EnterListAction(SdResId(STR_UNDO_SET_PRESLAYOUT), OUString(), 0, nViewShellId);
1390     }
1391
1392     SdPage* pSelectedPage   = GetSdPage(nSdPageNum, PageKind::Standard);
1393     SdPage* pNotes          = static_cast<SdPage*>( GetPage(pSelectedPage->GetPageNum()+1) );
1394     SdPage& rOldMaster      = static_cast<SdPage&>(pSelectedPage->TRG_GetMasterPage());
1395     SdPage& rOldNotesMaster = static_cast<SdPage&>(pNotes->TRG_GetMasterPage());
1396     SdPage* pMaster         = nullptr;
1397     SdPage* pNotesMaster    = nullptr;
1398     OUString aOldPageLayoutName(pSelectedPage->GetLayoutName());
1399     OUString aOldLayoutName(aOldPageLayoutName);
1400     sal_Int32 nIndex = aOldLayoutName.indexOf( SD_LT_SEPARATOR );
1401     if( nIndex != -1 )
1402         aOldLayoutName = aOldLayoutName.copy(0, nIndex);
1403
1404     if (pSourceDoc)
1405     {
1406         std::vector<StyleReplaceData> aReplList; // List of replaced stylesheets
1407         bool bLayoutReloaded = false;   // Was ex. layout reloaded?
1408
1409         // LayoutName, Page and Notes page
1410         if (rLayoutName.isEmpty())
1411         {
1412             // No LayoutName: take first MasterPage
1413             pMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Standard);
1414             pNotesMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Notes);
1415         }
1416         else
1417         {
1418             OUString aSearchFor = rLayoutName + SD_LT_SEPARATOR STR_LAYOUT_OUTLINE;
1419
1420             for (sal_uInt16 nMP = 0; nMP < pSourceDoc->GetMasterPageCount(); ++nMP)
1421             {
1422                 SdPage* pMP = static_cast<SdPage*>( pSourceDoc->GetMasterPage(nMP) );
1423
1424                 if (pMP->GetLayoutName() == aSearchFor)
1425                 {
1426                     if (pMP->GetPageKind() == PageKind::Standard)
1427                         pMaster = pMP;
1428                     if (pMP->GetPageKind() == PageKind::Notes)
1429                         pNotesMaster = pMP;
1430                 }
1431                 if (pMaster && pNotesMaster)
1432                     break;
1433             }
1434             DBG_ASSERT(pMaster, "MasterPage (Standard page) not found");
1435             DBG_ASSERT(pNotesMaster, "MasterPage (Notes page) not found");
1436
1437             // this should not happen, but looking at crash reports, it does
1438             if( (pMaster == nullptr) || (pNotesMaster == nullptr) )
1439             {
1440                 // so take the first MasterPage
1441                 pMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Standard);
1442                 pNotesMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Notes);
1443             }
1444         }
1445
1446         // we should never reach this, but one never knows...
1447         if( (pMaster == nullptr) || (pNotesMaster == nullptr) )
1448         {
1449             if (bUndo)
1450                 pUndoMgr->LeaveListAction();
1451
1452             if( mpDocSh )
1453                 mpDocSh->SetWaitCursor( false );
1454
1455             OSL_FAIL( "SdDrawDocument::SetMasterPage() failed!" );
1456
1457             return;
1458         }
1459
1460         const OUString aOriginalNewLayoutName( pMaster->GetName() );
1461         OUString aTargetNewLayoutName(aOriginalNewLayoutName);
1462
1463         if (pSourceDoc != this)
1464         {
1465             // #i121863# clone masterpages, they are from another model (!)
1466             std::unique_ptr<SdPage> pNewNotesMaster(dynamic_cast< SdPage* >(pNotesMaster->CloneSdrPage(*this)));
1467             std::unique_ptr<SdPage> pNewMaster(dynamic_cast< SdPage* >(pMaster->CloneSdrPage(*this)));
1468
1469             if(!pNewNotesMaster || !pNewMaster)
1470             {
1471                 OSL_FAIL("SdDrawDocument::SetMasterPage() cloning of MasterPage/NoteAmsterPage failed!" );
1472                 return;
1473             }
1474
1475             pNotesMaster = pNewNotesMaster.release();
1476             pMaster = pNewMaster.release();
1477
1478             // layout name needs to be unique
1479             aTargetNewLayoutName = pMaster->GetLayoutName();
1480             sal_Int32 nIndex2 = aTargetNewLayoutName.indexOf(SD_LT_SEPARATOR);
1481             if( nIndex2 != -1 )
1482                 aTargetNewLayoutName = aTargetNewLayoutName.copy(0, nIndex2);
1483
1484             if(!isMasterPageLayoutNameUnique(*this, aTargetNewLayoutName))
1485             {
1486                 aTargetNewLayoutName = createNewMasterPageLayoutName(*this);
1487
1488                 OUString aTemp = aTargetNewLayoutName + SD_LT_SEPARATOR STR_LAYOUT_OUTLINE;
1489
1490                 pMaster->SetName(aTargetNewLayoutName);
1491                 pMaster->SetLayoutName(aTemp);
1492
1493                 pNotesMaster->SetName(aTargetNewLayoutName);
1494                 pNotesMaster->SetLayoutName(aTemp);
1495             }
1496         }
1497
1498         if (pSourceDoc != this)
1499         {
1500             const sal_uInt16 nMasterPageCount = GetMasterPageCount();
1501             for ( sal_uInt16 nMPage = 0; nMPage < nMasterPageCount; nMPage++ )
1502             {
1503                 SdPage* pCheckMaster = static_cast<SdPage*>(GetMasterPage(nMPage));
1504                 if( pCheckMaster->GetName() == aTargetNewLayoutName )
1505                 {
1506                     bLayoutReloaded = true;
1507                     break;
1508                 }
1509             }
1510
1511             // Correct or create presentation templates --
1512             // only worry about presentation templates
1513             OUString aName;
1514             SdStyleSheetPool* pSourceStyleSheetPool = static_cast<SdStyleSheetPool*>( pSourceDoc->GetStyleSheetPool() );
1515
1516             StyleSheetCopyResultVector aCreatedStyles;          // List of created stylesheets
1517             SfxStyleSheetBase* pHisSheet = pSourceStyleSheetPool->First(SfxStyleFamily::Page);
1518
1519             while (pHisSheet)
1520             {
1521                 aName = pHisSheet->GetName();
1522
1523                 // #i121863# search in source styles with original style name from source of
1524                 // evtl. cloned master (not-cloned, renamed for uniqueness)
1525                 if( aName.startsWith( aOriginalNewLayoutName ) )
1526                 {
1527                     // #i121863# build name of evtl. cloned master style to search for
1528                     if(aOriginalNewLayoutName != aTargetNewLayoutName)
1529                     {
1530                         const sal_Int32 nPos(aName.indexOf(SD_LT_SEPARATOR));
1531                         aName = aTargetNewLayoutName + aName.subView(nPos);
1532                     }
1533
1534                     SfxStyleSheet* pMySheet = static_cast<SfxStyleSheet*>( mxStyleSheetPool->Find(aName, SfxStyleFamily::Page) );
1535
1536                     if (pMySheet)
1537                     {
1538                         // A stylesheet of the same name already exists -> overwrite contents
1539                         bool bTest = pMySheet->SetName(pHisSheet->GetName());
1540                         DBG_ASSERT(bTest, "Renaming StyleSheet failed.");
1541                         pMySheet->GetItemSet().ClearItem();  // Delete all
1542
1543                         if (bUndo)
1544                         {
1545                             pUndoMgr->AddUndoAction(std::make_unique<StyleSheetUndoAction>(this,
1546                                                                  pMySheet, &pHisSheet->GetItemSet()));
1547                         }
1548                         pMySheet->GetItemSet().Put(pHisSheet->GetItemSet());
1549                         pMySheet->Broadcast(SfxHint(SfxHintId::DataChanged));
1550                     }
1551                     else
1552                     {
1553                         // create new style
1554                         OUString aHelpFile;
1555                         pMySheet = static_cast<SfxStyleSheet*>( &mxStyleSheetPool->Make(aName, SfxStyleFamily::Page, pHisSheet->GetMask()) );
1556                         pMySheet->SetHelpId( aHelpFile, pHisSheet->GetHelpId(aHelpFile) );
1557                         pMySheet->GetItemSet().ClearItem();  // Delete all
1558                         pMySheet->GetItemSet().Put(pHisSheet->GetItemSet());
1559
1560                         aCreatedStyles.emplace_back(static_cast<SdStyleSheet*>(pMySheet), true);
1561                     }
1562
1563                     StyleReplaceData aReplData;
1564                     aReplData.nNewFamily = pMySheet->GetFamily();
1565                     aReplData.nFamily    = pMySheet->GetFamily();
1566                     aReplData.aNewName   = pMySheet->GetName();
1567
1568                     // #i121863# re-create original name of style used at page where to replace with
1569                     // this new style
1570                     OUString aTemp(pMySheet->GetName());
1571                     const sal_Int32 nPos(aTemp.indexOf(SD_LT_SEPARATOR));
1572                     aTemp = aOldLayoutName + aTemp.subView(nPos);
1573                     aReplData.aName = aTemp;
1574                     aReplList.push_back(aReplData);
1575                 }
1576
1577                 pHisSheet = pSourceStyleSheetPool->Next();
1578             }
1579
1580             // If new styles were created: re-create parent chaining of the item
1581             // sets in the styles.
1582             if(!aCreatedStyles.empty())
1583             {
1584                 for ( const auto& rRData : aReplList )
1585                 {
1586                     SfxStyleSheetBase* pSOld = mxStyleSheetPool->Find(rRData.aName, SfxStyleFamily::Page);
1587                     SfxStyleSheetBase* pSNew = mxStyleSheetPool->Find(rRData.aNewName, SfxStyleFamily::Page);
1588
1589                     if (pSOld && pSNew)
1590                     {
1591                         const OUString& rParentOfOld = pSOld->GetParent();
1592                         const OUString& rParentOfNew = pSNew->GetParent();
1593
1594                         if (!rParentOfOld.isEmpty() && rParentOfNew.isEmpty())
1595                         {
1596                             std::vector<StyleReplaceData>::iterator pRDIter = std::find_if(aReplList.begin(), aReplList.end(),
1597                                 [&rParentOfOld](const StyleReplaceData& rRD) { return (rRD.aName == rParentOfOld) && (rRD.aName != rRD.aNewName); });
1598                             if (pRDIter != aReplList.end())
1599                             {
1600                                 OUString aParentOfNew(pRDIter->aNewName);
1601                                 pSNew->SetParent(aParentOfNew);
1602                             }
1603                         }
1604                     }
1605                 }
1606             }
1607
1608             if (bUndo && !aCreatedStyles.empty())
1609             {
1610                 // Add UndoAction for creating and inserting the stylesheets to
1611                 // the top of the UndoManager
1612                 pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>( this, aCreatedStyles, true));
1613             }
1614         }
1615
1616         // Create layout name based upon the name of the page layout of the
1617         // master page
1618         OUString aPageLayoutName(pMaster->GetLayoutName());
1619         OUString aLayoutName = aPageLayoutName;
1620         sal_Int32 nIndex2 = aLayoutName.indexOf( SD_LT_SEPARATOR );
1621         if( nIndex2 != -1 )
1622             aLayoutName = aLayoutName.copy( 0, nIndex2);
1623
1624         // #i121863# Do *not* remove from original document any longer, it is potentially used there
1625         // and would lead to crashes. Rely on the automatic process of removing unused masterpages
1626         // (see RemoveUnnecessaryMasterPages)
1627         //if (pSourceDoc != this)
1628         //{
1629         //    // Remove from the source document
1630         //    pSourceDoc->RemoveMasterPage(pNotesMaster->GetPageNum());
1631         //    pSourceDoc->RemoveMasterPage(pMaster->GetPageNum());
1632         //}
1633
1634         // Register the new master pages with the document and then use
1635         // the new presentation layout for the default and notes pages
1636         if (pSourceDoc != this)
1637         {
1638             // Insert the master pages:
1639             // Insert master pages from new layouts at the end.
1640             // If a layout is being replaced, however, insert them before the
1641             // position of the old master page, so from now on the new master
1642             // page will be found when searching (e.g.
1643             // SdPage::SetPresentationLayout).
1644             sal_uInt16 nInsertPos = rOldMaster.GetPageNum();
1645             BegUndo();
1646
1647             if (!bLayoutReloaded)
1648                 nInsertPos = 0xFFFF;
1649             InsertMasterPage(pMaster, nInsertPos);
1650             if( bUndo )
1651                 AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pMaster));
1652
1653             nInsertPos++;
1654             if (!bLayoutReloaded)
1655                 nInsertPos = 0xFFFF;
1656             InsertMasterPage(pNotesMaster, nInsertPos);
1657             if( bUndo )
1658             {
1659                 AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pNotesMaster));
1660
1661                 EndUndo(); // do this here already, so Joe's actions happen _between_ our own.
1662             }
1663         }
1664
1665         // Fill list with pages
1666         std::vector<SdPage*> aPageList;
1667
1668 //      #98456, this has to be removed according to CL (KA 07/08/2002)
1669 //      #109884# but we need them again to restore the styles of the presentation objects while undo
1670         aPageList.push_back(pMaster);
1671         aPageList.push_back(pNotesMaster);
1672
1673         if (bMaster || bLayoutReloaded)
1674         {
1675             for (sal_uInt16 nPage = 1; nPage < GetPageCount(); nPage++)
1676             {
1677                 SdPage* pPage = static_cast<SdPage*>( GetPage(nPage) );
1678                 OUString aTest = pPage->GetLayoutName();
1679                 if (aTest == aOldPageLayoutName)
1680                 {
1681                     aPageList.push_back(pPage);
1682                 }
1683             }
1684
1685         }
1686         else
1687         {
1688             aPageList.push_back(pSelectedPage);
1689             aPageList.push_back(pNotes);
1690         }
1691
1692         for (SdPage* pPage : aPageList)
1693         {
1694             AutoLayout eAutoLayout = pPage->GetAutoLayout();
1695
1696             if( bUndo )
1697             {
1698                 pUndoMgr->AddUndoAction(std::make_unique<SdPresentationLayoutUndoAction>
1699                         (this,
1700                         pPage->IsMasterPage() ? aLayoutName : aOldLayoutName,
1701                         aLayoutName,
1702                          eAutoLayout, eAutoLayout, false, pPage));
1703             }
1704             pPage->SetPresentationLayout(aLayoutName);
1705             pPage->SetAutoLayout(eAutoLayout);
1706         }
1707
1708         // Adapt new master pages
1709         if (pSourceDoc != this)
1710         {
1711             Size aSize(rOldMaster.GetSize());
1712             ::tools::Rectangle aBorderRect(rOldMaster.GetLeftBorder(),
1713                                   rOldMaster.GetUpperBorder(),
1714                                   rOldMaster.GetRightBorder(),
1715                                   rOldMaster.GetLowerBorder());
1716             pMaster->ScaleObjects(aSize, aBorderRect, true);
1717             pMaster->SetSize(aSize);
1718             pMaster->SetBorder(rOldMaster.GetLeftBorder(),
1719                                rOldMaster.GetUpperBorder(),
1720                                rOldMaster.GetRightBorder(),
1721                                rOldMaster.GetLowerBorder());
1722             pMaster->SetOrientation( rOldMaster.GetOrientation() );
1723             pMaster->SetAutoLayout(pMaster->GetAutoLayout());
1724
1725             aSize = rOldNotesMaster.GetSize();
1726             ::tools::Rectangle aNotesBorderRect(rOldNotesMaster.GetLeftBorder(),
1727                                        rOldNotesMaster.GetUpperBorder(),
1728                                        rOldNotesMaster.GetRightBorder(),
1729                                        rOldNotesMaster.GetLowerBorder());
1730             pNotesMaster->ScaleObjects(aSize, aNotesBorderRect, true);
1731             pNotesMaster->SetSize(aSize);
1732             pNotesMaster->SetBorder(rOldNotesMaster.GetLeftBorder(),
1733                                     rOldNotesMaster.GetUpperBorder(),
1734                                     rOldNotesMaster.GetRightBorder(),
1735                                     rOldNotesMaster.GetLowerBorder());
1736             pNotesMaster->SetOrientation( rOldNotesMaster.GetOrientation() );
1737             pNotesMaster->SetAutoLayout(pNotesMaster->GetAutoLayout());
1738
1739             if( (pSourceDoc->GetDocumentType() == DocumentType::Impress) &&
1740                 (GetDocumentType() == DocumentType::Draw) )
1741             {
1742                 pMaster->RemoveEmptyPresentationObjects();
1743                 pNotesMaster->RemoveEmptyPresentationObjects();
1744             }
1745         }
1746     }
1747     else
1748     {
1749         // Find a new name for the layout
1750         OUString aName(createNewMasterPageLayoutName(*this));
1751         OUString aPageLayoutName(aName + SD_LT_SEPARATOR STR_LAYOUT_OUTLINE);
1752
1753         // Generate new stylesheets
1754         static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutStyleSheets(aName);
1755         SdStyleSheetVector aCreatedStyles;
1756         static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutSheetList(aName, aCreatedStyles);
1757
1758         if( bUndo )
1759         {
1760             StyleSheetCopyResultVector aUndoInsert;
1761             aUndoInsert.reserve(aCreatedStyles.size());
1762             for (const auto& a : aCreatedStyles)
1763                 aUndoInsert.emplace_back(a.get(), true);
1764             pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aUndoInsert, true));
1765             // Generate new master pages and register them with the document
1766             BegUndo();
1767         }
1768
1769         pMaster = AllocSdPage(true);
1770         pMaster->SetSize(pSelectedPage->GetSize());
1771         pMaster->SetBorder(pSelectedPage->GetLeftBorder(),
1772                            pSelectedPage->GetUpperBorder(),
1773                            pSelectedPage->GetRightBorder(),
1774                            pSelectedPage->GetLowerBorder() );
1775         pMaster->SetName(aName);
1776         pMaster->SetLayoutName(aPageLayoutName);
1777         InsertMasterPage(pMaster);
1778
1779         if( bUndo )
1780             AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pMaster));
1781
1782         pMaster->SetAutoLayout(AUTOLAYOUT_NONE, true, true);
1783
1784         pNotesMaster = AllocSdPage(true);
1785         pNotesMaster->SetPageKind(PageKind::Notes);
1786         pNotesMaster->SetSize(pNotes->GetSize());
1787         pNotesMaster->SetBorder(pNotes->GetLeftBorder(),
1788                                 pNotes->GetUpperBorder(),
1789                                 pNotes->GetRightBorder(),
1790                                 pNotes->GetLowerBorder() );
1791         pNotesMaster->SetName(aName);
1792         pNotesMaster->SetLayoutName(aPageLayoutName);
1793         InsertMasterPage(pNotesMaster);
1794
1795         if( bUndo )
1796             AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pNotesMaster));
1797
1798         pNotesMaster->SetAutoLayout(AUTOLAYOUT_NOTES, true, true);
1799
1800         if( bUndo )
1801             EndUndo();
1802
1803         // Create a list of affected default and notes pages
1804         std::vector<SdPage*> aPageList;
1805         if (bMaster)
1806         {
1807             for (sal_uInt16 nPage = 1; nPage < GetPageCount(); nPage++)
1808             {
1809                 SdPage* pPage = static_cast<SdPage*>( GetPage(nPage) );
1810                 if (pPage->GetLayoutName() == aOldPageLayoutName)
1811                 {
1812                     aPageList.push_back(pPage);
1813                 }
1814             }
1815         }
1816         else
1817         {
1818             aPageList.push_back(pSelectedPage);
1819             aPageList.push_back(pNotes);
1820         }
1821
1822         // Set presentation layout and AutoLayout for the affected pages
1823         for ( auto& rpPage : aPageList )
1824         {
1825             AutoLayout eOldAutoLayout = rpPage->GetAutoLayout();
1826             AutoLayout eNewAutoLayout =
1827                 rpPage->GetPageKind() == PageKind::Standard ? AUTOLAYOUT_NONE : AUTOLAYOUT_NOTES;
1828
1829             if( bUndo )
1830             {
1831                 pUndoMgr->AddUndoAction(std::make_unique<SdPresentationLayoutUndoAction>
1832                             (this, aOldLayoutName, aName,
1833                              eOldAutoLayout, eNewAutoLayout, true,
1834                              rpPage));
1835             }
1836
1837             rpPage->SetPresentationLayout(aName);
1838             rpPage->SetAutoLayout(eNewAutoLayout);
1839         }
1840     }
1841
1842     // If the old master pages aren't used anymore, they and their styles have
1843     // to be removed.
1844     if (bCheckMasters)
1845     {
1846         // Check all
1847         RemoveUnnecessaryMasterPages();
1848     }
1849     else
1850     {
1851         // Check only the master page that was replaced
1852         RemoveUnnecessaryMasterPages(&rOldMaster);
1853     }
1854
1855     if( bUndo )
1856         pUndoMgr->LeaveListAction();
1857
1858     if( mpDocSh )
1859         mpDocSh->SetWaitCursor( false );
1860 }
1861
1862 void SdDrawDocument::Merge(SdrModel& rSourceModel,
1863                sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
1864                sal_uInt16 nDestPos,
1865                bool bMergeMasterPages, bool bAllMasterPages,
1866                bool bUndo, bool bTreadSourceAsConst)
1867 {
1868     sal_uInt16 nMasterPageCount = GetMasterPageCount();
1869     SdrModel::Merge( rSourceModel, nFirstPageNum, nLastPageNum, nDestPos, bMergeMasterPages, bAllMasterPages, bUndo, bTreadSourceAsConst );
1870
1871     // add style family for each new master page
1872     for( sal_uInt16 nMaster = nMasterPageCount; nMaster < GetMasterPageCount(); nMaster++ )
1873     {
1874         SdPage* pPage = static_cast< SdPage* >( GetMasterPage( nMaster ) );
1875         if( pPage && pPage->IsMasterPage() && (pPage->GetPageKind() == PageKind::Standard) )
1876         {
1877             // new master page created, add its style family
1878             SdStyleSheetPool* pStylePool = static_cast<SdStyleSheetPool*>( GetStyleSheetPool() );
1879             if( pStylePool )
1880                 pStylePool->AddStyleFamily( pPage );
1881         }
1882     }
1883 }
1884
1885 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */