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