Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sd / source / core / drawdoc3.cxx
blob: 7b5df1c46581e2ca0e7674680092ee911d397f83 [file] [log] [blame]
/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include "comphelper/anytostring.hxx"
#include "cppuhelper/exc_hlp.hxx"
#include <utility>
#include <algorithm>
#include <vcl/wrkwin.hxx>
#include <sfx2/docfile.hxx>
#include <sot/storage.hxx>
#include <sfx2/app.hxx>
#include <svl/itemset.hxx>
#include <unotools/ucbstreamhelper.hxx>
#include <sfx2/fcontnr.hxx>
#include <svx/svdopath.hxx>
#include <svx/svditer.hxx>
#include <svl/style.hxx>
#include <sfx2/linkmgr.hxx>
#include <svx/svdpagv.hxx>
#include <svx/svdogrp.hxx>
#include <svx/svdundo.hxx>
#include <vcl/msgbox.hxx>
#include <sot/storage.hxx>
#include <sot/formats.hxx>
#include <set>
#include <boost/bind.hpp>
#include "glob.hrc"
#include "drawdoc.hxx"
#include "sdpage.hxx"
#include "stlpool.hxx"
#include "sdresid.hxx"
#include "sdiocmpt.hxx"
#include "strmname.h"
#include "anminfo.hxx"
#include "../ui/inc/unmovss.hxx"
#include "../ui/inc/unchss.hxx"
#include "../ui/inc/unprlout.hxx"
#include "../ui/inc/DrawDocShell.hxx"
#include "../ui/inc/GraphicDocShell.hxx"
#include "../ui/inc/ViewShell.hxx"
#include "../ui/inc/View.hxx"
#include "../ui/inc/cfgids.hxx"
#include "../ui/inc/strings.hrc"
using namespace ::com::sun::star;
#define POOL_BUFFER_SIZE (sal_uInt16)32768
#define BASIC_BUFFER_SIZE (sal_uInt16)8192
#define DOCUMENT_BUFFER_SIZE (sal_uInt16)32768
/*************************************************************************
|*
|* Oeffnet ein Bookmark-Dokument
|*
\************************************************************************/
/*
SdStorageListener : public BaseImplHelper1 < lang::XEventListener >
{
uno::Reference < embed::XStorage >& xStor;
public:
SdStorageListener ( uno::Reference < embed::XStorage >& rStor )
: xStor( rStor )
{}
void disposing ( const lang::EventObject& aEvent ) throw ( uno::RuntimeException );
};
void SdStorageListener::disposing( const lang::EventObject& aEvent ) throw ( uno::RuntimeException )
{
xStor = NULL;
}*/
SdDrawDocument* SdDrawDocument::OpenBookmarkDoc(SfxMedium& rMedium)
{
sal_Bool bOK = sal_True;
SdDrawDocument* pBookmarkDoc = NULL;
String aBookmarkName = rMedium.GetName();
const SfxFilter* pFilter = rMedium.GetFilter();
if ( !pFilter )
{
rMedium.UseInteractionHandler( sal_True );
SFX_APP()->GetFilterMatcher().GuessFilter( rMedium, &pFilter );
}
if ( !pFilter )
{
bOK = sal_False;
}
else if ( maBookmarkFile != aBookmarkName && aBookmarkName.Len() )
{
sal_Bool bCreateGraphicShell = pFilter->GetServiceName().EqualsAscii( "com.sun.star.drawing.DrawingDocument" );
sal_Bool bCreateImpressShell = pFilter->GetServiceName().EqualsAscii( "com.sun.star.presentation.PresentationDocument" );
if ( bCreateGraphicShell || bCreateImpressShell )
{
CloseBookmarkDoc();
// Es wird eine DocShell erzeugt, da in dem Dokument OLE-Objekte
// enthalten sein koennten (Persist)
// Wenn dem nicht so waere, so koennte man auch das Model
// direkt laden
if ( bCreateGraphicShell )
// Draw
mxBookmarkDocShRef = new ::sd::GraphicDocShell(SFX_CREATE_MODE_STANDARD, sal_True);
else
// Impress
mxBookmarkDocShRef = new ::sd::DrawDocShell(SFX_CREATE_MODE_STANDARD, sal_True);
bOK = mxBookmarkDocShRef->DoLoad(&rMedium);
if( bOK )
{
maBookmarkFile = aBookmarkName;
pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
}
}
}
DBG_ASSERT(aBookmarkName.Len(), "Empty document name!");
if (!bOK)
{
ErrorBox aErrorBox( NULL, (WinBits)WB_OK, String(SdResId(STR_READ_DATA_ERROR)));
aErrorBox.Execute();
CloseBookmarkDoc();
pBookmarkDoc = NULL;
}
else if (mxBookmarkDocShRef.Is())
{
pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
}
return(pBookmarkDoc);
}
/*************************************************************************
|*
|* Oeffnet ein Bookmark-Dokument
|*
\************************************************************************/
SdDrawDocument* SdDrawDocument::OpenBookmarkDoc(const String& rBookmarkFile)
{
SdDrawDocument* pBookmarkDoc = NULL;
if (maBookmarkFile != rBookmarkFile && rBookmarkFile.Len())
{
SfxMedium* pMedium = new SfxMedium( rBookmarkFile, STREAM_READ, sal_False );
pBookmarkDoc = OpenBookmarkDoc(*pMedium);
}
else if (mxBookmarkDocShRef.Is())
{
pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
}
return(pBookmarkDoc);
}
/*************************************************************************
|*
|* Fuegt ein Bookmark (Seite oder Objekt) ein
|*
\************************************************************************/
sal_Bool SdDrawDocument::InsertBookmark(
List* pBookmarkList, // Liste der Namen der einzufuegenden Bookmarks
List* pExchangeList, // Liste der zu verwendenen Namen
sal_Bool bLink, // Bookmarks sollen als Verknuepfung eingefuegt werden
sal_Bool bReplace, // Aktuellen Seiten (Standard&Notiz) werden ersetzt
sal_uInt16 nInsertPos, // Einfuegeposition fuer Seiten
sal_Bool bNoDialogs, // Keine Dialoge anzeigen
::sd::DrawDocShell* pBookmarkDocSh, // Wenn gesetzt, so ist dieses das Source-Dokument
sal_Bool bCopy, // Seiten werden kopiert
Point* pObjPos) // Einfuegeposition fuer Objekte
{
sal_Bool bOK = sal_True;
sal_Bool bInsertPages = sal_False;
if (!pBookmarkList)
{
/**********************************************************************
* Alle Seiten werden eingefuegt
**********************************************************************/
bInsertPages = sal_True;
}
else
{
SdDrawDocument* pBookmarkDoc = NULL;
String aBookmarkName;
if (pBookmarkDocSh)
{
pBookmarkDoc = pBookmarkDocSh->GetDoc();
aBookmarkName = pBookmarkDocSh->GetMedium()->GetName();
}
else if ( mxBookmarkDocShRef.Is() )
{
pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
aBookmarkName = maBookmarkFile;
}
else
bOK = sal_False;
for (sal_uInt16 nPos = 0; bOK && ( nPos < pBookmarkList->Count() ) && !bInsertPages; nPos++)
{
/******************************************************************
* Gibt es in der Bookmark-Liste einen Seitennamen?
******************************************************************/
String aBMPgName (*(String*) pBookmarkList->GetObject(nPos));
sal_Bool bIsMasterPage;
if( pBookmarkDoc->GetPageByName( aBMPgName, bIsMasterPage ) != SDRPAGE_NOTFOUND )
{
// Seite gefunden
bInsertPages = sal_True;
}
}
}
if ( bOK && bInsertPages )
{
// Zuerst werden alle Seiten-Bookmarks eingefuegt
bOK = InsertBookmarkAsPage(pBookmarkList, pExchangeList, bLink, bReplace,
nInsertPos, bNoDialogs, pBookmarkDocSh, bCopy, sal_True, sal_False);
}
if ( bOK && pBookmarkList )
{
// Es werden alle Objekt-Bookmarks eingefuegt
bOK = InsertBookmarkAsObject(pBookmarkList, pExchangeList, bLink,
pBookmarkDocSh, pObjPos);
}
return bOK;
}
/*************************************************************************
|*
|* Fuegt ein Bookmark als Seite ein
|*
\************************************************************************/
/** Concrete incarnations get called by IterateBookmarkPages, for
every page in the bookmark document/list
*/
class SdDrawDocument::InsertBookmarkAsPage_PageFunctorBase
{
public:
virtual ~InsertBookmarkAsPage_PageFunctorBase() = 0;
virtual void operator()( SdDrawDocument&, SdPage* ) = 0;
};
SdDrawDocument::InsertBookmarkAsPage_PageFunctorBase::~InsertBookmarkAsPage_PageFunctorBase()
{
}
void SdDrawDocument::IterateBookmarkPages( SdDrawDocument* pBookmarkDoc, List* pBookmarkList, sal_uInt16 nBMSdPageCount,
SdDrawDocument::InsertBookmarkAsPage_PageFunctorBase& rPageIterator )
{
//
// #96029# Refactored copy'n'pasted layout name collection from InsertBookmarkAsPage
//
int nPos, nEndPos;
if( !pBookmarkList )
{
// no list? whole source document
nEndPos = nBMSdPageCount;
}
else
{
// bookmark list? number of entries
nEndPos = pBookmarkList->Count();
}
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 = NULL;
if( !pBookmarkList )
{
// simply take master page of nPos'th page in source document
pBMMPage = (SdPage*)(&(pBookmarkDoc->GetSdPage((sal_uInt16)nPos, PK_STANDARD)->TRG_GetMasterPage()));
}
else
{
// fetch nPos'th entry from bookmark list, and determine master page
String aBMPgName (*(String*) pBookmarkList->GetObject(nPos));
sal_Bool bIsMasterPage;
sal_uInt16 nBMPage = pBookmarkDoc->GetPageByName( aBMPgName, bIsMasterPage );
if (nBMPage != SDRPAGE_NOTFOUND)
{
pBMPage = (SdPage*) pBookmarkDoc->GetPage(nBMPage);
}
else
{
pBMPage = NULL;
}
// enforce that bookmarked page is a standard page and not already a master page
if (pBMPage && pBMPage->GetPageKind()==PK_STANDARD && !pBMPage->IsMasterPage())
{
const sal_uInt16 nBMSdPage = (nBMPage - 1) / 2;
pBMMPage = (SdPage*) (&(pBookmarkDoc->GetSdPage(nBMSdPage, PK_STANDARD)->TRG_GetMasterPage()));
}
}
// successfully determined valid (bookmarked) page?
if( pBMMPage )
{
// yes, call functor
rPageIterator( *this, pBMMPage );
}
}
}
class InsertBookmarkAsPage_FindDuplicateLayouts : public SdDrawDocument::InsertBookmarkAsPage_PageFunctorBase
{
public:
InsertBookmarkAsPage_FindDuplicateLayouts( List* pLayoutsToTransfer, SdDrawDocument* pBookmarkDoc,
List* pBookmarkList, sal_uInt16 nBMSdPageCount ) :
mpLayoutsToTransfer(pLayoutsToTransfer), mpBookmarkDoc(pBookmarkDoc),
mpBookmarkList(pBookmarkList), mnBMSdPageCount(nBMSdPageCount) {}
virtual ~InsertBookmarkAsPage_FindDuplicateLayouts() {};
virtual void operator()( SdDrawDocument&, SdPage* );
private:
List* mpLayoutsToTransfer;
SdDrawDocument* mpBookmarkDoc;
List* mpBookmarkList;
sal_uInt16 mnBMSdPageCount;
};
void InsertBookmarkAsPage_FindDuplicateLayouts::operator()( SdDrawDocument& rDoc, SdPage* pBMMPage )
{
// now check for duplicate masterpage and layout names
// ===================================================
String sFullLayoutName( pBMMPage->GetLayoutName() );
String* pLayout = new String(sFullLayoutName);
pLayout->Erase( pLayout->SearchAscii( SD_LT_SEPARATOR ));
String* pTest = (String*) mpLayoutsToTransfer->First();
sal_Bool bFound = sal_False;
while (pTest && !bFound) // found yet?
{
if (*pLayout == *pTest)
bFound = sal_True;
else
pTest = (String*)mpLayoutsToTransfer->Next();
}
const sal_uInt16 nMPageCount = rDoc.GetMasterPageCount();
for (sal_uInt16 nMPage = 0; nMPage < nMPageCount && !bFound; nMPage++)
{
/**************************************************************
* Gibt es die Layouts schon im Dokument?
**************************************************************/
SdPage* pTestPage = (SdPage*) rDoc.GetMasterPage(nMPage);
String aTest(pTestPage->GetLayoutName());
aTest.Erase( aTest.SearchAscii( SD_LT_SEPARATOR ));
if (aTest == *pLayout)
bFound = sal_True;
}
if (!bFound)
mpLayoutsToTransfer->Insert(pLayout, LIST_APPEND);
else
delete pLayout;
}
/** Just add one page to the container given to the constructor.
*/
class InsertBookmarkAsPage_AddBookmarkedPages
: public SdDrawDocument::InsertBookmarkAsPage_PageFunctorBase
{
public:
InsertBookmarkAsPage_AddBookmarkedPages(::std::vector<SdPage*>& rContainer)
: mrContainer(rContainer) {}
~InsertBookmarkAsPage_AddBookmarkedPages(void) {}
void operator() (SdDrawDocument&, SdPage* pPage) { mrContainer.push_back(pPage); }
private:
::std::vector<SdPage*>& mrContainer;
};
sal_Bool SdDrawDocument::InsertBookmarkAsPage(
List* pBookmarkList,
List* pExchangeList, // Liste der zu verwendenen Namen
sal_Bool bLink,
sal_Bool bReplace,
sal_uInt16 nInsertPos,
sal_Bool bNoDialogs,
::sd::DrawDocShell* pBookmarkDocSh,
sal_Bool bCopy,
sal_Bool bMergeMasterPages,
sal_Bool bPreservePageNames)
{
sal_Bool bOK = sal_True;
sal_Bool bContinue = sal_True;
sal_Bool bScaleObjects = sal_False;
sal_uInt16 nReplacedStandardPages = 0;
SdDrawDocument* pBookmarkDoc = NULL;
String aBookmarkName;
if (pBookmarkDocSh)
{
pBookmarkDoc = pBookmarkDocSh->GetDoc();
if (pBookmarkDocSh->GetMedium())
{
aBookmarkName = pBookmarkDocSh->GetMedium()->GetName();
}
}
else if ( mxBookmarkDocShRef.Is() )
{
pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
aBookmarkName = maBookmarkFile;
}
else
{
return sal_False;
}
const sal_uInt16 nSdPageCount = GetSdPageCount(PK_STANDARD);
const sal_uInt16 nBMSdPageCount = pBookmarkDoc->GetSdPageCount(PK_STANDARD);
const sal_uInt16 nMPageCount = GetMasterPageCount();
if (nSdPageCount==0 || nBMSdPageCount==0 || nMPageCount==0)
{
bContinue = bOK = sal_False;
return(bContinue);
}
// 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, PK_STANDARD);
Size aSize(pRefPage->GetSize());
sal_Int32 nLeft = pRefPage->GetLftBorder();
sal_Int32 nRight = pRefPage->GetRgtBorder();
sal_Int32 nUpper = pRefPage->GetUppBorder();
sal_Int32 nLower = pRefPage->GetLwrBorder();
Orientation eOrient = pRefPage->GetOrientation();
SdPage* pNPage = GetSdPage(0, PK_NOTES);
Size aNSize(GetSdPage(0, PK_NOTES)->GetSize());
sal_Int32 nNLeft = pNPage->GetLftBorder();
sal_Int32 nNRight = pNPage->GetRgtBorder();
sal_Int32 nNUpper = pNPage->GetUppBorder();
sal_Int32 nNLower = pNPage->GetLwrBorder();
Orientation eNOrient = pRefPage->GetOrientation();
// Seitengroesse und -raender an die Werte der letzten
// Seiten anpassen?
pRefPage = GetSdPage(nSdPageCount - 1, PK_STANDARD);
if( bNoDialogs )
{
if( !pBookmarkList )
bScaleObjects = pRefPage->IsScaleObjects();
else
bScaleObjects = sal_True;
}
else
{
SdPage* pBMPage = pBookmarkDoc->GetSdPage(0,PK_STANDARD);
if (pBMPage->GetSize() != pRefPage->GetSize() ||
pBMPage->GetLftBorder() != pRefPage->GetLftBorder() ||
pBMPage->GetRgtBorder() != pRefPage->GetRgtBorder() ||
pBMPage->GetUppBorder() != pRefPage->GetUppBorder() ||
pBMPage->GetLwrBorder() != pRefPage->GetLwrBorder())
{
String aStr(SdResId(STR_SCALE_OBJECTS));
sal_uInt16 nBut = QueryBox( NULL, WB_YES_NO_CANCEL, aStr).Execute();
bScaleObjects = nBut == RET_YES;
bContinue = nBut != RET_CANCEL;
if (!bContinue)
{
return(bContinue);
}
}
}
/**************************************************************************
|* Die benoetigten Praesentations-StyleSheets ermitteln und vor
|* den Seiten transferieren, sonst verlieren die Textobjekte
|* beim Transfer den Bezug zur Vorlage
\*************************************************************************/
::svl::IUndoManager* pUndoMgr = NULL;
if( mpDocSh )
{
pUndoMgr = mpDocSh->GetUndoManager();
pUndoMgr->EnterListAction(String(SdResId(STR_UNDO_INSERTPAGES)), String());
}
List* pLayoutsToTransfer = new List;
//
// #96029# Refactored copy'n'pasted layout name collection into IterateBookmarkPages
//
InsertBookmarkAsPage_FindDuplicateLayouts aSearchFunctor( pLayoutsToTransfer, pBookmarkDoc,
pBookmarkList, nBMSdPageCount );
IterateBookmarkPages( pBookmarkDoc, pBookmarkList, nBMSdPageCount, aSearchFunctor );
/**************************************************************************
* Die tatsaechlich benoetigten Vorlagen kopieren
**************************************************************************/
SdStyleSheetPool* pBookmarkStyleSheetPool =
(SdStyleSheetPool*) pBookmarkDoc->GetStyleSheetPool();
String* pLayout = (String*) pLayoutsToTransfer->First();
// Wenn Vorlagen kopiert werden muessen, dann muessen auch die
// MasterPages kopiert werden!
if( pLayout )
bMergeMasterPages = sal_True;
while (pLayout)
{
SdStyleSheetVector aCreatedStyles;
((SdStyleSheetPool*)GetStyleSheetPool())->CopyLayoutSheets(*pLayout, *pBookmarkStyleSheetPool,aCreatedStyles);
if(!aCreatedStyles.empty())
{
if( pUndoMgr )
{
SdMoveStyleSheetsUndoAction* pMovStyles = new SdMoveStyleSheetsUndoAction(this, aCreatedStyles, sal_True);
pUndoMgr->AddUndoAction(pMovStyles);
}
}
delete pLayout;
pLayout = (String*)pLayoutsToTransfer->Next();
}
delete pLayoutsToTransfer;
/**************************************************************************
* Dokument einfuegen
**************************************************************************/
const bool bUndo = IsUndoEnabled();
if( bUndo )
BegUndo(String(SdResId(STR_UNDO_INSERTPAGES)));
if (!pBookmarkList)
{
if (nInsertPos >= GetPageCount())
{
// Seiten werden hinten angefuegt
nInsertPos = GetPageCount();
}
sal_uInt16 nActualInsertPos = nInsertPos;
List aNameList;
std::set<sal_uInt16> aRenameSet;
sal_uInt16 nBMSdPage;
for (nBMSdPage=0; nBMSdPage < nBMSdPageCount; nBMSdPage++)
{
SdPage* pBMPage = pBookmarkDoc->GetSdPage(nBMSdPage, PK_STANDARD);
String pName( pBMPage->GetName() );
sal_Bool bIsMasterPage;
if (bLink)
{
// Es werden sich die Namen aller Seiten gemerkt
aNameList.Insert(new String(pName), nBMSdPage);
}
// #95677# Have to check for duplicate names here, too
// #67905# don't change name if source and dest model are the same!
if( pBookmarkDoc != this &&
GetPageByName(pName, bIsMasterPage ) != SDRPAGE_NOTFOUND )
{
// #95991# delay renaming *after* pages are copied (might destroy source otherwise)
aRenameSet.insert(nBMSdPage);
}
}
Merge(*pBookmarkDoc,
1, // Nicht die Handzettelseite
0xFFFF, // Aber alle anderen
nActualInsertPos, // An Position einfuegen
bMergeMasterPages, // MasterPages mitnehmen
sal_False, // Aber nur die benoetigten MasterPages
sal_True, // Undo-Aktion erzeugen
bCopy); // Seiten kopieren (oder mergen)
for (nBMSdPage=0; nBMSdPage < nBMSdPageCount; nBMSdPage++)
{
SdPage* pPage = (SdPage*) GetPage(nActualInsertPos);
SdPage* pNotesPage = (SdPage*) GetPage(nActualInsertPos+1);
String* pName = (String*) aNameList.GetObject(nBMSdPage);
// #95991# delay renaming *after* pages are copied (might destroy source otherwise)
if( aRenameSet.find(nBMSdPage) != aRenameSet.end() )
{
// Seitenname schon vorhanden -> Defaultname
// fuer Standard & Notizseite
pPage->SetName(String());
pNotesPage->SetName(String());
}
if (bLink)
{
// Nun werden die Link-Namen zusammengestellt
pPage->SetFileName(aBookmarkName);
pPage->SetBookmarkName(*(pName));
delete pName;
pPage->SetModel(this);
}
nActualInsertPos += 2;
}
}
else
{
/**********************************************************************
* Ausgewaehlte Seiten einfuegen
**********************************************************************/
SdPage* pBMPage;
if (nInsertPos >= GetPageCount())
{
// Seiten werden hinten angefuegt
bReplace = sal_False;
nInsertPos = GetPageCount();
}
sal_uInt16 nActualInsertPos = nInsertPos;
// Collect the bookmarked pages.
::std::vector<SdPage*> aBookmarkedPages (pBookmarkList->Count(), NULL);
for (sal_uInt16 nPos = 0; nPos < pBookmarkList->Count(); nPos++)
{
String aPgName(*(String*) pBookmarkList->GetObject(nPos));
sal_Bool bIsMasterPage;
sal_uInt16 nBMPage = pBookmarkDoc->GetPageByName( aPgName, bIsMasterPage );
if (nBMPage != SDRPAGE_NOTFOUND)
{
aBookmarkedPages[nPos] = dynamic_cast<SdPage*>(pBookmarkDoc->GetPage(nBMPage));
}
}
for (sal_uInt16 nPos = 0; nPos < pBookmarkList->Count(); nPos++)
{
pBMPage = aBookmarkedPages[nPos];
sal_uInt16 nBMPage = pBMPage!=NULL ? pBMPage->GetPageNum() : SDRPAGE_NOTFOUND;
if (pBMPage && pBMPage->GetPageKind()==PK_STANDARD && !pBMPage->IsMasterPage())
{
/**************************************************************
* Es muss eine StandardSeite sein
**************************************************************/
sal_Bool bMustRename = sal_False;
// #95991# delay renaming *after* pages are copied (might destroy source otherwise)
// #67905# don't change name if source and dest model are the same!
// #96029# avoid renaming if replacing the same page
String aPgName(*(String*) pBookmarkList->GetObject(nPos));
sal_Bool bIsMasterPage;
sal_uInt16 nPageSameName = GetPageByName(aPgName, bIsMasterPage);
if( pBookmarkDoc != this &&
nPageSameName != SDRPAGE_NOTFOUND &&
( !bReplace ||
nPageSameName != nActualInsertPos ) )
{
bMustRename = sal_True;
}
SdPage* pBookmarkPage = pBMPage;
if (bReplace )
{
ReplacePageInCustomShows( dynamic_cast< SdPage* >( GetPage( nActualInsertPos ) ), pBookmarkPage );
}
Merge(*pBookmarkDoc,
nBMPage, // Von Seite (Standard)
nBMPage+1, // Bis Seite (Notizen)
nActualInsertPos, // An Position einfuegen
bMergeMasterPages, // MasterPages mitnehmen
sal_False, // Aber nur die benoetigten MasterPages
sal_True, // Undo-Aktion erzeugen
bCopy); // Seiten kopieren (oder mergen)
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 ) ) );
}
}
if( bMustRename )
{
// Seitenname schon vorhanden -> Defaultname
// fuer Standard & Notizseite
SdPage* pPage = (SdPage*) GetPage(nActualInsertPos);
pPage->SetName(String());
SdPage* pNotesPage = (SdPage*) GetPage(nActualInsertPos+1);
pNotesPage->SetName(String());
}
if (bLink)
{
SdPage* pPage = (SdPage*) GetPage(nActualInsertPos);
pPage->SetFileName(aBookmarkName);
pPage->SetBookmarkName(aPgName);
pPage->SetModel(this);
}
if (bReplace)
{
// Seite & Notizseite ausfuegen
const sal_uInt16 nDestPageNum(nActualInsertPos + 2);
SdPage* pStandardPage = 0L;
if(nDestPageNum < GetPageCount())
{
pStandardPage = (SdPage*)GetPage(nDestPageNum);
}
if (pStandardPage)
{
if( bPreservePageNames )
{
// #96029# Take old slide names for inserted pages
SdPage* pPage = (SdPage*) GetPage(nActualInsertPos);
pPage->SetName( pStandardPage->GetRealName() );
}
if( bUndo )
AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pStandardPage));
RemovePage(nDestPageNum);
if( !bUndo )
delete pStandardPage;
}
SdPage* pNotesPage = 0L;
if(nDestPageNum < GetPageCount())
{
pNotesPage = (SdPage*)GetPage(nDestPageNum);
}
if (pNotesPage)
{
if( bPreservePageNames )
{
// #96029# Take old slide names for inserted pages
SdPage* pNewNotesPage = (SdPage*) GetPage(nActualInsertPos+1);
if( pNewNotesPage )
pNewNotesPage->SetName( pStandardPage->GetRealName() );
}
if( bUndo )
AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pNotesPage));
RemovePage(nDestPageNum);
if( !bUndo )
delete pNotesPage;
}
nReplacedStandardPages++;
}
nActualInsertPos += 2;
}
}
}
/**************************************************************************
|* Dabei sind evtl. zu viele Masterpages ruebergekommen, da die
|* DrawingEngine gleiche Praesentationslayouts nicht erkennen kann.
|* Ueberzaehlige MasterPages entfernen.
\*************************************************************************/
sal_uInt16 nNewMPageCount = GetMasterPageCount();
// rueckwaerts, damit Nummern nicht durcheinander geraten
for (sal_uInt16 nPage = nNewMPageCount - 1; nPage >= nMPageCount; nPage--)
{
pRefPage = (SdPage*) GetMasterPage(nPage);
String aMPLayout(pRefPage->GetLayoutName());
PageKind eKind = pRefPage->GetPageKind();
// gibt's den schon?
for (sal_uInt16 nTest = 0; nTest < nMPageCount; nTest++)
{
SdPage* pTest = (SdPage*) GetMasterPage(nTest);
String aTest(pTest->GetLayoutName());
// #96029# 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);
if( !bUndo )
delete pRefPage;
nNewMPageCount--;
break;
}
}
}
// #96029# nInsertPos > 2 is always true when inserting into non-empty models
if (nInsertPos > 0)
{
sal_uInt16 nSdPageStart = (nInsertPos - 1) / 2;
sal_uInt16 nSdPageEnd = GetSdPageCount(PK_STANDARD) - nSdPageCount +
nSdPageStart - 1;
const bool bRemoveEmptyPresObj = pBookmarkDoc &&
(pBookmarkDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) &&
(GetDocumentType() == DOCUMENT_TYPE_DRAW);
if( bReplace )
{
nSdPageEnd = nSdPageStart + nReplacedStandardPages - 1;
}
for (sal_uInt16 nSdPage = nSdPageStart; nSdPage <= nSdPageEnd; nSdPage++)
{
pRefPage = GetSdPage(nSdPage, PK_STANDARD);
if (pExchangeList)
{
// Zuverwendener Name aus Exchange-Liste holen
if (pExchangeList->GetCurObject())
{
String aExchangeName (*(String*) pExchangeList->GetCurObject());
pRefPage->SetName(aExchangeName);
SdrHint aHint(HINT_PAGEORDERCHG);
aHint.SetPage(pRefPage);
Broadcast(aHint);
SdPage* pNewNotesPage = GetSdPage(nSdPage, PK_NOTES);
pNewNotesPage->SetName(aExchangeName);
aHint.SetPage(pNewNotesPage);
Broadcast(aHint);
}
pExchangeList->Next();
}
String aLayout(pRefPage->GetLayoutName());
aLayout.Erase(aLayout.SearchAscii( SD_LT_SEPARATOR ));
// update layout and referred master page
pRefPage->SetPresentationLayout(aLayout);
if( bUndo )
AddUndo( GetSdrUndoFactory().CreateUndoPageChangeMasterPage( *pRefPage ) );
if (bScaleObjects)
{
Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
pRefPage->ScaleObjects(aSize, aBorderRect, sal_True);
}
pRefPage->SetSize(aSize);
pRefPage->SetBorder(nLeft, nUpper, nRight, nLower);
pRefPage->SetOrientation( eOrient );
if( bRemoveEmptyPresObj )
pRefPage->RemoveEmptyPresentationObjects();
pRefPage = GetSdPage(nSdPage, PK_NOTES);
// update layout and referred master page
pRefPage->SetPresentationLayout(aLayout);
if( bUndo )
AddUndo( GetSdrUndoFactory().CreateUndoPageChangeMasterPage( *pRefPage ) );
if (bScaleObjects)
{
Rectangle aBorderRect(nNLeft, nNUpper, nNRight, nNLower);
pRefPage->ScaleObjects(aNSize, aBorderRect, sal_True);
}
pRefPage->SetSize(aNSize);
pRefPage->SetBorder(nNLeft, nNUpper, nNRight, nNLower);
pRefPage->SetOrientation( eNOrient );
if( bRemoveEmptyPresObj )
pRefPage->RemoveEmptyPresentationObjects();
}
for (sal_uInt16 nPage = nMPageCount; nPage < nNewMPageCount; nPage++)
{
pRefPage = (SdPage*) GetMasterPage(nPage);
if (pRefPage->GetPageKind() == PK_STANDARD)
{
if (bScaleObjects)
{
Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
pRefPage->ScaleObjects(aSize, aBorderRect, sal_True);
}
pRefPage->SetSize(aSize);
pRefPage->SetBorder(nLeft, nUpper, nRight, nLower);
pRefPage->SetOrientation( eOrient );
}
else // kann nur noch NOTES sein
{
if (bScaleObjects)
{
Rectangle aBorderRect(nNLeft, nNUpper, nNRight, nNLower);
pRefPage->ScaleObjects(aNSize, aBorderRect, sal_True);
}
pRefPage->SetSize(aNSize);
pRefPage->SetBorder(nNLeft, nNUpper, nNRight, nNLower);
pRefPage->SetOrientation( eNOrient );
}
if( bRemoveEmptyPresObj )
pRefPage->RemoveEmptyPresentationObjects();
}
}
// #91146# Make absolutely sure no double masterpages are there
RemoveUnnecessaryMasterPages(NULL, sal_True, sal_True);
if( bUndo )
EndUndo();
pUndoMgr->LeaveListAction();
return bContinue;
}
/*************************************************************************
|*
|* Fuegt ein Bookmark als Objekt ein
|*
\************************************************************************/
sal_Bool SdDrawDocument::InsertBookmarkAsObject(
List* pBookmarkList,
List* pExchangeList, // Liste der zu verwendenen Namen
sal_Bool /* bLink */,
::sd::DrawDocShell* pBookmarkDocSh,
Point* pObjPos)
{
sal_Bool bOK = sal_True;
sal_Bool bOLEObjFound = sal_False;
::sd::View* pBMView = NULL;
SdDrawDocument* pBookmarkDoc = NULL;
String aBookmarkName;
if (pBookmarkDocSh)
{
pBookmarkDoc = pBookmarkDocSh->GetDoc();
if (pBookmarkDocSh->GetMedium())
{
aBookmarkName = pBookmarkDocSh->GetMedium()->GetName();
}
}
else if ( mxBookmarkDocShRef.Is() )
{
pBookmarkDoc = mxBookmarkDocShRef->GetDoc();
aBookmarkName = maBookmarkFile;
}
else
{
return sal_False;
}
if (!pBookmarkList)
{
pBMView = new ::sd::View(pBookmarkDoc, (OutputDevice*) NULL);
pBMView->EndListening(*pBookmarkDoc);
pBMView->MarkAll();
}
else
{
SdrPage* pPage;
SdrPageView* pPV;
for (sal_uInt16 nPos = 0; nPos < pBookmarkList->Count(); nPos++)
{
/******************************************************************
* Namen der Bookmarks aus Liste holen
******************************************************************/
String aBMName (*(String*) pBookmarkList->GetObject(nPos));
SdrObject* pObj = pBookmarkDoc->GetObj(aBMName);
if (pObj)
{
// Objekt gefunden
if (pObj->GetObjInventor() == SdrInventor &&
pObj->GetObjIdentifier() == OBJ_OLE2)
{
bOLEObjFound = sal_True;
}
if (!pBMView)
{
// View erstmalig erzeugen
pBMView = new ::sd::View(pBookmarkDoc, (OutputDevice*) NULL);
pBMView->EndListening(*pBookmarkDoc);
}
pPage = pObj->GetPage();
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, sal_False);
}
}
}
if (pBMView)
{
/**********************************************************************
* Selektierte Objekte einfuegen
**********************************************************************/
::sd::View* pView = new ::sd::View(this, (OutputDevice*) NULL);
pView->EndListening(*this);
// Seite bestimmen, auf der die Objekte eingefuegt werden sollen
SdrPage* pPage = GetSdPage(0, PK_STANDARD);
if (mpDocSh)
{
::sd::ViewShell* pViewSh = mpDocSh->GetViewShell();
if (pViewSh)
{
// Welche Seite wird denn aktuell angezeigt?
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 = Rectangle(Point(), pPage->GetSize()).Center();
}
sal_uLong nCountBefore = 0;
if (pExchangeList)
{
// OrdNums sortieren und Anzahl Objekte vor dem Einfuegen bestimmen
pPage->RecalcObjOrdNums();
nCountBefore = pPage->GetObjCount();
}
if (bOLEObjFound)
pBMView->GetDoc()->SetAllocDocSh(sal_True);
SdDrawDocument* pTmpDoc = (SdDrawDocument*) pBMView->GetAllMarkedModel();
bOK = pView->Paste(*pTmpDoc, aObjPos, pPage);
if (bOLEObjFound)
pBMView->GetDoc()->SetAllocDocSh(sal_False);
if (!bOLEObjFound)
delete pTmpDoc; // Wird ansonsten von der DocShell zerstoert
delete pView;
List* pList = pBookmarkList;
if (pExchangeList)
{
// Anzahl Objekte nach dem Einfuegen bestimmen
sal_uLong nCount = pPage->GetObjCount();
for (sal_uLong nObj = nCountBefore; nObj < nCount; nObj++)
{
// Zuverwendener Name aus Exchange-Liste holen
if (pExchangeList->GetCurObject())
{
String aExchangeName (*(String*) pExchangeList->GetCurObject());
if (pPage->GetObj(nObj))
{
pPage->GetObj(nObj)->SetName(aExchangeName);
}
}
pExchangeList->Next();
}
pList = pExchangeList;
}
}
delete pBMView;
return bOK;
}
/*************************************************************************
|*
|* Beendet das Einfuegen von Bookmarks
|*
\************************************************************************/
void SdDrawDocument::CloseBookmarkDoc()
{
if (mxBookmarkDocShRef.Is())
{
mxBookmarkDocShRef->DoClose();
}
mxBookmarkDocShRef.Clear();
maBookmarkFile = String();
}
/*************************************************************************
|*
|* Dokument laden (fuer gelinkte Objekte)
|*
\************************************************************************/
const SdrModel* SdDrawDocument::LoadModel(const String& rFileName)
{
return ( OpenBookmarkDoc(rFileName) );
}
/*************************************************************************
|*
|* Dokument schliessen (fuer gelinkte Objekte)
|*
\************************************************************************/
void SdDrawDocument::DisposeLoadedModels()
{
CloseBookmarkDoc();
}
/*************************************************************************
|*
|* Ist das Dokument read-only?
|*
\************************************************************************/
FASTBOOL SdDrawDocument::IsReadOnly() const
{
return sal_False;
}
/*************************************************************************
|*
|* In anschliessendem AllocModel() wird eine DocShell erzeugt
|* (xAllocedDocShRef). Eine bereits bestehende DocShell wird ggf. geloescht
|*
\************************************************************************/
void SdDrawDocument::SetAllocDocSh(sal_Bool bAlloc)
{
mbAllocDocSh = bAlloc;
if(mxAllocedDocShRef.Is())
{
mxAllocedDocShRef->DoClose();
}
mxAllocedDocShRef.Clear();
}
/*************************************************************************
|*
|* Liste der CustomShows zurueckgeben (ggf. zuerst erzeugen)
|*
\************************************************************************/
List* SdDrawDocument::GetCustomShowList(sal_Bool bCreate)
{
if (!mpCustomShowList && bCreate)
{
// Liste erzeugen
mpCustomShowList = new List();
}
return(mpCustomShowList);
}
/*************************************************************************
|*
|* Document-Stream herausgeben (fuer load-on-demand Graphiken)
|*
\************************************************************************/
SvStream* SdDrawDocument::GetDocumentStream(SdrDocumentStreamInfo& rStreamInfo) const
{
uno::Reference < embed::XStorage > xStor;
if (mpDocSh)
xStor = mpDocSh->GetStorage();
SvStream* pRet = NULL;
if( xStor.is() )
{
//TODO/MBA: binary format removed, needs testing
if( rStreamInfo.maUserData.Len() &&
( rStreamInfo.maUserData.GetToken( 0, ':' ) ==
String( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package" ) ) ) )
{
const String aPicturePath( rStreamInfo.maUserData.GetToken( 1, ':' ) );
// graphic from picture stream in picture storage in XML package
if( aPicturePath.GetTokenCount( '/' ) == 2 ) try
{
const String aPictureStreamName( aPicturePath.GetToken( 1, '/' ) );
const String aPictureStorageName( aPicturePath.GetToken( 0, '/' ) );
if( xStor->isStorageElement( aPictureStorageName ) )
{
uno::Reference < embed::XStorage > xPictureStorage =
xStor->openStorageElement( aPictureStorageName, embed::ElementModes::READ );
try
{
if( xPictureStorage.is() && xPictureStorage->isStreamElement( aPictureStreamName ) )
{
uno::Reference < io::XStream > xStream = xPictureStorage->openStreamElement( aPictureStreamName, embed::ElementModes::READ );
if( xStream.is() )
pRet = ::utl::UcbStreamHelper::CreateStream( xStream );
}
}
catch( container::NoSuchElementException& )
{
}
}
}
catch( uno::Exception& e )
{
(void)e;
DBG_ERROR(
(rtl::OString("sd::SdDrawDocument::GetDocumentStream(), "
"exception caught: ") +
rtl::OUStringToOString(
comphelper::anyToString( cppu::getCaughtException() ),
RTL_TEXTENCODING_UTF8 ) +
rtl::OString("\r\nATTENTION: Graphics may get lost now, please inform CL or KA!") ).getStr() );
}
rStreamInfo.mbDeleteAfterUse = ( pRet != NULL );
}
}
#if OSL_DEBUG_LEVEL > 1
if( pRet )
{
// try to get some information from stream
const sal_uLong nStartPos = pRet->Tell();
const sal_uLong nEndPos = pRet->Seek( STREAM_SEEK_TO_END );
const sal_uLong nStmLen = nEndPos - nStartPos;
sal_uChar aTestByte;
// try to read one byte
if( nStmLen )
*pRet >> aTestByte;
pRet->Seek( nStartPos );
}
#endif
return pRet;
}
/*************************************************************************
|*
|* Nicht benutzte MasterPages und Layouts entfernen
|*
\************************************************************************/
void SdDrawDocument::RemoveUnnecessaryMasterPages(SdPage* pMasterPage, sal_Bool bOnlyDuplicatePages, sal_Bool bUndo)
{
::sd::View* pView = NULL;
::svl::IUndoManager* pUndoMgr = NULL;
if( bUndo && !IsUndoEnabled() )
bUndo = sal_False;
if (mpDocSh)
{
pUndoMgr = mpDocSh->GetUndoManager();
if (mpDocSh->GetViewShell())
pView = mpDocSh->GetViewShell()->GetView();
}
/***********************************************************
* Alle MasterPages pruefen
***********************************************************/
sal_uInt16 nSdMasterPageCount = GetMasterSdPageCount( PK_STANDARD );
for (sal_Int32 nMPage = nSdMasterPageCount - 1; nMPage >= 0; nMPage--)
{
SdPage* pMaster = pMasterPage;
SdPage* pNotesMaster = NULL;
if (!pMaster)
{
pMaster = (SdPage*) GetMasterSdPage( (sal_uInt16) nMPage, PK_STANDARD );
pNotesMaster = (SdPage*) GetMasterSdPage( (sal_uInt16) nMPage, PK_NOTES );
}
else
{
for ( sal_uInt16 nMPg = 0; nMPg < GetMasterPageCount(); nMPg++ )
{
if ( pMaster == GetMasterPage( nMPg ) )
{
pNotesMaster = (SdPage*) GetMasterPage( ++nMPg );
break;
}
}
}
DBG_ASSERT( pMaster->GetPageKind() == PK_STANDARD, "wrong page kind" );
if ( pMaster->GetPageKind() == PK_STANDARD &&
GetMasterPageUserCount( pMaster ) == 0 &&
pNotesMaster )
{
// Do not delete master pages that have their precious flag set.
sal_Bool bDeleteMaster = !pMaster->IsPrecious();
String aLayoutName = pMaster->GetLayoutName();
if(bOnlyDuplicatePages )
{
// remove only duplicate pages
bDeleteMaster = sal_False;
for (sal_uInt16 i = 0; i < GetMasterSdPageCount( PK_STANDARD ); i++)
{
SdPage* pMPg = (SdPage*) GetMasterSdPage( i, PK_STANDARD );
if( pMPg != pMaster &&
pMPg->GetLayoutName() == aLayoutName )
{
// duplicate page found -> remove it
bDeleteMaster = sal_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, PK_STANDARD ) );
}
}
}
if( bUndo )
{
BegUndo();
AddUndo( GetSdrUndoFactory().CreateUndoDeletePage( *pNotesMaster ) );
}
RemoveMasterPage( pNotesMaster->GetPageNum() );
if( !bUndo )
delete pNotesMaster;
if( bUndo )
AddUndo(GetSdrUndoFactory().CreateUndoDeletePage(*pMaster));
RemoveMasterPage( pMaster->GetPageNum() );
if( !bUndo )
delete pMaster;
if( bUndo )
EndUndo(); // schon hier, damit sich Joes Actions ZWISCHEN unsere eigenen schieben
// alte Layoutvorlagen loeschen, wenn sie nicht mehr benoetigt werden
sal_Bool bDeleteOldStyleSheets = sal_True;
for ( sal_uInt16 nMPg = 0;
nMPg < GetMasterPageCount() && bDeleteOldStyleSheets;
nMPg++ )
{
SdPage* pMPg = (SdPage*) GetMasterPage(nMPg);
if (pMPg->GetLayoutName() == aLayoutName)
{
bDeleteOldStyleSheets = sal_False;
}
}
if (bDeleteOldStyleSheets)
{
SdStyleSheetVector aRemove;
static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutSheetList( aLayoutName, aRemove );
if( bUndo )
{
// die Liste gehoert der UndoAction
SdMoveStyleSheetsUndoAction* pMovStyles = new SdMoveStyleSheetsUndoAction( this, aRemove, false );
if (pUndoMgr)
pUndoMgr->AddUndoAction(pMovStyles);
}
for( SdStyleSheetVector::iterator iter = aRemove.begin(); iter != aRemove.end(); iter++ )
static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->Remove((*iter).get());
}
}
}
if (pMasterPage)
break; // Nur diese eine MasterPage!
}
}
/*************************************************************************
|*
|* MasterPage austauschen
|*
|* Entweder erhaelt nSdPageNum eine neue, eigene MasterPage, oder die MasterPage
|* wird komplett ausgetauscht (gilt dann fuer alle Seiten).
|*
|* nSdPageNum : Nummer der Seite, welche die neue MasterPage erhalten soll
|* rLayoutName : LayoutName der neuen MasterPage
|* pSourceDoc : Dokument (Vorlage) aus dem die MasterPage geholt wird
|* bMaster : Die MasterPage von nSdPageNum soll ausgetauscht werden
|* bCheckMasters: Nicht benutzte MasterPages sollen entfernt werden
|*
|* Ist pSourceDoc == NULL, so wird eine leere MasterPage zugewiesen.
|* Ist rLayoutName leer, so wird die erste MasterPage genommen
\************************************************************************/
// #121863# factored out functionality
bool isMasterPageLayoutNameUnique(const SdDrawDocument& rDoc, const String& rCandidate)
{
if(!rCandidate.Len())
{
return false;
}
const sal_uInt16 nPageCount(rDoc.GetMasterPageCount());
for(sal_uInt16 a(0); a < nPageCount; a++)
{
const SdrPage* pCandidate = rDoc.GetMasterPage(a);
String aPageLayoutName(pCandidate->GetLayoutName());
aPageLayoutName.Erase(aPageLayoutName.SearchAscii(SD_LT_SEPARATOR));
if(aPageLayoutName == rCandidate)
{
return false;
}
}
return true;
}
// #121863# factored out functinality
String createNewMasterPageLayoutName(const SdDrawDocument& rDoc)
{
const String aBaseName(SdResId(STR_LAYOUT_DEFAULT_NAME));
String aRetval;
sal_uInt16 nCount(0);
while(!aRetval.Len())
{
aRetval = aBaseName;
if(nCount)
{
aRetval += String::CreateFromInt32(nCount);
}
nCount++;
if(!isMasterPageLayoutNameUnique(rDoc, aRetval))
{
aRetval.Erase();
}
}
return aRetval;
}
void SdDrawDocument::SetMasterPage(sal_uInt16 nSdPageNum,
const String& rLayoutName,
SdDrawDocument* pSourceDoc,
sal_Bool bMaster,
sal_Bool bCheckMasters)
{
if( mpDocSh )
mpDocSh->SetWaitCursor( sal_True );
::svl::IUndoManager* pUndoMgr = mpDocSh->GetUndoManager();
const bool bUndo = IsUndoEnabled();
if( bUndo )
{
pUndoMgr->EnterListAction(String(SdResId(STR_UNDO_SET_PRESLAYOUT)), String());
}
SdPage* pSelectedPage = GetSdPage(nSdPageNum, PK_STANDARD);
SdPage* pNotes = (SdPage*) GetPage(pSelectedPage->GetPageNum()+1);
SdPage& rOldMaster = (SdPage&)pSelectedPage->TRG_GetMasterPage();
SdPage& rOldNotesMaster = (SdPage&)pNotes->TRG_GetMasterPage();
SdPage* pMaster = NULL;
SdPage* pNotesMaster = NULL;
SdPage* pPage = NULL;
String aOldPageLayoutName(pSelectedPage->GetLayoutName());
String aOldLayoutName(aOldPageLayoutName);
aOldLayoutName.Erase(aOldLayoutName.SearchAscii( SD_LT_SEPARATOR ));
if (pSourceDoc)
{
List* pReplList = NULL;
sal_Bool bLayoutReloaded = sal_False; // Wurde ex. Layout wieder geladen?
/*********************************************************************
|* LayoutName, Page and Notespage
\*********************************************************************/
if (rLayoutName.Len() == 0)
{
// No LayoutName: take first MasterPage
pMaster = (SdPage*) pSourceDoc->GetMasterSdPage(0, PK_STANDARD);
pNotesMaster = (SdPage*) pSourceDoc->GetMasterSdPage(0, PK_NOTES);
}
else
{
String aSearchFor(rLayoutName);
aSearchFor.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR ));
aSearchFor.Append( String(SdResId(STR_LAYOUT_OUTLINE))) ;
for (sal_uInt16 nMP = 0; nMP < pSourceDoc->GetMasterPageCount(); nMP++)
{
SdPage* pMP = (SdPage*) pSourceDoc->GetMasterPage(nMP);
if (pMP->GetLayoutName() == aSearchFor)
{
if (pMP->GetPageKind() == PK_STANDARD)
pMaster = pMP;
if (pMP->GetPageKind() == PK_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 crashreports, it does
if( (pMaster == NULL) || (pNotesMaster == NULL) )
{
// so take the first MasterPage
pMaster = (SdPage*) pSourceDoc->GetMasterSdPage(0, PK_STANDARD);
pNotesMaster = (SdPage*) pSourceDoc->GetMasterSdPage(0, PK_NOTES);
}
}
// we should never reach this, but one never knows....
if( (pMaster == NULL) || (pNotesMaster == NULL) )
{
pUndoMgr->LeaveListAction();
if( mpDocSh )
mpDocSh->SetWaitCursor( sal_False );
DBG_ERROR( "SdDrawDocument::SetMasterPage() failed!" );
return;
}
const String aOriginalNewLayoutName( pMaster->GetName() );
String aTargetNewLayoutName(aOriginalNewLayoutName);
if (pSourceDoc != this)
{
// #121863# clone masterpages, they are from another model (!)
SdPage* pNewNotesMaster = dynamic_cast< SdPage* >(pNotesMaster->Clone(this));
SdPage* pNewMaster = dynamic_cast< SdPage* >(pMaster->Clone(this));
if(!pNewNotesMaster || !pNewMaster)
{
delete pNewNotesMaster;
delete pNewMaster;
OSL_ASSERT("SdDrawDocument::SetMasterPage() cloning of MasterPage/NoteAmsterPage failed!" );
return;
}
pNotesMaster = pNewNotesMaster;
pMaster = pNewMaster;
// layout name needs to be unique
aTargetNewLayoutName = pMaster->GetLayoutName();
aTargetNewLayoutName.Erase(aTargetNewLayoutName.SearchAscii(SD_LT_SEPARATOR));
if(!isMasterPageLayoutNameUnique(*this, aTargetNewLayoutName))
{
aTargetNewLayoutName = createNewMasterPageLayoutName(*this);
String aTemp(aTargetNewLayoutName);
aTemp.AppendAscii(RTL_CONSTASCII_STRINGPARAM(SD_LT_SEPARATOR));
aTemp.Append(String(SdResId(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 = (SdPage*)GetMasterPage(nMPage);
if( pCheckMaster->GetName() == aTargetNewLayoutName )
{
bLayoutReloaded = sal_True;
break;
}
}
/*****************************************************************
|* Praesentationsvorlagen korrigieren bzw. neu anlegen
\****************************************************************/
// nur die Praesentationsvorlagen beachten
String aName;
SdStyleSheetPool* pSourceStyleSheetPool = (SdStyleSheetPool*) pSourceDoc->GetStyleSheetPool();
pSourceStyleSheetPool->SetSearchMask(SD_STYLE_FAMILY_MASTERPAGE);
static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->SetSearchMask(SD_STYLE_FAMILY_MASTERPAGE);
pReplList = new List; // Liste fuer ersetzte StyleSheets
SdStyleSheetVector aCreatedStyles; // Liste fuer erzeugte StyleSheets
SfxStyleSheetBase* pHisSheet = pSourceStyleSheetPool->First();
while (pHisSheet)
{
aName = pHisSheet->GetName();
// #121863# search in source styles with original style name from source of
// evtl. cloned master (not-cloned, renamed for uniqueness)
if( aName.Search( aOriginalNewLayoutName ) == 0 )
{
// #121863# build name of evtl. cloned master style to search for
if(aOriginalNewLayoutName != aTargetNewLayoutName)
{
const sal_uInt16 nPos(aName.SearchAscii(SD_LT_SEPARATOR));
aName.Erase(0, nPos);
aName.Insert(aTargetNewLayoutName, 0);
}
SfxStyleSheet* pMySheet = static_cast<SfxStyleSheet*>( mxStyleSheetPool->Find(aName, SD_STYLE_FAMILY_MASTERPAGE) );
if (pMySheet)
{
// Es ist eine gleichnamige Vorlage vorhanden ist: Inhalte ersetzen
#ifdef DBG_UTIL
sal_Bool bTest =
#endif
pMySheet->SetName(pHisSheet->GetName());
DBG_ASSERT(bTest, "StyleSheet-Umbenennung fehlgeschlagen");
pMySheet->GetItemSet().ClearItem(0); // alle loeschen
StyleSheetUndoAction* pUndoChStyle = new StyleSheetUndoAction(this,
pMySheet, &pHisSheet->GetItemSet());
pUndoMgr->AddUndoAction(pUndoChStyle);
pMySheet->GetItemSet().Put(pHisSheet->GetItemSet());
pMySheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
}
else
{
// create new style
String aHelpFile;
pMySheet = static_cast<SfxStyleSheet*>( &mxStyleSheetPool->Make(aName, SD_STYLE_FAMILY_MASTERPAGE, pHisSheet->GetMask()) );
pMySheet->SetHelpId( aHelpFile, pHisSheet->GetHelpId(aHelpFile) );
pMySheet->GetItemSet().ClearItem(0); // alle loeschen
pMySheet->GetItemSet().Put(pHisSheet->GetItemSet());
aCreatedStyles.push_back( SdStyleSheetRef( static_cast< SdStyleSheet* >( pMySheet ) ) );
}
StyleReplaceData* pReplData = new StyleReplaceData;
pReplData->nNewFamily = pMySheet->GetFamily();
pReplData->nFamily = pMySheet->GetFamily();
pReplData->aNewName = pMySheet->GetName();
// #121863# re-create original name of styte used at page where to replace with
// this new style
String aTemp(pMySheet->GetName());
const sal_uInt16 nPos(aTemp.SearchAscii(SD_LT_SEPARATOR));
aTemp.Erase(0, nPos);
aTemp.Insert(aOldLayoutName, 0);
pReplData->aName = aTemp;
pReplList->Insert(pReplData, LIST_APPEND);
}
pHisSheet = (SfxStyleSheet*) pSourceStyleSheetPool->Next();
}
// wenn neue Vorlagen erzeugt wurden:
// eventuell bestehende Parent-Verkettung der Itemsets in den
// Vorlagen wieder aufbauen
if(!aCreatedStyles.empty())
{
StyleReplaceData* pRData = (StyleReplaceData*)pReplList->First();
while (pRData)
{
SfxStyleSheetBase* pSOld = mxStyleSheetPool->Find(pRData->aName);
SfxStyleSheetBase* pSNew = mxStyleSheetPool->Find(pRData->aNewName);
if (pSOld && pSNew)
{
const String& rParentOfOld = pSOld->GetParent();
const String& rParentOfNew = pSNew->GetParent();
if (rParentOfOld.Len() > 0 && rParentOfNew.Len() == 0)
{
for (sal_uLong i = 0; i < pReplList->Count(); i++)
{
StyleReplaceData* pRD = (StyleReplaceData*)pReplList->
GetObject(i);
if ((pRD->aName == rParentOfOld) && (pRD->aName != pRD->aNewName))
{
String aParentOfNew(pRD->aNewName);
pSNew->SetParent(aParentOfNew);
break;
}
}
}
}
pRData = (StyleReplaceData*) pReplList->Next();
}
// ab jetzt beim Suchen alle beachten
pSourceStyleSheetPool->SetSearchMask(SFX_STYLE_FAMILY_ALL);
mxStyleSheetPool->SetSearchMask(SFX_STYLE_FAMILY_ALL);
}
if( !aCreatedStyles.empty() )
{
// UndoAction fuer das Erzeugen und Einfuegen vorn StyleSheets
// auf den UndoManager legen
SdMoveStyleSheetsUndoAction* pMovStyles = new SdMoveStyleSheetsUndoAction( this, aCreatedStyles, sal_True);
pUndoMgr->AddUndoAction(pMovStyles);
}
}
// Layoutnamen auf Basis des Seitenlayoutnamens der Masterpage bilden
String aPageLayoutName(pMaster->GetLayoutName());
String aLayoutName = aPageLayoutName;
aLayoutName.Erase( aLayoutName.SearchAscii( SD_LT_SEPARATOR ));
// #121863# 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)
//{
// // Aus dem Source-Dokument austragen
// SdrPage* pTest = NULL;
// pTest = pSourceDoc->RemoveMasterPage(pNotesMaster->GetPageNum());
// pTest = pSourceDoc->RemoveMasterPage(pMaster->GetPageNum());
//}
/*********************************************************************
|* Neue MasterPages ins Dokument eintragen und den Standard- und
|* Notizseiten das Praesentationslayout ueberbraten
\********************************************************************/
if (pSourceDoc != this)
{
// Die Masterpages einfuegen:
// Masterpages von neuen Layouts hinten anhaengen; wird ein Layout
// dagegen ersetzt, so muss vor der Position der alten Masterpage
// eingefuegt werden, damit ab jetzt beim Suchen (z. B. SdPage::
// SetPresentationLayout) die neue Masterpage zuerst gefunden wird
sal_uInt16 nInsertPos = rOldMaster.GetPageNum();
BegUndo();
if (!bLayoutReloaded)
nInsertPos = 0xFFFF;
InsertMasterPage(pMaster, nInsertPos);
if( bUndo )
AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pMaster));
nInsertPos++;
if (!bLayoutReloaded)
nInsertPos = 0xFFFF;
InsertMasterPage(pNotesMaster, nInsertPos);
if( bUndo )
{
AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pNotesMaster));
EndUndo(); // schon hier, damit sich Joes Actions ZWISCHEN unsere eigenen schieben
}
}
// Liste mit Seiten fuellen
List* pPageList = new List;
// #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
pPageList->Insert(pMaster, LIST_APPEND);
pPageList->Insert(pNotesMaster, LIST_APPEND);
if (bMaster || bLayoutReloaded)
{
for (sal_uInt16 nPage = 1; nPage < GetPageCount(); nPage++)
{
pPage = (SdPage*) GetPage(nPage);
String aTest = pPage->GetLayoutName();
if (aTest == aOldPageLayoutName)
{
pPageList->Insert(pPage, LIST_APPEND);
}
}
}
else
{
pPageList->Insert(pSelectedPage, LIST_APPEND);
pPageList->Insert(pNotes, LIST_APPEND);
}
pPage = (SdPage*)pPageList->First();
while (pPage)
{
AutoLayout eAutoLayout = pPage->GetAutoLayout();
if( bUndo )
{
SdPresentationLayoutUndoAction * pPLUndoAction =
new SdPresentationLayoutUndoAction
(this,
pPage->IsMasterPage() ? aLayoutName : aOldLayoutName,
aLayoutName,
eAutoLayout, eAutoLayout, sal_False, pPage);
pUndoMgr->AddUndoAction(pPLUndoAction);
}
pPage->SetPresentationLayout(aLayoutName);
pPage->SetAutoLayout(eAutoLayout);
pPage = (SdPage*)pPageList->Next();
}
delete pPageList;
/*********************************************************************
|* Neue Masterpages angleichen
\********************************************************************/
if (pSourceDoc != this)
{
// die Masterpages angleichen
Size aSize(rOldMaster.GetSize());
Rectangle aBorderRect(rOldMaster.GetLftBorder(),
rOldMaster.GetUppBorder(),
rOldMaster.GetRgtBorder(),
rOldMaster.GetLwrBorder());
pMaster->ScaleObjects(aSize, aBorderRect, sal_True);
pMaster->SetSize(aSize);
pMaster->SetBorder(rOldMaster.GetLftBorder(),
rOldMaster.GetUppBorder(),
rOldMaster.GetRgtBorder(),
rOldMaster.GetLwrBorder());
pMaster->SetOrientation( rOldMaster.GetOrientation() );
pMaster->SetAutoLayout(pMaster->GetAutoLayout());
aSize = rOldNotesMaster.GetSize();
Rectangle aNotesBorderRect(rOldNotesMaster.GetLftBorder(),
rOldNotesMaster.GetUppBorder(),
rOldNotesMaster.GetRgtBorder(),
rOldNotesMaster.GetLwrBorder());
pNotesMaster->ScaleObjects(aSize, aNotesBorderRect, sal_True);
pNotesMaster->SetSize(aSize);
pNotesMaster->SetBorder(rOldNotesMaster.GetLftBorder(),
rOldNotesMaster.GetUppBorder(),
rOldNotesMaster.GetRgtBorder(),
rOldNotesMaster.GetLwrBorder());
pNotesMaster->SetOrientation( rOldNotesMaster.GetOrientation() );
pNotesMaster->SetAutoLayout(pNotesMaster->GetAutoLayout());
// Liste der ersetzten Vorlagen mit Inhalt loeschen
StyleReplaceData* pReplData = (StyleReplaceData*)pReplList->First();
while (pReplData)
{
delete pReplData;
pReplData = (StyleReplaceData*)pReplList->Next();
}
delete pReplList;
if( (pSourceDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) &&
(GetDocumentType() == DOCUMENT_TYPE_DRAW) )
{
pMaster->RemoveEmptyPresentationObjects();
pNotesMaster->RemoveEmptyPresentationObjects();
}
}
}
else
{
/*********************************************************************
|* Einen neuen Layoutnamen ausdenken
\********************************************************************/
String aName(createNewMasterPageLayoutName(*this));
String aPageLayoutName(aName);
aPageLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR ));
aPageLayoutName += String(SdResId(STR_LAYOUT_OUTLINE));
/*********************************************************************
|* Neue StyleSheets erzeugen
\********************************************************************/
static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutStyleSheets(aName);
SdStyleSheetVector aCreatedStyles;
static_cast<SdStyleSheetPool*>( mxStyleSheetPool.get())->CreateLayoutSheetList(aName, aCreatedStyles);
if( bUndo )
{
SdMoveStyleSheetsUndoAction* pMovStyles = new SdMoveStyleSheetsUndoAction(this, aCreatedStyles, sal_True);
pUndoMgr->AddUndoAction(pMovStyles);
}
/*********************************************************************
|* Neue MasterPages erzeugen und ins Dokument eintragen
\********************************************************************/
if( bUndo )
BegUndo();
pMaster = (SdPage*) AllocPage(sal_True);
pMaster->SetSize(pSelectedPage->GetSize());
pMaster->SetBorder(pSelectedPage->GetLftBorder(),
pSelectedPage->GetUppBorder(),
pSelectedPage->GetRgtBorder(),
pSelectedPage->GetLwrBorder() );
pMaster->SetName(aName);
pMaster->SetLayoutName(aPageLayoutName);
InsertMasterPage(pMaster);
if( bUndo )
AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pMaster));
pMaster->SetAutoLayout(AUTOLAYOUT_NONE, true, true);
pNotesMaster = (SdPage*) AllocPage(sal_True);
pNotesMaster->SetPageKind(PK_NOTES);
pNotesMaster->SetSize(pNotes->GetSize());
pNotesMaster->SetBorder(pNotes->GetLftBorder(),
pNotes->GetUppBorder(),
pNotes->GetRgtBorder(),
pNotes->GetLwrBorder() );
pNotesMaster->SetName(aName);
pNotesMaster->SetLayoutName(aPageLayoutName);
InsertMasterPage(pNotesMaster);
if( bUndo )
AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pNotesMaster));
pNotesMaster->SetAutoLayout(AUTOLAYOUT_NOTES, true, true);
if( bUndo )
EndUndo();
/*********************************************************************
|* Liste der betroffenen Standard- und Notizseiten erstellen
\********************************************************************/
List* pPageList = new List;
if (bMaster)
{
for (sal_uInt16 nPage = 1; nPage < GetPageCount(); nPage++)
{
pPage = (SdPage*) GetPage(nPage);
const String s(pPage->GetLayoutName());
if(s == aOldPageLayoutName)
{
pPageList->Insert(pPage, LIST_APPEND);
}
}
}
else
{
pPageList->Insert(pSelectedPage, LIST_APPEND);
pPageList->Insert(pNotes, LIST_APPEND);
}
/*********************************************************************
|* An den betroffenen Seiten Praesentations- und Autolayout setzen
\********************************************************************/
pPage = (SdPage*)pPageList->First();
while(pPage)
{
AutoLayout eOldAutoLayout = pPage->GetAutoLayout();
AutoLayout eNewAutoLayout =
pPage->GetPageKind() == PK_STANDARD ? AUTOLAYOUT_NONE : AUTOLAYOUT_NOTES;
if( bUndo )
{
SdPresentationLayoutUndoAction * pPLUndoAction =
new SdPresentationLayoutUndoAction
(this, aOldLayoutName, aName,
eOldAutoLayout, eNewAutoLayout, sal_True,
pPage);
pUndoMgr->AddUndoAction(pPLUndoAction);
}
pPage->SetPresentationLayout(aName);
pPage->SetAutoLayout(eNewAutoLayout);
pPage = (SdPage*)pPageList->Next();
}
// Seitenliste loeschen
delete pPageList;
}
/*********************************************************************
|* falls die alten Masterpages nicht mehr benoetigt werden,
|* muessen sie und die entsprechenden Praesentationsvorlagen
|* entfernt werden
\********************************************************************/
if (bCheckMasters)
{
// Alle pruefen
RemoveUnnecessaryMasterPages();
}
else
{
// Nur die ausgetauschte MasterPage pruefen
RemoveUnnecessaryMasterPages(&rOldMaster);
}
if( bUndo )
pUndoMgr->LeaveListAction();
if( mpDocSh )
mpDocSh->SetWaitCursor( sal_False );
}
void SdDrawDocument::Merge(SdrModel& rSourceModel,
sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum,
sal_uInt16 nDestPos,
FASTBOOL bMergeMasterPages, FASTBOOL bAllMasterPages,
FASTBOOL bUndo, FASTBOOL 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() == PK_STANDARD) )
{
// new master page created, add its style family
SdStyleSheetPool* pStylePool = (SdStyleSheetPool*) GetStyleSheetPool();
if( pStylePool )
pStylePool->AddStyleFamily( pPage );
}
}
}