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