svx/source/svdraw/svdmark.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
  21
  22
  23 #include <svx/svdmark.hxx>
  24 #include <svx/svdetc.hxx>
  25 #include <svx/svdobj.hxx>
  26 #include <svx/svdpage.hxx>
  27 #include "svx/svditer.hxx"
  28 #include <svx/svdpagv.hxx>
  29 #include <svx/svdopath.hxx>
  30 #include <svx/svdogrp.hxx>
  31 #include <svx/svdorect.hxx>
  32 #include "svx/svdstr.hrc"
  33 #include "svdglob.hxx"
  34
  35
  36 #include <svx/obj3d.hxx>
  37 #include <svx/scene3d.hxx>
  38 #include <svl/SfxBroadcaster.hxx>
  39 #include <svx/svdoedge.hxx>
  40
  41
  42
  43
  44 SdrMark::SdrMark(SdrObject* pNewObj, SdrPageView* pNewPageView)
  45 :   mpSelectedSdrObject(pNewObj),
  46     mpPageView(pNewPageView),
  47     mpPoints(0L),
  48     mpLines(0L),
  49     mpGluePoints(0L),
  50     mbCon1(false),
  51     mbCon2(false),
  52     mnUser(0)
  53 {
  54     if(mpSelectedSdrObject)
  55     {
  56         mpSelectedSdrObject->AddObjectUser( *this );
  57     }
  58 }
  59
  60 SdrMark::SdrMark(const SdrMark& rMark)
  61 :   ObjectUser(),
  62     mpSelectedSdrObject(0L),
  63     mpPageView(0L),
  64     mpPoints(0L),
  65     mpLines(0L),
  66     mpGluePoints(0L),
  67     mbCon1(false),
  68     mbCon2(false),
  69     mnUser(0)
  70 {
  71     *this = rMark;
  72 }
  73
  74 SdrMark::~SdrMark()
  75 {
  76     if(mpSelectedSdrObject)
  77     {
  78         mpSelectedSdrObject->RemoveObjectUser( *this );
  79     }
  80
  81     if(mpPoints)
  82     {
  83         delete mpPoints;
  84     }
  85
  86     if(mpLines)
  87     {
  88         delete mpLines;
  89     }
  90
  91     if(mpGluePoints)
  92     {
  93         delete mpGluePoints;
  94     }
  95 }
  96
  97 void SdrMark::ObjectInDestruction(const SdrObject& rObject)
  98 {
  99     (void) rObject; // avoid warnings
 100     OSL_ENSURE(mpSelectedSdrObject && mpSelectedSdrObject == &rObject, "SdrMark::ObjectInDestruction: called form object different from hosted one (!)");
 101     OSL_ENSURE(mpSelectedSdrObject, "SdrMark::ObjectInDestruction: still selected SdrObject is deleted, deselect first (!)");
 102     mpSelectedSdrObject = 0L;
 103 }
 104
 105 void SdrMark::SetMarkedSdrObj(SdrObject* pNewObj)
 106 {
 107     if(mpSelectedSdrObject)
 108     {
 109         mpSelectedSdrObject->RemoveObjectUser( *this );
 110     }
 111
 112     mpSelectedSdrObject = pNewObj;
 113
 114     if(mpSelectedSdrObject)
 115     {
 116         mpSelectedSdrObject->AddObjectUser( *this );
 117     }
 118 }
 119
 120
 121 SdrMark& SdrMark::operator=(const SdrMark& rMark)
 122 {
 123     SetMarkedSdrObj(rMark.mpSelectedSdrObject);
 124     mpPageView = rMark.mpPageView;
 125     mbCon1 = rMark.mbCon1;
 126     mbCon2 = rMark.mbCon2;
 127     mnUser = rMark.mnUser;
 128
 129     if(!rMark.mpPoints)
 130     {
 131         if(mpPoints)
 132         {
 133             delete mpPoints;
 134             mpPoints = 0L;
 135         }
 136     }
 137     else
 138     {
 139         if(!mpPoints)
 140         {
 141             mpPoints = new SdrUShortCont(*rMark.mpPoints);
 142         }
 143         else
 144         {
 145             *mpPoints = *rMark.mpPoints;
 146         }
 147     }
 148
 149     if(!rMark.mpLines)
 150     {
 151         if(mpLines)
 152         {
 153             delete mpLines;
 154             mpLines = 0L;
 155         }
 156     }
 157     else
 158     {
 159         if(!mpLines)
 160         {
 161             mpLines = new SdrUShortCont(*rMark.mpLines);
 162         }
 163         else
 164         {
 165             *mpLines = *rMark.mpLines;
 166         }
 167     }
 168
 169     if(!rMark.mpGluePoints)
 170     {
 171         if(mpGluePoints)
 172         {
 173             delete mpGluePoints;
 174             mpGluePoints = 0L;
 175         }
 176     }
 177     else
 178     {
 179         if(!mpGluePoints)
 180         {
 181             mpGluePoints = new SdrUShortCont(*rMark.mpGluePoints);
 182         }
 183         else
 184         {
 185             *mpGluePoints = *rMark.mpGluePoints;
 186         }
 187     }
 188
 189     return *this;
 190 }
 191
 192 bool SdrMark::operator==(const SdrMark& rMark) const
 193 {
 194     bool bRet(mpSelectedSdrObject == rMark.mpSelectedSdrObject && mpPageView == rMark.mpPageView && mbCon1 == rMark.mbCon1 && mbCon2 == rMark.mbCon2 && mnUser == rMark.mnUser);
 195
 196     if((mpPoints != 0L) != (rMark.mpPoints != 0L))
 197         bRet = false;
 198
 199     if((mpLines != 0L) != (rMark.mpLines != 0L))
 200         bRet = false;
 201
 202     if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L))
 203         bRet = false;
 204
 205     if(bRet && mpPoints && *mpPoints != *rMark.mpPoints)
 206         bRet = false;
 207
 208     if(bRet && mpLines && *mpLines != *rMark.mpLines)
 209         bRet = false;
 210
 211     if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints)
 212         bRet = false;
 213
 214     return bRet;
 215 }
 216
 217
 218
 219 static bool ImpSdrMarkListSorter(SdrMark* const& lhs, SdrMark* const& rhs)
 220 {
 221     SdrObject* pObj1 = lhs->GetMarkedSdrObj();
 222     SdrObject* pObj2 = rhs->GetMarkedSdrObj();
 223     SdrObjList* pOL1 = (pObj1) ? pObj1->GetObjList() : 0L;
 224     SdrObjList* pOL2 = (pObj2) ? pObj2->GetObjList() : 0L;
 225
 226     if (pOL1 == pOL2)
 227     {
 228         // AF: Note that I reverted a change from sal_uInt32 to sal_uLong (made
 229         // for 64bit compliance, #i78198#) because internally in SdrObject
 230         // both nOrdNum and mnNavigationPosition are stored as sal_uInt32.
 231         sal_uInt32 nObjOrd1((pObj1) ? pObj1->GetNavigationPosition() : 0);
 232         sal_uInt32 nObjOrd2((pObj2) ? pObj2->GetNavigationPosition() : 0);
 233
 234         return nObjOrd1 < nObjOrd2;
 235     }
 236     else
 237     {
 238         return pOL1 < pOL2;
 239     }
 240 }
 241
 242
 243
 244 void SdrMarkList::ForceSort() const
 245 {
 246     if(!mbSorted)
 247     {
 248         const_cast<SdrMarkList*>(this)->ImpForceSort();
 249     }
 250 }
 251
 252 void SdrMarkList::ImpForceSort()
 253 {
 254     if(!mbSorted)
 255     {
 256         mbSorted = true;
 257         size_t nCount = maList.size();
 258
 259         // remove invalid
 260         if(nCount > 0 )
 261         {
 262             for(std::vector<SdrMark*>::iterator it = maList.begin(); it != maList.end(); )
 263             {
 264                 SdrMark* pAkt = *it;
 265                 if(pAkt->GetMarkedSdrObj() == 0)
 266                 {
 267                     it = maList.erase( it );
 268                     delete pAkt;
 269                 }
 270                 else
 271                     ++it;
 272             }
 273             nCount = maList.size();
 274         }
 275
 276         if(nCount > 1)
 277         {
 278             std::sort(maList.begin(), maList.end(), ImpSdrMarkListSorter);
 279
 280             // remove duplicates
 281             if(maList.size() > 1)
 282             {
 283                 SdrMark* pAkt = maList.back();
 284                 for (size_t i = maList.size() - 2; i; --i)
 285                 {
 286                     SdrMark* pCmp = maList[i];
 287                     if(pAkt->GetMarkedSdrObj() == pCmp->GetMarkedSdrObj() && pAkt->GetMarkedSdrObj())
 288                     {
 289                         // Con1/Con2 Merging
 290                         if(pCmp->IsCon1())
 291                             pAkt->SetCon1(true);
 292
 293                         if(pCmp->IsCon2())
 294                             pAkt->SetCon2(true);
 295
 296                         // delete pCmp
 297                         maList.erase(maList.begin() + i);
 298
 299                         delete pCmp;
 300                     }
 301                     else
 302                     {
 303                         pAkt = pCmp;
 304                     }
 305                 }
 306             }
 307         }
 308     }
 309 }
 310
 311 void SdrMarkList::Clear()
 312 {
 313     for(size_t i = 0; i < GetMarkCount(); ++i)
 314     {
 315         SdrMark* pMark = GetMark(i);
 316         delete pMark;
 317     }
 318
 319     maList.clear();
 320     SetNameDirty();
 321 }
 322
 323 void SdrMarkList::operator=(const SdrMarkList& rLst)
 324 {
 325     Clear();
 326
 327     for(size_t i = 0; i < rLst.GetMarkCount(); ++i)
 328     {
 329         SdrMark* pMark = rLst.GetMark(i);
 330         SdrMark* pNeuMark = new SdrMark(*pMark);
 331         maList.push_back(pNeuMark);
 332     }
 333
 334     maMarkName = rLst.maMarkName;
 335     mbNameOk = rLst.mbNameOk;
 336     maPointName = rLst.maPointName;
 337     mbPointNameOk = rLst.mbPointNameOk;
 338     maGluePointName = rLst.maGluePointName;
 339     mbGluePointNameOk = rLst.mbGluePointNameOk;
 340     mbSorted = rLst.mbSorted;
 341 }
 342
 343 SdrMark* SdrMarkList::GetMark(size_t nNum) const
 344 {
 345     return (nNum < maList.size()) ? maList[nNum] : NULL;
 346 }
 347
 348 size_t SdrMarkList::FindObject(const SdrObject* pObj) const
 349 {
 350     // Since relying on OrdNums is not allowed for the selection because objects in the
 351     // selection may not be inserted in a list if they are e.g. modified ATM, i changed
 352     // this loop to just look if the object pointer is in the selection.
 353
 354     // Problem is that GetOrdNum() which is const, internally casts to non-const and
 355     // hardly sets the OrdNum member of the object (nOrdNum) to 0 (ZERO) if the object
 356     // is not inserted in a object list.
 357     // Since this may be by purpose and necessary somewhere else i decided that it is
 358     // less dangerous to change this method then changing SdrObject::GetOrdNum().
 359     if(pObj && !maList.empty())
 360     {
 361         for(size_t a = 0; a < maList.size(); ++a)
 362         {
 363             if(maList[a]->GetMarkedSdrObj() == pObj)
 364             {
 365                 return a;
 366             }
 367         }
 368     }
 369
 370     return SAL_MAX_SIZE;
 371 }
 372
 373 void SdrMarkList::InsertEntry(const SdrMark& rMark, bool bChkSort)
 374 {
 375     SetNameDirty();
 376     const size_t nCount(maList.size());
 377
 378     if(!bChkSort || !mbSorted || nCount == 0)
 379     {
 380         if(!bChkSort)
 381             mbSorted = false;
 382
 383         maList.push_back(new SdrMark(rMark));
 384     }
 385     else
 386     {
 387         SdrMark* pLast = GetMark(nCount - 1);
 388         const SdrObject* pLastObj = pLast->GetMarkedSdrObj();
 389         const SdrObject* pNeuObj = rMark.GetMarkedSdrObj();
 390
 391         if(pLastObj == pNeuObj)
 392         {
 393             // This one already exists.
 394             // Con1/Con2 Merging
 395             if(rMark.IsCon1())
 396                 pLast->SetCon1(true);
 397
 398             if(rMark.IsCon2())
 399                 pLast->SetCon2(true);
 400         }
 401         else
 402         {
 403             SdrMark* pKopie = new SdrMark(rMark);
 404             maList.push_back(pKopie);
 405
 406             // now check if the sort is ok
 407             const SdrObjList* pLastOL = pLastObj!=0L ? pLastObj->GetObjList() : 0L;
 408             const SdrObjList* pNeuOL = pNeuObj !=0L ? pNeuObj ->GetObjList() : 0L;
 409
 410             if(pLastOL == pNeuOL)
 411             {
 412                 const sal_uLong nLastNum(pLastObj!=0L ? pLastObj->GetOrdNum() : 0);
 413                 const sal_uLong nNeuNum(pNeuObj !=0L ? pNeuObj ->GetOrdNum() : 0);
 414
 415                 if(nNeuNum < nLastNum)
 416                 {
 417                     // at some point, we have to sort
 418                     mbSorted = false;
 419                 }
 420             }
 421             else
 422             {
 423                 // at some point, we have to sort
 424                 mbSorted = false;
 425             }
 426         }
 427     }
 428
 429     return;
 430 }
 431
 432 void SdrMarkList::DeleteMark(size_t nNum)
 433 {
 434     SdrMark* pMark = GetMark(nNum);
 435     DBG_ASSERT(pMark!=0L,"DeleteMark: MarkEntry not found.");
 436
 437     if(pMark)
 438     {
 439         maList.erase(maList.begin() + nNum);
 440         delete pMark;
 441         SetNameDirty();
 442     }
 443 }
 444
 445 void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, size_t nNum)
 446 {
 447     SdrMark* pMark = GetMark(nNum);
 448     DBG_ASSERT(pMark!=0L,"ReplaceMark: MarkEntry not found.");
 449
 450     if(pMark)
 451     {
 452         delete pMark;
 453         SetNameDirty();
 454         SdrMark* pKopie = new SdrMark(rNewMark);
 455         maList[nNum] = pKopie;
 456         mbSorted = false;
 457     }
 458 }
 459
 460 void SdrMarkList::Merge(const SdrMarkList& rSrcList, bool bReverse)
 461 {
 462     const size_t nCount(rSrcList.maList.size());
 463
 464     if(rSrcList.mbSorted)
 465     {
 466         // merge without forcing a Sort in rSrcList
 467         bReverse = false;
 468     }
 469
 470     if(!bReverse)
 471     {
 472         for(size_t i = 0; i < nCount; ++i)
 473         {
 474             SdrMark* pM = rSrcList.maList[i];
 475             InsertEntry(*pM);
 476         }
 477     }
 478     else
 479     {
 480         for(size_t i = nCount; i > 0;)
 481         {
 482             --i;
 483             SdrMark* pM = rSrcList.maList[i];
 484             InsertEntry(*pM);
 485         }
 486     }
 487 }
 488
 489 bool SdrMarkList::DeletePageView(const SdrPageView& rPV)
 490 {
 491     bool bChgd(false);
 492
 493     for(std::vector<SdrMark*>::iterator it = maList.begin(); it != maList.end(); )
 494     {
 495         SdrMark* pMark = *it;
 496
 497         if(pMark->GetPageView()==&rPV)
 498         {
 499             it = maList.erase(it);
 500             delete pMark;
 501             SetNameDirty();
 502             bChgd = true;
 503         }
 504         else
 505             ++it;
 506     }
 507
 508     return bChgd;
 509 }
 510
 511 bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
 512 {
 513     bool bChgd(false);
 514     DeletePageView(rPV); // delete all of them, then append the entire page
 515     const SdrObjList* pOL = rPV.GetObjList();
 516     const size_t nObjAnz(pOL->GetObjCount());
 517
 518     for(size_t nO = 0; nO < nObjAnz; ++nO)
 519     {
 520         SdrObject* pObj = pOL->GetObj(nO);
 521         bool bDoIt(rPV.IsObjMarkable(pObj));
 522
 523         if(bDoIt)
 524         {
 525             SdrMark* pM = new SdrMark(pObj, const_cast<SdrPageView*>(&rPV));
 526             maList.push_back(pM);
 527             SetNameDirty();
 528             bChgd = true;
 529         }
 530     }
 531
 532     return bChgd;
 533 }
 534
 535 const OUString& SdrMarkList::GetMarkDescription() const
 536 {
 537     const size_t nCount(GetMarkCount());
 538
 539     if(mbNameOk && 1L == nCount)
 540     {
 541         // if it's a single selection, cache only text frame
 542         const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 543         const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj, pObj);
 544
 545         if(!pTextObj || !pTextObj->IsTextFrame())
 546         {
 547             const_cast<SdrMarkList*>(this)->mbNameOk = false;
 548         }
 549     }
 550
 551     if(!mbNameOk)
 552     {
 553         SdrMark* pMark = GetMark(0);
 554         OUString aNam;
 555
 556         if(!nCount)
 557         {
 558             const_cast<SdrMarkList*>(this)->maMarkName = ImpGetResStr(STR_ObjNameNoObj);
 559         }
 560         else if(1L == nCount)
 561         {
 562             if(pMark->GetMarkedSdrObj())
 563             {
 564                 aNam = pMark->GetMarkedSdrObj()->TakeObjNameSingul();
 565             }
 566         }
 567         else
 568         {
 569             if(pMark->GetMarkedSdrObj())
 570             {
 571                 aNam = pMark->GetMarkedSdrObj()->TakeObjNamePlural();
 572                 bool bEq(true);
 573
 574                 for(size_t i = 1; i < GetMarkCount() && bEq; ++i)
 575                 {
 576                     SdrMark* pMark2 = GetMark(i);
 577                     OUString aStr1(pMark2->GetMarkedSdrObj()->TakeObjNamePlural());
 578                     bEq = aNam == aStr1;
 579                 }
 580
 581                 if(!bEq)
 582                 {
 583                     aNam = ImpGetResStr(STR_ObjNamePlural);
 584                 }
 585             }
 586
 587             aNam = OUString::number( nCount ) + " " + aNam;
 588         }
 589
 590         const_cast<SdrMarkList*>(this)->maMarkName = aNam;
 591         const_cast<SdrMarkList*>(this)->mbNameOk = true;
 592     }
 593
 594     return maMarkName;
 595 }
 596
 597 const OUString& SdrMarkList::GetPointMarkDescription(bool bGlue) const
 598 {
 599     bool& rNameOk = (bool&)(bGlue ? mbGluePointNameOk : mbPointNameOk);
 600     OUString& rName = const_cast<OUString&>(bGlue ? maGluePointName : maPointName);
 601     const size_t nMarkCount(GetMarkCount());
 602     size_t nMarkPtAnz(0);
 603     size_t nMarkPtObjAnz(0);
 604     size_t n1stMarkNum(SAL_MAX_SIZE);
 605
 606     for(size_t nMarkNum = 0; nMarkNum < nMarkCount; ++nMarkNum)
 607     {
 608         const SdrMark* pMark = GetMark(nMarkNum);
 609         const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
 610         const size_t nCount(pPts ? pPts->size() : 0);
 611
 612         if(nCount)
 613         {
 614             if(n1stMarkNum == SAL_MAX_SIZE)
 615             {
 616                 n1stMarkNum = nMarkNum;
 617             }
 618
 619             nMarkPtAnz += nCount;
 620             nMarkPtObjAnz++;
 621         }
 622
 623         if(nMarkPtObjAnz > 1 && rNameOk)
 624         {
 625             // preliminary decision
 626             return rName;
 627         }
 628     }
 629
 630     if(rNameOk && 1 == nMarkPtObjAnz)
 631     {
 632         // if it's a single selection, cache only text frame
 633         const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 634         const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj,pObj);
 635
 636         if(!pTextObj || !pTextObj->IsTextFrame())
 637         {
 638             rNameOk = false;
 639         }
 640     }
 641
 642     if(!nMarkPtObjAnz)
 643     {
 644         rName.clear();
 645         rNameOk = true;
 646     }
 647     else if(!rNameOk)
 648     {
 649         const SdrMark* pMark = GetMark(n1stMarkNum);
 650         OUString aNam;
 651
 652         if(1L == nMarkPtObjAnz)
 653         {
 654             if(pMark->GetMarkedSdrObj())
 655             {
 656                 aNam = pMark->GetMarkedSdrObj()->TakeObjNameSingul();
 657             }
 658         }
 659         else
 660         {
 661             if(pMark->GetMarkedSdrObj())
 662             {
 663                 aNam = pMark->GetMarkedSdrObj()->TakeObjNamePlural();
 664             }
 665
 666             bool bEq(true);
 667
 668             for(size_t i = n1stMarkNum + 1; i < GetMarkCount() && bEq; ++i)
 669             {
 670                 const SdrMark* pMark2 = GetMark(i);
 671                 const SdrUShortCont* pPts = bGlue ? pMark2->GetMarkedGluePoints() : pMark2->GetMarkedPoints();
 672
 673                 if(pPts && !pPts->empty() && pMark2->GetMarkedSdrObj())
 674                 {
 675                     OUString aStr1(pMark2->GetMarkedSdrObj()->TakeObjNamePlural());
 676                     bEq = aNam == aStr1;
 677                 }
 678             }
 679
 680             if(!bEq)
 681             {
 682                 aNam = ImpGetResStr(STR_ObjNamePlural);
 683             }
 684
 685             aNam = OUString::number( nMarkPtObjAnz ) + " " + aNam;
 686         }
 687
 688         OUString aStr1;
 689
 690         if(1L == nMarkPtAnz)
 691         {
 692             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint));
 693         }
 694         else
 695         {
 696             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoints : STR_ViewMarkedPoints));
 697             aStr1 = aStr1.replaceFirst("%2", OUString::number( nMarkPtAnz ));
 698         }
 699
 700         aStr1 = aStr1.replaceFirst("%1", aNam);
 701         rName = aStr1;
 702         rNameOk = true;
 703     }
 704
 705     return rName;
 706 }
 707
 708 bool SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
 709 {
 710     bool bFnd(false);
 711     Rectangle aR;
 712
 713     for(size_t i = 0; i < GetMarkCount(); ++i)
 714     {
 715         SdrMark* pMark = GetMark(i);
 716
 717         if(!pPV || pMark->GetPageView() == pPV)
 718         {
 719             if(pMark->GetMarkedSdrObj())
 720             {
 721                 aR = pMark->GetMarkedSdrObj()->GetCurrentBoundRect();
 722
 723                 if(bFnd)
 724                 {
 725                     rRect.Union(aR);
 726                 }
 727                 else
 728                 {
 729                     rRect = aR;
 730                     bFnd = true;
 731                 }
 732             }
 733         }
 734     }
 735
 736     return bFnd;
 737 }
 738
 739 bool SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
 740 {
 741     bool bFnd(false);
 742
 743     for(size_t i = 0; i < GetMarkCount(); ++i)
 744     {
 745         SdrMark* pMark = GetMark(i);
 746
 747         if(!pPV || pMark->GetPageView() == pPV)
 748         {
 749             if(pMark->GetMarkedSdrObj())
 750             {
 751                 Rectangle aR(pMark->GetMarkedSdrObj()->GetSnapRect());
 752
 753                 if(bFnd)
 754                 {
 755                     rRect.Union(aR);
 756                 }
 757                 else
 758                 {
 759                     rRect = aR;
 760                     bFnd = true;
 761                 }
 762             }
 763         }
 764     }
 765
 766     return bFnd;
 767 }
 768
 769
 770
 771 namespace sdr
 772 {
 773     ViewSelection::ViewSelection()
 774     :   mbEdgesOfMarkedNodesDirty(false)
 775     {
 776     }
 777
 778     void ViewSelection::SetEdgesOfMarkedNodesDirty()
 779     {
 780         if(!mbEdgesOfMarkedNodesDirty)
 781         {
 782             mbEdgesOfMarkedNodesDirty = true;
 783             maEdgesOfMarkedNodes.Clear();
 784             maMarkedEdgesOfMarkedNodes.Clear();
 785             maAllMarkedObjects.clear();
 786         }
 787     }
 788
 789     const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const
 790     {
 791         if(mbEdgesOfMarkedNodesDirty)
 792         {
 793             const_cast<ViewSelection*>(this)->ImpForceEdgesOfMarkedNodes();
 794         }
 795
 796         return maEdgesOfMarkedNodes;
 797     }
 798
 799     const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const
 800     {
 801         if(mbEdgesOfMarkedNodesDirty)
 802         {
 803             const_cast<ViewSelection*>(this)->ImpForceEdgesOfMarkedNodes();
 804         }
 805
 806         return maMarkedEdgesOfMarkedNodes;
 807     }
 808
 809     const std::vector<SdrObject*>& ViewSelection::GetAllMarkedObjects() const
 810     {
 811         if(mbEdgesOfMarkedNodesDirty)
 812             const_cast<ViewSelection*>(this)->ImpForceEdgesOfMarkedNodes();
 813
 814         return maAllMarkedObjects;
 815     }
 816
 817     void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj)
 818     {
 819         if(pObj)
 820         {
 821             bool bIsGroup(pObj->IsGroupObject());
 822
 823             if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene))
 824             {
 825                 bIsGroup = false;
 826             }
 827
 828             if(bIsGroup)
 829             {
 830                 SdrObjList* pList = pObj->GetSubList();
 831
 832                 for(size_t a = 0; a < pList->GetObjCount(); ++a)
 833                 {
 834                     SdrObject* pObj2 = pList->GetObj(a);
 835                     ImplCollectCompleteSelection(pObj2);
 836                 }
 837             }
 838
 839             maAllMarkedObjects.push_back(pObj);
 840         }
 841     }
 842
 843     void ViewSelection::ImpForceEdgesOfMarkedNodes()
 844     {
 845         if(mbEdgesOfMarkedNodesDirty)
 846         {
 847             mbEdgesOfMarkedNodesDirty = false;
 848             maMarkedObjectList.ForceSort();
 849             maEdgesOfMarkedNodes.Clear();
 850             maMarkedEdgesOfMarkedNodes.Clear();
 851             maAllMarkedObjects.clear();
 852
 853             // GetMarkCount after ForceSort
 854             const size_t nMarkCount(maMarkedObjectList.GetMarkCount());
 855
 856             for(size_t a = 0; a < nMarkCount; ++a)
 857             {
 858                 SdrObject* pCandidate = maMarkedObjectList.GetMark(a)->GetMarkedSdrObj();
 859
 860                 if(pCandidate)
 861                 {
 862                     // build transitive hull
 863                     ImplCollectCompleteSelection(pCandidate);
 864
 865                     if(pCandidate->IsNode())
 866                     {
 867                         // travel over broadcaster/listener to access edges connected to the selected object
 868                         const SfxBroadcaster* pBC = pCandidate->GetBroadcaster();
 869
 870                         if(pBC)
 871                         {
 872                             const size_t nLstAnz(pBC->GetSizeOfVector());
 873
 874                             for(size_t nl=0; nl < nLstAnz; ++nl)
 875                             {
 876                                 SfxListener* pLst = pBC->GetListener(nl);
 877                                 SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, pLst);
 878
 879                                 if(pEdge && pEdge->IsInserted() && pEdge->GetPage() == pCandidate->GetPage())
 880                                 {
 881                                     SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView());
 882
 883                                     if(pEdge->GetConnectedNode(true) == pCandidate)
 884                                     {
 885                                         aM.SetCon1(true);
 886                                     }
 887
 888                                     if(pEdge->GetConnectedNode(false) == pCandidate)
 889                                     {
 890                                         aM.SetCon2(true);
 891                                     }
 892
 893                                     if(SAL_MAX_SIZE == maMarkedObjectList.FindObject(pEdge))
 894                                     {
 895                                         // check if it itself is selected
 896                                         maEdgesOfMarkedNodes.InsertEntry(aM);
 897                                     }
 898                                     else
 899                                     {
 900                                         maMarkedEdgesOfMarkedNodes.InsertEntry(aM);
 901                                     }
 902                                 }
 903                             }
 904                         }
 905                     }
 906                 }
 907             }
 908
 909             maEdgesOfMarkedNodes.ForceSort();
 910             maMarkedEdgesOfMarkedNodes.ForceSort();
 911         }
 912     }
 913 } // end of namespace sdr
 914
 915 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */