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> // To turn off
  30 #include <svx/svdogrp.hxx>  // the cache at
  31 #include <svx/svdorect.hxx> // GetMarkDescription.
  32 #include "svx/svdstr.hrc"   // names taken from the resource
  33 #include "svx/svdglob.hxx"  // StringCache
  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(sal_False),
  51     mbCon2(sal_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(sal_False),
  68     mbCon2(sal_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 sal_Bool SdrMark::operator==(const SdrMark& rMark) const
 197 {
 198     sal_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 = sal_False;
 202
 203     if((mpLines != 0L) != (rMark.mpLines != 0L))
 204         bRet = sal_False;
 205
 206     if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L))
 207         bRet = sal_False;
 208
 209     if(bRet && mpPoints && *mpPoints != *rMark.mpPoints)
 210         bRet = sal_False;
 211
 212     if(bRet && mpLines && *mpLines != *rMark.mpLines)
 213         bRet = sal_False;
 214
 215     if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints)
 216         bRet = sal_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 (long)pOL1 < (long)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 = sal_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(sal_True);
 297
 298                         if(pCmp->IsCon2())
 299                             pAkt->SetCon2(sal_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, sal_Bool bChkSort)
 381 {
 382     SetNameDirty();
 383     sal_uLong nAnz(maList.size());
 384
 385     if(!bChkSort || !mbSorted || nAnz == 0)
 386     {
 387         if(!bChkSort)
 388             mbSorted = sal_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(sal_True);
 404
 405             if(rMark.IsCon2())
 406                 pLast->SetCon2(sal_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 = sal_False;
 426                 }
 427             }
 428             else
 429             {
 430                 // at some point, we have to sort
 431                 mbSorted = sal_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 = sal_False;
 464     }
 465 }
 466
 467 void SdrMarkList::Merge(const SdrMarkList& rSrcList, sal_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 = sal_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 sal_Bool SdrMarkList::DeletePageView(const SdrPageView& rPV)
 497 {
 498     sal_Bool bChgd(sal_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 = sal_True;
 510         }
 511         else
 512             ++it;
 513     }
 514
 515     return bChgd;
 516 }
 517
 518 sal_Bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
 519 {
 520     sal_Bool bChgd(sal_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         sal_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 = sal_True;
 537         }
 538     }
 539
 540     return bChgd;
 541 }
 542
 543 const XubString& 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 = sal_False;
 556         }
 557     }
 558
 559     if(!mbNameOk)
 560     {
 561         SdrMark* pMark = GetMark(0);
 562         XubString aNam;
 563
 564         if(!nAnz)
 565         {
 566             ((SdrMarkList*)(this))->maMarkName = ImpGetResStr(STR_ObjNameNoObj);
 567         }
 568         else if(1L == nAnz)
 569         {
 570             if(pMark->GetMarkedSdrObj())
 571             {
 572                 pMark->GetMarkedSdrObj()->TakeObjNameSingul(aNam);
 573             }
 574         }
 575         else
 576         {
 577             if(pMark->GetMarkedSdrObj())
 578             {
 579                 pMark->GetMarkedSdrObj()->TakeObjNamePlural(aNam);
 580                 XubString aStr1;
 581                 sal_Bool bEq(sal_True);
 582
 583                 for(sal_uLong i = 1; i < GetMarkCount() && bEq; i++)
 584                 {
 585                     SdrMark* pMark2 = GetMark(i);
 586                     pMark2->GetMarkedSdrObj()->TakeObjNamePlural(aStr1);
 587                     bEq = aNam.Equals(aStr1);
 588                 }
 589
 590                 if(!bEq)
 591                 {
 592                     aNam = ImpGetResStr(STR_ObjNamePlural);
 593                 }
 594             }
 595
 596             aNam.Insert(sal_Unicode(' '), 0);
 597             aNam.Insert(OUString::number( nAnz ), 0);
 598         }
 599
 600         ((SdrMarkList*)(this))->maMarkName = aNam;
 601         ((SdrMarkList*)(this))->mbNameOk = sal_True;
 602     }
 603
 604     return maMarkName;
 605 }
 606
 607 const XubString& SdrMarkList::GetPointMarkDescription(sal_Bool bGlue) const
 608 {
 609     sal_Bool& rNameOk = (sal_Bool&)(bGlue ? mbGluePointNameOk : mbPointNameOk);
 610     XubString& rName = (XubString&)(bGlue ? maGluePointName : maPointName);
 611     sal_uLong nMarkAnz(GetMarkCount());
 612     sal_uLong nMarkPtAnz(0L);
 613     sal_uLong nMarkPtObjAnz(0L);
 614     sal_uLong n1stMarkNum(ULONG_MAX);
 615
 616     for(sal_uLong nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++)
 617     {
 618         const SdrMark* pMark = GetMark(nMarkNum);
 619         const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
 620         sal_uLong nAnz(pPts ? pPts->size() : 0);
 621
 622         if(nAnz)
 623         {
 624             if(n1stMarkNum == ULONG_MAX)
 625             {
 626                 n1stMarkNum = nMarkNum;
 627             }
 628
 629             nMarkPtAnz += nAnz;
 630             nMarkPtObjAnz++;
 631         }
 632
 633         if(nMarkPtObjAnz > 1 && rNameOk)
 634         {
 635             // preliminary decision
 636             return rName;
 637         }
 638     }
 639
 640     if(rNameOk && 1L == nMarkPtObjAnz)
 641     {
 642         // if it's a single selection, cache only text frame
 643         const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 644         const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj,pObj);
 645
 646         if(!pTextObj || !pTextObj->IsTextFrame())
 647         {
 648             rNameOk = sal_False;
 649         }
 650     }
 651
 652     if(!nMarkPtObjAnz)
 653     {
 654         rName.Erase();
 655         rNameOk = sal_True;
 656     }
 657     else if(!rNameOk)
 658     {
 659         const SdrMark* pMark = GetMark(n1stMarkNum);
 660         XubString aNam;
 661
 662         if(1L == nMarkPtObjAnz)
 663         {
 664             if(pMark->GetMarkedSdrObj())
 665             {
 666                 pMark->GetMarkedSdrObj()->TakeObjNameSingul(aNam);
 667             }
 668         }
 669         else
 670         {
 671             if(pMark->GetMarkedSdrObj())
 672             {
 673                 pMark->GetMarkedSdrObj()->TakeObjNamePlural(aNam);
 674             }
 675
 676             XubString aStr1;
 677             sal_Bool bEq(sal_True);
 678
 679             for(sal_uLong i(n1stMarkNum + 1L); i < GetMarkCount() && bEq; i++)
 680             {
 681                 const SdrMark* pMark2 = GetMark(i);
 682                 const SdrUShortCont* pPts = bGlue ? pMark2->GetMarkedGluePoints() : pMark2->GetMarkedPoints();
 683
 684                 if(pPts && !pPts->empty() && pMark2->GetMarkedSdrObj())
 685                 {
 686                     pMark2->GetMarkedSdrObj()->TakeObjNamePlural(aStr1);
 687                     bEq = aNam.Equals(aStr1);
 688                 }
 689             }
 690
 691             if(!bEq)
 692             {
 693                 aNam = ImpGetResStr(STR_ObjNamePlural);
 694             }
 695
 696             aNam.Insert(sal_Unicode(' '), 0);
 697             aNam.Insert(OUString::number( nMarkPtObjAnz ), 0);
 698         }
 699
 700         XubString aStr1;
 701
 702         if(1L == nMarkPtAnz)
 703         {
 704             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint));
 705         }
 706         else
 707         {
 708             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoints : STR_ViewMarkedPoints));
 709             aStr1.SearchAndReplaceAscii("%2", OUString::number( nMarkPtAnz ));
 710         }
 711
 712         aStr1.SearchAndReplaceAscii("%1", aNam);
 713         rName = aStr1;
 714         rNameOk = sal_True;
 715     }
 716
 717     return rName;
 718 }
 719
 720 sal_Bool SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
 721 {
 722     sal_Bool bFnd(sal_False);
 723     Rectangle aR;
 724
 725     for(sal_uLong i(0L); i < GetMarkCount(); i++)
 726     {
 727         SdrMark* pMark = GetMark(i);
 728
 729         if(!pPV || pMark->GetPageView() == pPV)
 730         {
 731             if(pMark->GetMarkedSdrObj())
 732             {
 733                 aR = pMark->GetMarkedSdrObj()->GetCurrentBoundRect();
 734
 735                 if(bFnd)
 736                 {
 737                     rRect.Union(aR);
 738                 }
 739                 else
 740                 {
 741                     rRect = aR;
 742                     bFnd = sal_True;
 743                 }
 744             }
 745         }
 746     }
 747
 748     return bFnd;
 749 }
 750
 751 sal_Bool SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
 752 {
 753     sal_Bool bFnd(sal_False);
 754
 755     for(sal_uLong i(0L); i < GetMarkCount(); i++)
 756     {
 757         SdrMark* pMark = GetMark(i);
 758
 759         if(!pPV || pMark->GetPageView() == pPV)
 760         {
 761             if(pMark->GetMarkedSdrObj())
 762             {
 763                 Rectangle aR(pMark->GetMarkedSdrObj()->GetSnapRect());
 764
 765                 if(bFnd)
 766                 {
 767                     rRect.Union(aR);
 768                 }
 769                 else
 770                 {
 771                     rRect = aR;
 772                     bFnd = sal_True;
 773                 }
 774             }
 775         }
 776     }
 777
 778     return bFnd;
 779 }
 780
 781 ////////////////////////////////////////////////////////////////////////////////////////////////////
 782
 783 namespace sdr
 784 {
 785     ViewSelection::ViewSelection()
 786     :   mbEdgesOfMarkedNodesDirty(sal_False)
 787     {
 788     }
 789
 790     void ViewSelection::SetEdgesOfMarkedNodesDirty()
 791     {
 792         if(!mbEdgesOfMarkedNodesDirty)
 793         {
 794             mbEdgesOfMarkedNodesDirty = sal_True;
 795             maEdgesOfMarkedNodes.Clear();
 796             maMarkedEdgesOfMarkedNodes.Clear();
 797             maAllMarkedObjects.clear();
 798         }
 799     }
 800
 801     const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const
 802     {
 803         if(mbEdgesOfMarkedNodesDirty)
 804         {
 805             ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 806         }
 807
 808         return maEdgesOfMarkedNodes;
 809     }
 810
 811     const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const
 812     {
 813         if(mbEdgesOfMarkedNodesDirty)
 814         {
 815             ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 816         }
 817
 818         return maMarkedEdgesOfMarkedNodes;
 819     }
 820
 821     const std::vector<SdrObject*>& ViewSelection::GetAllMarkedObjects() const
 822     {
 823         if(mbEdgesOfMarkedNodesDirty)
 824             ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 825
 826         return maAllMarkedObjects;
 827     }
 828
 829     void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj)
 830     {
 831         if(pObj)
 832         {
 833             sal_Bool bIsGroup(pObj->IsGroupObject());
 834
 835             if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene))
 836             {
 837                 bIsGroup = sal_False;
 838             }
 839
 840             if(bIsGroup)
 841             {
 842                 SdrObjList* pList = pObj->GetSubList();
 843
 844                 for(sal_uLong a(0L); a < pList->GetObjCount(); a++)
 845                 {
 846                     SdrObject* pObj2 = pList->GetObj(a);
 847                     ImplCollectCompleteSelection(pObj2);
 848                 }
 849             }
 850
 851             maAllMarkedObjects.push_back(pObj);
 852         }
 853     }
 854
 855     void ViewSelection::ImpForceEdgesOfMarkedNodes()
 856     {
 857         if(mbEdgesOfMarkedNodesDirty)
 858         {
 859             mbEdgesOfMarkedNodesDirty = sal_False;
 860             maMarkedObjectList.ForceSort();
 861             maEdgesOfMarkedNodes.Clear();
 862             maMarkedEdgesOfMarkedNodes.Clear();
 863             maAllMarkedObjects.clear();
 864
 865             // GetMarkCount after ForceSort
 866             const sal_uLong nMarkAnz(maMarkedObjectList.GetMarkCount());
 867
 868             for(sal_uLong a(0L); a < nMarkAnz; a++)
 869             {
 870                 SdrObject* pCandidate = maMarkedObjectList.GetMark(a)->GetMarkedSdrObj();
 871
 872                 if(pCandidate)
 873                 {
 874                     // build transitive hull
 875                     ImplCollectCompleteSelection(pCandidate);
 876
 877                     if(pCandidate->IsNode())
 878                     {
 879                         // travel over broadcaster/listener to access edges connected to the selected object
 880                         const SfxBroadcaster* pBC = pCandidate->GetBroadcaster();
 881
 882                         if(pBC)
 883                         {
 884                             sal_uInt16 nLstAnz(pBC->GetListenerCount());
 885
 886                             for(sal_uInt16 nl(0); nl < nLstAnz; nl++)
 887                             {
 888                                 SfxListener* pLst = pBC->GetListener(nl);
 889                                 SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, pLst);
 890
 891                                 if(pEdge && pEdge->IsInserted() && pEdge->GetPage() == pCandidate->GetPage())
 892                                 {
 893                                     SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView());
 894
 895                                     if(pEdge->GetConnectedNode(sal_True) == pCandidate)
 896                                     {
 897                                         aM.SetCon1(sal_True);
 898                                     }
 899
 900                                     if(pEdge->GetConnectedNode(sal_False) == pCandidate)
 901                                     {
 902                                         aM.SetCon2(sal_True);
 903                                     }
 904
 905                                     if(CONTAINER_ENTRY_NOTFOUND == maMarkedObjectList.FindObject(pEdge))
 906                                     {
 907                                         // check if it itself is selected
 908                                         maEdgesOfMarkedNodes.InsertEntry(aM);
 909                                     }
 910                                     else
 911                                     {
 912                                         maMarkedEdgesOfMarkedNodes.InsertEntry(aM);
 913                                     }
 914                                 }
 915                             }
 916                         }
 917                     }
 918                 }
 919             }
 920
 921             maEdgesOfMarkedNodes.ForceSort();
 922             maMarkedEdgesOfMarkedNodes.ForceSort();
 923         }
 924     }
 925 } // end of namespace sdr
 926
 927 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */