sd/source/core/drawdoc2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: drawdoc2.cxx,v $
  10  * $Revision: 1.46.76.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34
  35 #include <com/sun/star/embed/XVisualObject.hpp>
  36 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
  37 #include <vcl/wrkwin.hxx>
  38 #include <sfx2/printer.hxx>
  39 #include <sfx2/app.hxx>
  40 #ifndef SD_OUTLINE_HXX
  41 #include "Outliner.hxx"
  42 #endif
  43 #include <svx/paperinf.hxx>
  44 #include <svx/svdopage.hxx>
  45 #include <svx/svdoole2.hxx>
  46 #include <svx/svdotext.hxx>
  47 #include <svx/svdograf.hxx>
  48 #include <svx/svdundo.hxx>
  49 #include <vcl/svapp.hxx>
  50 #include <svx/eeitem.hxx>
  51 #include <svx/langitem.hxx>
  52 #include <svtools/itempool.hxx>
  53 #include <svx/svdpool.hxx>
  54 #include <svx/flditem.hxx>
  55
  56 #include <svx/linkmgr.hxx>
  57 #include <svx/editdata.hxx>
  58 #include <svx/dialogs.hrc>
  59 #include <svx/dialmgr.hxx>                                      // SVX_RESSTR
  60
  61 #include "eetext.hxx"
  62 #include <svx/svditer.hxx>
  63 #include <svtools/imapobj.hxx>
  64
  65
  66 #include "sdresid.hxx"
  67 #include "drawdoc.hxx"
  68 #include "sdpage.hxx"
  69 #include "pglink.hxx"
  70 #include "glob.hrc"
  71 #include "glob.hxx"
  72 #include "stlpool.hxx"
  73 #include "sdiocmpt.hxx"
  74 #include "anminfo.hxx"
  75 #include "imapinfo.hxx"
  76 #include "cusshow.hxx"
  77 #include "undo/undomanager.hxx"
  78
  79 #include "../ui/inc/DrawDocShell.hxx"
  80 #include "../ui/inc/FrameView.hxx"
  81 #include "../ui/inc/cfgids.hxx"
  82 #include "../ui/inc/strings.hrc"
  83
  84 #include "PageListWatcher.hxx"
  85 #include <vcl/virdev.hxx>
  86
  87 using namespace ::sd;
  88
  89 const long PRINT_OFFSET = 30;           // siehe \svx\source\dialog\page.cxx (PB)
  90
  91 using namespace com::sun::star;
  92
  93 /*************************************************************************
  94 |*
  95 |* Sucht ein Objekt per Name
  96 |*
  97 \************************************************************************/
  98
  99 SdrObject* SdDrawDocument::GetObj(const String& rObjName) const
 100 {
 101     SdrObject* pObj = NULL;
 102     SdrObject* pObjFound = NULL;
 103     SdPage* pPage = NULL;
 104
 105     /**************************************************************************
 106     * Zuerst alle Pages durchsuchen
 107     **************************************************************************/
 108     USHORT nPage = 0;
 109     const USHORT nMaxPages = GetPageCount();
 110
 111     while (nPage < nMaxPages && !pObjFound)
 112     {
 113         pPage = (SdPage*) GetPage(nPage);
 114         SdrObjListIter aIter(*pPage, IM_DEEPWITHGROUPS);
 115
 116         while (aIter.IsMore() && !pObjFound)
 117         {
 118             pObj = aIter.Next();
 119
 120             if( ( rObjName == pObj->GetName() ) ||
 121                 ( SdrInventor == pObj->GetObjInventor() &&
 122                   OBJ_OLE2 == pObj->GetObjIdentifier() &&
 123                   rObjName == static_cast< SdrOle2Obj* >( pObj )->GetPersistName() ) )
 124             {
 125                 pObjFound = pObj;
 126             }
 127         }
 128
 129         nPage++;
 130     }
 131
 132     /**************************************************************************
 133     * Wenn nicht gefunden, dann alle MasterPages durchsuchen
 134     **************************************************************************/
 135     nPage = 0;
 136     const USHORT nMaxMasterPages = GetMasterPageCount();
 137
 138     while (nPage < nMaxMasterPages && !pObjFound)
 139     {
 140         pPage = (SdPage*) GetMasterPage(nPage);
 141         SdrObjListIter aIter(*pPage, IM_DEEPWITHGROUPS);
 142
 143         while (aIter.IsMore() && !pObjFound)
 144         {
 145             pObj = aIter.Next();
 146
 147             if( ( rObjName == pObj->GetName() ) ||
 148                 ( SdrInventor == pObj->GetObjInventor() &&
 149                   OBJ_OLE2 == pObj->GetObjIdentifier() &&
 150                   rObjName == static_cast< SdrOle2Obj* >( pObj )->GetPersistName() ) )
 151             {
 152                 pObjFound = pObj;
 153             }
 154         }
 155
 156         nPage++;
 157     }
 158
 159     return (pObjFound);
 160 }
 161
 162
 163 /*************************************************************************
 164 |*
 165 |* Sucht die SdPage per Name
 166 |*
 167 \************************************************************************/
 168
 169 USHORT SdDrawDocument::GetPageByName(const String& rPgName, BOOL& rbIsMasterPage) const
 170 {
 171     SdPage* pPage = NULL;
 172     USHORT nPage = 0;
 173     const USHORT nMaxPages = GetPageCount();
 174     USHORT nPageNum = SDRPAGE_NOTFOUND;
 175
 176     rbIsMasterPage = FALSE;
 177
 178     // Search all regular pages and all notes pages (handout pages are
 179     // ignored.)
 180     while (nPage < nMaxPages && nPageNum == SDRPAGE_NOTFOUND)
 181     {
 182         pPage = const_cast<SdPage*>(static_cast<const SdPage*>(
 183             GetPage(nPage)));
 184
 185         if (pPage != NULL
 186             && pPage->GetPageKind() != PK_HANDOUT
 187             && pPage->GetName() == rPgName)
 188         {
 189             nPageNum = nPage;
 190         }
 191
 192         nPage++;
 193     }
 194
 195     // Search all master pages when not found among non-master pages.
 196     const USHORT nMaxMasterPages = GetMasterPageCount();
 197     nPage = 0;
 198
 199     while (nPage < nMaxMasterPages && nPageNum == SDRPAGE_NOTFOUND)
 200     {
 201         pPage = const_cast<SdPage*>(static_cast<const SdPage*>(
 202             GetMasterPage(nPage)));
 203
 204         if (pPage && pPage->GetName() == rPgName)
 205         {
 206             nPageNum = nPage;
 207             rbIsMasterPage = TRUE;
 208         }
 209
 210         nPage++;
 211     }
 212
 213     return nPageNum;
 214 }
 215
 216
 217 /*************************************************************************
 218 |*
 219 |*
 220 |*
 221 \************************************************************************/
 222
 223 SdPage* SdDrawDocument::GetSdPage(USHORT nPgNum, PageKind ePgKind) const
 224 {
 225     // #109538#
 226     return mpDrawPageListWatcher->GetSdPage(ePgKind, sal_uInt32(nPgNum));
 227 }
 228
 229 /*************************************************************************
 230 |*
 231 |*
 232 |*
 233 \************************************************************************/
 234
 235 USHORT SdDrawDocument::GetSdPageCount(PageKind ePgKind) const
 236 {
 237     // #109538#
 238     return (sal_uInt16)mpDrawPageListWatcher->GetSdPageCount(ePgKind);
 239 }
 240
 241 /*************************************************************************
 242 |*
 243 |*
 244 |*
 245 \************************************************************************/
 246
 247 SdPage* SdDrawDocument::GetMasterSdPage(USHORT nPgNum, PageKind ePgKind)
 248 {
 249     // #109538#
 250     return mpMasterPageListWatcher->GetSdPage(ePgKind, sal_uInt32(nPgNum));
 251 }
 252
 253 /*************************************************************************
 254 |*
 255 |*
 256 |*
 257 \************************************************************************/
 258
 259 USHORT SdDrawDocument::GetMasterSdPageCount(PageKind ePgKind) const
 260 {
 261     // #109538#
 262     return (sal_uInt16)mpMasterPageListWatcher->GetSdPageCount(ePgKind);
 263 }
 264
 265 /*************************************************************************
 266 |*
 267 |*      die in den Seitenobjekten der Notizseiten eingetragenen
 268 |*      Seitennummern anpassen
 269 |*
 270 \************************************************************************/
 271
 272 void SdDrawDocument::UpdatePageObjectsInNotes(USHORT nStartPos)
 273 {
 274     USHORT      nPageCount      = GetPageCount();
 275     SdPage* pPage               = NULL;
 276
 277     for (USHORT nPage = nStartPos; nPage < nPageCount; nPage++)
 278     {
 279         pPage = (SdPage*)GetPage(nPage);
 280
 281         // wenn es eine Notizseite ist, Seitenobjekt suchen
 282         // und Nummer korrigieren
 283         if (pPage && pPage->GetPageKind() == PK_NOTES)
 284         {
 285             ULONG nObjCount = pPage->GetObjCount();
 286             SdrObject* pObj = NULL;
 287             for (ULONG nObj = 0; nObj < nObjCount; nObj++)
 288             {
 289                 pObj = pPage->GetObj(nObj);
 290                 if (pObj->GetObjIdentifier() == OBJ_PAGE &&
 291                     pObj->GetObjInventor() == SdrInventor)
 292                 {
 293                     // das Seitenobjekt stellt die vorhergende Seite (also
 294                     // die Zeichenseite) dar
 295                     DBG_ASSERTWARNING(nStartPos, "Notizseitenpos. darf nicht 0 sein");
 296
 297                     DBG_ASSERTWARNING(nPage > 1, "Seitenobjekt darf nicht Handzettel darstellen");
 298
 299                     if (nStartPos > 0 && nPage > 1)
 300                         ((SdrPageObj*)pObj)->SetReferencedPage(GetPage(nPage - 1));
 301                 }
 302             }
 303         }
 304     }
 305 }
 306
 307 void SdDrawDocument::UpdatePageRelativeURLs(const String& rOldName, const String& rNewName)
 308 {
 309     if (rNewName.Len() == 0)
 310         return;
 311
 312     SfxItemPool& pPool(GetPool());
 313     USHORT nCount = pPool.GetItemCount(EE_FEATURE_FIELD);
 314     for (USHORT nOff = 0; nOff < nCount; nOff++)
 315     {
 316         const SfxPoolItem *pItem = pPool.GetItem(EE_FEATURE_FIELD, nOff);
 317         const SvxFieldItem* pFldItem = dynamic_cast< const SvxFieldItem * > (pItem);
 318
 319         if(pFldItem)
 320         {
 321             SvxURLField* pURLField = const_cast< SvxURLField* >( dynamic_cast<const SvxURLField*>( pFldItem->GetField() ) );
 322
 323             if(pURLField)
 324             {
 325                 XubString aURL = pURLField->GetURL();
 326
 327                 if (aURL.Len() && (aURL.GetChar(0) == 35) && (aURL.Search(rOldName, 1) == 1))
 328                 {
 329                     if (aURL.Len() == rOldName.Len() + 1) // standard page name
 330                     {
 331                         aURL.Erase (1, aURL.Len() - 1);
 332                         aURL += rNewName;
 333                         pURLField->SetURL(aURL);
 334                     }
 335                     else
 336                     {
 337                         const XubString sNotes = SdResId(STR_NOTES);
 338                         if (aURL.Len() == rOldName.Len() + 2 + sNotes.Len() && aURL.Search(sNotes, rOldName.Len() + 2) == rOldName.Len() + 2)
 339                         {
 340                             aURL.Erase (1, aURL.Len() - 1);
 341                             aURL += rNewName;
 342                             aURL += ' ';
 343                             aURL += sNotes;
 344                             pURLField->SetURL(aURL);
 345                         }
 346                     }
 347                 }
 348             }
 349         }
 350     }
 351 }
 352
 353 void SdDrawDocument::UpdatePageRelativeURLs(SdPage* pPage, USHORT nPos, sal_Int32 nIncrement)
 354 {
 355     bool bNotes = (pPage->GetPageKind() == PK_NOTES);
 356
 357     SfxItemPool& pPool(GetPool());
 358     USHORT nCount = pPool.GetItemCount(EE_FEATURE_FIELD);
 359     for (USHORT nOff = 0; nOff < nCount; nOff++)
 360     {
 361         const SfxPoolItem *pItem = pPool.GetItem(EE_FEATURE_FIELD, nOff);
 362         const SvxFieldItem* pFldItem;
 363
 364         if ((pFldItem = dynamic_cast< const SvxFieldItem * > (pItem)) != 0)
 365         {
 366             SvxURLField* pURLField = const_cast< SvxURLField* >( dynamic_cast<const SvxURLField*>( pFldItem->GetField() ) );
 367
 368             if(pURLField)
 369             {
 370                 XubString aURL = pURLField->GetURL();
 371
 372                 if (aURL.Len() && (aURL.GetChar(0) == 35))
 373                 {
 374                     XubString aHashSlide('#');
 375                     aHashSlide += SdResId(STR_PAGE);
 376
 377                     if (aURL.CompareTo(aHashSlide, aHashSlide.Len()) == COMPARE_EQUAL)
 378                     {
 379                         XubString aURLCopy = aURL;
 380                         const XubString sNotes = SdResId(STR_NOTES);
 381
 382                         aURLCopy.Erase(0, aHashSlide.Len());
 383
 384                         bool bNotesLink = (aURLCopy.Len() >= sNotes.Len() + 3 && aURLCopy.Search(sNotes, aURLCopy.Len() - sNotes.Len()) == aURLCopy.Len() - sNotes.Len());
 385
 386                         if (bNotesLink ^ bNotes)
 387                             continue; // no compatible link and page
 388
 389                         if (bNotes)
 390                             aURLCopy.Erase(aURLCopy.Len() - sNotes.Len(), sNotes.Len());
 391
 392                         sal_Int32 number = aURLCopy.ToInt32();
 393                         USHORT realPageNumber = (nPos + 1)/ 2;
 394
 395                         if ( number >= realPageNumber )
 396                         {
 397                             // update link page number
 398                             number += nIncrement;
 399                             aURL.Erase (aHashSlide.Len() + 1, aURL.Len() - aHashSlide.Len() - 1);
 400                             aURL += XubString::CreateFromInt32(number);
 401                             if (bNotes)
 402                             {
 403                                 aURL += ' ';
 404                                 aURL += sNotes;
 405                             }
 406                             pURLField->SetURL(aURL);
 407                         }
 408                     }
 409                 }
 410             }
 411         }
 412     }
 413 }
 414
 415 /*************************************************************************
 416 |*
 417 |*      Seite verschieben
 418 |*
 419 \************************************************************************/
 420
 421 void SdDrawDocument::MovePage(USHORT nPgNum, USHORT nNewPos)
 422 {
 423     // Seite verschieben
 424     FmFormModel::MovePage(nPgNum, nNewPos);
 425
 426     USHORT nMin = Min(nPgNum, nNewPos);
 427
 428     UpdatePageObjectsInNotes(nMin);
 429 }
 430
 431 /*************************************************************************
 432 |*
 433 |*      Seite einfuegen
 434 |*
 435 \************************************************************************/
 436
 437 void SdDrawDocument::InsertPage(SdrPage* pPage, USHORT nPos)
 438 {
 439     bool bLast = (nPos == GetPageCount());
 440
 441     FmFormModel::InsertPage(pPage, nPos);
 442
 443     ((SdPage*)pPage)->ConnectLink();
 444
 445     UpdatePageObjectsInNotes(nPos);
 446
 447     if (!bLast)
 448         UpdatePageRelativeURLs(static_cast<SdPage*>( pPage ), nPos, 1);
 449
 450 }
 451
 452 /*************************************************************************
 453 |*
 454 |*      Seite loeschen
 455 |*
 456 \************************************************************************/
 457
 458 void SdDrawDocument::DeletePage(USHORT nPgNum)
 459 {
 460     FmFormModel::DeletePage(nPgNum);
 461
 462     UpdatePageObjectsInNotes(nPgNum);
 463 }
 464
 465 /*************************************************************************
 466 |*
 467 |*      Seite entfernen
 468 |*
 469 \************************************************************************/
 470
 471 SdrPage* SdDrawDocument::RemovePage(USHORT nPgNum)
 472 {
 473     SdrPage* pPage = FmFormModel::RemovePage(nPgNum);
 474
 475     bool bLast = ((nPgNum+1)/2 == (GetPageCount()+1)/2);
 476
 477     ((SdPage*)pPage)->DisconnectLink();
 478     ReplacePageInCustomShows( dynamic_cast< SdPage* >( pPage ), 0 );
 479     UpdatePageObjectsInNotes(nPgNum);
 480
 481     if (!bLast)
 482         UpdatePageRelativeURLs((SdPage*)pPage, nPgNum, -1);
 483
 484     return pPage;
 485 }
 486
 487 // Warning: This is not called for new master pages created from SdrModel::Merge,
 488 // you also have to modify code in SdDrawDocument::Merge!
 489 void SdDrawDocument::InsertMasterPage(SdrPage* pPage, USHORT nPos )
 490 {
 491     FmFormModel::InsertMasterPage( pPage, nPos );
 492     if( pPage && pPage->IsMasterPage() && (static_cast<SdPage*>(pPage)->GetPageKind() == PK_STANDARD) )
 493     {
 494         // new master page created, add its style family
 495         SdStyleSheetPool* pStylePool = (SdStyleSheetPool*) GetStyleSheetPool();
 496         if( pStylePool )
 497             pStylePool->AddStyleFamily( static_cast<SdPage*>(pPage) );
 498     }
 499 }
 500
 501 SdrPage* SdDrawDocument::RemoveMasterPage(USHORT nPgNum)
 502 {
 503     SdPage* pPage = static_cast<SdPage*>(GetMasterPage(nPgNum ));
 504     if( pPage && pPage->IsMasterPage() && (pPage->GetPageKind() == PK_STANDARD) )
 505     {
 506         // master page removed, remove its style family
 507         SdStyleSheetPool* pStylePool = (SdStyleSheetPool*) GetStyleSheetPool();
 508         if( pStylePool )
 509             pStylePool->RemoveStyleFamily( pPage );
 510     }
 511
 512     return FmFormModel::RemoveMasterPage(nPgNum);
 513 }
 514
 515 /*************************************************************************
 516 |*
 517 |* Seiten selektieren
 518 |*
 519 \************************************************************************/
 520
 521 void SdDrawDocument::SetSelected(SdPage* pPage, BOOL bSelect)
 522 {
 523     PageKind ePageKind = pPage->GetPageKind();
 524
 525     if (ePageKind == PK_STANDARD)
 526     {
 527         pPage->SetSelected(bSelect);
 528
 529         const sal_uInt16 nDestPageNum(pPage->GetPageNum() + 1);
 530         SdPage* pNotesPage = 0L;
 531
 532         if(nDestPageNum < GetPageCount())
 533         {
 534             pNotesPage = (SdPage*)GetPage(nDestPageNum);
 535         }
 536
 537         if (pNotesPage && pNotesPage->GetPageKind() == PK_NOTES)
 538         {
 539             pNotesPage->SetSelected(bSelect);
 540         }
 541     }
 542     else if (ePageKind == PK_NOTES)
 543     {
 544         pPage->SetSelected(bSelect);
 545         SdPage* pStandardPage = (SdPage*) GetPage( pPage->GetPageNum() - 1 );
 546
 547         if (pStandardPage && pStandardPage->GetPageKind() == PK_STANDARD)
 548             pStandardPage->SetSelected(bSelect);
 549     }
 550 }
 551
 552 /*************************************************************************
 553 |*
 554 |* Sofern noch keine Seiten vorhanden sind, werden nun Seiten erzeugt
 555 |*
 556 \************************************************************************/
 557
 558 void SdDrawDocument::CreateFirstPages( SdDrawDocument* pRefDocument /* = 0 */ )
 559 {
 560     /**************************************************************************
 561     * Wenn noch keine Seite im Model vorhanden ist (Datei-Neu), wird
 562     * eine neue Seite eingefuegt
 563     **************************************************************************/
 564     USHORT nPageCount = GetPageCount();
 565
 566     if (nPageCount <= 1)
 567     {
 568         // #i57181# Paper size depends on Language, like in Writer
 569         Size aDefSize = SvxPaperInfo::GetDefaultPaperSize( MAP_100TH_MM );
 570
 571         /**********************************************************************
 572         * Handzettel-Seite einfuegen
 573         **********************************************************************/
 574         BOOL bMasterPage;
 575         SdPage* pHandoutPage = dynamic_cast< SdPage* >( AllocPage(bMasterPage=FALSE) );
 576
 577         SdPage* pRefPage = NULL;
 578
 579         if( pRefDocument )
 580             pRefPage = pRefDocument->GetSdPage( 0, PK_HANDOUT );
 581
 582         if( pRefPage )
 583         {
 584             pHandoutPage->SetSize(pRefPage->GetSize());
 585             pHandoutPage->SetBorder( pRefPage->GetLftBorder(), pRefPage->GetUppBorder(), pRefPage->GetRgtBorder(), pRefPage->GetLwrBorder() );
 586         }
 587         else
 588         {
 589             pHandoutPage->SetSize(aDefSize);
 590             pHandoutPage->SetBorder(0, 0, 0, 0);
 591         }
 592
 593         pHandoutPage->SetPageKind(PK_HANDOUT);
 594         pHandoutPage->SetName( String (SdResId(STR_HANDOUT) ) );
 595         InsertPage(pHandoutPage, 0);
 596
 597         /**********************************************************************
 598         * MasterPage einfuegen und an der Handzettel-Seite vermerken
 599         **********************************************************************/
 600         SdPage* pHandoutMPage = (SdPage*) AllocPage(bMasterPage=TRUE);
 601         pHandoutMPage->SetSize( pHandoutPage->GetSize() );
 602         pHandoutMPage->SetPageKind(PK_HANDOUT);
 603         pHandoutMPage->SetBorder( pHandoutPage->GetLftBorder(),
 604                                   pHandoutPage->GetUppBorder(),
 605                                   pHandoutPage->GetRgtBorder(),
 606                                   pHandoutPage->GetLwrBorder() );
 607         InsertMasterPage(pHandoutMPage, 0);
 608         pHandoutPage->TRG_SetMasterPage( *pHandoutMPage );
 609
 610         /**********************************************************************
 611         * Seite einfuegen
 612         * Sofern nPageCount==1 ist, wurde das Model fuers Clipboad erzeugt.
 613         * Eine Standard-Seite ist daher schon vorhanden.
 614         **********************************************************************/
 615         SdPage* pPage;
 616         BOOL bClipboard = FALSE;
 617
 618         if( pRefDocument )
 619             pRefPage = pRefDocument->GetSdPage( 0, PK_STANDARD );
 620
 621         if (nPageCount == 0)
 622         {
 623             pPage = dynamic_cast< SdPage* >( AllocPage(bMasterPage=FALSE) );
 624
 625             if( pRefPage )
 626             {
 627                 pPage->SetSize( pRefPage->GetSize() );
 628                 pPage->SetBorder( pRefPage->GetLftBorder(), pRefPage->GetUppBorder(), pRefPage->GetRgtBorder(), pRefPage->GetLwrBorder() );
 629             }
 630             else if (meDocType == DOCUMENT_TYPE_DRAW)
 631             {
 632                 // Draw: stets Default-Groesse mit Raendern
 633                 pPage->SetSize(aDefSize);
 634
 635                 SfxPrinter* pPrinter = mpDocSh->GetPrinter(FALSE);
 636                 if (pPrinter && pPrinter->IsValid())
 637                 {
 638                     Size aOutSize(pPrinter->GetOutputSize());
 639                     Point aPageOffset(pPrinter->GetPageOffset());
 640                     aPageOffset -= pPrinter->PixelToLogic( Point() );
 641                     long nOffset = !aPageOffset.X() && !aPageOffset.X() ? 0 : PRINT_OFFSET;
 642
 643                     ULONG nTop    = aPageOffset.Y();
 644                     ULONG nLeft   = aPageOffset.X();
 645                     ULONG nBottom = Max((long)(aDefSize.Height() - aOutSize.Height() - nTop + nOffset), 0L);
 646                     ULONG nRight  = Max((long)(aDefSize.Width() - aOutSize.Width() - nLeft + nOffset), 0L);
 647
 648                     pPage->SetBorder(nLeft, nTop, nRight, nBottom);
 649                 }
 650                 else
 651                 {
 652                     // The printer is not available.  Use a border of 10mm
 653                     // on each side instead.
 654                     // This has to be kept synchronized with the border
 655                     // width set in the
 656                     // SvxPageDescPage::PaperSizeSelect_Impl callback.
 657                     pPage->SetBorder(1000, 1000, 1000, 1000);
 658                 }
 659             }
 660             else
 661             {
 662                 // Impress: stets Bildschirmformat, quer
 663                 Size aSz( SvxPaperInfo::GetPaperSize(PAPER_SCREEN, MAP_100TH_MM) );
 664                 pPage->SetSize( Size( aSz.Height(), aSz.Width() ) );
 665                 pPage->SetBorder(0, 0, 0, 0);
 666             }
 667
 668             InsertPage(pPage, 1);
 669         }
 670         else
 671         {
 672             bClipboard = TRUE;
 673             pPage = (SdPage*) GetPage(1);
 674         }
 675
 676         /**********************************************************************
 677         * MasterPage einfuegen und an der Seite vermerken
 678         **********************************************************************/
 679         SdPage* pMPage = (SdPage*) AllocPage(bMasterPage=TRUE);
 680         pMPage->SetSize( pPage->GetSize() );
 681         pMPage->SetBorder( pPage->GetLftBorder(),
 682                            pPage->GetUppBorder(),
 683                            pPage->GetRgtBorder(),
 684                            pPage->GetLwrBorder() );
 685         InsertMasterPage(pMPage, 1);
 686         pPage->TRG_SetMasterPage( *pMPage );
 687         if( bClipboard )
 688             pMPage->SetLayoutName( pPage->GetLayoutName() );
 689
 690         /**********************************************************************
 691         * Notizen-Seite einfuegen
 692         **********************************************************************/
 693         SdPage* pNotesPage = (SdPage*) AllocPage(bMasterPage=FALSE);
 694
 695         if( pRefDocument )
 696             pRefPage = pRefDocument->GetSdPage( 0, PK_NOTES );
 697
 698         if( pRefPage )
 699         {
 700             pNotesPage->SetSize( pRefPage->GetSize() );
 701             pNotesPage->SetBorder( pRefPage->GetLftBorder(), pRefPage->GetUppBorder(), pRefPage->GetRgtBorder(), pRefPage->GetLwrBorder() );
 702         }
 703         else
 704         {
 705             // Stets Hochformat
 706             if (aDefSize.Height() >= aDefSize.Width())
 707             {
 708                 pNotesPage->SetSize(aDefSize);
 709             }
 710             else
 711             {
 712                 pNotesPage->SetSize( Size(aDefSize.Height(), aDefSize.Width()) );
 713             }
 714
 715             pNotesPage->SetBorder(0, 0, 0, 0);
 716         }
 717         pNotesPage->SetPageKind(PK_NOTES);
 718         InsertPage(pNotesPage, 2);
 719         if( bClipboard )
 720             pNotesPage->SetLayoutName( pPage->GetLayoutName() );
 721
 722         /**********************************************************************
 723         * MasterPage einfuegen und an der Notizen-Seite vermerken
 724         **********************************************************************/
 725         SdPage* pNotesMPage = (SdPage*) AllocPage(bMasterPage=TRUE);
 726         pNotesMPage->SetSize( pNotesPage->GetSize() );
 727         pNotesMPage->SetPageKind(PK_NOTES);
 728         pNotesMPage->SetBorder( pNotesPage->GetLftBorder(),
 729                                 pNotesPage->GetUppBorder(),
 730                                 pNotesPage->GetRgtBorder(),
 731                                 pNotesPage->GetLwrBorder() );
 732         InsertMasterPage(pNotesMPage, 2);
 733         pNotesPage->TRG_SetMasterPage( *pNotesMPage );
 734         if( bClipboard )
 735             pNotesMPage->SetLayoutName( pPage->GetLayoutName() );
 736
 737         mpWorkStartupTimer = new Timer();
 738         mpWorkStartupTimer->SetTimeoutHdl( LINK(this, SdDrawDocument, WorkStartupHdl) );
 739         mpWorkStartupTimer->SetTimeout(2000);
 740         mpWorkStartupTimer->Start();
 741
 742         SetChanged(FALSE);
 743     }
 744 }
 745
 746 /*************************************************************************
 747 |*
 748 |* Erzeugt fehlende Notiz und Handzettelseiten (nach PowerPoint-Import)
 749 |* Es wird davon ausgegangen, dass mindestens eine Standard-Seite und
 750 |* eine Standard-MasterPage vorhanden sind.
 751 |*
 752 \************************************************************************/
 753
 754 BOOL SdDrawDocument::CreateMissingNotesAndHandoutPages()
 755 {
 756     BOOL bOK = FALSE;
 757     USHORT nPageCount = GetPageCount();
 758
 759     if (nPageCount != 0)
 760     {
 761         /**********************************************************************
 762         * PageKind setzen
 763         **********************************************************************/
 764         SdPage* pHandoutMPage = (SdPage*) GetMasterPage(0);
 765         pHandoutMPage->SetPageKind(PK_HANDOUT);
 766
 767         SdPage* pHandoutPage = (SdPage*) GetPage(0);
 768         pHandoutPage->SetPageKind(PK_HANDOUT);
 769         pHandoutPage->TRG_SetMasterPage( *pHandoutMPage );
 770
 771         for (USHORT i = 1; i < nPageCount; i = i + 2)
 772         {
 773             SdPage* pPage = (SdPage*) GetPage(i);
 774
 775             if(!pPage->TRG_HasMasterPage())
 776             {
 777                 // Keine MasterPage gesetzt -> erste Standard-MasterPage nehmen
 778                 // (Wenn bei PPT keine Standard-Seite vorhanden war)
 779                 pPage->TRG_SetMasterPage(*GetMasterPage(1));
 780             }
 781
 782             SdPage* pNotesPage = (SdPage*) GetPage(i+1);
 783             pNotesPage->SetPageKind(PK_NOTES);
 784
 785             // Notiz-MasterPages setzen
 786             sal_uInt16 nMasterPageAfterPagesMasterPage = (pPage->TRG_GetMasterPage()).GetPageNum() + 1;
 787             pNotesPage->TRG_SetMasterPage(*GetMasterPage(nMasterPageAfterPagesMasterPage));
 788         }
 789
 790         bOK = TRUE;
 791         StopWorkStartupDelay();
 792         SetChanged(FALSE);
 793     }
 794
 795     return(bOK);
 796 }
 797
 798 /*************************************************************************
 799 |*
 800 |* - selektierte Seiten hinter genannte Seite schieben
 801 |*       (nTargetPage = (USHORT)-1      --> vor erste Seite schieben)
 802 |* - ergibt TRUE, wenn Seiten verschoben wurden
 803 |*
 804 \************************************************************************/
 805
 806 BOOL SdDrawDocument::MovePages(USHORT nTargetPage)
 807 {
 808     SdPage* pTargetPage            = NULL;
 809     SdPage* pPage                          = NULL;
 810     USHORT      nPage;
 811     USHORT      nNoOfPages                 = GetSdPageCount(PK_STANDARD);
 812     BOOL        bSomethingHappened = FALSE;
 813
 814     const bool bUndo = IsUndoEnabled();
 815
 816     if( bUndo )
 817         BegUndo(String(SdResId(STR_UNDO_MOVEPAGES)));
 818
 819     // Liste mit selektierten Seiten
 820     List        aPageList;
 821     for (nPage = 0; nPage < nNoOfPages; nPage++)
 822     {
 823         pPage = GetSdPage(nPage, PK_STANDARD);
 824         if (pPage->IsSelected())
 825         {
 826             aPageList.Insert(pPage, LIST_APPEND);
 827         }
 828     }
 829
 830     // falls noetig, nach vorne hangeln, bis nicht selektierte Seite gefunden
 831     nPage = nTargetPage;
 832     if (nPage != (USHORT)-1)
 833     {
 834         pPage = GetSdPage(nPage, PK_STANDARD);
 835         while (nPage > 0 && pPage->IsSelected())
 836         {
 837             nPage--;
 838             pPage = GetSdPage(nPage, PK_STANDARD);
 839         }
 840
 841         if (pPage->IsSelected())
 842         {
 843             nPage = (USHORT)-1;
 844         }
 845     }
 846
 847     // vor der ersten Seite einfuegen
 848     if (nPage == (USHORT)-1)
 849     {
 850         while (aPageList.Count() > 0)
 851         {
 852             aPageList.Last();
 853
 854             nPage = ( (SdPage*) aPageList.GetCurObject() )->GetPageNum();
 855             if (nPage != 0)
 856             {
 857                 SdrPage* pPg = GetPage(nPage);
 858                 if( bUndo )
 859                     AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage, 1));
 860                 MovePage(nPage, 1);
 861                 pPg = GetPage(nPage+1);
 862                 if( bUndo )
 863                     AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage+1, 2));
 864                 MovePage(nPage+1, 2);
 865                 bSomethingHappened = TRUE;
 866             }
 867             aPageList.Remove();
 868         }
 869     }
 870     // hinter <nPage> einfuegen
 871     else
 872     {
 873         pTargetPage = GetSdPage(nPage, PK_STANDARD);
 874         nTargetPage = nPage;
 875         nTargetPage = 2 * nTargetPage + 1;        // PK_STANDARD --> absolut
 876         while (aPageList.Count() > 0)
 877         {
 878             pPage = (SdPage*)aPageList.GetObject(0);
 879             nPage = pPage->GetPageNum();
 880             if (nPage > nTargetPage)
 881             {
 882                 nTargetPage += 2;                // hinter (!) der Seite einfuegen
 883
 884                 if (nPage != nTargetPage)
 885                 {
 886                     SdrPage* pPg = GetPage(nPage);
 887                     if( bUndo )
 888                         AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage, nTargetPage));
 889                     MovePage(nPage, nTargetPage);
 890                     pPg = GetPage(nPage+1);
 891                     if( bUndo )
 892                         AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage+1, nTargetPage+1));
 893                     MovePage(nPage+1, nTargetPage+1);
 894                     bSomethingHappened = TRUE;
 895                 }
 896             }
 897             else
 898             {
 899                 if (nPage != nTargetPage)
 900                 {
 901                     SdrPage* pPg = GetPage(nPage+1);
 902                     if( bUndo )
 903                         AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage+1, nTargetPage+1));
 904                     MovePage(nPage+1, nTargetPage+1);
 905                     pPg = GetPage(nPage);
 906                     if( bUndo )
 907                         AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*pPg, nPage, nTargetPage));
 908                     MovePage(nPage, nTargetPage);
 909                     bSomethingHappened = TRUE;
 910                 }
 911             }
 912             aPageList.Remove((ULONG)0);
 913             nTargetPage = pPage->GetPageNum();
 914         }
 915     }
 916
 917     if( bUndo )
 918         EndUndo();
 919
 920     return bSomethingHappened;
 921 }
 922
 923
 924 /*************************************************************************
 925 |*
 926 |* Anzahl der Links im LinkManager zurueckgeben
 927 |*
 928 \************************************************************************/
 929
 930 ULONG SdDrawDocument::GetLinkCount()
 931 {
 932     return ( pLinkManager->GetLinks().Count() );
 933 }
 934
 935 /*************************************************************************
 936 |*
 937 |* Language setzen
 938 |*
 939 \************************************************************************/
 940
 941 void SdDrawDocument::SetLanguage( const LanguageType eLang, const USHORT nId )
 942 {
 943     BOOL bChanged = FALSE;
 944
 945     if( nId == EE_CHAR_LANGUAGE && meLanguage != eLang )
 946     {
 947         meLanguage = eLang;
 948         bChanged = TRUE;
 949     }
 950     else if( nId == EE_CHAR_LANGUAGE_CJK && meLanguageCJK != eLang )
 951     {
 952         meLanguageCJK = eLang;
 953         bChanged = TRUE;
 954     }
 955     else if( nId == EE_CHAR_LANGUAGE_CTL && meLanguageCTL != eLang )
 956     {
 957         meLanguageCTL = eLang;
 958         bChanged = TRUE;
 959     }
 960
 961     if( bChanged )
 962     {
 963         GetDrawOutliner().SetDefaultLanguage( Application::GetSettings().GetLanguage() );
 964         pHitTestOutliner->SetDefaultLanguage( Application::GetSettings().GetLanguage() );
 965         pItemPool->SetPoolDefaultItem( SvxLanguageItem( eLang, nId ) );
 966         SetChanged( bChanged );
 967     }
 968 }
 969
 970
 971 /*************************************************************************
 972 |*
 973 |* Return language
 974 |*
 975 \************************************************************************/
 976
 977 LanguageType SdDrawDocument::GetLanguage( const USHORT nId ) const
 978 {
 979     LanguageType eLangType = meLanguage;
 980
 981     if( nId == EE_CHAR_LANGUAGE_CJK )
 982         eLangType = meLanguageCJK;
 983     else if( nId == EE_CHAR_LANGUAGE_CTL )
 984         eLangType = meLanguageCTL;
 985
 986     return eLangType;
 987 }
 988
 989
 990 /*************************************************************************
 991 |*
 992 |* WorkStartup einleiten
 993 |*
 994 \************************************************************************/
 995
 996 IMPL_LINK( SdDrawDocument, WorkStartupHdl, Timer *, EMPTYARG )
 997 {
 998     if( mpDocSh )
 999         mpDocSh->SetWaitCursor( TRUE );
1000
1001     BOOL bChanged = IsChanged();                // merken
1002
1003     // Autolayouts initialisieren
1004     SdPage* pHandoutMPage = GetMasterSdPage(0, PK_HANDOUT);
1005
1006     if (pHandoutMPage->GetAutoLayout() == AUTOLAYOUT_NONE)
1007     {
1008         // AutoLayout wurde noch nicht umgesetzt -> Initialisieren
1009         pHandoutMPage->SetAutoLayout(AUTOLAYOUT_HANDOUT6, TRUE, TRUE);
1010     }
1011
1012     SdPage* pPage = GetSdPage(0, PK_STANDARD);
1013
1014     if (pPage->GetAutoLayout() == AUTOLAYOUT_NONE)
1015     {
1016         // AutoLayout wurde noch nicht umgesetzt -> Initialisieren
1017         pPage->SetAutoLayout(AUTOLAYOUT_NONE, TRUE, TRUE);
1018     }
1019
1020     SdPage* pNotesPage = GetSdPage(0, PK_NOTES);
1021
1022     if (pNotesPage->GetAutoLayout() == AUTOLAYOUT_NONE)
1023     {
1024         // AutoLayout wurde noch nicht umgesetzt -> Initialisieren
1025         pNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, TRUE, TRUE);
1026     }
1027
1028     SetChanged(bChanged || FALSE);
1029
1030     if( mpDocSh )
1031         mpDocSh->SetWaitCursor( FALSE );
1032     return 0;
1033 }
1034
1035
1036 /*************************************************************************
1037 |*
1038 |* Wenn der WorkStartupTimer erzeugt worden ist (das erfolgt ausschliesslich
1039 |* in SdDrawViewShell::Consruct() ), so wird der Timer ggf. gestoppt und
1040 |* das WorkStartup eingeleitet
1041 |*
1042 \************************************************************************/
1043
1044 void SdDrawDocument::StopWorkStartupDelay()
1045 {
1046     if (mpWorkStartupTimer)
1047     {
1048         if ( mpWorkStartupTimer->IsActive() )
1049         {
1050             // Timer war noch nicht abgelaufen -> WorkStartup wird eingeleitet
1051             mpWorkStartupTimer->Stop();
1052             WorkStartupHdl(NULL);
1053         }
1054
1055         delete mpWorkStartupTimer;
1056         mpWorkStartupTimer = NULL;
1057     }
1058 }
1059
1060 /*************************************************************************
1061 |*
1062 |* Wenn der WorkStartupTimer erzeugt worden ist (das erfolgt ausschliesslich
1063 |* in SdDrawViewShell::Consruct() ), so wird der Timer ggf. gestoppt und
1064 |* das WorkStartup eingeleitet
1065 |*
1066 \************************************************************************/
1067
1068 SdAnimationInfo* SdDrawDocument::GetAnimationInfo(SdrObject* pObject) const
1069 {
1070     DBG_ASSERT(pObject, "sd::SdDrawDocument::GetAnimationInfo(), invalid argument!");
1071     if( pObject )
1072         return GetShapeUserData( *pObject, false );
1073     else
1074         return 0;
1075 }
1076
1077 SdAnimationInfo* SdDrawDocument::GetShapeUserData(SdrObject& rObject, bool bCreate /* = false */ )
1078 {
1079     USHORT nUD                  = 0;
1080     USHORT nUDCount     = rObject.GetUserDataCount();
1081     SdrObjUserData* pUD = 0;
1082     SdAnimationInfo* pRet = 0;
1083
1084     // gibt es in den User-Daten eine Animationsinformation?
1085     for (nUD = 0; nUD < nUDCount; nUD++)
1086     {
1087         pUD = rObject.GetUserData(nUD);
1088         if((pUD->GetInventor() == SdUDInventor) && (pUD->GetId() == SD_ANIMATIONINFO_ID))
1089         {
1090             pRet = dynamic_cast<SdAnimationInfo*>(pUD);
1091             break;
1092         }
1093     }
1094
1095     if( (pRet == 0) && bCreate )
1096     {
1097         pRet = new SdAnimationInfo( rObject );
1098         rObject.InsertUserData( pRet);
1099     }
1100
1101     return pRet;
1102 }
1103
1104
1105 /*************************************************************************
1106 |*
1107 |*
1108 |*
1109 \************************************************************************/
1110
1111 SdIMapInfo* SdDrawDocument::GetIMapInfo( SdrObject* pObject ) const
1112 {
1113     DBG_ASSERT(pObject, "ohne Objekt keine IMapInfo");
1114
1115     SdrObjUserData* pUserData = NULL;
1116     SdIMapInfo*         pIMapInfo = NULL;
1117     USHORT                      nCount = pObject->GetUserDataCount();
1118
1119     // gibt es in den User-Daten eine IMap-Information?
1120     for ( USHORT i = 0; i < nCount; i++ )
1121     {
1122         pUserData = pObject->GetUserData( i );
1123
1124         if ( ( pUserData->GetInventor() == SdUDInventor ) && ( pUserData->GetId() == SD_IMAPINFO_ID ) )
1125             pIMapInfo = (SdIMapInfo*) pUserData;
1126     }
1127
1128     return pIMapInfo;
1129 }
1130
1131
1132 /*************************************************************************
1133 |*
1134 |*
1135 |*
1136 \************************************************************************/
1137
1138 IMapObject* SdDrawDocument::GetHitIMapObject( SdrObject* pObj,
1139                                               const Point& rWinPoint,
1140                                               const ::Window& /* rCmpWnd */ )
1141 {
1142     SdIMapInfo* pIMapInfo = GetIMapInfo( pObj );
1143     IMapObject* pIMapObj = NULL;
1144
1145     if ( pIMapInfo )
1146     {
1147         const MapMode           aMap100( MAP_100TH_MM );
1148         Size                            aGraphSize;
1149         Point                           aRelPoint( rWinPoint );
1150         ImageMap&                       rImageMap = (ImageMap&) pIMapInfo->GetImageMap();
1151         const Rectangle&        rRect = pObj->GetLogicRect();
1152         BOOL                            bObjSupported = FALSE;
1153
1154         // HitTest ausfuehren
1155         if ( pObj->ISA( SdrGrafObj )  ) // einfaches Grafik-Objekt
1156         {
1157             const SdrGrafObj*   pGrafObj = (const SdrGrafObj*) pObj;
1158             const GeoStat&              rGeo = pGrafObj->GetGeoStat();
1159             SdrGrafObjGeoData*  pGeoData = (SdrGrafObjGeoData*) pGrafObj->GetGeoData();
1160
1161             // Drehung rueckgaengig
1162             if ( rGeo.nDrehWink )
1163                 RotatePoint( aRelPoint, rRect.TopLeft(), -rGeo.nSin, rGeo.nCos );
1164
1165             // Spiegelung rueckgaengig
1166             if ( pGeoData->bMirrored )
1167                 aRelPoint.X() = rRect.Right() + rRect.Left() - aRelPoint.X();
1168
1169             // ggf. Unshear:
1170             if ( rGeo.nShearWink )
1171                 ShearPoint( aRelPoint, rRect.TopLeft(), -rGeo.nTan );
1172
1173             if ( pGrafObj->GetGrafPrefMapMode().GetMapUnit() == MAP_PIXEL )
1174                 aGraphSize = Application::GetDefaultDevice()->PixelToLogic( pGrafObj->GetGrafPrefSize(), aMap100 );
1175             else
1176                 aGraphSize = OutputDevice::LogicToLogic( pGrafObj->GetGrafPrefSize(),
1177                                                          pGrafObj->GetGrafPrefMapMode(), aMap100 );
1178
1179             delete pGeoData;
1180             bObjSupported = TRUE;
1181         }
1182         else if ( pObj->ISA( SdrOle2Obj ) ) // OLE-Objekt
1183         {
1184             aGraphSize = ( (SdrOle2Obj*) pObj )->GetOrigObjSize();
1185             bObjSupported = TRUE;
1186         }
1187
1188         // hat alles geklappt, dann HitTest ausfuehren
1189         if ( bObjSupported )
1190         {
1191             // relativen Mauspunkt berechnen
1192             aRelPoint -= rRect.TopLeft();
1193             pIMapObj = rImageMap.GetHitIMapObject( aGraphSize, rRect.GetSize(), aRelPoint );
1194
1195             // Deaktivierte Objekte wollen wir nicht
1196             if ( pIMapObj && !pIMapObj->IsActive() )
1197                 pIMapObj = NULL;
1198         }
1199     }
1200
1201     return pIMapObj;
1202 }
1203
1204 /** this method enforces that the masterpages are in the currect order,
1205     that is at position 1 is a PK_STANDARD masterpage followed by a
1206     PK_NOTES masterpage and so on. #
1207 */
1208 void SdDrawDocument::CheckMasterPages()
1209 {
1210 //      RemoveMasterPage(2); // code to test the creation of notes pages
1211
1212     USHORT nMaxPages = GetMasterPageCount();
1213
1214     // we need at least a handout master and one master page
1215     if( nMaxPages < 2 )
1216     {
1217         return;
1218     }
1219
1220     SdPage* pPage = NULL;
1221     SdPage* pNotesPage = NULL;
1222
1223     USHORT nPage;
1224
1225     // first see if the page order is correct
1226     for( nPage = 1; nPage < nMaxPages; nPage++ )
1227     {
1228         pPage = static_cast<SdPage*> (GetMasterPage( nPage ));
1229         // if an odd page is not a standard page or an even page is not a notes page
1230         if( ((1 == (nPage & 1)) && (pPage->GetPageKind() != PK_STANDARD) ) ||
1231             ((0 == (nPage & 1)) && (pPage->GetPageKind() != PK_NOTES) ) )
1232             break; // then we have a fatal error
1233     }
1234
1235     if( nPage < nMaxPages )
1236     {
1237         // there is a fatal error in the master page order,
1238         // we need to repair the document
1239         sal_Bool bChanged = sal_False;
1240
1241         nPage = 1;
1242         while( nPage < nMaxPages )
1243         {
1244             pPage = static_cast<SdPage*> (GetMasterPage( nPage ));
1245             if( pPage->GetPageKind() != PK_STANDARD )
1246             {
1247                 bChanged = sal_True;
1248                 USHORT nFound = nPage + 1;
1249                 while( nFound < nMaxPages )
1250                 {
1251                     pPage = static_cast<SdPage*>(GetMasterPage( nFound ));
1252                     if( PK_STANDARD == pPage->GetPageKind() )
1253                     {
1254                         MoveMasterPage( nFound, nPage );
1255                         pPage->SetInserted(sal_True);
1256                         break;
1257
1258                     }
1259
1260                     nFound++;
1261                 }
1262
1263                 // if we don't have any more standard pages, were done
1264                 if( nMaxPages == nFound )
1265                     break;
1266             }
1267
1268             nPage++;
1269
1270             if( nPage < nMaxPages )
1271                 pNotesPage = static_cast<SdPage*>(GetMasterPage( nPage ));
1272             else
1273                 pNotesPage = NULL;
1274
1275             if( (NULL == pNotesPage) || (pNotesPage->GetPageKind() != PK_NOTES) || ( pPage->GetLayoutName() != pNotesPage->GetLayoutName() ) )
1276             {
1277                 bChanged = sal_True;
1278
1279                 USHORT nFound = nPage + 1;
1280                 while( nFound < nMaxPages )
1281                 {
1282                     pNotesPage = static_cast<SdPage*>(GetMasterPage( nFound ));
1283                     if( (PK_NOTES == pNotesPage->GetPageKind()) && ( pPage->GetLayoutName() == pNotesPage->GetLayoutName() ) )
1284                     {
1285                         MoveMasterPage( nFound, nPage );
1286                         pNotesPage->SetInserted(sal_True);
1287                         break;
1288                     }
1289
1290                     nFound++;
1291                 }
1292
1293                 // looks like we lost a notes page
1294                 if( nMaxPages == nFound )
1295                 {
1296                     // so create one
1297
1298                     // first find a reference notes page for size
1299                     SdPage* pRefNotesPage = NULL;
1300                     nFound = 0;
1301                     while( nFound < nMaxPages )
1302                     {
1303                         pRefNotesPage = static_cast<SdPage*>(GetMasterPage( nFound ));
1304                         if( PK_NOTES == pRefNotesPage->GetPageKind() )
1305                             break;
1306                         nFound++;
1307                     }
1308                     if( nFound == nMaxPages )
1309                         pRefNotesPage = NULL;
1310
1311                     SdPage* pNewNotesPage = static_cast<SdPage*>(AllocPage(sal_True));
1312                     pNewNotesPage->SetPageKind(PK_NOTES);
1313                     if( pRefNotesPage )
1314                     {
1315                         pNewNotesPage->SetSize( pRefNotesPage->GetSize() );
1316                         pNewNotesPage->SetBorder( pRefNotesPage->GetLftBorder(),
1317                                                 pRefNotesPage->GetUppBorder(),
1318                                                 pRefNotesPage->GetRgtBorder(),
1319                                                 pRefNotesPage->GetLwrBorder() );
1320                     }
1321                     InsertMasterPage(pNewNotesPage,  nPage );
1322                     pNewNotesPage->SetLayoutName( pPage->GetLayoutName() );
1323                     pNewNotesPage->SetAutoLayout(AUTOLAYOUT_NOTES, sal_True, sal_True );
1324                     nMaxPages++;
1325                 }
1326             }
1327
1328             nPage++;
1329         }
1330
1331         // now remove all remaining and unused non PK_STANDARD slides
1332         while( nPage < nMaxPages )
1333         {
1334             bChanged = sal_True;
1335
1336             RemoveMasterPage( nPage );
1337             nMaxPages--;
1338         }
1339
1340         if( bChanged )
1341         {
1342             DBG_ERROR( "master pages where in a wrong order" );
1343             RecalcPageNums( sal_True);
1344         }
1345     }
1346 }
1347
1348
1349
1350
1351 USHORT SdDrawDocument::CreatePage (USHORT nPageNum)
1352 {
1353     PageKind ePageKind = PK_STANDARD;
1354
1355     // Get current page.
1356     SdPage* pActualPage = GetSdPage(nPageNum, ePageKind);
1357
1358     // Get background flags.
1359     SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
1360     BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE);
1361     BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE);
1362     SetOfByte aVisibleLayers = pActualPage->TRG_GetMasterPageVisibleLayers();
1363
1364     // Get layout from current page.
1365     AutoLayout eAutoLayout = pActualPage->GetAutoLayout();
1366
1367     return CreatePage (
1368         pActualPage, ePageKind,
1369         // No names for the new slides.
1370         String(), String(),
1371         eAutoLayout, eAutoLayout,
1372         aVisibleLayers.IsSet(aBckgrnd),
1373         aVisibleLayers.IsSet(aBckgrndObj));
1374 }
1375
1376
1377
1378
1379 USHORT SdDrawDocument::CreatePage (
1380     SdPage* pActualPage,
1381     PageKind ePageKind,
1382     const String& sStandardPageName,
1383     const String& sNotesPageName,
1384     AutoLayout eStandardLayout,
1385     AutoLayout eNotesLayout,
1386     BOOL bIsPageBack,
1387     BOOL bIsPageObj)
1388 {
1389     SdPage* pPreviousStandardPage;
1390     SdPage* pPreviousNotesPage;
1391     SdPage* pStandardPage;
1392     SdPage* pNotesPage;
1393
1394     // From the given page determine the standard page and notes page of which
1395     // to take the layout and the position where to insert the new pages.
1396     if (ePageKind == PK_NOTES)
1397     {
1398         pPreviousNotesPage = pActualPage;
1399         USHORT nNotesPageNum = pPreviousNotesPage->GetPageNum() + 2;
1400         pPreviousStandardPage = (SdPage*) GetPage(nNotesPageNum - 3);
1401         eStandardLayout = pPreviousStandardPage->GetAutoLayout();
1402     }
1403     else
1404     {
1405         pPreviousStandardPage = pActualPage;
1406         USHORT nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
1407         pPreviousNotesPage = (SdPage*) GetPage(nStandardPageNum - 1);
1408         eNotesLayout = pPreviousNotesPage->GetAutoLayout();
1409     }
1410
1411     // Create new standard page and set it up.
1412     pStandardPage = (SdPage*) AllocPage(FALSE);
1413
1414     // #108658#
1415     // Set the size here since else the presobj autolayout
1416     // will be wrong.
1417     pStandardPage->SetSize( pPreviousStandardPage->GetSize() );
1418     pStandardPage->SetBorder( pPreviousStandardPage->GetLftBorder(),
1419                               pPreviousStandardPage->GetUppBorder(),
1420                               pPreviousStandardPage->GetRgtBorder(),
1421                               pPreviousStandardPage->GetLwrBorder() );
1422
1423     // Use master page of current page.
1424     pStandardPage->TRG_SetMasterPage(pPreviousStandardPage->TRG_GetMasterPage());
1425
1426     // User layout of current standard page.
1427     pStandardPage->SetLayoutName( pPreviousStandardPage->GetLayoutName() );
1428     pStandardPage->SetAutoLayout(eStandardLayout, TRUE);
1429     pStandardPage->setHeaderFooterSettings( pPreviousStandardPage->getHeaderFooterSettings() );
1430
1431     // transition settings of current page
1432     pStandardPage->setTransitionType( pPreviousStandardPage->getTransitionType() );
1433     pStandardPage->setTransitionSubtype( pPreviousStandardPage->getTransitionSubtype() );
1434     pStandardPage->setTransitionDirection( pPreviousStandardPage->getTransitionDirection() );
1435     pStandardPage->setTransitionFadeColor( pPreviousStandardPage->getTransitionFadeColor() );
1436     pStandardPage->setTransitionDuration( pPreviousStandardPage->getTransitionDuration() );
1437
1438     // apply previous animation timing
1439     pStandardPage->SetPresChange( pPreviousStandardPage->GetPresChange() );
1440     pStandardPage->SetTime( pPreviousStandardPage->GetTime() );
1441
1442     // Create new notes page and set it up.
1443     pNotesPage = (SdPage*) AllocPage(FALSE);
1444     pNotesPage->SetPageKind(PK_NOTES);
1445
1446     // Use master page of current page.
1447     pNotesPage->TRG_SetMasterPage(pPreviousNotesPage->TRG_GetMasterPage());
1448
1449     // Use layout of current notes page.
1450     pNotesPage->SetLayoutName( pPreviousNotesPage->GetLayoutName() );
1451     pNotesPage->SetAutoLayout(eNotesLayout, TRUE);
1452     pNotesPage->setHeaderFooterSettings( pPreviousNotesPage->getHeaderFooterSettings() );
1453
1454     return InsertPageSet (
1455         pActualPage, ePageKind,
1456         sStandardPageName,
1457         sNotesPageName,
1458         eStandardLayout,
1459         eNotesLayout,
1460         bIsPageBack,
1461         bIsPageObj,
1462
1463         pStandardPage,
1464         pNotesPage);
1465 }
1466
1467
1468
1469
1470 USHORT SdDrawDocument::DuplicatePage (USHORT nPageNum)
1471 {
1472     PageKind ePageKind = PK_STANDARD;
1473
1474     // Get current page.
1475     SdPage* pActualPage = GetSdPage(nPageNum, ePageKind);
1476
1477     // Get background flags.
1478     SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
1479     BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE);
1480     BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE);
1481     SetOfByte aVisibleLayers = pActualPage->TRG_GetMasterPageVisibleLayers();
1482
1483     // Get layout from current page.
1484     AutoLayout eAutoLayout = pActualPage->GetAutoLayout();
1485
1486     return DuplicatePage (
1487         pActualPage, ePageKind,
1488         // No names for the new slides.
1489         String(), String(),
1490         eAutoLayout, eAutoLayout,
1491         aVisibleLayers.IsSet(aBckgrnd),
1492         aVisibleLayers.IsSet(aBckgrndObj));
1493 }
1494
1495
1496
1497
1498 USHORT SdDrawDocument::DuplicatePage (
1499     SdPage* pActualPage,
1500     PageKind ePageKind,
1501     const String& sStandardPageName,
1502     const String& sNotesPageName,
1503     AutoLayout eStandardLayout,
1504     AutoLayout eNotesLayout,
1505     BOOL bIsPageBack,
1506     BOOL bIsPageObj)
1507 {
1508     SdPage* pPreviousStandardPage;
1509     SdPage* pPreviousNotesPage;
1510     SdPage* pStandardPage;
1511     SdPage* pNotesPage;
1512
1513     // From the given page determine the standard page and the notes page
1514     // of which to make copies.
1515     if (ePageKind == PK_NOTES)
1516     {
1517         pPreviousNotesPage = pActualPage;
1518         USHORT nNotesPageNum = pPreviousNotesPage->GetPageNum() + 2;
1519         pPreviousStandardPage = (SdPage*) GetPage(nNotesPageNum - 3);
1520     }
1521     else
1522     {
1523         pPreviousStandardPage = pActualPage;
1524         USHORT nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
1525         pPreviousNotesPage = (SdPage*) GetPage(nStandardPageNum - 1);
1526     }
1527
1528     // Create duplicates of a standard page and the associated notes page.
1529     pStandardPage = (SdPage*) pPreviousStandardPage->Clone();
1530     pNotesPage = (SdPage*) pPreviousNotesPage->Clone();
1531
1532     return InsertPageSet (
1533         pActualPage, ePageKind,
1534         sStandardPageName,
1535         sNotesPageName,
1536         eStandardLayout,
1537         eNotesLayout,
1538         bIsPageBack,
1539         bIsPageObj,
1540
1541         pStandardPage,
1542         pNotesPage);
1543 }
1544
1545
1546
1547
1548 USHORT SdDrawDocument::InsertPageSet (
1549     SdPage* pActualPage,
1550     PageKind ePageKind,
1551     const String& sStandardPageName,
1552     const String& sNotesPageName,
1553     AutoLayout eStandardLayout,
1554     AutoLayout eNotesLayout,
1555     BOOL bIsPageBack,
1556     BOOL bIsPageObj,
1557
1558     SdPage* pStandardPage,
1559     SdPage* pNotesPage)
1560 {
1561     SdPage* pPreviousStandardPage;
1562     SdPage* pPreviousNotesPage;
1563     USHORT nStandardPageNum;
1564     USHORT nNotesPageNum;
1565     String aStandardPageName = sStandardPageName;
1566     String aNotesPageName = sNotesPageName;
1567
1568     // Gather some information about the standard page and the notes page
1569     // that are to be inserted.  This makes sure that there is allways one
1570     // standard page followed by one notes page.
1571     if (ePageKind == PK_NOTES)
1572     {
1573         pPreviousNotesPage = pActualPage;
1574         nNotesPageNum = pPreviousNotesPage->GetPageNum() + 2;
1575         pPreviousStandardPage = (SdPage*) GetPage(nNotesPageNum - 3);
1576         nStandardPageNum = nNotesPageNum - 1;
1577         eStandardLayout = pPreviousStandardPage->GetAutoLayout();
1578     }
1579     else
1580     {
1581         pPreviousStandardPage = pActualPage;
1582         nStandardPageNum = pPreviousStandardPage->GetPageNum() + 2;
1583         pPreviousNotesPage = (SdPage*) GetPage(nStandardPageNum - 1);
1584         nNotesPageNum = nStandardPageNum + 1;
1585         aNotesPageName = aStandardPageName;
1586         eNotesLayout = pPreviousNotesPage->GetAutoLayout();
1587     }
1588
1589
1590     // Set up and insert the standard page.
1591     SetupNewPage (
1592         pPreviousStandardPage,
1593         pStandardPage,
1594         aStandardPageName,
1595         nStandardPageNum,
1596         bIsPageBack,
1597         bIsPageObj);
1598
1599     // Set up and insert the notes page.
1600     pNotesPage->SetPageKind(PK_NOTES);
1601     SetupNewPage (
1602         pPreviousNotesPage,
1603         pNotesPage,
1604         aNotesPageName,
1605         nNotesPageNum,
1606         bIsPageBack,
1607         bIsPageObj);
1608
1609     // Return an index that allows the caller to access the newly inserted
1610     // pages by using GetSdPage().
1611     return pStandardPage->GetPageNum() / 2;
1612 }
1613
1614
1615
1616
1617 void SdDrawDocument::SetupNewPage (
1618     SdPage* pPreviousPage,
1619     SdPage* pPage,
1620     const String& sPageName,
1621     USHORT nInsertionPoint,
1622     BOOL bIsPageBack,
1623     BOOL bIsPageObj)
1624 {
1625     if (pPreviousPage != NULL)
1626     {
1627         pPage->SetSize( pPreviousPage->GetSize() );
1628         pPage->SetBorder( pPreviousPage->GetLftBorder(),
1629             pPreviousPage->GetUppBorder(),
1630             pPreviousPage->GetRgtBorder(),
1631             pPreviousPage->GetLwrBorder() );
1632     }
1633     pPage->SetName(sPageName);
1634
1635     InsertPage(pPage, nInsertionPoint);
1636
1637     if (pPreviousPage != NULL)
1638     {
1639         SdrLayerAdmin& rLayerAdmin = GetLayerAdmin();
1640         BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE);
1641         BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE);
1642         SetOfByte aVisibleLayers = pPreviousPage->TRG_GetMasterPageVisibleLayers();
1643         aVisibleLayers.Set(aBckgrnd, bIsPageBack);
1644         aVisibleLayers.Set(aBckgrndObj, bIsPageObj);
1645         pPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
1646     }
1647 }
1648
1649 sd::UndoManager* SdDrawDocument::GetUndoManager() const
1650 {
1651     return mpDocSh ? dynamic_cast< sd::UndoManager* >(mpDocSh->GetUndoManager()) : 0;
1652 }
1653
1654 // eof