svx/source/svdraw/svdpage.cxx

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