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