diff options
Diffstat (limited to 'sd/source/core/drawdoc3.cxx')
| -rw-r--r-- | sd/source/core/drawdoc3.cxx | 1940 |
1 files changed, 1940 insertions, 0 deletions
diff --git a/sd/source/core/drawdoc3.cxx b/sd/source/core/drawdoc3.cxx new file mode 100644 index 0000000000..5310789d29 --- /dev/null +++ b/sd/source/core/drawdoc3.cxx @@ -0,0 +1,1940 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +#include <memory> +#include <string_view> + +#include <sfx2/docfile.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/app.hxx> +#include <svl/itemset.hxx> +#include <tools/debug.hxx> +#include <comphelper/diagnose_ex.hxx> + +#include <sfx2/fcontnr.hxx> +#include <svl/style.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdundo.hxx> +#include <vcl/stdtext.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <xmloff/autolayout.hxx> + +#include <strings.hrc> +#include <drawdoc.hxx> +#include <sdmod.hxx> +#include <sdpage.hxx> +#include <stlpool.hxx> +#include <sdresid.hxx> +#include <customshowlist.hxx> +#include <sdxfer.hxx> + +#include <unmovss.hxx> +#include <unchss.hxx> +#include <unprlout.hxx> +#include <DrawDocShell.hxx> +#include <GraphicDocShell.hxx> +#include <ViewShell.hxx> +#include <View.hxx> +#include <ViewShellBase.hxx> +#include <strings.hxx> + +using namespace ::com::sun::star; + +/** Concrete incarnations get called by lcl_IterateBookmarkPages, for + every page in the bookmark document/list + */ + +namespace { + +class InsertBookmarkAsPage_FindDuplicateLayouts +{ +public: + explicit InsertBookmarkAsPage_FindDuplicateLayouts( std::vector<OUString> &rLayoutsToTransfer ) + : mrLayoutsToTransfer(rLayoutsToTransfer) {} + void operator()( SdDrawDocument&, SdPage const *, bool, SdDrawDocument* ); +private: + std::vector<OUString> &mrLayoutsToTransfer; +}; + +} + +void InsertBookmarkAsPage_FindDuplicateLayouts::operator()( SdDrawDocument& rDoc, SdPage const * pBMMPage, bool bRenameDuplicates, SdDrawDocument* pBookmarkDoc ) +{ + // now check for duplicate masterpage and layout names + + OUString aLayout( pBMMPage->GetLayoutName() ); + sal_Int32 nIndex = aLayout.indexOf( SD_LT_SEPARATOR ); + if( nIndex != -1 ) + aLayout = aLayout.copy(0, nIndex); + + std::vector<OUString>::const_iterator pIter = + find(mrLayoutsToTransfer.begin(), mrLayoutsToTransfer.end(), aLayout); + + bool bFound = pIter != mrLayoutsToTransfer.end(); + + const sal_uInt16 nMPageCount = rDoc.GetMasterPageCount(); + for (sal_uInt16 nMPage = 0; nMPage < nMPageCount && !bFound; nMPage++) + { + // Do the layouts already exist within the document? + SdPage* pTestPage = static_cast<SdPage*>( rDoc.GetMasterPage(nMPage) ); + OUString aTest(pTestPage->GetLayoutName()); + sal_Int32 nIndex2 = aTest.indexOf( SD_LT_SEPARATOR ); + if( nIndex2 != -1 ) + aTest = aTest.copy(0, nIndex2); + + if (aTest == aLayout && pBMMPage->GetPageKind() == pTestPage->GetPageKind()) + { + // Ignore Layouts with "Default" these seem to be special - in the sense that there are lot of assumption all over Impress + // about this + if( bRenameDuplicates && aTest != SdResId( STR_LAYOUT_DEFAULT_NAME ) && !(pTestPage->Equals(*pBMMPage)) ) + { + pBookmarkDoc->RenameLayoutTemplate( + pBMMPage->GetLayoutName(), pBMMPage->GetName() + "_"); + aLayout = pBMMPage->GetName(); + + break; + } + else + bFound = true; + } + } + + if (!bFound) + mrLayoutsToTransfer.push_back(aLayout); +} + +// Inserts a bookmark as a page +static void lcl_IterateBookmarkPages( SdDrawDocument &rDoc, SdDrawDocument* pBookmarkDoc, + const std::vector<OUString> &rBookmarkList, sal_uInt16 nBMSdPageCount, + InsertBookmarkAsPage_FindDuplicateLayouts& rPageIterator, bool bRenameDuplicates ) +{ + + // Refactored copy'n'pasted layout name collection from InsertBookmarkAsPage + + int nPos, nEndPos; + + if( rBookmarkList.empty() ) + { + // no list? whole source document + nEndPos = nBMSdPageCount; + } + else + { + // bookmark list? number of entries + nEndPos = rBookmarkList.size(); + } + + SdPage* pBMPage; + + // iterate over number of pages to insert + for (nPos = 0; nPos < nEndPos; ++nPos) + { + // the master page associated to the nPos'th page to insert + SdPage* pBMMPage = nullptr; + + if( rBookmarkList.empty() ) + { + // simply take master page of nPos'th page in source document + pBMMPage = static_cast<SdPage*>(&(pBookmarkDoc->GetSdPage(static_cast<sal_uInt16>(nPos), PageKind::Standard)->TRG_GetMasterPage())); + } + else + { + // fetch nPos'th entry from bookmark list, and determine master page + OUString aBMPgName(rBookmarkList[nPos]); + bool bIsMasterPage; + + sal_uInt16 nBMPage = pBookmarkDoc->GetPageByName( aBMPgName, bIsMasterPage ); + + if (nBMPage != SDRPAGE_NOTFOUND) + { + pBMPage = static_cast<SdPage*>( pBookmarkDoc->GetPage(nBMPage) ); + } + else + { + pBMPage = nullptr; + } + + // enforce that bookmarked page is a standard page and not already a master page + if (pBMPage && pBMPage->GetPageKind()==PageKind::Standard && !pBMPage->IsMasterPage()) + { + const sal_uInt16 nBMSdPage = (nBMPage - 1) / 2; + pBMMPage = static_cast<SdPage*> (&(pBookmarkDoc->GetSdPage(nBMSdPage, PageKind::Standard)->TRG_GetMasterPage())); + } + } + + // successfully determined valid (bookmarked) page? + if( pBMMPage ) + { + // yes, call functor + rPageIterator( rDoc, pBMMPage, bRenameDuplicates, pBookmarkDoc ); + } + } +} + +// Opens a bookmark document +SdDrawDocument* SdDrawDocument::OpenBookmarkDoc(SfxMedium* pMedium) +{ + bool bOK = true; + SdDrawDocument* pBookmarkDoc = nullptr; + OUString aBookmarkName = pMedium->GetName(); + std::shared_ptr<const SfxFilter> pFilter = pMedium->GetFilter(); + if ( !pFilter ) + { + pMedium->UseInteractionHandler( true ); + SfxGetpApp()->GetFilterMatcher().GuessFilter(*pMedium, pFilter); + } + + if ( !pFilter ) + { + bOK = false; + } + else if ( !aBookmarkName.isEmpty() && maBookmarkFile != aBookmarkName ) + { + bool bCreateGraphicShell = pFilter->GetServiceName() == "com.sun.star.drawing.DrawingDocument"; + bool bCreateImpressShell = pFilter->GetServiceName() == "com.sun.star.presentation.PresentationDocument"; + if ( bCreateGraphicShell || bCreateImpressShell ) + { + CloseBookmarkDoc(); + + // Create a DocShell, as OLE objects might be contained in the + // document. (Persist) + // If that wasn't the case, we could load the model directly. + if ( bCreateGraphicShell ) + // Draw + mxBookmarkDocShRef = new ::sd::GraphicDocShell(SfxObjectCreateMode::STANDARD); + else + // Impress + mxBookmarkDocShRef = new ::sd::DrawDocShell(SfxObjectCreateMode::STANDARD, true, DocumentType::Impress); + + bOK = mxBookmarkDocShRef->DoLoad(pMedium); + if( bOK ) + { + maBookmarkFile = aBookmarkName; + pBookmarkDoc = mxBookmarkDocShRef->GetDoc(); + } + } + } + + DBG_ASSERT(!aBookmarkName.isEmpty(), "Empty document name!"); + + if (!bOK) + { + std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Warning, VclButtonsType::Ok, SdResId(STR_READ_DATA_ERROR))); + xErrorBox->run(); + + CloseBookmarkDoc(); + pBookmarkDoc = nullptr; + } + else if (mxBookmarkDocShRef.is()) + { + pBookmarkDoc = mxBookmarkDocShRef->GetDoc(); + } + + return pBookmarkDoc; +} + +// Opens a bookmark document +SdDrawDocument* SdDrawDocument::OpenBookmarkDoc(const OUString& rBookmarkFile) +{ + SdDrawDocument* pBookmarkDoc = nullptr; + + if (!rBookmarkFile.isEmpty() && maBookmarkFile != rBookmarkFile) + { + std::unique_ptr<SfxMedium> xMedium(new SfxMedium(rBookmarkFile, StreamMode::READ)); + pBookmarkDoc = OpenBookmarkDoc(xMedium.release()); + } + else if (mxBookmarkDocShRef.is()) + { + pBookmarkDoc = mxBookmarkDocShRef->GetDoc(); + } + + return pBookmarkDoc; +} + +// Inserts a bookmark (page or object) +void SdDrawDocument::InsertBookmark( + const std::vector<OUString> &rBookmarkList, // List of names of the bookmarks to be inserted + std::vector<OUString> &rExchangeList, // List of the names to be used + bool bLink, // Insert bookmarks as links? + sal_uInt16 nInsertPos, // Insertion position of pages + ::sd::DrawDocShell* pBookmarkDocSh, // If set, this is the source document + Point const * pObjPos) // Insertion position of objects +{ + bool bOK = true; + bool bInsertPages = false; + + if (rBookmarkList.empty()) + { + // Insert all pages + bInsertPages = true; + } + else + { + SdDrawDocument* pBookmarkDoc = nullptr; + + if (pBookmarkDocSh) + { + pBookmarkDoc = pBookmarkDocSh->GetDoc(); + } + else if ( mxBookmarkDocShRef.is() ) + { + pBookmarkDoc = mxBookmarkDocShRef->GetDoc(); + } + else + bOK = false; + + bInsertPages = bOK && std::any_of(rBookmarkList.begin(), rBookmarkList.end(), + [&pBookmarkDoc](const OUString& rBookmark) { + // Is there a page name in the bookmark list? + bool bIsMasterPage; + return pBookmarkDoc->GetPageByName(rBookmark, bIsMasterPage) != SDRPAGE_NOTFOUND; + }); + } + + bool bCalcObjCount = !rExchangeList.empty(); + + if ( bOK && bInsertPages ) + { + // Insert all page bookmarks + bOK = InsertBookmarkAsPage(rBookmarkList, &rExchangeList, bLink, false/*bReplace*/, + nInsertPos, false/*bNoDialogs*/, pBookmarkDocSh, true/*bCopy*/, true, false); + } + + if ( bOK && !rBookmarkList.empty() ) + { + // Insert all object bookmarks + InsertBookmarkAsObject(rBookmarkList, rExchangeList, + pBookmarkDocSh, pObjPos, bCalcObjCount); + } +} + +namespace +{ + +void +lcl_removeUnusedStyles(SfxStyleSheetBasePool* const pStyleSheetPool, StyleSheetCopyResultVector& rStyles) +{ + StyleSheetCopyResultVector aUsedStyles; + aUsedStyles.reserve(rStyles.size()); + for (const auto& a : rStyles) + { + if (a.m_xStyleSheet->IsUsed()) + aUsedStyles.push_back(a); + else + pStyleSheetPool->Remove(a.m_xStyleSheet.get()); + } + rStyles = aUsedStyles; +} + +void +lcl_removeUnusedTableStyles(SdStyleSheetPool* const pStyleSheetPool, XStyleVector const & rStyles) +{ + css::uno::Reference<css::container::XNameContainer> xTableFamily( + pStyleSheetPool->getByName("table"), css::uno::UNO_QUERY); + if (!xTableFamily) + return; + + for (const auto& a : rStyles) + { + if (!a->isInUse()) + xTableFamily->removeByName(a->getName()); + } +} + +SfxStyleSheet *lcl_findStyle(StyleSheetCopyResultVector& rStyles, std::u16string_view aStyleName) +{ + for (const auto& a : rStyles) + { + if (a.m_xStyleSheet->GetName().startsWith(aStyleName)) + return a.m_xStyleSheet.get(); + } + return nullptr; +} + +} + +bool SdDrawDocument::InsertBookmarkAsPage( + const std::vector<OUString> &rBookmarkList, + std::vector<OUString> *pExchangeList, // List of names to be used + bool bLink, + bool bReplace, + sal_uInt16 nInsertPos, + bool bNoDialogs, + ::sd::DrawDocShell* pBookmarkDocSh, + bool bCopy, + bool bMergeMasterPages, + bool bPreservePageNames) +{ + bool bContinue = true; + bool bScaleObjects = false; + sal_uInt16 nReplacedStandardPages = 0; + + SdDrawDocument* pBookmarkDoc = nullptr; + OUString aBookmarkName; + + if (pBookmarkDocSh) + { + pBookmarkDoc = pBookmarkDocSh->GetDoc(); + + if (pBookmarkDocSh->GetMedium()) + { + aBookmarkName = pBookmarkDocSh->GetMedium()->GetName(); + } + } + else if ( mxBookmarkDocShRef.is() ) + { + pBookmarkDoc = mxBookmarkDocShRef->GetDoc(); + aBookmarkName = maBookmarkFile; + } + else + { + return false; + } + + const sal_uInt16 nSdPageCount = GetSdPageCount(PageKind::Standard); + const sal_uInt16 nBMSdPageCount = pBookmarkDoc->GetSdPageCount(PageKind::Standard); + const sal_uInt16 nMPageCount = GetMasterPageCount(); + + if (nSdPageCount==0 || nBMSdPageCount==0 || nMPageCount==0) + { + return false; + } + + // Store the size and some other properties of the first page and notes + // page so that inserted pages can be properly scaled even when inserted + // before the first page. + // Note that the pointers are used later on as general page pointers. + SdPage* pRefPage = GetSdPage(0, PageKind::Standard); + Size aSize(pRefPage->GetSize()); + sal_Int32 nLeft = pRefPage->GetLeftBorder(); + sal_Int32 nRight = pRefPage->GetRightBorder(); + sal_Int32 nUpper = pRefPage->GetUpperBorder(); + sal_Int32 nLower = pRefPage->GetLowerBorder(); + Orientation eOrient = pRefPage->GetOrientation(); + + SdPage* pNPage = GetSdPage(0, PageKind::Notes); + Size aNSize(pNPage->GetSize()); + sal_Int32 nNLeft = pNPage->GetLeftBorder(); + sal_Int32 nNRight = pNPage->GetRightBorder(); + sal_Int32 nNUpper = pNPage->GetUpperBorder(); + sal_Int32 nNLower = pNPage->GetLowerBorder(); + Orientation eNOrient = pNPage->GetOrientation(); + + // Adapt page size and margins to those of the later pages? + pRefPage = GetSdPage(nSdPageCount - 1, PageKind::Standard); + + if( bNoDialogs ) + { + // If this is clipboard, then no need to scale objects: + // this will make copied masters to differ from the originals, + // and thus InsertBookmarkAsPage_FindDuplicateLayouts will + // duplicate masters on insert to same document + m_bTransportContainer = (SD_MOD()->pTransferClip && + SD_MOD()->pTransferClip->GetWorkDocument() == this); + if (!m_bTransportContainer) + { + if (rBookmarkList.empty()) + bScaleObjects = pRefPage->IsScaleObjects(); + else + bScaleObjects = true; + } + } + else + { + SdPage* pBMPage = pBookmarkDoc->GetSdPage(0,PageKind::Standard); + + if (pBMPage->GetSize() != pRefPage->GetSize() || + pBMPage->GetLeftBorder() != pRefPage->GetLeftBorder() || + pBMPage->GetRightBorder() != pRefPage->GetRightBorder() || + pBMPage->GetUpperBorder() != pRefPage->GetUpperBorder() || + pBMPage->GetLowerBorder() != pRefPage->GetLowerBorder()) + { + OUString aStr(SdResId(STR_SCALE_OBJECTS)); + std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Question, VclButtonsType::YesNo, + aStr)); + xQueryBox->add_button(GetStandardText(StandardButtonType::Cancel), RET_CANCEL); + sal_uInt16 nBut = xQueryBox->run(); + + bScaleObjects = nBut == RET_YES; + bContinue = nBut != RET_CANCEL; + + if (!bContinue) + { + return bContinue; + } + } + } + + // Get the necessary presentation stylesheets and transfer them before + // the pages, else, the text objects won't reference their styles anymore. + SfxUndoManager* pUndoMgr = nullptr; + if( mpDocSh ) + { + pUndoMgr = mpDocSh->GetUndoManager(); + ViewShellId nViewShellId(-1); + if (sd::ViewShell* pViewShell = mpDocSh->GetViewShell()) + nViewShellId = pViewShell->GetViewShellBase().GetViewShellId(); + pUndoMgr->EnterListAction(SdResId(STR_UNDO_INSERTPAGES), "", 0, nViewShellId); + } + + // Refactored copy'n'pasted layout name collection into IterateBookmarkPages + + std::vector<OUString> aLayoutsToTransfer; + InsertBookmarkAsPage_FindDuplicateLayouts aSearchFunctor( aLayoutsToTransfer ); + lcl_IterateBookmarkPages( *this, pBookmarkDoc, rBookmarkList, nBMSdPageCount, aSearchFunctor, ( rBookmarkList.empty() && pBookmarkDoc != this ) ); + + // Copy the style that we actually need. + SdStyleSheetPool& rBookmarkStyleSheetPool = dynamic_cast<SdStyleSheetPool&>(*pBookmarkDoc->GetStyleSheetPool()); + SdStyleSheetPool& rStyleSheetPool = dynamic_cast<SdStyleSheetPool&>(*GetStyleSheetPool()); + + // When copying styles, also copy the master pages! + if( !aLayoutsToTransfer.empty() ) + bMergeMasterPages = true; + + std::map<OUString, sal_Int32> aSlideLayoutsToTransfer; + std::map<OUString, std::shared_ptr<model::Theme>> aThemesToTransfer; + + for ( const OUString& layoutName : aLayoutsToTransfer ) + { + StyleSheetCopyResultVector aCreatedStyles; + + rStyleSheetPool.CopyLayoutSheets(layoutName, rBookmarkStyleSheetPool, aCreatedStyles); + + if(!aCreatedStyles.empty()) + { + if( pUndoMgr ) + { + pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aCreatedStyles, true)); + } + } + + // copy SlideLayout and Theme of the master slide + sal_Int32 nLayout = 20; // blank page - master slide layout ID + bool bIsMasterPage = false; + sal_uInt16 nBMPage = pBookmarkDoc->GetPageByName(layoutName, bIsMasterPage); + if (bIsMasterPage) + { + uno::Reference< drawing::XDrawPage > xOldPage(pBookmarkDoc->GetMasterPage(nBMPage)->getUnoPage(), uno::UNO_QUERY_THROW); + SdrPage* pMasterPage = SdPage::getImplementation(xOldPage); + if (pMasterPage) + { + aThemesToTransfer.insert({ layoutName, pMasterPage->getSdrPageProperties().getTheme() }); + uno::Reference<beans::XPropertySet> xPropSet(xOldPage, uno::UNO_QUERY_THROW); + if (xPropSet.is()) + { + uno::Any aLayoutID = xPropSet->getPropertyValue("SlideLayout"); + if (aLayoutID.hasValue()) { + aLayoutID >>= nLayout; + } + } + } + aSlideLayoutsToTransfer.insert({ layoutName, nLayout }); + } + } + + // Copy styles. This unconditionally copies all styles, even those + // that are not used in any of the inserted pages. The unused styles + // are then removed at the end of the function, where we also create + // undo records for the inserted styles. + StyleSheetCopyResultVector aNewGraphicStyles; + OUString aRenameStr; + if(!bReplace && !bNoDialogs) + aRenameStr = "_"; + rStyleSheetPool.RenameAndCopyGraphicSheets(rBookmarkStyleSheetPool, aNewGraphicStyles, aRenameStr); + StyleSheetCopyResultVector aNewCellStyles; + rStyleSheetPool.CopyCellSheets(rBookmarkStyleSheetPool, aNewCellStyles); + + // TODO handle undo of table styles too + XStyleVector aNewTableStyles; + rStyleSheetPool.CopyTableStyles(rBookmarkStyleSheetPool, aNewTableStyles); + + // Insert document + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(SdResId(STR_UNDO_INSERTPAGES)); + + if (rBookmarkList.empty()) + { + if (nInsertPos >= GetPageCount()) + { + // Add pages to the end + nInsertPos = GetPageCount(); + } + + sal_uInt16 nActualInsertPos = nInsertPos; + + sal_uInt16 nBMSdPage; + std::set<sal_uInt16> aRenameSet; + std::map<sal_uInt16,OUString> aNameMap; + + for (nBMSdPage=0; nBMSdPage < nBMSdPageCount; nBMSdPage++) + { + SdPage* pBMPage = pBookmarkDoc->GetSdPage(nBMSdPage, PageKind::Standard); + OUString sName(pBMPage->GetName()); + bool bIsMasterPage; + + if (bLink) + { + // Remember the names of all pages + aNameMap.insert(std::make_pair(nBMSdPage,sName)); + } + + // Have to check for duplicate names here, too + // don't change name if source and dest model are the same! + if( pBookmarkDoc != this && + GetPageByName(sName, bIsMasterPage ) != SDRPAGE_NOTFOUND ) + { + // delay renaming *after* pages are copied (might destroy source otherwise) + aRenameSet.insert(nBMSdPage); + } + } + + Merge(*pBookmarkDoc, + 1, // Not the handout page + 0xFFFF, // But all others + nActualInsertPos, // Insert at position ... + bMergeMasterPages, // Move master pages? + false, // But only the master pages used + true, // Create an undo action + bCopy); // Copy (or merge) pages? + + for (nBMSdPage=0; nBMSdPage < nBMSdPageCount; nBMSdPage++) + { + SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) ); + SdPage* pNotesPage = static_cast<SdPage*>( GetPage(nActualInsertPos+1) ); + + // delay renaming *after* pages are copied (might destroy source otherwise) + if( aRenameSet.find(nBMSdPage) != aRenameSet.end() ) + { + // Page name already in use -> Use default name for default and + // notes page + pPage->SetName(OUString()); + pNotesPage->SetName(OUString()); + } + + if (bLink) + { + OUString aName(aNameMap[nBMSdPage]); + + // Assemble all link names + pPage->SetFileName(aBookmarkName); + pPage->SetBookmarkName(aName); + } + + nActualInsertPos += 2; + } + } + else + { + // Insert selected pages + SdPage* pBMPage; + + if (nInsertPos >= GetPageCount()) + { + // Add pages to the end + bReplace = false; + nInsertPos = GetPageCount(); + } + + sal_uInt16 nActualInsertPos = nInsertPos; + + // Collect the bookmarked pages + ::std::vector<SdPage*> aBookmarkedPages (rBookmarkList.size(), nullptr); + for ( size_t nPos = 0, n = rBookmarkList.size(); nPos < n; ++nPos) + { + OUString aPgName(rBookmarkList[nPos]); + bool bIsMasterPage; + sal_uInt16 nBMPage = pBookmarkDoc->GetPageByName( aPgName, bIsMasterPage ); + + if (nBMPage != SDRPAGE_NOTFOUND) + { + aBookmarkedPages[nPos] = dynamic_cast<SdPage*>(pBookmarkDoc->GetPage(nBMPage)); + } + } + + for ( size_t nPos = 0, n = rBookmarkList.size(); nPos < n; ++nPos) + { + pBMPage = aBookmarkedPages[nPos]; + sal_uInt16 nBMPage = pBMPage!=nullptr ? pBMPage->GetPageNum() : SDRPAGE_NOTFOUND; + + if (pBMPage && pBMPage->GetPageKind()==PageKind::Standard && !pBMPage->IsMasterPage()) + { + // It has to be a default page + bool bMustRename = false; + + // delay renaming *after* pages are copied (might destroy source otherwise) + // don't change name if source and dest model are the same! + // avoid renaming if replacing the same page + OUString aPgName(rBookmarkList[nPos]); + bool bIsMasterPage; + sal_uInt16 nPageSameName = GetPageByName(aPgName, bIsMasterPage); + if( pBookmarkDoc != this && + nPageSameName != SDRPAGE_NOTFOUND && + ( !bReplace || + nPageSameName != nActualInsertPos ) ) + { + bMustRename = true; + } + + SdPage* pBookmarkPage = pBMPage; + if (bReplace ) + { + ReplacePageInCustomShows( dynamic_cast< SdPage* >( GetPage( nActualInsertPos ) ), pBookmarkPage ); + } + + Merge(*pBookmarkDoc, + nBMPage, // From page (default page) + nBMPage+1, // To page (notes page) + nActualInsertPos, // Insert at position + bMergeMasterPages, // Move master pages? + false, // But only the master pages used + true, // Create undo action + bCopy); // Copy (or merge) pages? + + if( bReplace ) + { + if( GetPage( nActualInsertPos ) != pBookmarkPage ) + { + // bookmark page was not moved but cloned, so update custom shows again + ReplacePageInCustomShows( pBookmarkPage, dynamic_cast< SdPage* >( GetPage( nActualInsertPos ) ) ); + } + } + + // tdf#39519 - rename page if its name is not unique, e.g., if a slide is copied by + // ctrl + drag and drop (DND_ACTION_COPY) + if (bMustRename || !mpDocSh->IsPageNameUnique(aPgName)) + { + // Page name already in use -> use default name for default and + // notes page + SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) ); + pPage->SetName(OUString()); + SdPage* pNotesPage = static_cast<SdPage*>( GetPage(nActualInsertPos+1) ); + pNotesPage->SetName(OUString()); + } + + if (bLink) + { + SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) ); + pPage->SetFileName(aBookmarkName); + pPage->SetBookmarkName(aPgName); + } + + if (bReplace) + { + // Remove page and notes page. + const sal_uInt16 nDestPageNum(nActualInsertPos + 2); + SdPage* pStandardPage = nullptr; + + if(nDestPageNum < GetPageCount()) + { + pStandardPage = static_cast<SdPage*>(GetPage(nDestPageNum)); + } + + if (pStandardPage) + { + if( bPreservePageNames ) + { + // Take old slide names for inserted pages + SdPage* pPage = static_cast<SdPage*>( GetPage(nActualInsertPos) ); + pPage->SetName( pStandardPage->GetRealName() ); + } + + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pStandardPage)); + + RemovePage(nDestPageNum); + } + + SdPage* pNotesPage = nullptr; + + if(nDestPageNum < GetPageCount()) + { + pNotesPage = static_cast<SdPage*>(GetPage(nDestPageNum)); + } + + if (pNotesPage) + { + if( bPreservePageNames ) + { + // Take old slide names for inserted pages + SdPage* pNewNotesPage = static_cast<SdPage*>( GetPage(nActualInsertPos+1)); + if( pNewNotesPage ) + pNewNotesPage->SetName( pStandardPage->GetRealName() ); + } + + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage)); + + RemovePage(nDestPageNum); + } + + nReplacedStandardPages++; + } + + nActualInsertPos += 2; + } + } + } + + // We might have duplicate master pages now, as the drawing engine does not + // recognize duplicates. Remove these now. + sal_uInt16 nNewMPageCount = GetMasterPageCount(); + + // Go backwards, so the numbers don't become messed up + for (sal_uInt16 nPage = nNewMPageCount - 1; nPage >= nMPageCount; nPage--) + { + pRefPage = static_cast<SdPage*>( GetMasterPage(nPage) ); + OUString aMPLayout(pRefPage->GetLayoutName()); + PageKind eKind = pRefPage->GetPageKind(); + + // Does this already exist? + for (sal_uInt16 nTest = 0; nTest < nMPageCount; nTest++) + { + SdPage* pTest = static_cast<SdPage*>( GetMasterPage(nTest) ); + OUString aTest(pTest->GetLayoutName()); + + // nInsertPos > 2 is always true when inserting into non-empty models + if ( nInsertPos > 2 && + aTest == aMPLayout && + eKind == pTest->GetPageKind() ) + { + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pRefPage)); + + RemoveMasterPage(nPage); + + nNewMPageCount--; + break; + } + } + } + + // nInsertPos > 2 is always true when inserting into non-empty models + if (nInsertPos > 0) + { + sal_uInt16 nSdPageStart = (nInsertPos - 1) / 2; + sal_uInt16 nSdPageEnd = bReplace + ? nSdPageStart + nReplacedStandardPages - 1 + : GetSdPageCount(PageKind::Standard) - nSdPageCount + nSdPageStart - 1; + const bool bRemoveEmptyPresObj = + (pBookmarkDoc->GetDocumentType() == DocumentType::Impress) && + (GetDocumentType() == DocumentType::Draw); + + std::vector<OUString>::iterator pExchangeIter; + + if (pExchangeList) + pExchangeIter = pExchangeList->begin(); + + for (sal_uInt16 nSdPage = nSdPageStart; nSdPage <= nSdPageEnd; nSdPage++) + { + pRefPage = GetSdPage(nSdPage, PageKind::Standard); + + if (pExchangeList && pExchangeIter != pExchangeList->end()) + { + // Get the name to use from Exchange list + OUString aExchangeName(*pExchangeIter); + pRefPage->SetName(aExchangeName); + Broadcast(SdrHint(SdrHintKind::PageOrderChange, pRefPage)); + + SdPage* pNewNotesPage = GetSdPage(nSdPage, PageKind::Notes); + pNewNotesPage->SetName(aExchangeName); + Broadcast(SdrHint(SdrHintKind::PageOrderChange, pNewNotesPage)); + + ++pExchangeIter; + } + + OUString aLayout(pRefPage->GetLayoutName()); + sal_Int32 nIndex = aLayout.indexOf( SD_LT_SEPARATOR ); + if( nIndex != -1 ) + aLayout = aLayout.copy(0, nIndex); + + // update layout and referred master page + pRefPage->SetPresentationLayout(aLayout); + if( bUndo ) + AddUndo( GetSdrUndoFactory().CreateUndoPageChangeMasterPage( *pRefPage ) ); + + if (bScaleObjects) + { + ::tools::Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); + pRefPage->ScaleObjects(aSize, aBorderRect, true); + } + pRefPage->SetSize(aSize); + pRefPage->SetBorder(nLeft, nUpper, nRight, nLower); + pRefPage->SetOrientation( eOrient ); + + if( bRemoveEmptyPresObj ) + pRefPage->RemoveEmptyPresentationObjects(); + + pRefPage = GetSdPage(nSdPage, PageKind::Notes); + + // update layout and referred master page + pRefPage->SetPresentationLayout(aLayout); + if( bUndo ) + AddUndo( GetSdrUndoFactory().CreateUndoPageChangeMasterPage( *pRefPage ) ); + + if (bScaleObjects) + { + ::tools::Rectangle aBorderRect(nNLeft, nNUpper, nNRight, nNLower); + pRefPage->ScaleObjects(aNSize, aBorderRect, true); + } + + pRefPage->SetSize(aNSize); + pRefPage->SetBorder(nNLeft, nNUpper, nNRight, nNLower); + pRefPage->SetOrientation( eNOrient ); + + if( bRemoveEmptyPresObj ) + pRefPage->RemoveEmptyPresentationObjects(); + } + + ///Remove processed elements, to avoid doing hacks in InsertBookmarkAsObject + if ( pExchangeList ) + pExchangeList->erase(pExchangeList->begin(),pExchangeIter); + + for (sal_uInt16 nPage = nMPageCount; nPage < nNewMPageCount; nPage++) + { + pRefPage = static_cast<SdPage*>( GetMasterPage(nPage) ); + if (pRefPage->GetPageKind() == PageKind::Standard) + { + if (bScaleObjects) + { + ::tools::Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); + pRefPage->ScaleObjects(aSize, aBorderRect, true); + } + pRefPage->SetSize(aSize); + pRefPage->SetBorder(nLeft, nUpper, nRight, nLower); + pRefPage->SetOrientation( eOrient ); + + uno::Reference< drawing::XDrawPage > xNewPage(GetMasterPage(nPage)->getUnoPage(), uno::UNO_QUERY_THROW); + + SdrPage* pMasterPage = SdPage::getImplementation(xNewPage); + if (pMasterPage) + { + OUString aLayout(pRefPage->GetName()); + if (auto it{ aThemesToTransfer.find(aLayout) }; it != std::end(aThemesToTransfer)) + { + pMasterPage->getSdrPageProperties().setTheme(it->second); + } + } + + uno::Reference<beans::XPropertySet> xNewPropSet(xNewPage, uno::UNO_QUERY_THROW); + if (xNewPropSet.is()) + { + OUString aLayout(pRefPage->GetName()); + sal_Int32 nLayout = 20; // blank page - master slide layout ID + if (auto it{ aSlideLayoutsToTransfer.find(aLayout) }; it != std::end(aSlideLayoutsToTransfer)) + { + nLayout = it->second; + } + xNewPropSet->setPropertyValue("SlideLayout", uno::Any(nLayout)); + } + } + else // Can only be notes + { + if (bScaleObjects) + { + ::tools::Rectangle aBorderRect(nNLeft, nNUpper, nNRight, nNLower); + pRefPage->ScaleObjects(aNSize, aBorderRect, true); + } + pRefPage->SetSize(aNSize); + pRefPage->SetBorder(nNLeft, nNUpper, nNRight, nNLower); + pRefPage->SetOrientation( eNOrient ); + } + + if( bRemoveEmptyPresObj ) + pRefPage->RemoveEmptyPresentationObjects(); + } + } + + // Make absolutely sure no double masterpages are there + RemoveUnnecessaryMasterPages(nullptr, true); + + // Rename object styles if necessary + if(!aRenameStr.isEmpty()) + { + try + { + for(sal_uInt32 p = nInsertPos; p < sal_uInt32(nInsertPos) + sal_uInt32(nBMSdPageCount); p++) + { + if (SdPage *pPg = static_cast<SdPage *>( GetPage(p) )) + for (const rtl::Reference<SdrObject>& pObj : *pPg) + { + if(pObj->GetStyleSheet()) + { + OUString aStyleName = pObj->GetStyleSheet()->GetName(); + SfxStyleSheet *pSheet = lcl_findStyle(aNewGraphicStyles, Concat2View(aStyleName + aRenameStr)); + if(pSheet != nullptr) + pObj->SetStyleSheet(pSheet, true); + } + } + } + } + catch(...) + { + TOOLS_WARN_EXCEPTION( "sd", "Exception while renaming styles @ SdDrawDocument::InsertBookmarkAsPage"); + } + } + // remove copied styles not used on any inserted page and create + // undo records + // WARNING: SdMoveStyleSheetsUndoAction clears the passed list of + // styles, so it cannot be used after this point + lcl_removeUnusedStyles(GetStyleSheetPool(), aNewGraphicStyles); + if (!aNewGraphicStyles.empty() && pUndoMgr) + pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aNewGraphicStyles, true)); + lcl_removeUnusedTableStyles(static_cast<SdStyleSheetPool*>(GetStyleSheetPool()), aNewTableStyles); + lcl_removeUnusedStyles(GetStyleSheetPool(), aNewCellStyles); + + if( bUndo ) + EndUndo(); + + if (pUndoMgr) + pUndoMgr->LeaveListAction(); + + return bContinue; +} + +// Inserts a bookmark as an object +bool SdDrawDocument::InsertBookmarkAsObject( + const std::vector<OUString> &rBookmarkList, + const std::vector<OUString> &rExchangeList, // List of names to use + ::sd::DrawDocShell* pBookmarkDocSh, + Point const * pObjPos, + bool bCalcObjCount) +{ + bool bOK = true; + bool bOLEObjFound = false; + std::unique_ptr<::sd::View> pBMView; + + SdDrawDocument* pBookmarkDoc = nullptr; + + if (pBookmarkDocSh) + { + pBookmarkDoc = pBookmarkDocSh->GetDoc(); + } + else if ( mxBookmarkDocShRef.is() ) + { + pBookmarkDoc = mxBookmarkDocShRef->GetDoc(); + } + else + { + return false; + } + + if (rBookmarkList.empty()) + { + pBMView.reset(new ::sd::View(*pBookmarkDoc, nullptr)); + pBMView->EndListening(*pBookmarkDoc); + pBMView->MarkAll(); + } + else + { + SdrPage* pPage; + SdrPageView* pPV; + + for ( const auto& rBookmark : rBookmarkList ) + { + // Get names of bookmarks from the list + SdrObject* pObj = pBookmarkDoc->GetObj(rBookmark); + + if (pObj) + { + // Found an object + if (pObj->GetObjInventor() == SdrInventor::Default && + pObj->GetObjIdentifier() == SdrObjKind::OLE2) + { + bOLEObjFound = true; + } + + if (!pBMView) + { + // Create View for the first time + pBMView.reset(new ::sd::View(*pBookmarkDoc, nullptr)); + pBMView->EndListening(*pBookmarkDoc); + } + + pPage = pObj->getSdrPageFromSdrObject(); + + if (pPage->IsMasterPage()) + { + pPV = pBMView->ShowSdrPage(pBMView->GetModel().GetMasterPage(pPage->GetPageNum())); + } + else + { + pPV = pBMView->GetSdrPageView(); + if( !pPV || (pPV->GetPage() != pPage)) + pPV = pBMView->ShowSdrPage(pPage); + } + + pBMView->MarkObj(pObj, pPV); + } + } + } + + if (pBMView) + { + // Insert selected objects + std::optional<::sd::View> pView(std::in_place, *this, nullptr); + pView->EndListening(*this); + + // Look for the page into which the objects are supposed to be inserted + SdrPage* pPage = GetSdPage(0, PageKind::Standard); + + if (mpDocSh) + { + ::sd::ViewShell* pViewSh = mpDocSh->GetViewShell(); + + if (pViewSh) + { + // Which page is currently in view? + SdrPageView* pPV = pViewSh->GetView()->GetSdrPageView(); + + if (pPV) + { + pPage = pPV->GetPage(); + } + else if (pViewSh->GetActualPage()) + { + pPage = pViewSh->GetActualPage(); + } + } + } + + Point aObjPos; + + if (pObjPos) + { + aObjPos = *pObjPos; + } + else + { + aObjPos = ::tools::Rectangle(Point(), pPage->GetSize()).Center(); + } + + size_t nCountBefore = 0; + + if (!rExchangeList.empty() || bCalcObjCount) + { + // Sort OrdNums and get the number of objects before inserting + pPage->RecalcObjOrdNums(); + nCountBefore = pPage->GetObjCount(); + } + + if (bOLEObjFound) + pBMView->GetDoc().SetAllocDocSh(true); + + SdDrawDocument* pTmpDoc = static_cast<SdDrawDocument*>( pBMView->CreateMarkedObjModel().release() ); + bOK = pView->Paste(*pTmpDoc, aObjPos, pPage, SdrInsertFlags::NONE); + + if (bOLEObjFound) + pBMView->GetDoc().SetAllocDocSh(false); + + if (!bOLEObjFound) + delete pTmpDoc; // Would otherwise be destroyed by DocShell + + pView.reset(); + + // Get number of objects after inserting. + const size_t nCount = pPage->GetObjCount(); + if (nCountBefore < nCount) + { + size_t nObj = nCountBefore; + for (const auto& rExchange : rExchangeList) + { + // Get the name to use from the Exchange list + if (pPage->GetObj(nObj)) + { + pPage->GetObj(nObj)->SetName(rExchange); + } + + ++nObj; + if (nObj >= nCount) + break; + } + } + } + + return bOK; +} + +// Stops the bookmark insertion +void SdDrawDocument::CloseBookmarkDoc() +{ + if (mxBookmarkDocShRef.is()) + { + mxBookmarkDocShRef->DoClose(); + } + + mxBookmarkDocShRef.clear(); + maBookmarkFile.clear(); +} + +// Is this document read-only? +bool SdDrawDocument::IsReadOnly() const +{ + return false; +} + +// In the subsequent AllocModel() a DocShell (xAllocedDocShRef) is created. +// Any pre-existing DocShell is deleted +void SdDrawDocument::SetAllocDocSh(bool bAlloc) +{ + mbAllocDocSh = bAlloc; + + if(mxAllocedDocShRef.is()) + { + mxAllocedDocShRef->DoClose(); + } + + mxAllocedDocShRef.clear(); +} + +// Return list of CustomShows (create it, too, if necessary) +SdCustomShowList* SdDrawDocument::GetCustomShowList(bool bCreate) +{ + if (!mpCustomShowList && bCreate) + { + mpCustomShowList.reset(new SdCustomShowList); + } + + return mpCustomShowList.get(); +} + +// Remove unused master pages and layouts +void SdDrawDocument::RemoveUnnecessaryMasterPages(SdPage* pMasterPage, bool bOnlyDuplicatePages, bool bUndo) +{ + ::sd::View* pView = nullptr; + SfxUndoManager* pUndoMgr = nullptr; + + if( bUndo && !IsUndoEnabled() ) + bUndo = false; + + if (mpDocSh) + { + pUndoMgr = mpDocSh->GetUndoManager(); + + if (mpDocSh->GetViewShell()) + pView = mpDocSh->GetViewShell()->GetView(); + } + + // Check all master pages + sal_uInt16 nSdMasterPageCount = GetMasterSdPageCount( PageKind::Standard ); + for (sal_Int32 nMPage = nSdMasterPageCount - 1; nMPage >= 0; nMPage--) + { + SdPage* pMaster = pMasterPage; + SdPage* pNotesMaster = nullptr; + + if (!pMaster) + { + pMaster = GetMasterSdPage( static_cast<sal_uInt16>(nMPage), PageKind::Standard ); + pNotesMaster = GetMasterSdPage( static_cast<sal_uInt16>(nMPage), PageKind::Notes ); + } + else + { + for ( sal_uInt16 nMPg = 0; nMPg < GetMasterPageCount(); nMPg++ ) + { + if ( pMaster == GetMasterPage( nMPg ) ) + { + pNotesMaster = static_cast<SdPage*>( GetMasterPage( ++nMPg ) ); + break; + } + } + } + + DBG_ASSERT( pMaster->GetPageKind() == PageKind::Standard, "wrong page kind" ); + + if ( pMaster->GetPageKind() == PageKind::Standard && + GetMasterPageUserCount( pMaster ) == 0 && + pNotesMaster ) + { + // Do not delete master pages that have their precious flag set + bool bDeleteMaster = !pMaster->IsPrecious(); + OUString aLayoutName = pMaster->GetLayoutName(); + + if(bOnlyDuplicatePages ) + { + // remove only duplicate pages + bDeleteMaster = false; + for (sal_uInt16 i = 0; i < GetMasterSdPageCount( PageKind::Standard ); i++) + { + SdPage* pMPg = GetMasterSdPage( i, PageKind::Standard ); + if( pMPg != pMaster && + pMPg->GetLayoutName() == aLayoutName ) + { + // duplicate page found -> remove it + bDeleteMaster = true; + } + } + } + + if( bDeleteMaster ) + { + if (pView) + { + // if MasterPage is visible hide on pageview + SdrPageView* pPgView = pView->GetSdrPageView(); + if (pPgView) + { + SdrPage* pShownPage = pPgView->GetPage(); + if( (pShownPage == pMaster) || (pShownPage == pNotesMaster) ) + { + pView->HideSdrPage(); + pView->ShowSdrPage( GetSdPage( 0, PageKind::Standard ) ); + } + } + } + + if( bUndo ) + { + BegUndo(); + AddUndo( GetSdrUndoFactory().CreateUndoDeletePage( *pNotesMaster ) ); + } + + RemoveMasterPage( pNotesMaster->GetPageNum() ); + + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pMaster)); + + RemoveMasterPage( pMaster->GetPageNum() ); + + if( bUndo ) + EndUndo(); // do this here already, so Joe's actions happen _between_ our own + + // Delete old, unused layout stylesheets + bool bDeleteOldStyleSheets = true; + for ( sal_uInt16 nMPg = 0; + nMPg < GetMasterPageCount() && bDeleteOldStyleSheets; + nMPg++ ) + { + SdPage* pMPg = static_cast<SdPage*>( GetMasterPage(nMPg) ); + if (pMPg->GetLayoutName() == aLayoutName) + { + bDeleteOldStyleSheets = false; + } + } + + if (bDeleteOldStyleSheets) + { + SdStyleSheetVector aRemove; + static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutSheetList( aLayoutName, aRemove ); + + if( bUndo ) + { + StyleSheetCopyResultVector aUndoRemove; + aUndoRemove.reserve(aRemove.size()); + for (const auto& a : aRemove) + aUndoRemove.emplace_back(a.get(), true); + + if (pUndoMgr) + pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aUndoRemove, false)); + } + + for( const auto& a : aRemove ) + static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->Remove(a.get()); + } + } + } + + if (pMasterPage) + break; // Just this one master page! + } +} + +/** Exchange master page + * + * Either the nSdPageNum gets a new, own master page or the master page is + * exchanged completely (which then applies to all pages). + * + * nSdPageNum : page number that the new master page should get. + * rLayoutName : LayoutName of the new master page + * pSourceDoc : document (template) to get the master page from + * bMaster : exchange the master page of nSdPageNum + * bCheckMasters: remove unused master pages + * + * If pSourceDoc == NULL, an empty master page is applied. + * If rLayoutName is empty, the first master page is used. + */ +// #i121863# factored out functionality +static bool isMasterPageLayoutNameUnique(const SdDrawDocument& rDoc, std::u16string_view rCandidate) +{ + if (rCandidate.empty()) + { + return false; + } + + const sal_uInt16 nPageCount(rDoc.GetMasterPageCount()); + + for(sal_uInt16 a(0); a < nPageCount; a++) + { + const SdrPage* pCandidate = rDoc.GetMasterPage(a); + OUString aPageLayoutName(pCandidate->GetLayoutName()); + sal_Int32 nIndex = aPageLayoutName.indexOf(SD_LT_SEPARATOR); + if( nIndex != -1 ) + aPageLayoutName = aPageLayoutName.copy(0, nIndex); + + if(aPageLayoutName == rCandidate) + { + return false; + } + } + + return true; +} + +// #i121863# factored out functionality +static OUString createNewMasterPageLayoutName(const SdDrawDocument& rDoc) +{ + const OUString aBaseName(SdResId(STR_LAYOUT_DEFAULT_NAME)); + sal_uInt16 nCount(0); + for (;;) + { + OUString aRetval = aBaseName; + if(nCount) + { + aRetval += OUString::number(nCount); + } + if (isMasterPageLayoutNameUnique(rDoc, aRetval)) + return aRetval; + nCount++; + } +} + +void SdDrawDocument::SetMasterPage(sal_uInt16 nSdPageNum, + std::u16string_view rLayoutName, + SdDrawDocument* pSourceDoc, + bool bMaster, + bool bCheckMasters) +{ + SfxUndoManager* pUndoMgr = nullptr; + + if( mpDocSh ) + { + mpDocSh->SetWaitCursor( true ); + pUndoMgr = mpDocSh->GetUndoManager(); + } + + const bool bUndo = pUndoMgr && IsUndoEnabled(); + + if (bUndo) + { + ViewShellId nViewShellId(-1); + if (sd::ViewShell* pViewShell = mpDocSh->GetViewShell()) + nViewShellId = pViewShell->GetViewShellBase().GetViewShellId(); + pUndoMgr->EnterListAction(SdResId(STR_UNDO_SET_PRESLAYOUT), OUString(), 0, nViewShellId); + } + + SdPage* pSelectedPage = GetSdPage(nSdPageNum, PageKind::Standard); + SdPage* pNotes = static_cast<SdPage*>( GetPage(pSelectedPage->GetPageNum()+1) ); + SdPage& rOldMaster = static_cast<SdPage&>(pSelectedPage->TRG_GetMasterPage()); + SdPage& rOldNotesMaster = static_cast<SdPage&>(pNotes->TRG_GetMasterPage()); + rtl::Reference<SdPage> pMaster; + rtl::Reference<SdPage> pNotesMaster; + OUString aOldPageLayoutName(pSelectedPage->GetLayoutName()); + OUString aOldLayoutName(aOldPageLayoutName); + sal_Int32 nIndex = aOldLayoutName.indexOf( SD_LT_SEPARATOR ); + if( nIndex != -1 ) + aOldLayoutName = aOldLayoutName.copy(0, nIndex); + + if (pSourceDoc) + { + std::vector<StyleReplaceData> aReplList; // List of replaced stylesheets + bool bLayoutReloaded = false; // Was ex. layout reloaded? + + // LayoutName, Page and Notes page + if (rLayoutName.empty()) + { + // No LayoutName: take first MasterPage + pMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Standard); + pNotesMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Notes); + } + else + { + OUString aSearchFor + = OUString::Concat(rLayoutName) + SD_LT_SEPARATOR + STR_LAYOUT_OUTLINE; + + for (sal_uInt16 nMP = 0; nMP < pSourceDoc->GetMasterPageCount(); ++nMP) + { + SdPage* pMP = static_cast<SdPage*>( pSourceDoc->GetMasterPage(nMP) ); + + if (pMP->GetLayoutName() == aSearchFor) + { + if (pMP->GetPageKind() == PageKind::Standard) + pMaster = pMP; + if (pMP->GetPageKind() == PageKind::Notes) + pNotesMaster = pMP; + } + if (pMaster && pNotesMaster) + break; + } + DBG_ASSERT(pMaster, "MasterPage (Standard page) not found"); + DBG_ASSERT(pNotesMaster, "MasterPage (Notes page) not found"); + + // this should not happen, but looking at crash reports, it does + if( (pMaster == nullptr) || (pNotesMaster == nullptr) ) + { + // so take the first MasterPage + pMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Standard); + pNotesMaster = pSourceDoc->GetMasterSdPage(0, PageKind::Notes); + } + } + + // we should never reach this, but one never knows... + if( (pMaster == nullptr) || (pNotesMaster == nullptr) ) + { + if (bUndo) + pUndoMgr->LeaveListAction(); + + if( mpDocSh ) + mpDocSh->SetWaitCursor( false ); + + OSL_FAIL( "SdDrawDocument::SetMasterPage() failed!" ); + + return; + } + + const OUString aOriginalNewLayoutName( pMaster->GetName() ); + OUString aTargetNewLayoutName(aOriginalNewLayoutName); + + if (pSourceDoc != this) + { + // #i121863# clone masterpages, they are from another model (!) + rtl::Reference<SdPage> pNewNotesMaster(dynamic_cast< SdPage* >(pNotesMaster->CloneSdrPage(*this).get())); + rtl::Reference<SdPage> pNewMaster(dynamic_cast< SdPage* >(pMaster->CloneSdrPage(*this).get())); + + if(!pNewNotesMaster || !pNewMaster) + { + OSL_FAIL("SdDrawDocument::SetMasterPage() cloning of MasterPage/NoteAmsterPage failed!" ); + return; + } + + pNotesMaster = pNewNotesMaster; + pMaster = pNewMaster; + + // layout name needs to be unique + aTargetNewLayoutName = pMaster->GetLayoutName(); + sal_Int32 nIndex2 = aTargetNewLayoutName.indexOf(SD_LT_SEPARATOR); + if( nIndex2 != -1 ) + aTargetNewLayoutName = aTargetNewLayoutName.copy(0, nIndex2); + + if(!isMasterPageLayoutNameUnique(*this, aTargetNewLayoutName)) + { + aTargetNewLayoutName = createNewMasterPageLayoutName(*this); + + OUString aTemp = aTargetNewLayoutName + SD_LT_SEPARATOR + STR_LAYOUT_OUTLINE; + + pMaster->SetName(aTargetNewLayoutName); + pMaster->SetLayoutName(aTemp); + + pNotesMaster->SetName(aTargetNewLayoutName); + pNotesMaster->SetLayoutName(aTemp); + } + } + + if (pSourceDoc != this) + { + const sal_uInt16 nMasterPageCount = GetMasterPageCount(); + for ( sal_uInt16 nMPage = 0; nMPage < nMasterPageCount; nMPage++ ) + { + SdPage* pCheckMaster = static_cast<SdPage*>(GetMasterPage(nMPage)); + if( pCheckMaster->GetName() == aTargetNewLayoutName ) + { + bLayoutReloaded = true; + break; + } + } + + // Correct or create presentation templates -- + // only worry about presentation templates + OUString aName; + SdStyleSheetPool* pSourceStyleSheetPool = static_cast<SdStyleSheetPool*>( pSourceDoc->GetStyleSheetPool() ); + + StyleSheetCopyResultVector aCreatedStyles; // List of created stylesheets + SfxStyleSheetBase* pHisSheet = pSourceStyleSheetPool->First(SfxStyleFamily::Page); + + while (pHisSheet) + { + aName = pHisSheet->GetName(); + + // #i121863# search in source styles with original style name from source of + // evtl. cloned master (not-cloned, renamed for uniqueness) + if( aName.startsWith( aOriginalNewLayoutName ) ) + { + // #i121863# build name of evtl. cloned master style to search for + if(aOriginalNewLayoutName != aTargetNewLayoutName) + { + const sal_Int32 nPos(aName.indexOf(SD_LT_SEPARATOR)); + aName = aTargetNewLayoutName + aName.subView(nPos); + } + + SfxStyleSheet* pMySheet = static_cast<SfxStyleSheet*>( mxStyleSheetPool->Find(aName, SfxStyleFamily::Page) ); + + if (pMySheet) + { + // A stylesheet of the same name already exists -> overwrite contents + bool bTest = pMySheet->SetName(pHisSheet->GetName()); + DBG_ASSERT(bTest, "Renaming StyleSheet failed."); + pMySheet->GetItemSet().ClearItem(); // Delete all + + if (bUndo) + { + pUndoMgr->AddUndoAction(std::make_unique<StyleSheetUndoAction>(this, + pMySheet, &pHisSheet->GetItemSet())); + } + pMySheet->GetItemSet().Put(pHisSheet->GetItemSet()); + pMySheet->Broadcast(SfxHint(SfxHintId::DataChanged)); + } + else + { + // create new style + OUString aHelpFile; + pMySheet = static_cast<SfxStyleSheet*>( &mxStyleSheetPool->Make(aName, SfxStyleFamily::Page, pHisSheet->GetMask()) ); + pMySheet->SetHelpId( aHelpFile, pHisSheet->GetHelpId(aHelpFile) ); + pMySheet->GetItemSet().ClearItem(); // Delete all + pMySheet->GetItemSet().Put(pHisSheet->GetItemSet()); + + aCreatedStyles.emplace_back(static_cast<SdStyleSheet*>(pMySheet), true); + } + + StyleReplaceData aReplData; + aReplData.nNewFamily = pMySheet->GetFamily(); + aReplData.nFamily = pMySheet->GetFamily(); + aReplData.aNewName = pMySheet->GetName(); + + // #i121863# re-create original name of style used at page where to replace with + // this new style + OUString aTemp(pMySheet->GetName()); + const sal_Int32 nPos(aTemp.indexOf(SD_LT_SEPARATOR)); + aTemp = aOldLayoutName + aTemp.subView(nPos); + aReplData.aName = aTemp; + aReplList.push_back(aReplData); + } + + pHisSheet = pSourceStyleSheetPool->Next(); + } + + // If new styles were created: re-create parent chaining of the item + // sets in the styles. + if(!aCreatedStyles.empty()) + { + for ( const auto& rRData : aReplList ) + { + SfxStyleSheetBase* pSOld = mxStyleSheetPool->Find(rRData.aName, SfxStyleFamily::Page); + SfxStyleSheetBase* pSNew = mxStyleSheetPool->Find(rRData.aNewName, SfxStyleFamily::Page); + + if (pSOld && pSNew) + { + const OUString& rParentOfOld = pSOld->GetParent(); + const OUString& rParentOfNew = pSNew->GetParent(); + + if (!rParentOfOld.isEmpty() && rParentOfNew.isEmpty()) + { + std::vector<StyleReplaceData>::iterator pRDIter = std::find_if(aReplList.begin(), aReplList.end(), + [&rParentOfOld](const StyleReplaceData& rRD) { return (rRD.aName == rParentOfOld) && (rRD.aName != rRD.aNewName); }); + if (pRDIter != aReplList.end()) + { + OUString aParentOfNew(pRDIter->aNewName); + pSNew->SetParent(aParentOfNew); + } + } + } + } + } + + if (bUndo && !aCreatedStyles.empty()) + { + // Add UndoAction for creating and inserting the stylesheets to + // the top of the UndoManager + pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>( this, aCreatedStyles, true)); + } + } + + // Create layout name based upon the name of the page layout of the + // master page + OUString aPageLayoutName(pMaster->GetLayoutName()); + OUString aLayoutName = aPageLayoutName; + sal_Int32 nIndex2 = aLayoutName.indexOf( SD_LT_SEPARATOR ); + if( nIndex2 != -1 ) + aLayoutName = aLayoutName.copy( 0, nIndex2); + + // #i121863# Do *not* remove from original document any longer, it is potentially used there + // and would lead to crashes. Rely on the automatic process of removing unused masterpages + // (see RemoveUnnecessaryMasterPages) + //if (pSourceDoc != this) + //{ + // // Remove from the source document + // pSourceDoc->RemoveMasterPage(pNotesMaster->GetPageNum()); + // pSourceDoc->RemoveMasterPage(pMaster->GetPageNum()); + //} + + // Register the new master pages with the document and then use + // the new presentation layout for the default and notes pages + if (pSourceDoc != this) + { + // Insert the master pages: + // Insert master pages from new layouts at the end. + // If a layout is being replaced, however, insert them before the + // position of the old master page, so from now on the new master + // page will be found when searching (e.g. + // SdPage::SetPresentationLayout). + sal_uInt16 nInsertPos = rOldMaster.GetPageNum(); + BegUndo(); + + if (!bLayoutReloaded) + nInsertPos = 0xFFFF; + InsertMasterPage(pMaster.get(), nInsertPos); + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pMaster)); + + nInsertPos++; + if (!bLayoutReloaded) + nInsertPos = 0xFFFF; + InsertMasterPage(pNotesMaster.get(), nInsertPos); + if( bUndo ) + { + AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pNotesMaster)); + + EndUndo(); // do this here already, so Joe's actions happen _between_ our own. + } + } + + // Fill list with pages + std::vector<rtl::Reference<SdPage>> aPageList; + +// #98456, this has to be removed according to CL (KA 07/08/2002) +// #109884# but we need them again to restore the styles of the presentation objects while undo + aPageList.push_back(pMaster); + aPageList.push_back(pNotesMaster); + + if (bMaster || bLayoutReloaded) + { + for (sal_uInt16 nPage = 1; nPage < GetPageCount(); nPage++) + { + SdPage* pPage = static_cast<SdPage*>( GetPage(nPage) ); + OUString aTest = pPage->GetLayoutName(); + if (aTest == aOldPageLayoutName) + { + aPageList.push_back(pPage); + } + } + + } + else + { + aPageList.push_back(pSelectedPage); + aPageList.push_back(pNotes); + } + + for (rtl::Reference<SdPage>& pPage : aPageList) + { + AutoLayout eAutoLayout = pPage->GetAutoLayout(); + + if( bUndo ) + { + pUndoMgr->AddUndoAction(std::make_unique<SdPresentationLayoutUndoAction> + (this, + pPage->IsMasterPage() ? aLayoutName : aOldLayoutName, + aLayoutName, + eAutoLayout, eAutoLayout, false, pPage.get())); + } + pPage->SetPresentationLayout(aLayoutName); + pPage->SetAutoLayout(eAutoLayout); + } + + // Adapt new master pages + if (pSourceDoc != this) + { + Size aSize(rOldMaster.GetSize()); + ::tools::Rectangle aBorderRect(rOldMaster.GetLeftBorder(), + rOldMaster.GetUpperBorder(), + rOldMaster.GetRightBorder(), + rOldMaster.GetLowerBorder()); + pMaster->ScaleObjects(aSize, aBorderRect, true); + pMaster->SetSize(aSize); + pMaster->SetBorder(rOldMaster.GetLeftBorder(), + rOldMaster.GetUpperBorder(), + rOldMaster.GetRightBorder(), + rOldMaster.GetLowerBorder()); + pMaster->SetOrientation( rOldMaster.GetOrientation() ); + pMaster->SetAutoLayout(pMaster->GetAutoLayout()); + + aSize = rOldNotesMaster.GetSize(); + ::tools::Rectangle aNotesBorderRect(rOldNotesMaster.GetLeftBorder(), + rOldNotesMaster.GetUpperBorder(), + rOldNotesMaster.GetRightBorder(), + rOldNotesMaster.GetLowerBorder()); + pNotesMaster->ScaleObjects(aSize, aNotesBorderRect, true); + pNotesMaster->SetSize(aSize); + pNotesMaster->SetBorder(rOldNotesMaster.GetLeftBorder(), + rOldNotesMaster.GetUpperBorder(), + rOldNotesMaster.GetRightBorder(), + rOldNotesMaster.GetLowerBorder()); + pNotesMaster->SetOrientation( rOldNotesMaster.GetOrientation() ); + pNotesMaster->SetAutoLayout(pNotesMaster->GetAutoLayout()); + + if( (pSourceDoc->GetDocumentType() == DocumentType::Impress) && + (GetDocumentType() == DocumentType::Draw) ) + { + pMaster->RemoveEmptyPresentationObjects(); + pNotesMaster->RemoveEmptyPresentationObjects(); + } + } + } + else + { + // Find a new name for the layout + OUString aName(createNewMasterPageLayoutName(*this)); + OUString aPageLayoutName(aName + SD_LT_SEPARATOR + STR_LAYOUT_OUTLINE); + + // Generate new stylesheets + static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutStyleSheets(aName); + SdStyleSheetVector aCreatedStyles; + static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutSheetList(aName, aCreatedStyles); + + if( bUndo ) + { + StyleSheetCopyResultVector aUndoInsert; + aUndoInsert.reserve(aCreatedStyles.size()); + for (const auto& a : aCreatedStyles) + aUndoInsert.emplace_back(a.get(), true); + pUndoMgr->AddUndoAction(std::make_unique<SdMoveStyleSheetsUndoAction>(this, aUndoInsert, true)); + // Generate new master pages and register them with the document + BegUndo(); + } + + pMaster = AllocSdPage(true); + pMaster->SetSize(pSelectedPage->GetSize()); + pMaster->SetBorder(pSelectedPage->GetLeftBorder(), + pSelectedPage->GetUpperBorder(), + pSelectedPage->GetRightBorder(), + pSelectedPage->GetLowerBorder() ); + pMaster->SetName(aName); + pMaster->SetLayoutName(aPageLayoutName); + InsertMasterPage(pMaster.get()); + + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pMaster)); + + pMaster->SetAutoLayout(AUTOLAYOUT_NONE, true, true); + + pNotesMaster = AllocSdPage(true); + pNotesMaster->SetPageKind(PageKind::Notes); + pNotesMaster->SetSize(pNotes->GetSize()); + pNotesMaster->SetBorder(pNotes->GetLeftBorder(), + pNotes->GetUpperBorder(), + pNotes->GetRightBorder(), + pNotes->GetLowerBorder() ); + pNotesMaster->SetName(aName); + pNotesMaster->SetLayoutName(aPageLayoutName); + InsertMasterPage(pNotesMaster.get()); + + if( bUndo ) + AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pNotesMaster)); + + pNotesMaster->SetAutoLayout(AUTOLAYOUT_NOTES, true, true); + + if( bUndo ) + EndUndo(); + + // Create a list of affected default and notes pages + std::vector<SdPage*> aPageList; + if (bMaster) + { + for (sal_uInt16 nPage = 1; nPage < GetPageCount(); nPage++) + { + SdPage* pPage = static_cast<SdPage*>( GetPage(nPage) ); + if (pPage->GetLayoutName() == aOldPageLayoutName) + { + aPageList.push_back(pPage); + } + } + } + else + { + aPageList.push_back(pSelectedPage); + aPageList.push_back(pNotes); + } + + // Set presentation layout and AutoLayout for the affected pages + for ( auto& rpPage : aPageList ) + { + AutoLayout eOldAutoLayout = rpPage->GetAutoLayout(); + AutoLayout eNewAutoLayout = + rpPage->GetPageKind() == PageKind::Standard ? AUTOLAYOUT_NONE : AUTOLAYOUT_NOTES; + + if( bUndo ) + { + pUndoMgr->AddUndoAction(std::make_unique<SdPresentationLayoutUndoAction> + (this, aOldLayoutName, aName, + eOldAutoLayout, eNewAutoLayout, true, + rpPage)); + } + + rpPage->SetPresentationLayout(aName); + rpPage->SetAutoLayout(eNewAutoLayout); + } + } + + // If the old master pages aren't used anymore, they and their styles have + // to be removed. + if (bCheckMasters) + { + // Check all + RemoveUnnecessaryMasterPages(); + } + else + { + // Check only the master page that was replaced + RemoveUnnecessaryMasterPages(&rOldMaster); + } + + if( bUndo ) + pUndoMgr->LeaveListAction(); + + if( mpDocSh ) + mpDocSh->SetWaitCursor( false ); +} + +void SdDrawDocument::Merge(SdrModel& rSourceModel, + sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum, + sal_uInt16 nDestPos, + bool bMergeMasterPages, bool bAllMasterPages, + bool bUndo, bool bTreadSourceAsConst) +{ + sal_uInt16 nMasterPageCount = GetMasterPageCount(); + SdrModel::Merge( rSourceModel, nFirstPageNum, nLastPageNum, nDestPos, bMergeMasterPages, bAllMasterPages, bUndo, bTreadSourceAsConst ); + + // add style family for each new master page + for( sal_uInt16 nMaster = nMasterPageCount; nMaster < GetMasterPageCount(); nMaster++ ) + { + SdPage* pPage = static_cast< SdPage* >( GetMasterPage( nMaster ) ); + if( pPage && pPage->IsMasterPage() && (pPage->GetPageKind() == PageKind::Standard) ) + { + // new master page created, add its style family + SdStyleSheetPool* pStylePool = static_cast<SdStyleSheetPool*>( GetStyleSheetPool() ); + if( pStylePool ) + pStylePool->AddStyleFamily( pPage ); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |