svx/source/svdraw/svdpage.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: svdpage.cxx,v $
  10  * $Revision: 1.67 $
  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_svx.hxx"
  33
  34 #include <svx/svdpage.hxx>
  35
  36 // HACK
  37 #include <sot/storage.hxx>
  38 #include <sot/clsids.hxx>
  39 #include <sot/storage.hxx>
  40 #include <svx/svdview.hxx>
  41 #include <string.h>
  42 #ifndef _STRING_H
  43 #define _STRING_H
  44 #endif
  45 #include <vcl/svapp.hxx>
  46
  47 #include <tools/diagnose_ex.h>
  48
  49 #include <svx/svdetc.hxx>
  50 #include <svx/svdobj.hxx>
  51 #include <svx/svdogrp.hxx>
  52 #include <svx/svdograf.hxx> // fuer SwapInAll()
  53 #include <svx/svdoedge.hxx> // Zum kopieren der Konnektoren
  54 #include <svx/svdoole2.hxx> // Sonderbehandlung OLE beim SdrExchangeFormat
  55 #include "svditer.hxx"
  56 #include <svx/svdmodel.hxx>
  57 #include <svx/svdlayer.hxx>
  58 #include <svx/svdotext.hxx>
  59 #include <svx/svdpagv.hxx>
  60 #include <svx/svdundo.hxx>
  61 #include <svx/fmglob.hxx>
  62 #include <svx/polysc3d.hxx>
  63
  64 #include <svx/fmdpage.hxx>
  65
  66 #include <sfx2/objsh.hxx>
  67 #include <vcl/salbtype.hxx>             // FRound
  68 #include <svx/sdr/contact/viewcontactofsdrpage.hxx>
  69 #include <svx/sdr/contact/viewobjectcontact.hxx>
  70 #include <svx/sdr/contact/displayinfo.hxx>
  71 #include <algorithm>
  72
  73 using namespace ::com::sun::star;
  74
  75 namespace {
  76 void DumpObjectList (const ::std::vector<SdrObjectWeakRef>& rContainer)
  77 {
  78     ::std::vector<SdrObjectWeakRef>::const_iterator iObject (rContainer.begin());
  79     ::std::vector<SdrObjectWeakRef>::const_iterator iEnd (rContainer.end());
  80     for (int nIndex=0 ; iObject!=iEnd; ++iObject,++nIndex)
  81     {
  82         const SdrObject* pObject = iObject->get();
  83         OSL_TRACE("%d : %x, %s", nIndex,
  84             pObject,
  85             ::rtl::OUStringToOString(pObject->GetName(),RTL_TEXTENCODING_UTF8).getStr());
  86     }
  87 }
  88 }
  89
  90
  91 class SdrObjList::WeakSdrObjectContainerType
  92     : public ::std::vector<SdrObjectWeakRef>
  93 {
  94 public:
  95     WeakSdrObjectContainerType (const sal_Int32 nInitialSize)
  96         : ::std::vector<SdrObjectWeakRef>(nInitialSize) {};
  97 };
  98
  99
 100
 101 static const sal_Int32 InitialObjectContainerCapacity (64);
 102 DBG_NAME(SdrObjList)
 103
 104 TYPEINIT0(SdrObjList);
 105
 106 SdrObjList::SdrObjList(SdrModel* pNewModel, SdrPage* pNewPage, SdrObjList* pNewUpList):
 107     maList(),
 108     mpNavigationOrder(),
 109     mbIsNavigationOrderDirty(false)
 110 {
 111     DBG_CTOR(SdrObjList,NULL);
 112     maList.reserve(InitialObjectContainerCapacity);
 113     pModel=pNewModel;
 114     pPage=pNewPage;
 115     pUpList=pNewUpList;
 116     bObjOrdNumsDirty=FALSE;
 117     bRectsDirty=FALSE;
 118     pOwnerObj=NULL;
 119     eListKind=SDROBJLIST_UNKNOWN;
 120 }
 121
 122 SdrObjList::SdrObjList(const SdrObjList& rSrcList):
 123     maList(),
 124     mpNavigationOrder(),
 125     mbIsNavigationOrderDirty(false)
 126 {
 127     DBG_CTOR(SdrObjList,NULL);
 128     maList.reserve(InitialObjectContainerCapacity);
 129     pModel=NULL;
 130     pPage=NULL;
 131     pUpList=NULL;
 132     bObjOrdNumsDirty=FALSE;
 133     bRectsDirty=FALSE;
 134     pOwnerObj=NULL;
 135     eListKind=SDROBJLIST_UNKNOWN;
 136     *this=rSrcList;
 137 }
 138
 139 SdrObjList::~SdrObjList()
 140 {
 141     DBG_DTOR(SdrObjList,NULL);
 142
 143     // #111111#
 144     // To avoid that the Clear() method will broadcast changes when in destruction
 145     // which would call virtual methos (not allowed in destructor), the model is set
 146     // to NULL here.
 147     pModel = 0L;
 148
 149     Clear(); // Containerinhalt loeschen!
 150 }
 151
 152 void SdrObjList::operator=(const SdrObjList& rSrcList)
 153 {
 154     Clear();
 155     eListKind=rSrcList.eListKind;
 156     CopyObjects(rSrcList);
 157 }
 158
 159 void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
 160 {
 161     Clear();
 162     bObjOrdNumsDirty=FALSE;
 163     bRectsDirty     =FALSE;
 164     ULONG nCloneErrCnt=0;
 165     ULONG nAnz=rSrcList.GetObjCount();
 166     SdrInsertReason aReason(SDRREASON_COPY);
 167     ULONG no;
 168     for (no=0; no<nAnz; no++) {
 169         SdrObject* pSO=rSrcList.GetObj(no);
 170
 171         // #116235#
 172         //SdrObject* pDO=pSO->Clone(pPage,pModel);
 173         SdrObject* pDO = pSO->Clone();
 174         pDO->SetModel(pModel);
 175         pDO->SetPage(pPage);
 176
 177         if (pDO!=NULL) {
 178             NbcInsertObject(pDO,CONTAINER_APPEND,&aReason);
 179         } else {
 180             nCloneErrCnt++;
 181         }
 182     }
 183     // und nun zu den Konnektoren
 184     // Die neuen Objekte werden auf die der rSrcList abgebildet
 185     // und so die Objektverbindungen hergestellt.
 186     // Aehnliche Implementation an folgenden Stellen:
 187     //    void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
 188     //    SdrModel* SdrExchangeView::GetMarkedObjModel() const
 189     //    FASTBOOL SdrExchangeView::Paste(const SdrModel& rMod,...)
 190     //    void SdrEditView::CopyMarked()
 191     if (nCloneErrCnt==0) {
 192         for (no=0; no<nAnz; no++) {
 193             const SdrObject* pSrcOb=rSrcList.GetObj(no);
 194             SdrEdgeObj* pSrcEdge=PTR_CAST(SdrEdgeObj,pSrcOb);
 195             if (pSrcEdge!=NULL) {
 196                 SdrObject* pSrcNode1=pSrcEdge->GetConnectedNode(TRUE);
 197                 SdrObject* pSrcNode2=pSrcEdge->GetConnectedNode(FALSE);
 198                 if (pSrcNode1!=NULL && pSrcNode1->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode1=NULL; // Listenuebergreifend
 199                 if (pSrcNode2!=NULL && pSrcNode2->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode2=NULL; // ist (noch) nicht
 200                 if (pSrcNode1!=NULL || pSrcNode2!=NULL) {
 201                     SdrObject* pEdgeObjTmp=GetObj(no);
 202                     SdrEdgeObj* pDstEdge=PTR_CAST(SdrEdgeObj,pEdgeObjTmp);
 203                     if (pDstEdge!=NULL) {
 204                         if (pSrcNode1!=NULL) {
 205                             ULONG nDstNode1=pSrcNode1->GetOrdNum();
 206                             SdrObject* pDstNode1=GetObj(nDstNode1);
 207                             if (pDstNode1!=NULL) { // Sonst grober Fehler!
 208                                 pDstEdge->ConnectToNode(TRUE,pDstNode1);
 209                             } else {
 210                                 DBG_ERROR("SdrObjList::operator=(): pDstNode1==NULL!");
 211                             }
 212                         }
 213                         if (pSrcNode2!=NULL) {
 214                             ULONG nDstNode2=pSrcNode2->GetOrdNum();
 215                             SdrObject* pDstNode2=GetObj(nDstNode2);
 216                             if (pDstNode2!=NULL) { // Node war sonst wohl nicht markiert
 217                                 pDstEdge->ConnectToNode(FALSE,pDstNode2);
 218                             } else {
 219                                 DBG_ERROR("SdrObjList::operator=(): pDstNode2==NULL!");
 220                             }
 221                         }
 222                     } else {
 223                         DBG_ERROR("SdrObjList::operator=(): pDstEdge==NULL!");
 224                     }
 225                 }
 226             }
 227         }
 228     } else {
 229 #ifdef DBG_UTIL
 230         ByteString aStr("SdrObjList::operator=(): Fehler beim Clonen ");
 231
 232         if(nCloneErrCnt == 1)
 233         {
 234             aStr += "eines Zeichenobjekts.";
 235         }
 236         else
 237         {
 238             aStr += "von ";
 239             aStr += ByteString::CreateFromInt32( nCloneErrCnt );
 240             aStr += " Zeichenobjekten.";
 241         }
 242
 243         aStr += " Objektverbindungen werden nicht mitkopiert.";
 244
 245         DBG_ERROR(aStr.GetBuffer());
 246 #endif
 247     }
 248 }
 249
 250 void SdrObjList::Clear()
 251 {
 252     sal_Bool bObjectsRemoved(sal_False);
 253
 254     while( ! maList.empty())
 255     {
 256         // remove last object from list
 257         SdrObject* pObj = maList.back();
 258         RemoveObjectFromContainer(maList.size()-1);
 259
 260         // flushViewObjectContacts() is done since SdrObject::Free is not guaranteed
 261         // to delete the object and thus refresh visualisations
 262         pObj->GetViewContact().flushViewObjectContacts(true);
 263
 264         bObjectsRemoved = sal_True;
 265
 266         // sent remove hint (after removal, see RemoveObject())
 267         if(pModel)
 268         {
 269             SdrHint aHint(*pObj);
 270             aHint.SetKind(HINT_OBJREMOVED);
 271             aHint.SetPage(pPage);
 272             pModel->Broadcast(aHint);
 273         }
 274
 275         // delete the object itself
 276         SdrObject::Free( pObj );
 277     }
 278
 279     if(pModel && bObjectsRemoved)
 280     {
 281         pModel->SetChanged();
 282     }
 283 }
 284
 285 SdrPage* SdrObjList::GetPage() const
 286 {
 287     return pPage;
 288 }
 289
 290 void SdrObjList::SetPage(SdrPage* pNewPage)
 291 {
 292     if (pPage!=pNewPage) {
 293         pPage=pNewPage;
 294         ULONG nAnz=GetObjCount();
 295         for (ULONG no=0; no<nAnz; no++) {
 296             SdrObject* pObj=GetObj(no);
 297             pObj->SetPage(pPage);
 298         }
 299     }
 300 }
 301
 302 SdrModel* SdrObjList::GetModel() const
 303 {
 304     return pModel;
 305 }
 306
 307 void SdrObjList::SetModel(SdrModel* pNewModel)
 308 {
 309     if (pModel!=pNewModel) {
 310         pModel=pNewModel;
 311         ULONG nAnz=GetObjCount();
 312         for (ULONG i=0; i<nAnz; i++) {
 313             SdrObject* pObj=GetObj(i);
 314             pObj->SetModel(pModel);
 315         }
 316     }
 317 }
 318
 319 void SdrObjList::RecalcObjOrdNums()
 320 {
 321     ULONG nAnz=GetObjCount();
 322     for (ULONG no=0; no<nAnz; no++) {
 323         SdrObject* pObj=GetObj(no);
 324         pObj->SetOrdNum(no);
 325     }
 326     bObjOrdNumsDirty=FALSE;
 327 }
 328
 329 void SdrObjList::RecalcRects()
 330 {
 331     aOutRect=Rectangle();
 332     aSnapRect=aOutRect;
 333     ULONG nAnz=GetObjCount();
 334     ULONG i;
 335     for (i=0; i<nAnz; i++) {
 336         SdrObject* pObj=GetObj(i);
 337         if (i==0) {
 338             aOutRect=pObj->GetCurrentBoundRect();
 339             aSnapRect=pObj->GetSnapRect();
 340         } else {
 341             aOutRect.Union(pObj->GetCurrentBoundRect());
 342             aSnapRect.Union(pObj->GetSnapRect());
 343         }
 344     }
 345 }
 346
 347 void SdrObjList::SetRectsDirty()
 348 {
 349     bRectsDirty=TRUE;
 350     if (pUpList!=NULL) pUpList->SetRectsDirty();
 351 }
 352
 353 void SdrObjList::impChildInserted(SdrObject& rChild) const
 354 {
 355     sdr::contact::ViewContact* pParent = rChild.GetViewContact().GetParentContact();
 356
 357     if(pParent)
 358     {
 359         pParent->ActionChildInserted(rChild.GetViewContact());
 360     }
 361 }
 362
 363 void SdrObjList::NbcInsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* /*pReason*/)
 364 {
 365     DBG_ASSERT(pObj!=NULL,"SdrObjList::NbcInsertObject(NULL)");
 366     if (pObj!=NULL) {
 367         DBG_ASSERT(!pObj->IsInserted(),"ZObjekt hat bereits Inserted-Status");
 368         ULONG nAnz=GetObjCount();
 369         if (nPos>nAnz) nPos=nAnz;
 370         InsertObjectIntoContainer(*pObj,nPos);
 371
 372         if (nPos<nAnz) bObjOrdNumsDirty=TRUE;
 373         pObj->SetOrdNum(nPos);
 374         pObj->SetObjList(this);
 375         pObj->SetPage(pPage);
 376
 377         // #110094# Inform the parent about change to allow invalidations at
 378         // evtl. existing parent visualisations
 379         impChildInserted(*pObj);
 380
 381         if (!bRectsDirty) {
 382             aOutRect.Union(pObj->GetCurrentBoundRect());
 383             aSnapRect.Union(pObj->GetSnapRect());
 384         }
 385         pObj->SetInserted(TRUE); // Ruft u.a. den UserCall
 386     }
 387 }
 388
 389 void SdrObjList::InsertObject(SdrObject* pObj, ULONG nPos, const SdrInsertReason* pReason)
 390 {
 391     DBG_ASSERT(pObj!=NULL,"SdrObjList::InsertObject(NULL)");
 392
 393     if(pObj)
 394     {
 395         // #69055# if anchor is used, reset it before grouping
 396         if(GetOwnerObj())
 397         {
 398             const Point& rAnchorPos = pObj->GetAnchorPos();
 399             if(rAnchorPos.X() || rAnchorPos.Y())
 400                 pObj->NbcSetAnchorPos(Point());
 401         }
 402
 403         // do insert to new group
 404         NbcInsertObject(pObj, nPos, pReason);
 405
 406         // Falls das Objekt in eine Gruppe eingefuegt wird
 407         // und nicht mit seinen Bruedern ueberlappt, muss es
 408         // einen eigenen Redraw bekommen
 409         if(pOwnerObj)
 410         {
 411             // only repaint here
 412             pOwnerObj->ActionChanged();
 413         }
 414
 415         if(pModel)
 416         {
 417             // Hier muss ein anderer Broadcast her!
 418             // Repaint ab Objekt Nummer ... (Achtung: GroupObj)
 419             if(pObj->GetPage())
 420             {
 421                 SdrHint aHint(*pObj);
 422
 423                 aHint.SetKind(HINT_OBJINSERTED);
 424                 pModel->Broadcast(aHint);
 425             }
 426
 427             pModel->SetChanged();
 428         }
 429     }
 430 }
 431
 432 SdrObject* SdrObjList::NbcRemoveObject(ULONG nObjNum)
 433 {
 434     if (nObjNum >= maList.size())
 435     {
 436         OSL_ASSERT(nObjNum<maList.size());
 437         return NULL;
 438     }
 439
 440     ULONG nAnz=GetObjCount();
 441     SdrObject* pObj=maList[nObjNum];
 442     RemoveObjectFromContainer(nObjNum);
 443
 444     // flushViewObjectContacts() clears the VOC's and those invalidate
 445     pObj->GetViewContact().flushViewObjectContacts(true);
 446
 447     DBG_ASSERT(pObj!=NULL,"Object zum Removen nicht gefunden");
 448     if (pObj!=NULL) {
 449         DBG_ASSERT(pObj->IsInserted(),"ZObjekt hat keinen Inserted-Status");
 450         pObj->SetInserted(FALSE); // Ruft u.a. den UserCall
 451         pObj->SetObjList(NULL);
 452         pObj->SetPage(NULL);
 453         if (!bObjOrdNumsDirty) { // Optimierung fuer den Fall, dass das letzte Obj rausgenommen wird
 454             if (nObjNum!=ULONG(nAnz-1)) {
 455                 bObjOrdNumsDirty=TRUE;
 456             }
 457         }
 458         SetRectsDirty();
 459     }
 460     return pObj;
 461 }
 462
 463 SdrObject* SdrObjList::RemoveObject(ULONG nObjNum)
 464 {
 465     if (nObjNum >= maList.size())
 466     {
 467         OSL_ASSERT(nObjNum<maList.size());
 468         return NULL;
 469     }
 470
 471     ULONG nAnz=GetObjCount();
 472     SdrObject* pObj=maList[nObjNum];
 473     RemoveObjectFromContainer(nObjNum);
 474
 475     DBG_ASSERT(pObj!=NULL,"Object zum Removen nicht gefunden");
 476     if(pObj)
 477     {
 478         // flushViewObjectContacts() clears the VOC's and those invalidate
 479         pObj->GetViewContact().flushViewObjectContacts(true);
 480
 481         DBG_ASSERT(pObj->IsInserted(),"ZObjekt hat keinen Inserted-Status");
 482         if (pModel!=NULL) {
 483             // Hier muss ein anderer Broadcast her!
 484             if (pObj->GetPage()!=NULL) {
 485                 SdrHint aHint(*pObj);
 486                 aHint.SetKind(HINT_OBJREMOVED);
 487                 pModel->Broadcast(aHint);
 488             }
 489             pModel->SetChanged();
 490         }
 491         pObj->SetInserted(FALSE); // Ruft u.a. den UserCall
 492         pObj->SetObjList(NULL);
 493         pObj->SetPage(NULL);
 494         if (!bObjOrdNumsDirty) { // Optimierung fuer den Fall, dass das letzte Obj rausgenommen wird
 495             if (nObjNum!=ULONG(nAnz-1)) {
 496                 bObjOrdNumsDirty=TRUE;
 497             }
 498         }
 499         SetRectsDirty();
 500
 501         if(pOwnerObj && !GetObjCount())
 502         {
 503             // empty group created; it needs to be repainted since it's
 504             // visualisation changes
 505             pOwnerObj->ActionChanged();
 506         }
 507     }
 508     return pObj;
 509 }
 510
 511 SdrObject* SdrObjList::NbcReplaceObject(SdrObject* pNewObj, ULONG nObjNum)
 512 {
 513     if (nObjNum >= maList.size() || pNewObj == NULL)
 514     {
 515         OSL_ASSERT(nObjNum<maList.size());
 516         OSL_ASSERT(pNewObj!=NULL);
 517         return NULL;
 518     }
 519
 520     SdrObject* pObj=maList[nObjNum];
 521     DBG_ASSERT(pObj!=NULL,"SdrObjList::ReplaceObject: Object zum Removen nicht gefunden");
 522     if (pObj!=NULL) {
 523         DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: ZObjekt hat keinen Inserted-Status");
 524         pObj->SetInserted(FALSE);
 525         pObj->SetObjList(NULL);
 526         pObj->SetPage(NULL);
 527         ReplaceObjectInContainer(*pNewObj,nObjNum);
 528
 529         // flushViewObjectContacts() clears the VOC's and those invalidate
 530         pObj->GetViewContact().flushViewObjectContacts(true);
 531
 532         pNewObj->SetOrdNum(nObjNum);
 533         pNewObj->SetObjList(this);
 534         pNewObj->SetPage(pPage);
 535
 536         // #110094#  Inform the parent about change to allow invalidations at
 537         // evtl. existing parent visualisations
 538         impChildInserted(*pNewObj);
 539
 540         pNewObj->SetInserted(TRUE);
 541         SetRectsDirty();
 542     }
 543     return pObj;
 544 }
 545
 546 SdrObject* SdrObjList::ReplaceObject(SdrObject* pNewObj, ULONG nObjNum)
 547 {
 548     if (nObjNum >= maList.size())
 549     {
 550         OSL_ASSERT(nObjNum<maList.size());
 551         return NULL;
 552     }
 553     if (pNewObj == NULL)
 554     {
 555         OSL_ASSERT(pNewObj!=NULL);
 556         return NULL;
 557     }
 558
 559     SdrObject* pObj=maList[nObjNum];
 560     DBG_ASSERT(pObj!=NULL,"SdrObjList::ReplaceObject: Object zum Removen nicht gefunden");
 561     if (pObj!=NULL) {
 562         DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: ZObjekt hat keinen Inserted-Status");
 563         if (pModel!=NULL) {
 564             // Hier muss ein anderer Broadcast her!
 565             if (pObj->GetPage()!=NULL) {
 566                 SdrHint aHint(*pObj);
 567                 aHint.SetKind(HINT_OBJREMOVED);
 568                 pModel->Broadcast(aHint);
 569             }
 570         }
 571         pObj->SetInserted(FALSE);
 572         pObj->SetObjList(NULL);
 573         pObj->SetPage(NULL);
 574         ReplaceObjectInContainer(*pNewObj,nObjNum);
 575
 576         // flushViewObjectContacts() clears the VOC's and those invalidate
 577         pObj->GetViewContact().flushViewObjectContacts(true);
 578
 579         pNewObj->SetOrdNum(nObjNum);
 580         pNewObj->SetObjList(this);
 581         pNewObj->SetPage(pPage);
 582
 583         // #110094#  Inform the parent about change to allow invalidations at
 584         // evtl. existing parent visualisations
 585         impChildInserted(*pNewObj);
 586
 587         pNewObj->SetInserted(TRUE);
 588         if (pModel!=NULL) {
 589             // Hier muss ein anderer Broadcast her!
 590             if (pNewObj->GetPage()!=NULL) {
 591                 SdrHint aHint(*pNewObj);
 592                 aHint.SetKind(HINT_OBJINSERTED);
 593                 pModel->Broadcast(aHint);
 594             }
 595             pModel->SetChanged();
 596         }
 597         SetRectsDirty();
 598     }
 599     return pObj;
 600 }
 601
 602 SdrObject* SdrObjList::NbcSetObjectOrdNum(ULONG nOldObjNum, ULONG nNewObjNum)
 603 {
 604     if (nOldObjNum >= maList.size() || nNewObjNum >= maList.size())
 605     {
 606         OSL_ASSERT(nOldObjNum<maList.size());
 607         OSL_ASSERT(nNewObjNum<maList.size());
 608         return NULL;
 609     }
 610
 611     SdrObject* pObj=maList[nOldObjNum];
 612     if (nOldObjNum==nNewObjNum) return pObj;
 613     DBG_ASSERT(pObj!=NULL,"SdrObjList::NbcSetObjectOrdNum: Object nicht gefunden");
 614     if (pObj!=NULL) {
 615         DBG_ASSERT(pObj->IsInserted(),"SdrObjList::NbcSetObjectOrdNum: ZObjekt hat keinen Inserted-Status");
 616         RemoveObjectFromContainer(nOldObjNum);
 617
 618         InsertObjectIntoContainer(*pObj,nNewObjNum);
 619
 620         // #110094# No need to delete visualisation data since same object
 621         // gets inserted again. Also a single ActionChanged is enough
 622         pObj->ActionChanged();
 623
 624         pObj->SetOrdNum(nNewObjNum);
 625         bObjOrdNumsDirty=TRUE;
 626     }
 627     return pObj;
 628 }
 629
 630 SdrObject* SdrObjList::SetObjectOrdNum(ULONG nOldObjNum, ULONG nNewObjNum)
 631 {
 632     if (nOldObjNum >= maList.size() || nNewObjNum >= maList.size())
 633     {
 634         OSL_ASSERT(nOldObjNum<maList.size());
 635         OSL_ASSERT(nNewObjNum<maList.size());
 636         return NULL;
 637     }
 638
 639     SdrObject* pObj=maList[nOldObjNum];
 640     if (nOldObjNum==nNewObjNum) return pObj;
 641     DBG_ASSERT(pObj!=NULL,"SdrObjList::SetObjectOrdNum: Object nicht gefunden");
 642     if (pObj!=NULL) {
 643         DBG_ASSERT(pObj->IsInserted(),"SdrObjList::SetObjectOrdNum: ZObjekt hat keinen Inserted-Status");
 644         RemoveObjectFromContainer(nOldObjNum);
 645         InsertObjectIntoContainer(*pObj,nNewObjNum);
 646
 647         // #110094#No need to delete visualisation data since same object
 648         // gets inserted again. Also a single ActionChanged is enough
 649         pObj->ActionChanged();
 650
 651         pObj->SetOrdNum(nNewObjNum);
 652         bObjOrdNumsDirty=TRUE;
 653         if (pModel!=NULL)
 654         {
 655             // Hier muss ein anderer Broadcast her!
 656             if (pObj->GetPage()!=NULL) pModel->Broadcast(SdrHint(*pObj));
 657             pModel->SetChanged();
 658         }
 659     }
 660     return pObj;
 661 }
 662
 663 const Rectangle& SdrObjList::GetAllObjSnapRect() const
 664 {
 665     if (bRectsDirty) {
 666         ((SdrObjList*)this)->RecalcRects();
 667         ((SdrObjList*)this)->bRectsDirty=FALSE;
 668     }
 669     return aSnapRect;
 670 }
 671
 672 const Rectangle& SdrObjList::GetAllObjBoundRect() const
 673 {
 674     if (bRectsDirty) {
 675         ((SdrObjList*)this)->RecalcRects();
 676         ((SdrObjList*)this)->bRectsDirty=FALSE;
 677     }
 678     return aOutRect;
 679 }
 680
 681 void SdrObjList::NbcReformatAllTextObjects()
 682 {
 683     ULONG nAnz=GetObjCount();
 684     ULONG nNum=0;
 685
 686     Printer* pPrinter = NULL;
 687
 688     if (pModel)
 689     {
 690         if (pModel->GetRefDevice() && pModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER)
 691         {
 692             // Kein RefDevice oder RefDevice kein Printer
 693             pPrinter = (Printer*) pModel->GetRefDevice();
 694         }
 695     }
 696
 697     while (nNum<nAnz)
 698     {
 699         SdrObject* pObj = GetObj(nNum);
 700         if (pPrinter &&
 701             pObj->GetObjInventor() == SdrInventor &&
 702             pObj->GetObjIdentifier() == OBJ_OLE2  &&
 703             !( (SdrOle2Obj*) pObj )->IsEmpty() )
 704         {
 705             //const SvInPlaceObjectRef& xObjRef = ((SdrOle2Obj*) pObj)->GetObjRef();
 706             //TODO/LATER: PrinterChangeNotification needed
 707             //if( xObjRef.Is() && ( xObjRef->GetMiscStatus() & SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE ) )
 708             //  xObjRef->OnDocumentPrinterChanged(pPrinter);
 709         }
 710
 711         pObj->NbcReformatText();
 712         nAnz=GetObjCount();                         // ReformatText may delete an object
 713         nNum++;
 714     }
 715
 716 }
 717
 718 void SdrObjList::ReformatAllTextObjects()
 719 {
 720     NbcReformatAllTextObjects();
 721 }
 722
 723 /** steps over all available objects and reformats all
 724     edge objects that are connected to other objects so that
 725     they may reposition itselfs.
 726     #103122#
 727 */
 728 void SdrObjList::ReformatAllEdgeObjects()
 729 {
 730     const sal_uInt32 nCount=GetObjCount();
 731     sal_uInt32 nObj;
 732
 733     for( nObj = 0; nObj < nCount; nObj++ )
 734     {
 735         SdrObject* pObj = GetObj(nObj);
 736         if( pObj->ISA(SdrEdgeObj) )
 737             static_cast<SdrEdgeObj*>(pObj)->Reformat();
 738     }
 739 }
 740
 741 void SdrObjList::BurnInStyleSheetAttributes()
 742 {
 743     for(sal_uInt32 a(0L); a < GetObjCount(); a++)
 744     {
 745         GetObj(a)->BurnInStyleSheetAttributes();
 746     }
 747 }
 748
 749 ULONG SdrObjList::GetObjCount() const
 750 {
 751     return maList.size();
 752 }
 753
 754
 755
 756
 757 SdrObject* SdrObjList::GetObj(ULONG nNum) const
 758 {
 759     if (nNum >= maList.size())
 760     {
 761         OSL_ASSERT(nNum<maList.size());
 762         return NULL;
 763     }
 764     else
 765         return maList[nNum];
 766 }
 767
 768
 769
 770
 771 FASTBOOL SdrObjList::IsReadOnly() const
 772 {
 773     FASTBOOL bRet=FALSE;
 774     if (pPage!=NULL && pPage!=this) bRet=pPage->IsReadOnly();
 775     return bRet;
 776 }
 777
 778 ULONG SdrObjList::CountAllObjects() const
 779 {
 780     ULONG nCnt=GetObjCount();
 781     ULONG nAnz=nCnt;
 782     for (USHORT nNum=0; nNum<nAnz; nNum++) {
 783         SdrObjList* pSubOL=GetObj(nNum)->GetSubList();
 784         if (pSubOL!=NULL) {
 785             nCnt+=pSubOL->CountAllObjects();
 786         }
 787     }
 788     return nCnt;
 789 }
 790
 791 void SdrObjList::ForceSwapInObjects() const
 792 {
 793     ULONG nObjAnz=GetObjCount();
 794     for (ULONG nObjNum=nObjAnz; nObjNum>0;) {
 795         SdrObject* pObj=GetObj(--nObjNum);
 796         SdrGrafObj* pGrafObj=PTR_CAST(SdrGrafObj,pObj);
 797         if (pGrafObj!=NULL) {
 798             pGrafObj->ForceSwapIn();
 799         }
 800         SdrObjList* pOL=pObj->GetSubList();
 801         if (pOL!=NULL) {
 802             pOL->ForceSwapInObjects();
 803         }
 804     }
 805 }
 806
 807 void SdrObjList::ForceSwapOutObjects() const
 808 {
 809     ULONG nObjAnz=GetObjCount();
 810     for (ULONG nObjNum=nObjAnz; nObjNum>0;) {
 811         SdrObject* pObj=GetObj(--nObjNum);
 812         SdrGrafObj* pGrafObj=PTR_CAST(SdrGrafObj,pObj);
 813         if (pGrafObj!=NULL) {
 814             pGrafObj->ForceSwapOut();
 815         }
 816         SdrObjList* pOL=pObj->GetSubList();
 817         if (pOL!=NULL) {
 818             pOL->ForceSwapOutObjects();
 819         }
 820     }
 821 }
 822
 823 void SdrObjList::FlattenGroups()
 824 {
 825     sal_Int32 nObj = GetObjCount();
 826     sal_Int32 i;
 827     for( i=nObj-1; i>=0; --i)
 828         UnGroupObj(i);
 829 }
 830
 831 void SdrObjList::UnGroupObj( ULONG nObjNum )
 832 {
 833     // if the given object is no group, this method is a noop
 834     SdrObject* pUngroupObj = GetObj( nObjNum );
 835     if( pUngroupObj )
 836     {
 837         SdrObjList* pSrcLst = pUngroupObj->GetSubList();
 838         //sal_Int32 nCount( 0 );
 839         if( pUngroupObj->ISA( SdrObjGroup ) && pSrcLst )
 840         {
 841             SdrObjGroup* pUngroupGroup = static_cast< SdrObjGroup* > (pUngroupObj);
 842
 843             // ungroup recursively (has to be head recursion,
 844             // otherwise our indices will get trashed when doing it in
 845             // the loop)
 846             pSrcLst->FlattenGroups();
 847
 848             // the position at which we insert the members of rUngroupGroup
 849             sal_Int32 nInsertPos( pUngroupGroup->GetOrdNum() );
 850
 851             SdrObject* pObj;
 852             sal_Int32 i, nAnz = pSrcLst->GetObjCount();
 853             for( i=0; i<nAnz; ++i )
 854             {
 855                 pObj = pSrcLst->RemoveObject(0);
 856                 SdrInsertReason aReason(SDRREASON_VIEWCALL, pUngroupGroup);
 857                 InsertObject(pObj, nInsertPos, &aReason);
 858                 ++nInsertPos;
 859             }
 860
 861             RemoveObject(nInsertPos);
 862         }
 863     }
 864 #ifdef DBG_UTIL
 865     else
 866         DBG_ERROR("SdrObjList::UnGroupObj: object index invalid");
 867 #endif
 868 }
 869
 870
 871
 872
 873 bool SdrObjList::HasObjectNavigationOrder (void) const
 874 {
 875     return mpNavigationOrder.get() != NULL;
 876 }
 877
 878
 879
 880
 881 void SdrObjList::SetObjectNavigationPosition (
 882     SdrObject& rObject,
 883     const sal_uInt32 nNewPosition)
 884 {
 885     // When the navigation order container has not yet been created then
 886     // create one now.  It is initialized with the z-order taken from
 887     // maList.
 888     if (mpNavigationOrder.get() == NULL)
 889     {
 890         mpNavigationOrder.reset(new WeakSdrObjectContainerType(maList.size()));
 891         ::std::copy(
 892             maList.begin(),
 893             maList.end(),
 894             mpNavigationOrder->begin());
 895     }
 896     OSL_ASSERT(mpNavigationOrder.get()!=NULL);
 897     OSL_ASSERT( mpNavigationOrder->size() == maList.size());
 898
 899     SdrObjectWeakRef aReference (&rObject);
 900
 901     // Look up the object whose navigation position is to be changed.
 902     WeakSdrObjectContainerType::iterator iObject (::std::find(
 903         mpNavigationOrder->begin(),
 904         mpNavigationOrder->end(),
 905         aReference));
 906     if (iObject == mpNavigationOrder->end())
 907     {
 908         // The given object is not a member of the navigation order.
 909         return;
 910     }
 911
 912     // Move the object to its new position.
 913     const sal_uInt32 nOldPosition = ::std::distance(mpNavigationOrder->begin(), iObject);
 914     if (nOldPosition != nNewPosition)
 915     {
 916         mpNavigationOrder->erase(iObject);
 917         sal_uInt32 nInsertPosition (nNewPosition);
 918         // Adapt insertion position for the just erased object.
 919         if (nNewPosition >= nOldPosition)
 920             nInsertPosition -= 1;
 921         if (nInsertPosition >= mpNavigationOrder->size())
 922             mpNavigationOrder->push_back(aReference);
 923         else
 924             mpNavigationOrder->insert(mpNavigationOrder->begin()+nInsertPosition, aReference);
 925
 926         mbIsNavigationOrderDirty = true;
 927
 928         // The navigation order is written out to file so mark the model as modified.
 929         if (pModel != NULL)
 930             pModel->SetChanged();
 931     }
 932 }
 933
 934
 935
 936
 937 SdrObject* SdrObjList::GetObjectForNavigationPosition (const sal_uInt32 nNavigationPosition) const
 938 {
 939     if (HasObjectNavigationOrder())
 940     {
 941         // There is a user defined navigation order.  Make sure the object
 942         // index is correct and look up the object in mpNavigationOrder.
 943         if (nNavigationPosition >= mpNavigationOrder->size())
 944         {
 945             OSL_ASSERT(nNavigationPosition < mpNavigationOrder->size());
 946         }
 947         else
 948             return (*mpNavigationOrder)[nNavigationPosition].get();
 949     }
 950     else
 951     {
 952         // There is no user defined navigation order.  Use the z-order
 953         // instead.
 954         if (nNavigationPosition >= maList.size())
 955         {
 956             OSL_ASSERT(nNavigationPosition < maList.size());
 957         }
 958         else
 959             return maList[nNavigationPosition];
 960     }
 961     return NULL;
 962 }
 963
 964
 965
 966
 967 void SdrObjList::ClearObjectNavigationOrder (void)
 968 {
 969     mpNavigationOrder.reset();
 970     mbIsNavigationOrderDirty = true;
 971 }
 972
 973
 974
 975
 976 bool SdrObjList::RecalcNavigationPositions (void)
 977 {
 978     bool bUpToDate (false);
 979
 980     if (mbIsNavigationOrderDirty)
 981     {
 982         if (mpNavigationOrder.get() != NULL)
 983         {
 984             mbIsNavigationOrderDirty = false;
 985
 986             WeakSdrObjectContainerType::iterator iObject;
 987             WeakSdrObjectContainerType::const_iterator iEnd (mpNavigationOrder->end());
 988             sal_uInt32 nIndex (0);
 989             for (iObject=mpNavigationOrder->begin(); iObject!=iEnd; ++iObject,++nIndex)
 990                 (*iObject)->SetNavigationPosition(nIndex);
 991
 992             bUpToDate = true;
 993         }
 994     }
 995
 996     return mpNavigationOrder.get() != NULL;
 997 }
 998
 999
1000
1001
1002 void SdrObjList::SetNavigationOrder (const uno::Reference<container::XIndexAccess>& rxOrder)
1003 {
1004     if (rxOrder.is())
1005     {
1006         const sal_Int32 nCount = rxOrder->getCount();
1007         if ((sal_uInt32)nCount != maList.size())
1008             return;
1009
1010         if (mpNavigationOrder.get() == NULL)
1011             mpNavigationOrder.reset(new WeakSdrObjectContainerType(nCount));
1012
1013         for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
1014         {
1015             uno::Reference<uno::XInterface> xShape (rxOrder->getByIndex(nIndex), uno::UNO_QUERY);
1016             SdrObject* pObject = SdrObject::getSdrObjectFromXShape(xShape);
1017             if (pObject == NULL)
1018                 break;
1019             (*mpNavigationOrder)[nIndex] = pObject;
1020         }
1021
1022         mbIsNavigationOrderDirty = true;
1023     }
1024     else
1025         ClearObjectNavigationOrder();
1026 }
1027
1028
1029
1030
1031 void SdrObjList::InsertObjectIntoContainer (
1032     SdrObject& rObject,
1033     const sal_uInt32 nInsertPosition)
1034 {
1035     OSL_ASSERT(nInsertPosition<=maList.size());
1036
1037     // Update the navigation positions.
1038     if (HasObjectNavigationOrder())
1039     {
1040         // The new object does not have a user defined position so append it
1041         // to the list.
1042         rObject.SetNavigationPosition(mpNavigationOrder->size());
1043         mpNavigationOrder->push_back(&rObject);
1044     }
1045
1046     // Insert object into object list.  Because the insert() method requires
1047     // a valid iterator as insertion position, we have to use push_back() to
1048     // insert at the end of the list.
1049     if (nInsertPosition >= maList.size())
1050         maList.push_back(&rObject);
1051     else
1052         maList.insert(maList.begin()+nInsertPosition, &rObject);
1053     bObjOrdNumsDirty=TRUE;
1054 }
1055
1056
1057
1058
1059 void SdrObjList::ReplaceObjectInContainer (
1060     SdrObject& rNewObject,
1061     const sal_uInt32 nObjectPosition)
1062 {
1063     if (nObjectPosition >= maList.size())
1064     {
1065         OSL_ASSERT(nObjectPosition<maList.size());
1066         return;
1067     }
1068
1069     // Update the navigation positions.
1070     if (HasObjectNavigationOrder())
1071     {
1072         // A user defined position of the object that is to be replaced is
1073         // not transferred to the new object so erase the former and append
1074         // the later object from/to the navigation order.
1075         OSL_ASSERT(nObjectPosition < maList.size());
1076         SdrObjectWeakRef aReference (maList[nObjectPosition]);
1077         WeakSdrObjectContainerType::iterator iObject (::std::find(
1078             mpNavigationOrder->begin(),
1079             mpNavigationOrder->end(),
1080             aReference));
1081         if (iObject != mpNavigationOrder->end())
1082             mpNavigationOrder->erase(iObject);
1083
1084         mpNavigationOrder->push_back(&rNewObject);
1085
1086         mbIsNavigationOrderDirty = true;
1087     }
1088
1089     maList[nObjectPosition] = &rNewObject;
1090     bObjOrdNumsDirty=TRUE;
1091 }
1092
1093
1094
1095
1096 void SdrObjList::RemoveObjectFromContainer (
1097     const sal_uInt32 nObjectPosition)
1098 {
1099     if (nObjectPosition >= maList.size())
1100     {
1101         OSL_ASSERT(nObjectPosition<maList.size());
1102         return;
1103     }
1104
1105     // Update the navigation positions.
1106     if (HasObjectNavigationOrder())
1107     {
1108         SdrObjectWeakRef aReference (maList[nObjectPosition]);
1109         WeakSdrObjectContainerType::iterator iObject (::std::find(
1110             mpNavigationOrder->begin(),
1111             mpNavigationOrder->end(),
1112             aReference));
1113         if (iObject != mpNavigationOrder->end())
1114             mpNavigationOrder->erase(iObject);
1115         mbIsNavigationOrderDirty = true;
1116     }
1117
1118     maList.erase(maList.begin()+nObjectPosition);
1119     bObjOrdNumsDirty=TRUE;
1120 }
1121
1122
1123
1124
1125 ////////////////////////////////////////////////////////////////////////////////////////////////////
1126
1127 void SdrPageGridFrameList::Clear()
1128 {
1129     USHORT nAnz=GetCount();
1130     for (USHORT i=0; i<nAnz; i++) {
1131         delete GetObject(i);
1132     }
1133     aList.Clear();
1134 }
1135
1136 //////////////////////////////////////////////////////////////////////////////
1137 // #111111# PageUser section
1138
1139 void SdrPage::AddPageUser(sdr::PageUser& rNewUser)
1140 {
1141     maPageUsers.push_back(&rNewUser);
1142 }
1143
1144 void SdrPage::RemovePageUser(sdr::PageUser& rOldUser)
1145 {
1146     const ::sdr::PageUserVector::iterator aFindResult = ::std::find(maPageUsers.begin(), maPageUsers.end(), &rOldUser);
1147     if(aFindResult != maPageUsers.end())
1148     {
1149         maPageUsers.erase(aFindResult);
1150     }
1151 }
1152
1153 //////////////////////////////////////////////////////////////////////////////
1154 // #110094# DrawContact section
1155
1156 sdr::contact::ViewContact* SdrPage::CreateObjectSpecificViewContact()
1157 {
1158     return new sdr::contact::ViewContactOfSdrPage(*this);
1159 }
1160
1161 sdr::contact::ViewContact& SdrPage::GetViewContact() const
1162 {
1163     if(!mpViewContact)
1164     {
1165         ((SdrPage*)this)->mpViewContact = ((SdrPage*)this)->CreateObjectSpecificViewContact();
1166     }
1167
1168     return *mpViewContact;
1169 }
1170
1171 ////////////////////////////////////////////////////////////////////////////////////////////////////
1172
1173 TYPEINIT1(SdrPage,SdrObjList);
1174 DBG_NAME(SdrPage)
1175 SdrPage::SdrPage(SdrModel& rNewModel, bool bMasterPage)
1176 :       SdrObjList(&rNewModel, this),
1177     mpViewContact(0L),
1178     nWdt(10L),
1179     nHgt(10L),
1180     nBordLft(0L),
1181     nBordUpp(0L),
1182     nBordRgt(0L),
1183     nBordLwr(0L),
1184     pLayerAdmin(new SdrLayerAdmin(&rNewModel.GetLayerAdmin())),
1185     pBackgroundObj(0L),
1186     mpMasterPageDescriptor(0L),
1187     nPageNum(0L),
1188     mbMaster(bMasterPage),
1189     mbInserted(false),
1190     mbObjectsNotPersistent(false),
1191     mbSwappingLocked(false),
1192     mbPageBorderOnlyLeftRight(false)
1193 {
1194     DBG_CTOR(SdrPage,NULL);
1195     aPrefVisiLayers.SetAll();
1196     eListKind = (bMasterPage) ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
1197 }
1198
1199 SdrPage::SdrPage(const SdrPage& rSrcPage)
1200 :       SdrObjList(rSrcPage.pModel, this),
1201     tools::WeakBase< SdrPage >(),
1202     mpViewContact(0L),
1203     nWdt(rSrcPage.nWdt),
1204     nHgt(rSrcPage.nHgt),
1205     nBordLft(rSrcPage.nBordLft),
1206     nBordUpp(rSrcPage.nBordUpp),
1207     nBordRgt(rSrcPage.nBordRgt),
1208     nBordLwr(rSrcPage.nBordLwr),
1209     pLayerAdmin(new SdrLayerAdmin(rSrcPage.pModel->GetLayerAdmin())),
1210     pBackgroundObj(0L),
1211     mpMasterPageDescriptor(0L),
1212     nPageNum(rSrcPage.nPageNum),
1213     mbMaster(rSrcPage.mbMaster),
1214     mbInserted(false),
1215     mbObjectsNotPersistent(rSrcPage.mbObjectsNotPersistent),
1216     mbSwappingLocked(rSrcPage.mbSwappingLocked),
1217     mbPageBorderOnlyLeftRight(rSrcPage.mbPageBorderOnlyLeftRight)
1218 {
1219     DBG_CTOR(SdrPage,NULL);
1220     aPrefVisiLayers.SetAll();
1221     eListKind = (mbMaster) ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
1222
1223     // copy things from source
1224     // Warning: this leads to slicing (see issue 93186) and has to be
1225     // removed as soon as possible.
1226     *this = rSrcPage;
1227
1228     // be careful and correct eListKind, a member of SdrObjList which
1229     // will be changed by the SdrOIbjList::operator= before...
1230     eListKind = (mbMaster) ? SDROBJLIST_MASTERPAGE : SDROBJLIST_DRAWPAGE;
1231
1232     // The previous assignment to *this may have resulted in a call to
1233     // createUnoPage at a partially initialized (sliced) SdrPage object.
1234     // Due to the vtable being not yet fully set-up at this stage,
1235     // createUnoPage() may have been called at the wrong class.
1236     // To force a call to the right createUnoPage() at a later time when the
1237     // new object is full constructed mxUnoPage is disposed now.
1238     uno::Reference<lang::XComponent> xComponent (mxUnoPage, uno::UNO_QUERY);
1239     if (xComponent.is())
1240     {
1241         mxUnoPage = NULL;
1242         xComponent->dispose();
1243     }
1244 }
1245
1246 SdrPage::~SdrPage()
1247 {
1248     if( mxUnoPage.is() ) try
1249     {
1250         uno::Reference< lang::XComponent > xPageComponent( mxUnoPage, uno::UNO_QUERY_THROW );
1251         mxUnoPage.clear();
1252         xPageComponent->dispose();
1253     }
1254     catch( const uno::Exception& )
1255     {
1256         DBG_UNHANDLED_EXCEPTION();
1257     }
1258
1259     // #111111#
1260     // tell all the registered PageUsers that the page is in destruction
1261     // This causes some (all?) PageUsers to remove themselves from the list
1262     // of page users.  Therefore we have to use a copy of the list for the
1263     // iteration.
1264     ::sdr::PageUserVector aListCopy (maPageUsers.begin(), maPageUsers.end());
1265     for(::sdr::PageUserVector::iterator aIterator = aListCopy.begin(); aIterator != aListCopy.end(); aIterator++)
1266     {
1267         sdr::PageUser* pPageUser = *aIterator;
1268         DBG_ASSERT(pPageUser, "SdrPage::~SdrPage: corrupt PageUser list (!)");
1269         pPageUser->PageInDestruction(*this);
1270     }
1271
1272     // #111111#
1273     // Clear the vector. This means that user do not need to call RemovePageUser()
1274     // when they get called from PageInDestruction().
1275     maPageUsers.clear();
1276
1277     SdrObject::Free( pBackgroundObj );
1278     delete pLayerAdmin;
1279
1280     TRG_ClearMasterPage();
1281
1282     // #110094#
1283     if(mpViewContact)
1284     {
1285         delete mpViewContact;
1286         mpViewContact = 0L;
1287     }
1288
1289     DBG_DTOR(SdrPage,NULL);
1290 }
1291
1292 void SdrPage::operator=(const SdrPage& rSrcPage)
1293 {
1294     if(mpViewContact)
1295     {
1296         delete mpViewContact;
1297         mpViewContact = 0L;
1298     }
1299
1300     SdrObject::Free( pBackgroundObj );
1301
1302     // Joe also sets some parameters for the class this one
1303     // is derived from. SdrObjList does the same bad handling of
1304     // copy constructor and operator=, so i better let it stand here.
1305     pPage = this;
1306
1307     // copy all the local parameters to make this instance
1308     // a valid copy od source page before copying and inserting
1309     // the contained objects
1310     mbMaster = rSrcPage.mbMaster;
1311     mbSwappingLocked = rSrcPage.mbSwappingLocked;
1312     mbPageBorderOnlyLeftRight = rSrcPage.mbPageBorderOnlyLeftRight;
1313     aPrefVisiLayers = rSrcPage.aPrefVisiLayers;
1314     nWdt = rSrcPage.nWdt;
1315     nHgt = rSrcPage.nHgt;
1316     nBordLft = rSrcPage.nBordLft;
1317     nBordUpp = rSrcPage.nBordUpp;
1318     nBordRgt = rSrcPage.nBordRgt;
1319     nBordLwr = rSrcPage.nBordLwr;
1320     nPageNum = rSrcPage.nPageNum;
1321
1322     if(rSrcPage.TRG_HasMasterPage())
1323     {
1324         TRG_SetMasterPage(rSrcPage.TRG_GetMasterPage());
1325         TRG_SetMasterPageVisibleLayers(rSrcPage.TRG_GetMasterPageVisibleLayers());
1326     }
1327     else
1328     {
1329         TRG_ClearMasterPage();
1330     }
1331     //aMasters = rSrcPage.aMasters;
1332
1333     mbObjectsNotPersistent = rSrcPage.mbObjectsNotPersistent;
1334
1335     if(rSrcPage.pBackgroundObj)
1336     {
1337         pBackgroundObj = rSrcPage.pBackgroundObj->Clone();
1338           pBackgroundObj->SetPage( this );
1339         pBackgroundObj->SetModel( pModel );
1340
1341         // #i62000# for single-page MPBGO, force no line
1342         pBackgroundObj->SetMergedItem(XLineStyleItem(XLINE_NONE));
1343     }
1344
1345     // Now copy the contained obejcts (by cloning them)
1346     SdrObjList::operator=(rSrcPage);
1347 }
1348
1349 SdrPage* SdrPage::Clone() const
1350 {
1351     return Clone(NULL);
1352 }
1353
1354 SdrPage* SdrPage::Clone(SdrModel* pNewModel) const
1355 {
1356     if (pNewModel==NULL) pNewModel=pModel;
1357     SdrPage* pPage2=new SdrPage(*pNewModel);
1358     *pPage2=*this;
1359     return pPage2;
1360 }
1361
1362 void SdrPage::SetSize(const Size& aSiz)
1363 {
1364     bool bChanged(false);
1365
1366     if(aSiz.Width() != nWdt)
1367     {
1368         nWdt = aSiz.Width();
1369         bChanged = true;
1370     }
1371
1372     if(aSiz.Height() != nHgt)
1373     {
1374         nHgt = aSiz.Height();
1375         bChanged = true;
1376     }
1377
1378     if(bChanged)
1379     {
1380         SetChanged();
1381     }
1382 }
1383
1384 Size SdrPage::GetSize() const
1385 {
1386     return Size(nWdt,nHgt);
1387 }
1388
1389 INT32 SdrPage::GetWdt() const
1390 {
1391     return nWdt;
1392 }
1393
1394 void SdrPage::SetOrientation(Orientation eOri)
1395 {
1396     // Quadratisch ist und bleibt immer Portrait
1397     Size aSiz(GetSize());
1398     if (aSiz.Width()!=aSiz.Height()) {
1399         if ((eOri==ORIENTATION_PORTRAIT) == (aSiz.Width()>aSiz.Height())) {
1400             SetSize(Size(aSiz.Height(),aSiz.Width()));
1401         }
1402     }
1403 }
1404
1405 Orientation SdrPage::GetOrientation() const
1406 {
1407     // Quadratisch ist Portrait
1408     Orientation eRet=ORIENTATION_PORTRAIT;
1409     Size aSiz(GetSize());
1410     if (aSiz.Width()>aSiz.Height()) eRet=ORIENTATION_LANDSCAPE;
1411     return eRet;
1412 }
1413
1414 INT32 SdrPage::GetHgt() const
1415 {
1416     return nHgt;
1417 }
1418
1419 void  SdrPage::SetBorder(INT32 nLft, INT32 nUpp, INT32 nRgt, INT32 nLwr)
1420 {
1421     bool bChanged(false);
1422
1423     if(nBordLft != nLft)
1424     {
1425         nBordLft = nLft;
1426         bChanged = true;
1427     }
1428
1429     if(nBordUpp != nUpp)
1430     {
1431         nBordUpp = nUpp;
1432         bChanged = true;
1433     }
1434
1435     if(nBordRgt != nRgt)
1436     {
1437         nBordRgt = nRgt;
1438         bChanged = true;
1439     }
1440
1441     if(nBordLwr != nLwr)
1442     {
1443         nBordLwr =  nLwr;
1444         bChanged = true;
1445     }
1446
1447     if(bChanged)
1448     {
1449         SetChanged();
1450     }
1451 }
1452
1453 void  SdrPage::SetLftBorder(INT32 nBorder)
1454 {
1455     if(nBordLft != nBorder)
1456     {
1457         nBordLft = nBorder;
1458         SetChanged();
1459     }
1460 }
1461
1462 void  SdrPage::SetUppBorder(INT32 nBorder)
1463 {
1464     if(nBordUpp != nBorder)
1465     {
1466         nBordUpp = nBorder;
1467         SetChanged();
1468     }
1469 }
1470
1471 void  SdrPage::SetRgtBorder(INT32 nBorder)
1472 {
1473     if(nBordRgt != nBorder)
1474     {
1475         nBordRgt=nBorder;
1476         SetChanged();
1477     }
1478 }
1479
1480 void  SdrPage::SetLwrBorder(INT32 nBorder)
1481 {
1482     if(nBordLwr != nBorder)
1483     {
1484         nBordLwr=nBorder;
1485         SetChanged();
1486     }
1487 }
1488
1489 INT32 SdrPage::GetLftBorder() const
1490 {
1491     return nBordLft;
1492 }
1493
1494 INT32 SdrPage::GetUppBorder() const
1495 {
1496     return nBordUpp;
1497 }
1498
1499 INT32 SdrPage::GetRgtBorder() const
1500 {
1501     return nBordRgt;
1502 }
1503
1504 INT32 SdrPage::GetLwrBorder() const
1505 {
1506     return nBordLwr;
1507 }
1508
1509 void SdrPage::SetModel(SdrModel* pNewModel)
1510 {
1511     SdrModel* pOldModel=pModel;
1512     SdrObjList::SetModel(pNewModel);
1513     if (pNewModel!=pOldModel)
1514     {
1515         if (pNewModel!=NULL) {
1516             pLayerAdmin->SetParent(&pNewModel->GetLayerAdmin());
1517         } else {
1518             pLayerAdmin->SetParent(NULL);
1519         }
1520         pLayerAdmin->SetModel(pNewModel);
1521
1522         if( pBackgroundObj )
1523             pBackgroundObj->SetModel( pNewModel );
1524     }
1525
1526     // update listeners at possible api wrapper object
1527     if( pOldModel != pNewModel )
1528     {
1529         if( mxUnoPage.is() )
1530         {
1531             SvxDrawPage* pPage2 = SvxDrawPage::getImplementation( mxUnoPage );
1532             if( pPage2 )
1533                 pPage2->ChangeModel( pNewModel );
1534         }
1535     }
1536 }
1537
1538 ////////////////////////////////////////////////////////////////////////////////////////////////////
1539
1540 // #i68775# React on PageNum changes (from Model in most cases)
1541 void SdrPage::SetPageNum(sal_uInt16 nNew)
1542 {
1543     if(nNew != nPageNum)
1544     {
1545         // change
1546         nPageNum = nNew;
1547
1548         // notify visualisations, also notifies e.g. buffered MasterPages
1549         ActionChanged();
1550     }
1551 }
1552
1553 USHORT SdrPage::GetPageNum() const
1554 {
1555     if (!mbInserted)
1556         return 0;
1557
1558     if (mbMaster) {
1559         if (pModel && pModel->IsMPgNumsDirty())
1560             ((SdrModel*)pModel)->RecalcPageNums(TRUE);
1561     } else {
1562         if (pModel && pModel->IsPagNumsDirty())
1563             ((SdrModel*)pModel)->RecalcPageNums(FALSE);
1564     }
1565     return nPageNum;
1566 }
1567
1568 void SdrPage::SetChanged()
1569 {
1570     // #110094#-11
1571     // For test purposes, use the new ViewContact for change
1572     // notification now.
1573     ActionChanged();
1574
1575     if( pModel )
1576     {
1577         pModel->SetChanged();
1578     }
1579 }
1580
1581 ////////////////////////////////////////////////////////////////////////////////////////////////////
1582 // MasterPage interface
1583
1584 void SdrPage::TRG_SetMasterPage(SdrPage& rNew)
1585 {
1586     if(mpMasterPageDescriptor && &(mpMasterPageDescriptor->GetUsedPage()) == &rNew)
1587         return;
1588
1589     if(mpMasterPageDescriptor)
1590         TRG_ClearMasterPage();
1591
1592     mpMasterPageDescriptor = new ::sdr::MasterPageDescriptor(*this, rNew);
1593     GetViewContact().ActionChanged();
1594 }
1595
1596 void SdrPage::TRG_ClearMasterPage()
1597 {
1598     if(mpMasterPageDescriptor)
1599     {
1600         SetChanged();
1601
1602         // the flushViewObjectContacts() will do needed invalidates by deleting the involved VOCs
1603         mpMasterPageDescriptor->GetUsedPage().GetViewContact().flushViewObjectContacts(true);
1604
1605         delete mpMasterPageDescriptor;
1606         mpMasterPageDescriptor = 0L;
1607     }
1608 }
1609
1610 SdrPage& SdrPage::TRG_GetMasterPage() const
1611 {
1612     DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_GetMasterPage(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1613     return mpMasterPageDescriptor->GetUsedPage();
1614 }
1615
1616 const SetOfByte& SdrPage::TRG_GetMasterPageVisibleLayers() const
1617 {
1618     DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_GetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1619     return mpMasterPageDescriptor->GetVisibleLayers();
1620 }
1621
1622 void SdrPage::TRG_SetMasterPageVisibleLayers(const SetOfByte& rNew)
1623 {
1624     DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_SetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1625     mpMasterPageDescriptor->SetVisibleLayers(rNew);
1626 }
1627
1628 sdr::contact::ViewContact& SdrPage::TRG_GetMasterPageDescriptorViewContact() const
1629 {
1630     DBG_ASSERT(mpMasterPageDescriptor != 0L, "TRG_GetMasterPageDescriptorViewContact(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1631     return mpMasterPageDescriptor->GetViewContact();
1632 }
1633
1634 // #115423# used from SdrModel::RemoveMasterPage
1635 void SdrPage::TRG_ImpMasterPageRemoved(const SdrPage& rRemovedPage)
1636 {
1637     if(TRG_HasMasterPage())
1638     {
1639         if(&TRG_GetMasterPage() == &rRemovedPage)
1640         {
1641             TRG_ClearMasterPage();
1642         }
1643     }
1644 }
1645
1646 const SdrPageGridFrameList* SdrPage::GetGridFrameList(const SdrPageView* /*pPV*/, const Rectangle* /*pRect*/) const
1647 {
1648     return NULL;
1649 }
1650
1651 XubString SdrPage::GetLayoutName() const
1652 {
1653     // Die wollte Dieter haben.
1654     return String();
1655 }
1656
1657 void SdrPage::SetBackgroundObj( SdrObject* pObj )
1658 {
1659     if ( pObj )
1660     {
1661         pObj->SetPage( this );
1662         pObj->SetModel( pModel );
1663         pObj->SetLayer( 1 );        // Nothing known about the backgroundlayer...
1664
1665         // #i62000# for single-page MPBGO, force no line
1666         pObj->SetMergedItem(XLineStyleItem(XLINE_NONE));
1667     }
1668
1669     SdrObject::Free( pBackgroundObj );
1670     pBackgroundObj = pObj;
1671 }
1672
1673 void SdrPage::SetInserted( bool bIns )
1674 {
1675     if( mbInserted != bIns )
1676     {
1677         mbInserted = bIns;
1678
1679         SdrObjListIter aIter( *this, IM_FLAT );
1680          while ( aIter.IsMore() )
1681         {
1682             SdrObject* pObj = aIter.Next();
1683             if ( pObj->ISA(SdrOle2Obj) )
1684             {
1685                 if( mbInserted )
1686                     ( (SdrOle2Obj*) pObj)->Connect();
1687                 else
1688                     ( (SdrOle2Obj*) pObj)->Disconnect();
1689             }
1690         }
1691     }
1692 }
1693
1694
1695 uno::Reference< uno::XInterface > SdrPage::getUnoPage()
1696 {
1697     // try weak reference first
1698     if( !mxUnoPage.is() )
1699     {
1700         // create one
1701         mxUnoPage = createUnoPage();
1702     }
1703
1704     return mxUnoPage;
1705 }
1706
1707 uno::Reference< uno::XInterface > SdrPage::createUnoPage()
1708 {
1709     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xInt =
1710         static_cast<cppu::OWeakObject*>( new SvxFmDrawPage( this ) );
1711     return xInt;
1712 }
1713
1714 SfxStyleSheet* SdrPage::GetTextStyleSheetForObject( SdrObject* pObj ) const
1715 {
1716     return pObj->GetStyleSheet();
1717 }
1718
1719 FASTBOOL SdrPage::HasTransparentObjects( BOOL bCheckForAlphaChannel ) const
1720 {
1721     FASTBOOL bRet = FALSE;
1722
1723     for( ULONG n = 0, nCount = GetObjCount(); ( n < nCount ) && !bRet; n++ )
1724         if( GetObj( n )->IsTransparent( bCheckForAlphaChannel ) )
1725             bRet = TRUE;
1726
1727     return bRet;
1728 }
1729
1730 /** returns an averaged background color of this page */
1731 // #i75566# GetBackgroundColor -> GetPageBackgroundColor and bScreenDisplay hint value
1732 Color SdrPage::GetPageBackgroundColor( SdrPageView* pView, bool bScreenDisplay ) const
1733 {
1734     Color aColor;
1735
1736     if(bScreenDisplay && (!pView || pView->GetApplicationDocumentColor() == COL_AUTO))
1737     {
1738         svtools::ColorConfig aColorConfig;
1739         aColor = aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor;
1740     }
1741     else
1742     {
1743         aColor = pView->GetApplicationDocumentColor();
1744     }
1745
1746     // first, see if we have a background object
1747     SdrObject* pBackgroundObj2 = NULL;
1748
1749
1750     if( IsMasterPage() )
1751     {
1752         if( GetObjCount() )
1753             pBackgroundObj2 = GetObj( 0 );
1754     }
1755     else
1756     {
1757         pBackgroundObj2 = GetBackgroundObj();
1758         if( NULL == pBackgroundObj2 )
1759         {
1760             // if not, see if we have a masterpage and get that background object
1761             if(TRG_HasMasterPage())
1762             {
1763                 SdrPage& rMasterPage = TRG_GetMasterPage();
1764
1765                 if(rMasterPage.GetObjCount())
1766                 {
1767                     pBackgroundObj2 = rMasterPage.GetObj( 0 );
1768                 }
1769             }
1770         }
1771     }
1772
1773     if( pBackgroundObj2 )
1774     {
1775         const SfxItemSet& rSet = pBackgroundObj2->GetMergedItemSet();
1776         GetDraftFillColor( rSet, aColor );
1777     }
1778
1779     return aColor;
1780 }
1781
1782 /** *deprecated, use GetBackgroundColor with SdrPageView */
1783 Color SdrPage::GetPageBackgroundColor() const
1784 // #i75566# GetBackgroundColor -> GetPageBackgroundColor
1785 {
1786     return GetPageBackgroundColor( NULL, true );
1787 }
1788
1789 /** this method returns true if the object from the ViewObjectContact should
1790     be visible on this page while rendering.
1791     bEdit selects if visibility test is for an editing view or a final render,
1792     like printing.
1793 */
1794 bool SdrPage::checkVisibility(
1795     const sdr::contact::ViewObjectContact& /*rOriginal*/,
1796     const sdr::contact::DisplayInfo& /*rDisplayInfo*/,
1797     bool /*bEdit*/)
1798 {
1799     // this will be handled in the application if needed
1800     return true;
1801 }
1802
1803 // #110094# DrawContact support: Methods for handling Page changes
1804 void SdrPage::ActionChanged() const
1805 {
1806     // Do necessary ViewContact actions
1807     GetViewContact().ActionChanged();
1808
1809     // #i48535# also handle MasterPage change
1810     if(TRG_HasMasterPage())
1811     {
1812         TRG_GetMasterPageDescriptorViewContact().ActionChanged();
1813     }
1814 }
1815
1816 // NYI: Dummy implementations for declarations in svdpage.hxx
1817 Bitmap      SdrPage::GetBitmap(const SetOfByte& /*rVisibleLayers*/, FASTBOOL /*bTrimBorders*/) const
1818 {
1819     DBG_ASSERT(0, "SdrPage::GetBitmap(): not yet implemented.");
1820     return Bitmap();
1821 }
1822 GDIMetaFile SdrPage::GetMetaFile(const SetOfByte& /*rVisibleLayers*/, FASTBOOL /*bTrimBorders*/)
1823 {
1824     DBG_ASSERT(0, "SdrPage::GetMetaFile(): not yet implemented.");
1825     return GDIMetaFile();
1826 }
1827
1828 //////////////////////////////////////////////////////////////////////////////
1829 // sdr::Comment interface
1830
1831 const sdr::Comment& SdrPage::GetCommentByIndex(sal_uInt32 nIndex)
1832 {
1833     DBG_ASSERT(nIndex < maComments.size(), "SdrPage::GetCommentByIndex: Access out of range (!)");
1834     return maComments[nIndex];
1835 }
1836
1837 void SdrPage::AddComment(const sdr::Comment& rNew)
1838 {
1839     maComments.push_back(rNew);
1840     ::std::sort(maComments.begin(), maComments.end());
1841 }
1842
1843 void SdrPage::ReplaceCommentByIndex(sal_uInt32 nIndex, const sdr::Comment& rNew)
1844 {
1845     DBG_ASSERT(nIndex < maComments.size(), "SdrPage::GetCommentByIndex: Access out of range (!)");
1846
1847     if(maComments[nIndex] != rNew)
1848     {
1849         maComments[nIndex] = rNew;
1850         ::std::sort(maComments.begin(), maComments.end());
1851     }
1852 }
1853
1854 //////////////////////////////////////////////////////////////////////////////
1855 // use new redirector instead of pPaintProc
1856
1857 StandardCheckVisisbilityRedirector::StandardCheckVisisbilityRedirector()
1858 :       ViewObjectContactRedirector()
1859 {
1860 }
1861
1862 StandardCheckVisisbilityRedirector::~StandardCheckVisisbilityRedirector()
1863 {
1864 }
1865
1866 drawinglayer::primitive2d::Primitive2DSequence StandardCheckVisisbilityRedirector::createRedirectedPrimitive2DSequence(
1867     const sdr::contact::ViewObjectContact& rOriginal,
1868     const sdr::contact::DisplayInfo& rDisplayInfo)
1869 {
1870     SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
1871
1872     if(pObject)
1873     {
1874         if(pObject->GetPage())
1875         {
1876             if(pObject->GetPage()->checkVisibility(rOriginal, rDisplayInfo, false))
1877             {
1878                 return ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
1879             }
1880         }
1881
1882         return drawinglayer::primitive2d::Primitive2DSequence();
1883     }
1884     else
1885     {
1886         // not an object, maybe a page
1887         return ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
1888     }
1889 }
1890
1891 //////////////////////////////////////////////////////////////////////////////
1892 // eof