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