Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <com/sun/star/embed/XVisualObject.hpp>
21 : #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
22 : #include <vcl/wrkwin.hxx>
23 : #include <vcl/settings.hxx>
24 :
25 : #include <sfx2/printer.hxx>
26 : #include <sfx2/app.hxx>
27 : #include "Outliner.hxx"
28 : #include <editeng/paperinf.hxx>
29 : #include <svx/svdopage.hxx>
30 : #include <svx/svdoole2.hxx>
31 : #include <svx/svdotext.hxx>
32 : #include <svx/svdograf.hxx>
33 : #include <svx/svdundo.hxx>
34 : #include <vcl/svapp.hxx>
35 : #include <editeng/eeitem.hxx>
36 : #include <editeng/langitem.hxx>
37 : #include <svl/itempool.hxx>
38 : #include <svx/svdpool.hxx>
39 : #include <editeng/flditem.hxx>
40 :
41 : #include <sfx2/linkmgr.hxx>
42 : #include <editeng/editdata.hxx>
43 : #include <svx/dialogs.hrc>
44 : #include <svx/dialmgr.hxx>
45 :
46 : #include <editeng/outliner.hxx>
47 : #include <svx/svditer.hxx>
48 : #include <svtools/imapobj.hxx>
49 :
50 : #include "sdresid.hxx"
51 : #include "drawdoc.hxx"
52 : #include "sdpage.hxx"
53 : #include "pglink.hxx"
54 : #include "glob.hrc"
55 : #include "glob.hxx"
56 : #include "stlpool.hxx"
57 : #include "sdiocmpt.hxx"
58 : #include "anminfo.hxx"
59 : #include "imapinfo.hxx"
60 : #include "cusshow.hxx"
61 : #include "undo/undomanager.hxx"
62 :
63 : #include "../ui/inc/DrawDocShell.hxx"
64 : #include "../ui/inc/FrameView.hxx"
65 : #include "../ui/inc/cfgids.hxx"
66 : #include "../ui/inc/strings.hrc"
67 :
68 : #include "PageListWatcher.hxx"
69 : #include <vcl/virdev.hxx>
70 : #include "customshowlist.hxx"
71 :
72 : using namespace ::sd;
73 :
74 : const long PRINT_OFFSET = 30; // see /svx/source/dialog/page.cxx
75 :
76 : using namespace com::sun::star;
77 :
78 : // Looks up an object by name
79 0 : SdrObject* SdDrawDocument::GetObj(const OUString& rObjName) const
80 : {
81 0 : SdrObject* pObj = NULL;
82 0 : SdrObject* pObjFound = NULL;
83 0 : SdPage* pPage = NULL;
84 :
85 : // First search in all pages
86 0 : sal_uInt16 nPage = 0;
87 0 : const sal_uInt16 nMaxPages = GetPageCount();
88 :
89 0 : while (nPage < nMaxPages && !pObjFound)
90 : {
91 0 : pPage = (SdPage*) GetPage(nPage);
92 0 : SdrObjListIter aIter(*pPage, IM_DEEPWITHGROUPS);
93 :
94 0 : while (aIter.IsMore() && !pObjFound)
95 : {
96 0 : pObj = aIter.Next();
97 :
98 0 : if( ( pObj->GetName().equals(rObjName) ) ||
99 0 : ( SdrInventor == pObj->GetObjInventor() &&
100 0 : OBJ_OLE2 == pObj->GetObjIdentifier() &&
101 0 : rObjName == static_cast< SdrOle2Obj* >( pObj )->GetPersistName() ) )
102 : {
103 0 : pObjFound = pObj;
104 : }
105 : }
106 :
107 0 : nPage++;
108 0 : }
109 :
110 : // If it couldn't be found, look through all master pages
111 0 : nPage = 0;
112 0 : const sal_uInt16 nMaxMasterPages = GetMasterPageCount();
113 :
114 0 : while (nPage < nMaxMasterPages && !pObjFound)
115 : {
116 0 : pPage = (SdPage*) GetMasterPage(nPage);
117 0 : SdrObjListIter aIter(*pPage, IM_DEEPWITHGROUPS);
118 :
119 0 : while (aIter.IsMore() && !pObjFound)
120 : {
121 0 : pObj = aIter.Next();
122 :
123 0 : if( ( pObj->GetName().equals(rObjName) ) ||
124 0 : ( SdrInventor == pObj->GetObjInventor() &&
125 0 : OBJ_OLE2 == pObj->GetObjIdentifier() &&
126 0 : rObjName == static_cast< SdrOle2Obj* >( pObj )->GetPersistName() ) )
127 : {
128 0 : pObjFound = pObj;
129 : }
130 : }
131 :
132 0 : nPage++;
133 0 : }
134 :
135 0 : return (pObjFound);
136 : }
137 :
138 : // Find SdPage by name
139 238 : sal_uInt16 SdDrawDocument::GetPageByName(const OUString& rPgName, bool& rbIsMasterPage) const
140 : {
141 238 : SdPage* pPage = NULL;
142 238 : sal_uInt16 nPage = 0;
143 238 : const sal_uInt16 nMaxPages = GetPageCount();
144 238 : sal_uInt16 nPageNum = SDRPAGE_NOTFOUND;
145 :
146 238 : rbIsMasterPage = false;
147 :
148 : // Search all regular pages and all notes pages (handout pages are
149 : // ignored)
150 1202 : while (nPage < nMaxPages && nPageNum == SDRPAGE_NOTFOUND)
151 : {
152 : pPage = const_cast<SdPage*>(static_cast<const SdPage*>(
153 726 : GetPage(nPage)));
154 :
155 726 : if (pPage != NULL
156 726 : && pPage->GetPageKind() != PK_HANDOUT
157 1214 : && pPage->GetName() == rPgName)
158 : {
159 0 : nPageNum = nPage;
160 : }
161 :
162 726 : nPage++;
163 : }
164 :
165 : // Search all master pages when not found among non-master pages
166 238 : const sal_uInt16 nMaxMasterPages = GetMasterPageCount();
167 238 : nPage = 0;
168 :
169 1086 : while (nPage < nMaxMasterPages && nPageNum == SDRPAGE_NOTFOUND)
170 : {
171 : pPage = const_cast<SdPage*>(static_cast<const SdPage*>(
172 610 : GetMasterPage(nPage)));
173 :
174 610 : if (pPage && pPage->GetName() == rPgName)
175 : {
176 120 : nPageNum = nPage;
177 120 : rbIsMasterPage = true;
178 : }
179 :
180 610 : nPage++;
181 : }
182 :
183 238 : return nPageNum;
184 : }
185 :
186 11806 : SdPage* SdDrawDocument::GetSdPage(sal_uInt16 nPgNum, PageKind ePgKind) const
187 : {
188 11806 : return mpDrawPageListWatcher->GetSdPage(ePgKind, sal_uInt32(nPgNum));
189 : }
190 :
191 11296 : sal_uInt16 SdDrawDocument::GetSdPageCount(PageKind ePgKind) const
192 : {
193 11296 : return (sal_uInt16)mpDrawPageListWatcher->GetSdPageCount(ePgKind);
194 : }
195 :
196 2618 : SdPage* SdDrawDocument::GetMasterSdPage(sal_uInt16 nPgNum, PageKind ePgKind)
197 : {
198 2618 : return mpMasterPageListWatcher->GetSdPage(ePgKind, sal_uInt32(nPgNum));
199 : }
200 :
201 3514 : sal_uInt16 SdDrawDocument::GetMasterSdPageCount(PageKind ePgKind) const
202 : {
203 3514 : return (sal_uInt16)mpMasterPageListWatcher->GetSdPageCount(ePgKind);
204 : }
205 :
206 209 : sal_uInt16 SdDrawDocument::GetActiveSdPageCount() const
207 : {
208 209 : return (sal_uInt16)mpDrawPageListWatcher->GetVisibleSdPageCount();
209 : }
210 :
211 : // Adapt the page numbers that are registered in the page objects of the notes
212 : // pages
213 5132 : void SdDrawDocument::UpdatePageObjectsInNotes(sal_uInt16 nStartPos)
214 : {
215 5132 : sal_uInt16 nPageCount = GetPageCount();
216 5132 : SdPage* pPage = NULL;
217 :
218 7118 : for (sal_uInt16 nPage = nStartPos; nPage < nPageCount; nPage++)
219 : {
220 1986 : pPage = (SdPage*)GetPage(nPage);
221 :
222 : // If this is a notes page, find its page object and correct the page
223 : // number
224 1986 : if (pPage && pPage->GetPageKind() == PK_NOTES)
225 : {
226 944 : const size_t nObjCount = pPage->GetObjCount();
227 944 : SdrObject* pObj = NULL;
228 1468 : for (size_t nObj = 0; nObj < nObjCount; ++nObj)
229 : {
230 524 : pObj = pPage->GetObj(nObj);
231 786 : if (pObj->GetObjIdentifier() == OBJ_PAGE &&
232 262 : pObj->GetObjInventor() == SdrInventor)
233 : {
234 : // The page object is the preceding page (drawing page)
235 : DBG_ASSERTWARNING(nStartPos, "Position of notes page must not be 0.");
236 :
237 : DBG_ASSERTWARNING(nPage > 1, "Page object must not be a handout.");
238 :
239 262 : if (nStartPos > 0 && nPage > 1)
240 262 : ((SdrPageObj*)pObj)->SetReferencedPage(GetPage(nPage - 1));
241 : }
242 : }
243 : }
244 : }
245 5132 : }
246 :
247 1892 : void SdDrawDocument::UpdatePageRelativeURLs(const OUString& rOldName, const OUString& rNewName)
248 : {
249 1892 : if (rNewName.isEmpty())
250 2844 : return;
251 :
252 940 : SfxItemPool& pPool(GetPool());
253 940 : sal_uInt32 nCount = pPool.GetItemCount2(EE_FEATURE_FIELD);
254 87296 : for (sal_uInt32 nOff = 0; nOff < nCount; nOff++)
255 : {
256 86356 : const SfxPoolItem *pItem = pPool.GetItem2(EE_FEATURE_FIELD, nOff);
257 86356 : const SvxFieldItem* pFldItem = dynamic_cast< const SvxFieldItem * > (pItem);
258 :
259 86356 : if(pFldItem)
260 : {
261 86356 : SvxURLField* pURLField = const_cast< SvxURLField* >( dynamic_cast<const SvxURLField*>( pFldItem->GetField() ) );
262 :
263 86356 : if(pURLField)
264 : {
265 0 : OUString aURL = pURLField->GetURL();
266 :
267 0 : if (!aURL.isEmpty() && (aURL[0] == 35) && (aURL.indexOf(rOldName, 1) == 1))
268 : {
269 0 : if (aURL.getLength() == rOldName.getLength() + 1) // standard page name
270 : {
271 0 : aURL = aURL.replaceAt(1, aURL.getLength() - 1, "");
272 0 : aURL += rNewName;
273 0 : pURLField->SetURL(aURL);
274 : }
275 : else
276 : {
277 0 : const OUString sNotes(SD_RESSTR(STR_NOTES));
278 0 : if (aURL.getLength() == rOldName.getLength() + 2 + sNotes.getLength()
279 0 : && aURL.indexOf(sNotes, rOldName.getLength() + 2) == rOldName.getLength() + 2)
280 : {
281 0 : aURL = aURL.replaceAt(1, aURL.getLength() - 1, "");
282 0 : aURL += rNewName + " " + sNotes;
283 0 : pURLField->SetURL(aURL);
284 0 : }
285 : }
286 0 : }
287 : }
288 : }
289 : }
290 : }
291 :
292 180 : void SdDrawDocument::UpdatePageRelativeURLs(SdPage* pPage, sal_uInt16 nPos, sal_Int32 nIncrement)
293 : {
294 180 : bool bNotes = (pPage->GetPageKind() == PK_NOTES);
295 :
296 180 : SfxItemPool& pPool(GetPool());
297 180 : sal_uInt32 nCount = pPool.GetItemCount2(EE_FEATURE_FIELD);
298 17498 : for (sal_uInt32 nOff = 0; nOff < nCount; nOff++)
299 : {
300 17318 : const SfxPoolItem *pItem = pPool.GetItem2(EE_FEATURE_FIELD, nOff);
301 : const SvxFieldItem* pFldItem;
302 :
303 17318 : if ((pFldItem = dynamic_cast< const SvxFieldItem * > (pItem)) != 0)
304 : {
305 17318 : SvxURLField* pURLField = const_cast< SvxURLField* >( dynamic_cast<const SvxURLField*>( pFldItem->GetField() ) );
306 :
307 17318 : if(pURLField)
308 : {
309 0 : OUString aURL = pURLField->GetURL();
310 :
311 0 : if (!aURL.isEmpty() && (aURL[0] == 35))
312 : {
313 0 : OUString aHashSlide("#");
314 0 : aHashSlide += SD_RESSTR(STR_PAGE);
315 :
316 0 : if (aURL.startsWith(aHashSlide))
317 : {
318 0 : OUString aURLCopy = aURL;
319 0 : const OUString sNotes(SD_RESSTR(STR_NOTES));
320 :
321 0 : aURLCopy = aURLCopy.replaceAt(0, aHashSlide.getLength(), "");
322 :
323 0 : bool bNotesLink = ( aURLCopy.getLength() >= sNotes.getLength() + 3
324 0 : && aURLCopy.endsWith(sNotes) );
325 :
326 0 : if (bNotesLink != bNotes)
327 0 : continue; // no compatible link and page
328 :
329 0 : if (bNotes)
330 0 : aURLCopy = aURLCopy.replaceAt(aURLCopy.getLength() - sNotes.getLength(), sNotes.getLength(), "");
331 :
332 0 : sal_Int32 number = aURLCopy.toInt32();
333 0 : sal_uInt16 realPageNumber = (nPos + 1)/ 2;
334 :
335 0 : if ( number >= realPageNumber )
336 : {
337 : // update link page number
338 0 : number += nIncrement;
339 0 : aURL = aURL.replaceAt(aHashSlide.getLength() + 1, aURL.getLength() - aHashSlide.getLength() - 1, "");
340 0 : aURL += OUString::number(number);
341 0 : if (bNotes)
342 : {
343 0 : aURL += " " + sNotes;
344 : }
345 0 : pURLField->SetURL(aURL);
346 0 : }
347 0 : }
348 0 : }
349 : }
350 : }
351 : }
352 180 : }
353 :
354 : // Move page
355 0 : void SdDrawDocument::MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos)
356 : {
357 0 : FmFormModel::MovePage(nPgNum, nNewPos);
358 :
359 0 : sal_uInt16 nMin = std::min(nPgNum, nNewPos);
360 :
361 0 : UpdatePageObjectsInNotes(nMin);
362 0 : }
363 :
364 : // Insert page
365 1872 : void SdDrawDocument::InsertPage(SdrPage* pPage, sal_uInt16 nPos)
366 : {
367 1872 : bool bLast = (nPos == GetPageCount());
368 :
369 1872 : FmFormModel::InsertPage(pPage, nPos);
370 :
371 1872 : ((SdPage*)pPage)->ConnectLink();
372 :
373 1872 : UpdatePageObjectsInNotes(nPos);
374 :
375 1872 : if (!bLast)
376 176 : UpdatePageRelativeURLs(static_cast<SdPage*>( pPage ), nPos, 1);
377 :
378 1872 : }
379 :
380 : // Delete page
381 1388 : void SdDrawDocument::DeletePage(sal_uInt16 nPgNum)
382 : {
383 1388 : FmFormModel::DeletePage(nPgNum);
384 :
385 1388 : UpdatePageObjectsInNotes(nPgNum);
386 1388 : }
387 :
388 : // Remove page
389 1872 : SdrPage* SdDrawDocument::RemovePage(sal_uInt16 nPgNum)
390 : {
391 1872 : SdrPage* pPage = FmFormModel::RemovePage(nPgNum);
392 :
393 1872 : bool bLast = ((nPgNum+1)/2 == (GetPageCount()+1)/2);
394 :
395 1872 : ((SdPage*)pPage)->DisconnectLink();
396 1872 : ReplacePageInCustomShows( dynamic_cast< SdPage* >( pPage ), 0 );
397 1872 : UpdatePageObjectsInNotes(nPgNum);
398 :
399 1872 : if (!bLast)
400 4 : UpdatePageRelativeURLs((SdPage*)pPage, nPgNum, -1);
401 :
402 1872 : return pPage;
403 : }
404 :
405 : // Warning: This is not called for new master pages created from SdrModel::Merge,
406 : // you also have to modify code in SdDrawDocument::Merge!
407 1146 : void SdDrawDocument::InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos )
408 : {
409 1146 : FmFormModel::InsertMasterPage( pPage, nPos );
410 1146 : if( pPage->IsMasterPage() && (static_cast<SdPage*>(pPage)->GetPageKind() == PK_STANDARD) )
411 : {
412 : // new master page created, add its style family
413 394 : SdStyleSheetPool* pStylePool = (SdStyleSheetPool*) GetStyleSheetPool();
414 394 : if( pStylePool )
415 394 : pStylePool->AddStyleFamily( static_cast<SdPage*>(pPage) );
416 : }
417 1146 : }
418 :
419 1146 : SdrPage* SdDrawDocument::RemoveMasterPage(sal_uInt16 nPgNum)
420 : {
421 1146 : SdPage* pPage = static_cast<SdPage*>(GetMasterPage(nPgNum ));
422 1146 : if( pPage && pPage->IsMasterPage() && (pPage->GetPageKind() == PK_STANDARD) )
423 : {
424 : // master page removed, remove its style family
425 394 : SdStyleSheetPool* pStylePool = (SdStyleSheetPool*) GetStyleSheetPool();
426 394 : if( pStylePool )
427 394 : pStylePool->RemoveStyleFamily( pPage );
428 : }
429 :
430 1146 : return FmFormModel::RemoveMasterPage(nPgNum);
431 : }
432 :
433 : //Select pages
434 2074 : void SdDrawDocument::SetSelected(SdPage* pPage, bool bSelect)
435 : {
436 2074 : PageKind ePageKind = pPage->GetPageKind();
437 :
438 2074 : if (ePageKind == PK_STANDARD)
439 : {
440 2074 : pPage->SetSelected(bSelect);
441 :
442 2074 : const sal_uInt16 nDestPageNum(pPage->GetPageNum() + 1);
443 2074 : SdPage* pNotesPage = 0L;
444 :
445 2074 : if(nDestPageNum < GetPageCount())
446 : {
447 1978 : pNotesPage = (SdPage*)GetPage(nDestPageNum);
448 : }
449 :
450 2074 : if (pNotesPage && pNotesPage->GetPageKind() == PK_NOTES)
451 : {
452 1966 : pNotesPage->SetSelected(bSelect);
453 : }
454 : }
455 0 : else if (ePageKind == PK_NOTES)
456 : {
457 0 : pPage->SetSelected(bSelect);
458 0 : SdPage* pStandardPage = (SdPage*) GetPage( pPage->GetPageNum() - 1 );
459 :
460 0 : if (pStandardPage && pStandardPage->GetPageKind() == PK_STANDARD)
461 0 : pStandardPage->SetSelected(bSelect);
462 : }
463 2074 : }
464 :
465 : // If no pages exist yet, create them now
466 364 : void SdDrawDocument::CreateFirstPages( SdDrawDocument* pRefDocument /* = 0 */ )
467 : {
468 : // If no page exists yet in the model, (File -> New), insert a page
469 364 : sal_uInt16 nPageCount = GetPageCount();
470 :
471 364 : if (nPageCount <= 1)
472 : {
473 : // #i57181# Paper size depends on Language, like in Writer
474 340 : Size aDefSize = SvxPaperInfo::GetDefaultPaperSize( MAP_100TH_MM );
475 :
476 : // Insert handout page
477 340 : SdPage* pHandoutPage = AllocSdPage(false);
478 :
479 340 : SdPage* pRefPage = NULL;
480 :
481 340 : if( pRefDocument )
482 0 : pRefPage = pRefDocument->GetSdPage( 0, PK_HANDOUT );
483 :
484 340 : if( pRefPage )
485 : {
486 0 : pHandoutPage->SetSize(pRefPage->GetSize());
487 0 : pHandoutPage->SetBorder( pRefPage->GetLftBorder(), pRefPage->GetUppBorder(), pRefPage->GetRgtBorder(), pRefPage->GetLwrBorder() );
488 : }
489 : else
490 : {
491 340 : pHandoutPage->SetSize(aDefSize);
492 340 : pHandoutPage->SetBorder(0, 0, 0, 0);
493 : }
494 :
495 340 : pHandoutPage->SetPageKind(PK_HANDOUT);
496 340 : pHandoutPage->SetName( SD_RESSTR(STR_HANDOUT) );
497 340 : InsertPage(pHandoutPage, 0);
498 :
499 : // Insert master page and register this with the handout page
500 340 : SdPage* pHandoutMPage = AllocSdPage(true);
501 340 : pHandoutMPage->SetSize( pHandoutPage->GetSize() );
502 340 : pHandoutMPage->SetPageKind(PK_HANDOUT);
503 340 : pHandoutMPage->SetBorder( pHandoutPage->GetLftBorder(),
504 340 : pHandoutPage->GetUppBorder(),
505 340 : pHandoutPage->GetRgtBorder(),
506 1360 : pHandoutPage->GetLwrBorder() );
507 340 : InsertMasterPage(pHandoutMPage, 0);
508 340 : pHandoutPage->TRG_SetMasterPage( *pHandoutMPage );
509 :
510 : // Insert page
511 : // If nPageCount==1 is, the model for the clipboard was created, thus a
512 : // default page must already exist
513 : SdPage* pPage;
514 340 : bool bClipboard = false;
515 :
516 340 : if( pRefDocument )
517 0 : pRefPage = pRefDocument->GetSdPage( 0, PK_STANDARD );
518 :
519 340 : if (nPageCount == 0)
520 : {
521 340 : pPage = AllocSdPage(false);
522 :
523 340 : if( pRefPage )
524 : {
525 0 : pPage->SetSize( pRefPage->GetSize() );
526 0 : pPage->SetBorder( pRefPage->GetLftBorder(), pRefPage->GetUppBorder(), pRefPage->GetRgtBorder(), pRefPage->GetLwrBorder() );
527 : }
528 340 : else if (meDocType == DOCUMENT_TYPE_DRAW)
529 : {
530 : // Draw: always use default size with margins
531 170 : pPage->SetSize(aDefSize);
532 :
533 170 : SfxPrinter* pPrinter = mpDocSh->GetPrinter(false);
534 170 : if (pPrinter && pPrinter->IsValid())
535 : {
536 0 : Size aOutSize(pPrinter->GetOutputSize());
537 0 : Point aPageOffset(pPrinter->GetPageOffset());
538 0 : aPageOffset -= pPrinter->PixelToLogic( Point() );
539 0 : long nOffset = !aPageOffset.X() && !aPageOffset.Y() ? 0 : PRINT_OFFSET;
540 :
541 0 : sal_uLong nTop = aPageOffset.Y();
542 0 : sal_uLong nLeft = aPageOffset.X();
543 0 : sal_uLong nBottom = std::max((long)(aDefSize.Height() - aOutSize.Height() - nTop + nOffset), 0L);
544 0 : sal_uLong nRight = std::max((long)(aDefSize.Width() - aOutSize.Width() - nLeft + nOffset), 0L);
545 :
546 0 : pPage->SetBorder(nLeft, nTop, nRight, nBottom);
547 : }
548 : else
549 : {
550 : // The printer is not available. Use a border of 10mm
551 : // on each side instead.
552 : // This has to be kept synchronized with the border
553 : // width set in the
554 : // SvxPageDescPage::PaperSizeSelect_Impl callback.
555 170 : pPage->SetBorder(1000, 1000, 1000, 1000);
556 : }
557 : }
558 : else
559 : {
560 : // Impress: always use screen format, landscape.
561 170 : Size aSz( SvxPaperInfo::GetPaperSize(PAPER_SCREEN_4_3, MAP_100TH_MM) );
562 170 : pPage->SetSize( Size( aSz.Height(), aSz.Width() ) );
563 170 : pPage->SetBorder(0, 0, 0, 0);
564 : }
565 :
566 340 : InsertPage(pPage, 1);
567 : }
568 : else
569 : {
570 0 : bClipboard = true;
571 0 : pPage = (SdPage*) GetPage(1);
572 : }
573 :
574 : // Insert master page, then register this with the page
575 340 : SdPage* pMPage = AllocSdPage(true);
576 340 : pMPage->SetSize( pPage->GetSize() );
577 340 : pMPage->SetBorder( pPage->GetLftBorder(),
578 340 : pPage->GetUppBorder(),
579 340 : pPage->GetRgtBorder(),
580 1360 : pPage->GetLwrBorder() );
581 340 : InsertMasterPage(pMPage, 1);
582 340 : pPage->TRG_SetMasterPage( *pMPage );
583 340 : if( bClipboard )
584 0 : pMPage->SetLayoutName( pPage->GetLayoutName() );
585 :
586 : // Insert notes page
587 340 : SdPage* pNotesPage = AllocSdPage(false);
588 :
589 340 : if( pRefDocument )
590 0 : pRefPage = pRefDocument->GetSdPage( 0, PK_NOTES );
591 :
592 340 : if( pRefPage )
593 : {
594 0 : pNotesPage->SetSize( pRefPage->GetSize() );
595 0 : pNotesPage->SetBorder( pRefPage->GetLftBorder(), pRefPage->GetUppBorder(), pRefPage->GetRgtBorder(), pRefPage->GetLwrBorder() );
596 : }
597 : else
598 : {
599 : // Always use portrait format
600 340 : if (aDefSize.Height() >= aDefSize.Width())
601 : {
602 340 : pNotesPage->SetSize(aDefSize);
603 : }
604 : else
605 : {
606 0 : pNotesPage->SetSize( Size(aDefSize.Height(), aDefSize.Width()) );
607 : }
608 :
609 340 : pNotesPage->SetBorder(0, 0, 0, 0);
610 : }
611 340 : pNotesPage->SetPageKind(PK_NOTES);
612 340 : InsertPage(pNotesPage, 2);
613 340 : if( bClipboard )
614 0 : pNotesPage->SetLayoutName( pPage->GetLayoutName() );
615 :
616 : // Insert master page, then register this with the notes page
617 340 : SdPage* pNotesMPage = AllocSdPage(true);
618 340 : pNotesMPage->SetSize( pNotesPage->GetSize() );
619 340 : pNotesMPage->SetPageKind(PK_NOTES);
620 340 : pNotesMPage->SetBorder( pNotesPage->GetLftBorder(),
621 340 : pNotesPage->GetUppBorder(),
622 340 : pNotesPage->GetRgtBorder(),
623 1360 : pNotesPage->GetLwrBorder() );
624 340 : InsertMasterPage(pNotesMPage, 2);
625 340 : pNotesPage->TRG_SetMasterPage( *pNotesMPage );
626 340 : if( bClipboard )
627 0 : pNotesMPage->SetLayoutName( pPage->GetLayoutName() );
628 :
629 340 : if( !pRefPage && (meDocType != DOCUMENT_TYPE_DRAW) )
630 170 : pPage->SetAutoLayout( AUTOLAYOUT_TITLE, true, true );
631 :
632 340 : mpWorkStartupTimer = new Timer();
633 340 : mpWorkStartupTimer->SetTimeoutHdl( LINK(this, SdDrawDocument, WorkStartupHdl) );
634 340 : mpWorkStartupTimer->SetTimeout(2000);
635 340 : mpWorkStartupTimer->Start();
636 :
637 340 : SetChanged(false);
638 : }
639 364 : }
640 :
641 : // Creates missing notes and handout pages (after PowerPoint import).
642 : // We assume that at least one default page and one default master page exist.
643 :
644 18 : bool SdDrawDocument::CreateMissingNotesAndHandoutPages()
645 : {
646 18 : bool bOK = false;
647 18 : sal_uInt16 nPageCount = GetPageCount();
648 :
649 18 : if (nPageCount != 0)
650 : {
651 : // Set PageKind
652 18 : SdPage* pHandoutMPage = (SdPage*) GetMasterPage(0);
653 18 : pHandoutMPage->SetPageKind(PK_HANDOUT);
654 :
655 18 : SdPage* pHandoutPage = (SdPage*) GetPage(0);
656 18 : pHandoutPage->SetPageKind(PK_HANDOUT);
657 18 : pHandoutPage->TRG_SetMasterPage( *pHandoutMPage );
658 :
659 92 : for (sal_uInt16 i = 1; i < nPageCount; i = i + 2)
660 : {
661 74 : SdPage* pPage = (SdPage*) GetPage(i);
662 :
663 74 : if(!pPage->TRG_HasMasterPage())
664 : {
665 : // No master page set -> use first default master page
666 : // (If there was no default page in the PPT)
667 0 : pPage->TRG_SetMasterPage(*GetMasterPage(1));
668 : }
669 :
670 74 : SdPage* pNotesPage = (SdPage*) GetPage(i+1);
671 74 : pNotesPage->SetPageKind(PK_NOTES);
672 :
673 : // Set notes master page
674 74 : sal_uInt16 nMasterPageAfterPagesMasterPage = (pPage->TRG_GetMasterPage()).GetPageNum() + 1;
675 74 : pNotesPage->TRG_SetMasterPage(*GetMasterPage(nMasterPageAfterPagesMasterPage));
676 : }
677 :
678 18 : bOK = true;
679 18 : StopWorkStartupDelay();
680 18 : SetChanged(false);
681 : }
682 :
683 18 : return(bOK);
684 : }
685 :
686 : // + Move selected pages after said page
687 : // (nTargetPage = (sal_uInt16)-1 --> move before first page)
688 : // + Returns sal_True when the page has been moved
689 0 : bool SdDrawDocument::MovePages(sal_uInt16 nTargetPage)
690 : {
691 0 : SdPage* pPage = NULL;
692 : sal_uInt16 nPage;
693 0 : sal_uInt16 nNoOfPages = GetSdPageCount(PK_STANDARD);
694 0 : bool bSomethingHappened = false;
695 :
696 0 : const bool bUndo = IsUndoEnabled();
697 :
698 0 : if( bUndo )
699 0 : BegUndo(SD_RESSTR(STR_UNDO_MOVEPAGES));
700 :
701 : // List of selected pages
702 0 : std::vector<SdPage*> aPageList;
703 0 : for (nPage = 0; nPage < nNoOfPages; nPage++)
704 : {
705 0 : pPage = GetSdPage(nPage, PK_STANDARD);
706 :
707 0 : if (pPage->IsSelected())
708 0 : aPageList.push_back(pPage);
709 : }
710 :
711 : // If necessary, look backwards, until we find a page that wasn't selected
712 0 : nPage = nTargetPage;
713 0 : if (nPage != (sal_uInt16)-1)
714 : {
715 0 : pPage = GetSdPage(nPage, PK_STANDARD);
716 0 : while (nPage > 0 && pPage->IsSelected())
717 : {
718 0 : nPage--;
719 0 : pPage = GetSdPage(nPage, PK_STANDARD);
720 : }
721 :
722 0 : if (pPage->IsSelected())
723 : {
724 0 : nPage = (sal_uInt16)-1;
725 : }
726 : }
727 :
728 : // Insert before the first page
729 0 : if (nPage == (sal_uInt16)-1)
730 : {
731 0 : std::vector<SdPage*>::reverse_iterator iter;
732 0 : for (iter = aPageList.rbegin(); iter != aPageList.rend(); ++iter)
733 : {
734 0 : nPage = (*iter)->GetPageNum();
735 0 : if (nPage != 0)
736 : {
737 0 : SdrPage* pPg = GetPage(nPage);
738 0 : if( bUndo )
739 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage, 1));
740 0 : MovePage(nPage, 1);
741 0 : pPg = GetPage(nPage+1);
742 0 : if( bUndo )
743 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage+1, 2));
744 0 : MovePage(nPage+1, 2);
745 0 : bSomethingHappened = true;
746 : }
747 : }
748 : }
749 : // Insert after <nPage>
750 : else
751 : {
752 0 : nTargetPage = nPage;
753 0 : nTargetPage = 2 * nTargetPage + 1; // PK_STANDARD --> absolute
754 :
755 0 : std::vector<SdPage*>::iterator iter;
756 0 : for (iter = aPageList.begin(); iter != aPageList.end(); ++iter)
757 : {
758 0 : pPage = *iter;
759 0 : nPage = pPage->GetPageNum();
760 0 : if (nPage > nTargetPage)
761 : {
762 0 : nTargetPage += 2; // Insert _after_ the page
763 :
764 0 : if (nPage != nTargetPage)
765 : {
766 0 : SdrPage* pPg = GetPage(nPage);
767 0 : if( bUndo )
768 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage, nTargetPage));
769 0 : MovePage(nPage, nTargetPage);
770 0 : pPg = GetPage(nPage+1);
771 0 : if( bUndo )
772 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage+1, nTargetPage+1));
773 0 : MovePage(nPage+1, nTargetPage+1);
774 0 : bSomethingHappened = true;
775 : }
776 : }
777 : else
778 : {
779 0 : if (nPage != nTargetPage)
780 : {
781 0 : SdrPage* pPg = GetPage(nPage+1);
782 0 : if( bUndo )
783 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage+1, nTargetPage+1));
784 0 : MovePage(nPage+1, nTargetPage+1);
785 0 : pPg = GetPage(nPage);
786 0 : if( bUndo )
787 0 : AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage, nTargetPage));
788 0 : MovePage(nPage, nTargetPage);
789 0 : bSomethingHappened = true;
790 : }
791 : }
792 0 : nTargetPage = pPage->GetPageNum();
793 : }
794 : }
795 :
796 0 : if( bUndo )
797 0 : EndUndo();
798 :
799 0 : return bSomethingHappened;
800 : }
801 :
802 : // Return number of links in sfx2::LinkManager
803 0 : sal_uLong SdDrawDocument::GetLinkCount()
804 : {
805 0 : return pLinkManager->GetLinks().size();
806 : }
807 :
808 : // Set Language
809 1434 : void SdDrawDocument::SetLanguage( const LanguageType eLang, const sal_uInt16 nId )
810 : {
811 1434 : bool bChanged = false;
812 :
813 1434 : if( nId == EE_CHAR_LANGUAGE && meLanguage != eLang )
814 : {
815 460 : meLanguage = eLang;
816 460 : bChanged = true;
817 : }
818 974 : else if( nId == EE_CHAR_LANGUAGE_CJK && meLanguageCJK != eLang )
819 : {
820 446 : meLanguageCJK = eLang;
821 446 : bChanged = true;
822 : }
823 528 : else if( nId == EE_CHAR_LANGUAGE_CTL && meLanguageCTL != eLang )
824 : {
825 444 : meLanguageCTL = eLang;
826 444 : bChanged = true;
827 : }
828 :
829 1434 : if( bChanged )
830 : {
831 1350 : GetDrawOutliner().SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
832 1350 : pHitTestOutliner->SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
833 1350 : pItemPool->SetPoolDefaultItem( SvxLanguageItem( eLang, nId ) );
834 1350 : SetChanged( bChanged );
835 : }
836 1434 : }
837 :
838 : // Return language
839 4036 : LanguageType SdDrawDocument::GetLanguage( const sal_uInt16 nId ) const
840 : {
841 4036 : LanguageType eLangType = meLanguage;
842 :
843 4036 : if( nId == EE_CHAR_LANGUAGE_CJK )
844 1126 : eLangType = meLanguageCJK;
845 2910 : else if( nId == EE_CHAR_LANGUAGE_CTL )
846 1126 : eLangType = meLanguageCTL;
847 :
848 4036 : return eLangType;
849 : }
850 :
851 : // Initiate WorkStartup
852 340 : IMPL_LINK_NOARG(SdDrawDocument, WorkStartupHdl)
853 : {
854 340 : if( mpDocSh )
855 340 : mpDocSh->SetWaitCursor( true );
856 :
857 340 : bool bChanged = IsChanged(); // remember this
858 :
859 : // Initialize Autolayouts
860 340 : SdPage* pHandoutMPage = GetMasterSdPage(0, PK_HANDOUT);
861 :
862 340 : if (pHandoutMPage->GetAutoLayout() == AUTOLAYOUT_NONE)
863 : {
864 : // No AutoLayout yet -> initialize
865 340 : pHandoutMPage->SetAutoLayout(AUTOLAYOUT_HANDOUT6, true, true);
866 : }
867 :
868 340 : SdPage* pPage = GetSdPage(0, PK_STANDARD);
869 :
870 340 : if (pPage->GetAutoLayout() == AUTOLAYOUT_NONE)
871 : {
872 : // No AutoLayout yet -> initialize
873 170 : pPage->SetAutoLayout(AUTOLAYOUT_NONE, true, true);
874 : }
875 :
876 340 : SdPage* pNotesPage = GetSdPage(0, PK_NOTES);
877 :
878 340 : if (pNotesPage->GetAutoLayout() == AUTOLAYOUT_NONE)
879 : {
880 : // No AutoLayout yet -> initialize
881 340 : pNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, true, true);
882 : }
883 :
884 340 : SetChanged(bChanged);
885 :
886 340 : if( mpDocSh )
887 340 : mpDocSh->SetWaitCursor( false );
888 340 : return 0;
889 : }
890 :
891 : // When the WorkStartupTimer has been created (this only happens in
892 : // SdDrawViewShell::Construct() ), the timer may be stopped and the WorkStartup
893 : // may be initiated.
894 764 : void SdDrawDocument::StopWorkStartupDelay()
895 : {
896 764 : if (mpWorkStartupTimer)
897 : {
898 340 : if ( mpWorkStartupTimer->IsActive() )
899 : {
900 : // Timer not yet expired -> initiate WorkStartup
901 340 : mpWorkStartupTimer->Stop();
902 340 : WorkStartupHdl(NULL);
903 : }
904 :
905 340 : delete mpWorkStartupTimer;
906 340 : mpWorkStartupTimer = NULL;
907 : }
908 764 : }
909 :
910 : // When the WorkStartupTimer has been created (this only happens in
911 : // SdDrawViewShell::Construct() ), the timer may be stopped and the WorkStartup
912 : // may be initiated.
913 0 : SdAnimationInfo* SdDrawDocument::GetAnimationInfo(SdrObject* pObject) const
914 : {
915 : DBG_ASSERT(pObject, "sd::SdDrawDocument::GetAnimationInfo(), invalid argument!");
916 0 : if( pObject )
917 0 : return GetShapeUserData( *pObject, false );
918 : else
919 0 : return 0;
920 : }
921 :
922 90994 : SdAnimationInfo* SdDrawDocument::GetShapeUserData(SdrObject& rObject, bool bCreate /* = false */ )
923 : {
924 90994 : sal_uInt16 nUD = 0;
925 90994 : sal_uInt16 nUDCount = rObject.GetUserDataCount();
926 90994 : SdrObjUserData* pUD = 0;
927 90994 : SdAnimationInfo* pRet = 0;
928 :
929 : // Can we find animation information within the user data?
930 90994 : for (nUD = 0; nUD < nUDCount; nUD++)
931 : {
932 79014 : pUD = rObject.GetUserData(nUD);
933 79014 : if((pUD->GetInventor() == SdUDInventor) && (pUD->GetId() == SD_ANIMATIONINFO_ID))
934 : {
935 79014 : pRet = dynamic_cast<SdAnimationInfo*>(pUD);
936 79014 : break;
937 : }
938 : }
939 :
940 90994 : if( (pRet == 0) && bCreate )
941 : {
942 10696 : pRet = new SdAnimationInfo( rObject );
943 10696 : rObject.AppendUserData( pRet);
944 : }
945 :
946 90994 : return pRet;
947 : }
948 :
949 0 : SdIMapInfo* SdDrawDocument::GetIMapInfo( SdrObject* pObject ) const
950 : {
951 : DBG_ASSERT(pObject, "Without an object there is no IMapInfo");
952 :
953 0 : SdrObjUserData* pUserData = NULL;
954 0 : SdIMapInfo* pIMapInfo = NULL;
955 0 : sal_uInt16 nCount = pObject->GetUserDataCount();
956 :
957 : // Can we find IMap information within the user data?
958 0 : for ( sal_uInt16 i = 0; i < nCount; i++ )
959 : {
960 0 : pUserData = pObject->GetUserData( i );
961 :
962 0 : if ( ( pUserData->GetInventor() == SdUDInventor ) && ( pUserData->GetId() == SD_IMAPINFO_ID ) )
963 0 : pIMapInfo = (SdIMapInfo*) pUserData;
964 : }
965 :
966 0 : return pIMapInfo;
967 : }
968 :
969 0 : IMapObject* SdDrawDocument::GetHitIMapObject( SdrObject* pObj,
970 : const Point& rWinPoint,
971 : const ::vcl::Window& /* rCmpWnd */ )
972 : {
973 0 : SdIMapInfo* pIMapInfo = GetIMapInfo( pObj );
974 0 : IMapObject* pIMapObj = NULL;
975 :
976 0 : if ( pIMapInfo )
977 : {
978 0 : const MapMode aMap100( MAP_100TH_MM );
979 0 : Size aGraphSize;
980 0 : Point aRelPoint( rWinPoint );
981 0 : ImageMap& rImageMap = (ImageMap&) pIMapInfo->GetImageMap();
982 0 : const Rectangle& rRect = pObj->GetLogicRect();
983 0 : bool bObjSupported = false;
984 :
985 : // execute HitTest
986 0 : if ( pObj->ISA( SdrGrafObj ) ) // simple graphics object
987 : {
988 0 : const SdrGrafObj* pGrafObj = (const SdrGrafObj*) pObj;
989 0 : const GeoStat& rGeo = pGrafObj->GetGeoStat();
990 0 : SdrGrafObjGeoData* pGeoData = (SdrGrafObjGeoData*) pGrafObj->GetGeoData();
991 :
992 : // Undo rotation
993 0 : if ( rGeo.nRotationAngle )
994 0 : RotatePoint( aRelPoint, rRect.TopLeft(), -rGeo.nSin, rGeo.nCos );
995 :
996 : // Undo mirroring
997 0 : if ( pGeoData->bMirrored )
998 0 : aRelPoint.X() = rRect.Right() + rRect.Left() - aRelPoint.X();
999 :
1000 : // Undo shearing
1001 0 : if ( rGeo.nShearAngle )
1002 0 : ShearPoint( aRelPoint, rRect.TopLeft(), -rGeo.nTan );
1003 :
1004 0 : if ( pGrafObj->GetGrafPrefMapMode().GetMapUnit() == MAP_PIXEL )
1005 0 : aGraphSize = Application::GetDefaultDevice()->PixelToLogic( pGrafObj->GetGrafPrefSize(), aMap100 );
1006 : else
1007 0 : aGraphSize = OutputDevice::LogicToLogic( pGrafObj->GetGrafPrefSize(),
1008 0 : pGrafObj->GetGrafPrefMapMode(), aMap100 );
1009 :
1010 0 : delete pGeoData;
1011 0 : bObjSupported = true;
1012 : }
1013 0 : else if ( pObj->ISA( SdrOle2Obj ) ) // OLE object
1014 : {
1015 0 : aGraphSize = ( (SdrOle2Obj*) pObj )->GetOrigObjSize();
1016 0 : bObjSupported = true;
1017 : }
1018 :
1019 : // Everything worked out well, thus execute HitTest
1020 0 : if ( bObjSupported )
1021 : {
1022 : // Calculate relative position of mouse cursor
1023 0 : aRelPoint -= rRect.TopLeft();
1024 0 : pIMapObj = rImageMap.GetHitIMapObject( aGraphSize, rRect.GetSize(), aRelPoint );
1025 :
1026 : // We don't care about deactivated objects
1027 0 : if ( pIMapObj && !pIMapObj->IsActive() )
1028 0 : pIMapObj = NULL;
1029 0 : }
1030 : }
1031 :
1032 0 : return pIMapObj;
1033 : }
1034 :
1035 0 : ImageMap* SdDrawDocument::GetImageMapForObject(SdrObject* pObj)
1036 : {
1037 0 : SdIMapInfo* pIMapInfo = GetIMapInfo( pObj );
1038 0 : if ( pIMapInfo )
1039 : {
1040 0 : return const_cast<ImageMap*>( &(pIMapInfo->GetImageMap()) );
1041 : }
1042 0 : return NULL;
1043 : }
1044 :
1045 : /** this method enforces that the masterpages are in the correct order,
1046 : that is at position 1 is a PK_STANDARD masterpage followed by a
1047 : PK_NOTES masterpage and so on. #
1048 : */
1049 0 : void SdDrawDocument::CheckMasterPages()
1050 : {
1051 0 : sal_uInt16 nMaxPages = GetMasterPageCount();
1052 :
1053 : // we need at least a handout master and one master page
1054 0 : if( nMaxPages < 2 )
1055 : {
1056 0 : return;
1057 : }
1058 :
1059 0 : SdPage* pPage = NULL;
1060 0 : SdPage* pNotesPage = NULL;
1061 :
1062 : sal_uInt16 nPage;
1063 :
1064 : // first see if the page order is correct
1065 0 : for( nPage = 1; nPage < nMaxPages; nPage++ )
1066 : {
1067 0 : pPage = static_cast<SdPage*> (GetMasterPage( nPage ));
1068 : // if an odd page is not a standard page or an even page is not a notes page
1069 0 : if( ((1 == (nPage & 1)) && (pPage->GetPageKind() != PK_STANDARD) ) ||
1070 0 : ((0 == (nPage & 1)) && (pPage->GetPageKind() != PK_NOTES) ) )
1071 0 : break; // then we have a fatal error
1072 : }
1073 :
1074 0 : if( nPage < nMaxPages )
1075 : {
1076 : // there is a fatal error in the master page order,
1077 : // we need to repair the document
1078 0 : bool bChanged = false;
1079 :
1080 0 : nPage = 1;
1081 0 : while( nPage < nMaxPages )
1082 : {
1083 0 : pPage = static_cast<SdPage*> (GetMasterPage( nPage ));
1084 0 : if( pPage->GetPageKind() != PK_STANDARD )
1085 : {
1086 0 : bChanged = true;
1087 0 : sal_uInt16 nFound = nPage + 1;
1088 0 : while( nFound < nMaxPages )
1089 : {
1090 0 : pPage = static_cast<SdPage*>(GetMasterPage( nFound ));
1091 0 : if( PK_STANDARD == pPage->GetPageKind() )
1092 : {
1093 0 : MoveMasterPage( nFound, nPage );
1094 0 : pPage->SetInserted(true);
1095 0 : break;
1096 :
1097 : }
1098 :
1099 0 : nFound++;
1100 : }
1101 :
1102 : // if we don't have any more standard pages, were done
1103 0 : if( nMaxPages == nFound )
1104 0 : break;
1105 : }
1106 :
1107 0 : nPage++;
1108 :
1109 0 : if( nPage < nMaxPages )
1110 0 : pNotesPage = static_cast<SdPage*>(GetMasterPage( nPage ));
1111 : else
1112 0 : pNotesPage = NULL;
1113 :
1114 0 : if( (NULL == pNotesPage) || (pNotesPage->GetPageKind() != PK_NOTES) || ( pPage->GetLayoutName() != pNotesPage->GetLayoutName() ) )
1115 : {
1116 0 : bChanged = true;
1117 :
1118 0 : sal_uInt16 nFound = nPage + 1;
1119 0 : while( nFound < nMaxPages )
1120 : {
1121 0 : pNotesPage = static_cast<SdPage*>(GetMasterPage( nFound ));
1122 0 : if( (PK_NOTES == pNotesPage->GetPageKind()) && ( pPage->GetLayoutName() == pNotesPage->GetLayoutName() ) )
1123 : {
1124 0 : MoveMasterPage( nFound, nPage );
1125 0 : pNotesPage->SetInserted(true);
1126 0 : break;
1127 : }
1128 :
1129 0 : nFound++;
1130 : }
1131 :
1132 : // looks like we lost a notes page
1133 0 : if( nMaxPages == nFound )
1134 : {
1135 : // so create one
1136 :
1137 : // first find a reference notes page for size
1138 0 : SdPage* pRefNotesPage = NULL;
1139 0 : nFound = 0;
1140 0 : while( nFound < nMaxPages )
1141 : {
1142 0 : pRefNotesPage = static_cast<SdPage*>(GetMasterPage( nFound ));
1143 0 : if( PK_NOTES == pRefNotesPage->GetPageKind() )
1144 0 : break;
1145 0 : nFound++;
1146 : }
1147 0 : if( nFound == nMaxPages )
1148 0 : pRefNotesPage = NULL;
1149 :
1150 0 : SdPage* pNewNotesPage = AllocSdPage(true);
1151 0 : pNewNotesPage->SetPageKind(PK_NOTES);
1152 0 : if( pRefNotesPage )
1153 : {
1154 0 : pNewNotesPage->SetSize( pRefNotesPage->GetSize() );
1155 0 : pNewNotesPage->SetBorder( pRefNotesPage->GetLftBorder(),
1156 0 : pRefNotesPage->GetUppBorder(),
1157 0 : pRefNotesPage->GetRgtBorder(),
1158 0 : pRefNotesPage->GetLwrBorder() );
1159 : }
1160 0 : InsertMasterPage(pNewNotesPage, nPage );
1161 0 : pNewNotesPage->SetLayoutName( pPage->GetLayoutName() );
1162 0 : pNewNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, true, true );
1163 0 : nMaxPages++;
1164 : }
1165 : }
1166 :
1167 0 : nPage++;
1168 : }
1169 :
1170 : // now remove all remaining and unused non PK_STANDARD slides
1171 0 : while( nPage < nMaxPages )
1172 : {
1173 0 : bChanged = true;
1174 :
1175 0 : RemoveMasterPage( nPage );
1176 0 : nMaxPages--;
1177 : }
1178 :
1179 0 : if( bChanged )
1180 : {
1181 : OSL_FAIL( "master pages where in a wrong order" );
1182 0 : RecalcPageNums( true);
1183 : }
1184 : }
1185 : }
1186 :
1187 0 : sal_uInt16 SdDrawDocument::CreatePage (
1188 : SdPage* pActualPage,
1189 : PageKind ePageKind,
1190 : const OUString& sStandardPageName,
1191 : const OUString& sNotesPageName,
1192 : AutoLayout eStandardLayout,
1193 : AutoLayout eNotesLayout,
1194 : bool bIsPageBack,
1195 : bool bIsPageObj,
1196 : const sal_Int32 nInsertPosition)
1197 : {
1198 : SdPage* pPreviousStandardPage;
1199 : SdPage* pPreviousNotesPage;
1200 : SdPage* pStandardPage;
1201 : SdPage* pNotesPage;
1202 :
1203 : // From the given page determine the standard page and notes page of which
1204 : // to take the layout and the position where to insert the new pages.
1205 0 : if (ePageKind == PK_NOTES)
1206 : {
1207 0 : pPreviousNotesPage = pActualPage;
1208 0 : sal_uInt16 nNotesPageNum = pPreviousNotesPage->GetPageNum() + 2;
1209 0 : pPreviousStandardPage = (SdPage*) GetPage(nNotesPageNum - 3);
1210 0 : eStandardLayout = pPreviousStandardPage->GetAutoLayout();
1211 : }
1212 : else
1213 : {
1214 0 : pPreviousStandardPage = pActualPage;
1215 0 : sal_uInt16 nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
1216 0 : pPreviousNotesPage = (SdPage*) GetPage(nStandardPageNum - 1);
1217 0 : eNotesLayout = pPreviousNotesPage->GetAutoLayout();
1218 : }
1219 :
1220 : // Create new standard page and set it up
1221 0 : pStandardPage = AllocSdPage(false);
1222 :
1223 : // Set the size here since else the presobj autolayout
1224 : // will be wrong.
1225 0 : pStandardPage->SetSize( pPreviousStandardPage->GetSize() );
1226 0 : pStandardPage->SetBorder( pPreviousStandardPage->GetLftBorder(),
1227 0 : pPreviousStandardPage->GetUppBorder(),
1228 0 : pPreviousStandardPage->GetRgtBorder(),
1229 0 : pPreviousStandardPage->GetLwrBorder() );
1230 :
1231 : // Use master page of current page.
1232 0 : pStandardPage->TRG_SetMasterPage(pPreviousStandardPage->TRG_GetMasterPage());
1233 :
1234 : // User layout of current standard page
1235 0 : pStandardPage->SetLayoutName( pPreviousStandardPage->GetLayoutName() );
1236 0 : pStandardPage->SetAutoLayout(eStandardLayout, true);
1237 0 : pStandardPage->setHeaderFooterSettings( pPreviousStandardPage->getHeaderFooterSettings() );
1238 :
1239 : // transition settings of current page
1240 0 : pStandardPage->setTransitionType( pPreviousStandardPage->getTransitionType() );
1241 0 : pStandardPage->setTransitionSubtype( pPreviousStandardPage->getTransitionSubtype() );
1242 0 : pStandardPage->setTransitionDirection( pPreviousStandardPage->getTransitionDirection() );
1243 0 : pStandardPage->setTransitionFadeColor( pPreviousStandardPage->getTransitionFadeColor() );
1244 0 : pStandardPage->setTransitionDuration( pPreviousStandardPage->getTransitionDuration() );
1245 :
1246 : // apply previous animation timing
1247 0 : pStandardPage->SetPresChange( pPreviousStandardPage->GetPresChange() );
1248 0 : pStandardPage->SetTime( pPreviousStandardPage->GetTime() );
1249 :
1250 : // Create new notes page and set it up
1251 0 : pNotesPage = AllocSdPage(false);
1252 0 : pNotesPage->SetPageKind(PK_NOTES);
1253 :
1254 : // Use master page of current page
1255 0 : pNotesPage->TRG_SetMasterPage(pPreviousNotesPage->TRG_GetMasterPage());
1256 :
1257 : // Use layout of current notes page
1258 0 : pNotesPage->SetLayoutName( pPreviousNotesPage->GetLayoutName() );
1259 0 : pNotesPage->SetAutoLayout(eNotesLayout, true);
1260 0 : pNotesPage->setHeaderFooterSettings( pPreviousNotesPage->getHeaderFooterSettings() );
1261 :
1262 : return InsertPageSet (
1263 : pActualPage,
1264 : ePageKind,
1265 : sStandardPageName,
1266 : sNotesPageName,
1267 : bIsPageBack,
1268 : bIsPageObj,
1269 : pStandardPage,
1270 : pNotesPage,
1271 0 : nInsertPosition);
1272 : }
1273 :
1274 0 : sal_uInt16 SdDrawDocument::DuplicatePage (sal_uInt16 nPageNum)
1275 : {
1276 0 : PageKind ePageKind = PK_STANDARD;
1277 :
1278 : // Get current page
1279 0 : SdPage* pActualPage = GetSdPage(nPageNum, ePageKind);
1280 :
1281 : // Get background flags
1282 0 : SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
1283 0 : sal_uInt8 aBckgrnd = rLayerAdmin.GetLayerID(SD_RESSTR(STR_LAYER_BCKGRND), false);
1284 0 : sal_uInt8 aBckgrndObj = rLayerAdmin.GetLayerID(SD_RESSTR(STR_LAYER_BCKGRNDOBJ), false);
1285 0 : SetOfByte aVisibleLayers = pActualPage->TRG_GetMasterPageVisibleLayers();
1286 :
1287 : return DuplicatePage (
1288 : pActualPage, ePageKind,
1289 : // No names for the new slides
1290 : OUString(), OUString(),
1291 0 : aVisibleLayers.IsSet(aBckgrnd),
1292 0 : aVisibleLayers.IsSet(aBckgrndObj));
1293 : }
1294 :
1295 0 : sal_uInt16 SdDrawDocument::DuplicatePage (
1296 : SdPage* pActualPage,
1297 : PageKind ePageKind,
1298 : const OUString& sStandardPageName,
1299 : const OUString& sNotesPageName,
1300 : bool bIsPageBack,
1301 : bool bIsPageObj,
1302 : const sal_Int32 nInsertPosition)
1303 : {
1304 : SdPage* pPreviousStandardPage;
1305 : SdPage* pPreviousNotesPage;
1306 : SdPage* pStandardPage;
1307 : SdPage* pNotesPage;
1308 :
1309 : // From the given page determine the standard page and the notes page
1310 : // of which to make copies.
1311 0 : if (ePageKind == PK_NOTES)
1312 : {
1313 0 : pPreviousNotesPage = pActualPage;
1314 0 : sal_uInt16 nNotesPageNum = pPreviousNotesPage->GetPageNum() + 2;
1315 0 : pPreviousStandardPage = (SdPage*) GetPage(nNotesPageNum - 3);
1316 : }
1317 : else
1318 : {
1319 0 : pPreviousStandardPage = pActualPage;
1320 0 : sal_uInt16 nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
1321 0 : pPreviousNotesPage = (SdPage*) GetPage(nStandardPageNum - 1);
1322 : }
1323 :
1324 : // Create duplicates of a standard page and the associated notes page
1325 0 : pStandardPage = (SdPage*) pPreviousStandardPage->Clone();
1326 0 : pNotesPage = (SdPage*) pPreviousNotesPage->Clone();
1327 :
1328 : return InsertPageSet (
1329 : pActualPage,
1330 : ePageKind,
1331 : sStandardPageName,
1332 : sNotesPageName,
1333 : bIsPageBack,
1334 : bIsPageObj,
1335 : pStandardPage,
1336 : pNotesPage,
1337 0 : nInsertPosition);
1338 : }
1339 :
1340 0 : sal_uInt16 SdDrawDocument::InsertPageSet (
1341 : SdPage* pActualPage,
1342 : PageKind ePageKind,
1343 : const OUString& sStandardPageName,
1344 : const OUString& sNotesPageName,
1345 : bool bIsPageBack,
1346 : bool bIsPageObj,
1347 : SdPage* pStandardPage,
1348 : SdPage* pNotesPage,
1349 : sal_Int32 nInsertPosition)
1350 : {
1351 : SdPage* pPreviousStandardPage;
1352 : SdPage* pPreviousNotesPage;
1353 : sal_uInt16 nStandardPageNum;
1354 : sal_uInt16 nNotesPageNum;
1355 0 : OUString aStandardPageName(sStandardPageName);
1356 0 : OUString aNotesPageName(sNotesPageName);
1357 :
1358 : // Gather some information about the standard page and the notes page
1359 : // that are to be inserted. This makes sure that there is always one
1360 : // standard page followed by one notes page.
1361 0 : if (ePageKind == PK_NOTES)
1362 : {
1363 0 : pPreviousNotesPage = pActualPage;
1364 0 : nNotesPageNum = pPreviousNotesPage->GetPageNum() + 2;
1365 0 : pPreviousStandardPage = (SdPage*) GetPage(nNotesPageNum - 3);
1366 0 : nStandardPageNum = nNotesPageNum - 1;
1367 : }
1368 : else
1369 : {
1370 0 : pPreviousStandardPage = pActualPage;
1371 0 : nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
1372 0 : pPreviousNotesPage = (SdPage*) GetPage(nStandardPageNum - 1);
1373 0 : nNotesPageNum = nStandardPageNum + 1;
1374 0 : aNotesPageName = aStandardPageName;
1375 : }
1376 :
1377 : OSL_ASSERT(nNotesPageNum==nStandardPageNum+1);
1378 0 : if (nInsertPosition < 0)
1379 0 : nInsertPosition = nStandardPageNum;
1380 :
1381 : // Set up and insert the standard page
1382 : SetupNewPage (
1383 : pPreviousStandardPage,
1384 : pStandardPage,
1385 : aStandardPageName,
1386 : nInsertPosition,
1387 : bIsPageBack,
1388 0 : bIsPageObj);
1389 :
1390 : // Set up and insert the notes page
1391 0 : pNotesPage->SetPageKind(PK_NOTES);
1392 : SetupNewPage (
1393 : pPreviousNotesPage,
1394 : pNotesPage,
1395 : aNotesPageName,
1396 : nInsertPosition+1,
1397 : bIsPageBack,
1398 0 : bIsPageObj);
1399 :
1400 : // Return an index that allows the caller to access the newly inserted
1401 : // pages by using GetSdPage()
1402 0 : return pStandardPage->GetPageNum() / 2;
1403 : }
1404 :
1405 0 : void SdDrawDocument::SetupNewPage (
1406 : SdPage* pPreviousPage,
1407 : SdPage* pPage,
1408 : const OUString& sPageName,
1409 : sal_uInt16 nInsertionPoint,
1410 : bool bIsPageBack,
1411 : bool bIsPageObj)
1412 : {
1413 0 : if (pPreviousPage != NULL)
1414 : {
1415 0 : pPage->SetSize( pPreviousPage->GetSize() );
1416 0 : pPage->SetBorder( pPreviousPage->GetLftBorder(),
1417 0 : pPreviousPage->GetUppBorder(),
1418 0 : pPreviousPage->GetRgtBorder(),
1419 0 : pPreviousPage->GetLwrBorder() );
1420 : }
1421 0 : pPage->SetName(sPageName);
1422 :
1423 0 : InsertPage(pPage, nInsertionPoint);
1424 :
1425 0 : if (pPreviousPage != NULL)
1426 : {
1427 0 : SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
1428 0 : sal_uInt8 aBckgrnd = rLayerAdmin.GetLayerID(SD_RESSTR(STR_LAYER_BCKGRND), false);
1429 0 : sal_uInt8 aBckgrndObj = rLayerAdmin.GetLayerID(SD_RESSTR(STR_LAYER_BCKGRNDOBJ), false);
1430 0 : SetOfByte aVisibleLayers = pPreviousPage->TRG_GetMasterPageVisibleLayers();
1431 0 : aVisibleLayers.Set(aBckgrnd, bIsPageBack);
1432 0 : aVisibleLayers.Set(aBckgrndObj, bIsPageObj);
1433 0 : pPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
1434 : }
1435 0 : }
1436 :
1437 15798 : sd::UndoManager* SdDrawDocument::GetUndoManager() const
1438 : {
1439 15798 : return mpDocSh ? dynamic_cast< sd::UndoManager* >(mpDocSh->GetUndoManager()) : 0;
1440 114 : }
1441 :
1442 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
