svx/source/svdraw/svdmark.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: svdmark.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 ////////////////////////////////////////////////////////////////////////////////////////////////////
  35
  36 #include <svx/svdmark.hxx>
  37 #include <svx/svdetc.hxx>
  38 #include <svx/svdobj.hxx>
  39 #include <svx/svdpage.hxx>
  40 #include "svditer.hxx"
  41 #include <svx/svdpagv.hxx>
  42 #include <svx/svdopath.hxx> // zur Abschaltung
  43 #include <svx/svdogrp.hxx>  // des Cache bei
  44 #include <svx/svdorect.hxx> // GetMarkDescription
  45 #include "svdstr.hrc"   // Namen aus der Resource
  46 #include "svdglob.hxx"  // StringCache
  47
  48 ////////////////////////////////////////////////////////////////////////////////////////////////////
  49 #include <svx/obj3d.hxx>
  50 #include <svx/scene3d.hxx>
  51 #include <svtools/brdcst.hxx>
  52 #include <svx/svdoedge.hxx>
  53
  54 ////////////////////////////////////////////////////////////////////////////////////////////////////
  55
  56 class ImpSdrUShortContSorter: public ContainerSorter
  57 {
  58 public:
  59     ImpSdrUShortContSorter(Container& rNewCont)
  60     :   ContainerSorter(rNewCont)
  61     {}
  62
  63     virtual int Compare(const void* pElem1, const void* pElem2) const;
  64 };
  65
  66 int ImpSdrUShortContSorter::Compare(const void* pElem1, const void* pElem2) const
  67 {
  68     sal_uInt16 n1((sal_uInt16)((sal_uIntPtr)pElem1));
  69     sal_uInt16 n2((sal_uInt16)((sal_uIntPtr)pElem2));
  70
  71     return ((n1 < n2) ? (-1) : (n1 > n2) ? (1) : (0));
  72 }
  73
  74 void SdrUShortCont::Sort() const
  75 {
  76     ImpSdrUShortContSorter aSort(*((Container*)(&maArray)));
  77     aSort.DoSort();
  78     ((SdrUShortCont*)this)->mbSorted = sal_True;
  79
  80     ULONG nNum(GetCount());
  81
  82     if(nNum > 1)
  83     {
  84         nNum--;
  85         sal_uInt16 nVal0 = GetObject(nNum);
  86
  87         while(nNum > 0)
  88         {
  89             nNum--;
  90             sal_uInt16 nVal1 = GetObject(nNum);
  91
  92             if(nVal1 == nVal0)
  93             {
  94                 ((SdrUShortCont*)this)->Remove(nNum);
  95             }
  96
  97             nVal0 = nVal1;
  98         }
  99     }
 100 }
 101
 102 void SdrUShortCont::CheckSort(ULONG nPos)
 103 {
 104     ULONG nAnz(maArray.Count());
 105
 106     if(nPos > nAnz)
 107         nPos = nAnz;
 108
 109     sal_uInt16 nAktVal = GetObject(nPos);
 110
 111     if(nPos > 0)
 112     {
 113         sal_uInt16 nPrevVal = GetObject(nPos - 1);
 114
 115         if(nPrevVal >= nAktVal)
 116             mbSorted = sal_False;
 117     }
 118
 119     if(nPos < nAnz - 1)
 120     {
 121         sal_uInt16 nNextVal = GetObject(nPos + 1);
 122
 123         if(nNextVal <= nAktVal)
 124             mbSorted = sal_False;
 125     }
 126 }
 127
 128 std::set< sal_uInt16 > SdrUShortCont::getContainer()
 129 {
 130     std::set< sal_uInt16 > aSet;
 131
 132     sal_uInt32 nAnz = maArray.Count();
 133     while(nAnz)
 134         aSet.insert( GetObject(--nAnz) );
 135
 136     return aSet;
 137 }
 138
 139 ////////////////////////////////////////////////////////////////////////////////////////////////////
 140
 141 SdrMark::SdrMark(SdrObject* pNewObj, SdrPageView* pNewPageView)
 142 :       mpSelectedSdrObject(pNewObj),
 143     mpPageView(pNewPageView),
 144     mpPoints(0L),
 145     mpLines(0L),
 146     mpGluePoints(0L),
 147     mbCon1(sal_False),
 148     mbCon2(sal_False),
 149     mnUser(0)
 150 {
 151     if(mpSelectedSdrObject)
 152     {
 153         mpSelectedSdrObject->AddObjectUser( *this );
 154     }
 155 }
 156
 157 SdrMark::SdrMark(const SdrMark& rMark)
 158 :       ObjectUser(),
 159     mpSelectedSdrObject(0L),
 160     mpPageView(0L),
 161     mpPoints(0L),
 162     mpLines(0L),
 163     mpGluePoints(0L),
 164     mbCon1(sal_False),
 165     mbCon2(sal_False),
 166     mnUser(0)
 167 {
 168     *this = rMark;
 169 }
 170
 171 SdrMark::~SdrMark()
 172 {
 173     if(mpSelectedSdrObject)
 174     {
 175         mpSelectedSdrObject->RemoveObjectUser( *this );
 176     }
 177
 178     if(mpPoints)
 179     {
 180         delete mpPoints;
 181     }
 182
 183     if(mpLines)
 184     {
 185         delete mpLines;
 186     }
 187
 188     if(mpGluePoints)
 189     {
 190         delete mpGluePoints;
 191     }
 192 }
 193
 194 void SdrMark::ObjectInDestruction(const SdrObject& rObject)
 195 {
 196     (void) rObject; // avoid warnings
 197     OSL_ENSURE(mpSelectedSdrObject && mpSelectedSdrObject == &rObject, "SdrMark::ObjectInDestruction: called form object different from hosted one (!)");
 198     OSL_ENSURE(mpSelectedSdrObject, "SdrMark::ObjectInDestruction: still seleceted SdrObject is deleted, deselect first (!)");
 199     mpSelectedSdrObject = 0L;
 200 }
 201
 202 void SdrMark::SetMarkedSdrObj(SdrObject* pNewObj)
 203 {
 204     if(mpSelectedSdrObject)
 205     {
 206         mpSelectedSdrObject->RemoveObjectUser( *this );
 207     }
 208
 209     mpSelectedSdrObject = pNewObj;
 210
 211     if(mpSelectedSdrObject)
 212     {
 213         mpSelectedSdrObject->AddObjectUser( *this );
 214     }
 215 }
 216
 217 SdrObject* SdrMark::GetMarkedSdrObj() const
 218 {
 219     return mpSelectedSdrObject;
 220 }
 221
 222 SdrMark& SdrMark::operator=(const SdrMark& rMark)
 223 {
 224     SetMarkedSdrObj(rMark.mpSelectedSdrObject);
 225     mpPageView = rMark.mpPageView;
 226     mbCon1 = rMark.mbCon1;
 227     mbCon2 = rMark.mbCon2;
 228     mnUser = rMark.mnUser;
 229
 230     if(!rMark.mpPoints)
 231     {
 232         if(mpPoints)
 233         {
 234             delete mpPoints;
 235             mpPoints = 0L;
 236         }
 237     }
 238     else
 239     {
 240         if(!mpPoints)
 241         {
 242             mpPoints = new SdrUShortCont(*rMark.mpPoints);
 243         }
 244         else
 245         {
 246             *mpPoints = *rMark.mpPoints;
 247         }
 248     }
 249
 250     if(!rMark.mpLines)
 251     {
 252         if(mpLines)
 253         {
 254             delete mpLines;
 255             mpLines = 0L;
 256         }
 257     }
 258     else
 259     {
 260         if(!mpLines)
 261         {
 262             mpLines = new SdrUShortCont(*rMark.mpLines);
 263         }
 264         else
 265         {
 266             *mpLines = *rMark.mpLines;
 267         }
 268     }
 269
 270     if(!rMark.mpGluePoints)
 271     {
 272         if(mpGluePoints)
 273         {
 274             delete mpGluePoints;
 275             mpGluePoints = 0L;
 276         }
 277     }
 278     else
 279     {
 280         if(!mpGluePoints)
 281         {
 282             mpGluePoints = new SdrUShortCont(*rMark.mpGluePoints);
 283         }
 284         else
 285         {
 286             *mpGluePoints = *rMark.mpGluePoints;
 287         }
 288     }
 289
 290     return *this;
 291 }
 292
 293 sal_Bool SdrMark::operator==(const SdrMark& rMark) const
 294 {
 295     sal_Bool bRet(mpSelectedSdrObject == rMark.mpSelectedSdrObject && mpPageView == rMark.mpPageView && mbCon1 == rMark.mbCon1 && mbCon2 == rMark.mbCon2 && mnUser == rMark.mnUser);
 296
 297     if((mpPoints != 0L) != (rMark.mpPoints != 0L))
 298         bRet = sal_False;
 299
 300     if((mpLines != 0L) != (rMark.mpLines != 0L))
 301         bRet = sal_False;
 302
 303     if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L))
 304         bRet = sal_False;
 305
 306     if(bRet && mpPoints && *mpPoints != *rMark.mpPoints)
 307         bRet = sal_False;
 308
 309     if(bRet && mpLines && *mpLines != *rMark.mpLines)
 310         bRet = sal_False;
 311
 312     if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints)
 313         bRet = sal_False;
 314
 315     return bRet;
 316 }
 317
 318 SdrPage* SdrMark::GetPage() const
 319 {
 320     return (mpSelectedSdrObject ? mpSelectedSdrObject->GetPage() : 0);
 321 }
 322
 323 SdrObjList* SdrMark::GetObjList() const
 324 {
 325     return (mpSelectedSdrObject ? mpSelectedSdrObject->GetObjList() : 0);
 326 }
 327
 328 ////////////////////////////////////////////////////////////////////////////////////////////////////
 329
 330 class ImpSdrMarkListSorter: public ContainerSorter
 331 {
 332 public:
 333     ImpSdrMarkListSorter(Container& rNewCont)
 334         :       ContainerSorter(rNewCont)
 335     {}
 336
 337     virtual int Compare(const void* pElem1, const void* pElem2) const;
 338 };
 339
 340 int ImpSdrMarkListSorter::Compare(const void* pElem1, const void* pElem2) const
 341 {
 342     SdrObject* pObj1 = ((SdrMark*)pElem1)->GetMarkedSdrObj();
 343     SdrObject* pObj2 = ((SdrMark*)pElem2)->GetMarkedSdrObj();
 344     SdrObjList* pOL1 = (pObj1) ? pObj1->GetObjList() : 0L;
 345     SdrObjList* pOL2 = (pObj2) ? pObj2->GetObjList() : 0L;
 346
 347     if (pOL1 == pOL2)
 348     {
 349         // AF: Note that I reverted a change from sal_uInt32 to ULONG (made
 350         // for 64bit compliance, #i78198#) because internally in SdrObject
 351         // both nOrdNum and mnNavigationPosition are stored as sal_uInt32.
 352         sal_uInt32 nObjOrd1((pObj1) ? pObj1->GetNavigationPosition() : 0);
 353         sal_uInt32 nObjOrd2((pObj2) ? pObj2->GetNavigationPosition() : 0);
 354
 355         return (nObjOrd1 < nObjOrd2 ? -1 : 1);
 356     }
 357     else
 358     {
 359         return ((long)pOL1 < (long)pOL2) ? -1 : 1;
 360     }
 361 }
 362
 363 ////////////////////////////////////////////////////////////////////////////////////////////////////
 364
 365 void SdrMarkList::ForceSort() const
 366 {
 367     if(!mbSorted)
 368     {
 369         ((SdrMarkList*)this)->ImpForceSort();
 370     }
 371 }
 372
 373 void SdrMarkList::ImpForceSort()
 374 {
 375     if(!mbSorted)
 376     {
 377         mbSorted = sal_True;
 378         ULONG nAnz = maList.Count();
 379
 380         // remove invalid
 381         if(nAnz > 0 )
 382         {
 383             SdrMark* pAkt = (SdrMark*)maList.First();
 384             while( pAkt )
 385             {
 386                 if(pAkt->GetMarkedSdrObj() == 0)
 387                 {
 388                     maList.Remove();
 389                     delete pAkt;
 390                 }
 391                 pAkt= (SdrMark*)maList.Next();
 392             }
 393             nAnz = maList.Count();
 394         }
 395
 396         if(nAnz > 1)
 397         {
 398             ImpSdrMarkListSorter aSort(maList);
 399             aSort.DoSort();
 400
 401             // remove duplicates
 402             if(maList.Count() > 1)
 403             {
 404                 SdrMark* pAkt = (SdrMark*)maList.Last();
 405                 SdrMark* pCmp = (SdrMark*)maList.Prev();
 406
 407                 while(pCmp)
 408                 {
 409                     if(pAkt->GetMarkedSdrObj() == pCmp->GetMarkedSdrObj() && pAkt->GetMarkedSdrObj())
 410                     {
 411                         // Con1/Con2 Merging
 412                         if(pCmp->IsCon1())
 413                             pAkt->SetCon1(sal_True);
 414
 415                         if(pCmp->IsCon2())
 416                             pAkt->SetCon2(sal_True);
 417
 418                         // pCmp loeschen.
 419                         maList.Remove();
 420
 421                         delete pCmp;
 422                     }
 423                     else
 424                     {
 425                         pAkt = pCmp;
 426                     }
 427
 428                     pCmp = (SdrMark*)maList.Prev();
 429                 }
 430             }
 431         }
 432     }
 433 }
 434
 435 void SdrMarkList::Clear()
 436 {
 437     for(ULONG i(0L); i < GetMarkCount(); i++)
 438     {
 439         SdrMark* pMark = GetMark(i);
 440         delete pMark;
 441     }
 442
 443     maList.Clear();
 444     SetNameDirty();
 445 }
 446
 447 void SdrMarkList::operator=(const SdrMarkList& rLst)
 448 {
 449     Clear();
 450
 451     for(ULONG i(0L); i < rLst.GetMarkCount(); i++)
 452     {
 453         SdrMark* pMark = rLst.GetMark(i);
 454         SdrMark* pNeuMark = new SdrMark(*pMark);
 455         maList.Insert(pNeuMark, CONTAINER_APPEND);
 456     }
 457
 458     maMarkName = rLst.maMarkName;
 459     mbNameOk = rLst.mbNameOk;
 460     maPointName = rLst.maPointName;
 461     mbPointNameOk = rLst.mbPointNameOk;
 462     maGluePointName = rLst.maGluePointName;
 463     mbGluePointNameOk = rLst.mbGluePointNameOk;
 464     mbSorted = rLst.mbSorted;
 465 }
 466
 467 ULONG SdrMarkList::FindObject(const SdrObject* pObj) const
 468 {
 469     // #109658#
 470     //
 471     // Since relying on OrdNums is not allowed for the selection because objects in the
 472     // selection may not be inserted in a list if they are e.g. modified ATM, i changed
 473     // this loop to just look if the object pointer is in the selection.
 474     //
 475     // Problem is that GetOrdNum() which is const, internally casts to non-const and
 476     // hardly sets the OrdNum member of the object (nOrdNum) to 0 (ZERO) if the object
 477     // is not inserted in a object list.
 478     // Since this may be by purpose and necessary somewhere else i decided that it is
 479     // less dangerous to change this method then changing SdrObject::GetOrdNum().
 480     if(pObj && maList.Count())
 481     {
 482         for(ULONG a(0L); a < maList.Count(); a++)
 483         {
 484             if(((SdrMark*)(maList.GetObject(a)))->GetMarkedSdrObj() == pObj)
 485             {
 486                 return a;
 487             }
 488         }
 489     }
 490
 491     return CONTAINER_ENTRY_NOTFOUND;
 492 }
 493
 494 void SdrMarkList::InsertEntry(const SdrMark& rMark, sal_Bool bChkSort)
 495 {
 496     SetNameDirty();
 497     ULONG nAnz(maList.Count());
 498
 499     if(!bChkSort || !mbSorted || nAnz == 0)
 500     {
 501         if(!bChkSort)
 502             mbSorted = sal_False;
 503
 504         maList.Insert(new SdrMark(rMark), CONTAINER_APPEND);
 505     }
 506     else
 507     {
 508         SdrMark* pLast = GetMark(ULONG(nAnz - 1));
 509         const SdrObject* pLastObj = pLast->GetMarkedSdrObj();
 510         const SdrObject* pNeuObj = rMark.GetMarkedSdrObj();
 511
 512         if(pLastObj == pNeuObj)
 513         {
 514             // Aha, den gibt's schon
 515             // Con1/Con2 Merging
 516             if(rMark.IsCon1())
 517                 pLast->SetCon1(sal_True);
 518
 519             if(rMark.IsCon2())
 520                 pLast->SetCon2(sal_True);
 521         }
 522         else
 523         {
 524             SdrMark* pKopie = new SdrMark(rMark);
 525             maList.Insert(pKopie, CONTAINER_APPEND);
 526
 527             // und nun checken, ob die Sortierung noch ok ist
 528             const SdrObjList* pLastOL = pLastObj!=0L ? pLastObj->GetObjList() : 0L;
 529             const SdrObjList* pNeuOL = pNeuObj !=0L ? pNeuObj ->GetObjList() : 0L;
 530
 531             if(pLastOL == pNeuOL)
 532             {
 533                 const ULONG nLastNum(pLastObj!=0L ? pLastObj->GetOrdNum() : 0);
 534                 const ULONG nNeuNum(pNeuObj !=0L ? pNeuObj ->GetOrdNum() : 0);
 535
 536                 if(nNeuNum < nLastNum)
 537                 {
 538                     // irgendwann muss mal sortiert werden
 539                     mbSorted = sal_False;
 540                 }
 541             }
 542             else
 543             {
 544                 // irgendwann muss mal sortiert werden
 545                 mbSorted = sal_False;
 546             }
 547         }
 548     }
 549
 550     return;
 551 }
 552
 553 void SdrMarkList::DeleteMark(ULONG nNum)
 554 {
 555     SdrMark* pMark = GetMark(nNum);
 556     DBG_ASSERT(pMark!=0L,"DeleteMark: MarkEntry nicht gefunden");
 557
 558     if(pMark)
 559     {
 560         maList.Remove(nNum);
 561         delete pMark;
 562         SetNameDirty();
 563     }
 564 }
 565
 566 void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, ULONG nNum)
 567 {
 568     SdrMark* pMark = GetMark(nNum);
 569     DBG_ASSERT(pMark!=0L,"ReplaceMark: MarkEntry nicht gefunden");
 570
 571     if(pMark)
 572     {
 573         delete pMark;
 574         SetNameDirty();
 575         SdrMark* pKopie = new SdrMark(rNewMark);
 576         maList.Replace(pKopie, nNum);
 577         mbSorted = sal_False;
 578     }
 579 }
 580
 581 void SdrMarkList::Merge(const SdrMarkList& rSrcList, sal_Bool bReverse)
 582 {
 583     ULONG nAnz(rSrcList.maList.Count());
 584
 585     if(rSrcList.mbSorted)
 586     {
 587         // Merging ohne ein Sort bei rSrcList zu erzwingen
 588         bReverse = sal_False;
 589     }
 590
 591     if(!bReverse)
 592     {
 593         for(ULONG i(0L); i < nAnz; i++)
 594         {
 595             SdrMark* pM = (SdrMark*)(rSrcList.maList.GetObject(i));
 596             InsertEntry(*pM);
 597         }
 598     }
 599     else
 600     {
 601         for(ULONG i(nAnz); i > 0;)
 602         {
 603             i--;
 604             SdrMark* pM = (SdrMark*)(rSrcList.maList.GetObject(i));
 605             InsertEntry(*pM);
 606         }
 607     }
 608 }
 609
 610 sal_Bool SdrMarkList::DeletePageView(const SdrPageView& rPV)
 611 {
 612     sal_Bool bChgd(sal_False);
 613
 614     for(ULONG i(GetMarkCount()); i > 0; )
 615     {
 616         i--;
 617         SdrMark* pMark = GetMark(i);
 618
 619         if(pMark->GetPageView()==&rPV)
 620         {
 621             maList.Remove(i);
 622             delete pMark;
 623             SetNameDirty();
 624             bChgd = sal_True;
 625         }
 626     }
 627
 628     return bChgd;
 629 }
 630
 631 sal_Bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
 632 {
 633     sal_Bool bChgd(sal_False);
 634     DeletePageView(rPV); // erstmal alle raus, dann die ganze Seite hinten dran
 635     SdrObject* pObj;
 636     const SdrObjList* pOL = rPV.GetObjList();
 637     ULONG nObjAnz(pOL->GetObjCount());
 638
 639     for(ULONG nO(0L); nO < nObjAnz; nO++)
 640     {
 641         pObj = pOL->GetObj(nO);
 642         sal_Bool bDoIt(rPV.IsObjMarkable(pObj));
 643
 644         if(bDoIt)
 645         {
 646             SdrMark* pM = new SdrMark(pObj, (SdrPageView*)&rPV);
 647             maList.Insert(pM, CONTAINER_APPEND);
 648             SetNameDirty();
 649             bChgd = sal_True;
 650         }
 651     }
 652
 653     return bChgd;
 654 }
 655
 656 const XubString& SdrMarkList::GetMarkDescription() const
 657 {
 658     ULONG nAnz(GetMarkCount());
 659
 660     if(mbNameOk && 1L == nAnz)
 661     {
 662         // Bei Einfachselektion nur Textrahmen cachen
 663         const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 664         const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj, pObj);
 665
 666         if(!pTextObj || !pTextObj->IsTextFrame())
 667         {
 668             ((SdrMarkList*)(this))->mbNameOk = sal_False;
 669         }
 670     }
 671
 672     if(!mbNameOk)
 673     {
 674         SdrMark* pMark = GetMark(0);
 675         XubString aNam;
 676
 677         if(!nAnz)
 678         {
 679             ((SdrMarkList*)(this))->maMarkName = ImpGetResStr(STR_ObjNameNoObj);
 680         }
 681         else if(1L == nAnz)
 682         {
 683             if(pMark->GetMarkedSdrObj())
 684             {
 685                 pMark->GetMarkedSdrObj()->TakeObjNameSingul(aNam);
 686             }
 687         }
 688         else
 689         {
 690             if(pMark->GetMarkedSdrObj())
 691             {
 692                 pMark->GetMarkedSdrObj()->TakeObjNamePlural(aNam);
 693                 XubString aStr1;
 694                 sal_Bool bEq(sal_True);
 695
 696                 for(ULONG i = 1; i < GetMarkCount() && bEq; i++)
 697                 {
 698                     SdrMark* pMark2 = GetMark(i);
 699                     pMark2->GetMarkedSdrObj()->TakeObjNamePlural(aStr1);
 700                     bEq = aNam.Equals(aStr1);
 701                 }
 702
 703                 if(!bEq)
 704                 {
 705                     aNam = ImpGetResStr(STR_ObjNamePlural);
 706                 }
 707             }
 708
 709             aNam.Insert(sal_Unicode(' '), 0);
 710             aNam.Insert(UniString::CreateFromInt32(nAnz), 0);
 711         }
 712
 713         ((SdrMarkList*)(this))->maMarkName = aNam;
 714         ((SdrMarkList*)(this))->mbNameOk = sal_True;
 715     }
 716
 717     return maMarkName;
 718 }
 719
 720 const XubString& SdrMarkList::GetPointMarkDescription(sal_Bool bGlue) const
 721 {
 722     sal_Bool& rNameOk = (sal_Bool&)(bGlue ? mbGluePointNameOk : mbPointNameOk);
 723     XubString& rName = (XubString&)(bGlue ? maGluePointName : maPointName);
 724     ULONG nMarkAnz(GetMarkCount());
 725     ULONG nMarkPtAnz(0L);
 726     ULONG nMarkPtObjAnz(0L);
 727     ULONG n1stMarkNum(ULONG_MAX);
 728
 729     for(ULONG nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++)
 730     {
 731         const SdrMark* pMark = GetMark(nMarkNum);
 732         const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
 733         ULONG nAnz(pPts ? pPts->GetCount() : 0);
 734
 735         if(nAnz)
 736         {
 737             if(n1stMarkNum == ULONG_MAX)
 738             {
 739                 n1stMarkNum = nMarkNum;
 740             }
 741
 742             nMarkPtAnz += nAnz;
 743             nMarkPtObjAnz++;
 744         }
 745
 746         if(nMarkPtObjAnz > 1 && rNameOk)
 747         {
 748             // vorzeitige Entscheidung
 749             return rName;
 750         }
 751     }
 752
 753     if(rNameOk && 1L == nMarkPtObjAnz)
 754     {
 755         // Bei Einfachselektion nur Textrahmen cachen
 756         const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
 757         const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj,pObj);
 758
 759         if(!pTextObj || !pTextObj->IsTextFrame())
 760         {
 761             rNameOk = sal_False;
 762         }
 763     }
 764
 765     if(!nMarkPtObjAnz)
 766     {
 767         rName.Erase();
 768         rNameOk = sal_True;
 769     }
 770     else if(!rNameOk)
 771     {
 772         const SdrMark* pMark = GetMark(n1stMarkNum);
 773         XubString aNam;
 774
 775         if(1L == nMarkPtObjAnz)
 776         {
 777             if(pMark->GetMarkedSdrObj())
 778             {
 779                 pMark->GetMarkedSdrObj()->TakeObjNameSingul(aNam);
 780             }
 781         }
 782         else
 783         {
 784             if(pMark->GetMarkedSdrObj())
 785             {
 786                 pMark->GetMarkedSdrObj()->TakeObjNamePlural(aNam);
 787             }
 788
 789             XubString aStr1;
 790             sal_Bool bEq(sal_True);
 791
 792             for(ULONG i(n1stMarkNum + 1L); i < GetMarkCount() && bEq; i++)
 793             {
 794                 const SdrMark* pMark2 = GetMark(i);
 795                 const SdrUShortCont* pPts = bGlue ? pMark2->GetMarkedGluePoints() : pMark2->GetMarkedPoints();
 796
 797                 if(pPts && pPts->GetCount() && pMark2->GetMarkedSdrObj())
 798                 {
 799                     pMark2->GetMarkedSdrObj()->TakeObjNamePlural(aStr1);
 800                     bEq = aNam.Equals(aStr1);
 801                 }
 802             }
 803
 804             if(!bEq)
 805             {
 806                 aNam = ImpGetResStr(STR_ObjNamePlural);
 807             }
 808
 809             aNam.Insert(sal_Unicode(' '), 0);
 810             aNam.Insert(UniString::CreateFromInt32(nMarkPtObjAnz), 0);
 811         }
 812
 813         XubString aStr1;
 814
 815         if(1L == nMarkPtAnz)
 816         {
 817             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint));
 818         }
 819         else
 820         {
 821             aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoints : STR_ViewMarkedPoints));
 822             aStr1.SearchAndReplaceAscii("%2", UniString::CreateFromInt32(nMarkPtAnz));
 823         }
 824
 825         aStr1.SearchAndReplaceAscii("%1", aNam);
 826         rName = aStr1;
 827         rNameOk = sal_True;
 828     }
 829
 830     return rName;
 831 }
 832
 833 sal_Bool SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
 834 {
 835     sal_Bool bFnd(sal_False);
 836     Rectangle aR;
 837
 838     for(ULONG i(0L); i < GetMarkCount(); i++)
 839     {
 840         SdrMark* pMark = GetMark(i);
 841
 842         if(!pPV || pMark->GetPageView() == pPV)
 843         {
 844             if(pMark->GetMarkedSdrObj())
 845             {
 846                 aR = pMark->GetMarkedSdrObj()->GetCurrentBoundRect();
 847
 848                 if(bFnd)
 849                 {
 850                     rRect.Union(aR);
 851                 }
 852                 else
 853                 {
 854                     rRect = aR;
 855                     bFnd = sal_True;
 856                 }
 857             }
 858         }
 859     }
 860
 861     return bFnd;
 862 }
 863
 864 sal_Bool SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
 865 {
 866     sal_Bool bFnd(sal_False);
 867
 868     for(ULONG i(0L); i < GetMarkCount(); i++)
 869     {
 870         SdrMark* pMark = GetMark(i);
 871
 872         if(!pPV || pMark->GetPageView() == pPV)
 873         {
 874             if(pMark->GetMarkedSdrObj())
 875             {
 876                 Rectangle aR(pMark->GetMarkedSdrObj()->GetSnapRect());
 877
 878                 if(bFnd)
 879                 {
 880                     rRect.Union(aR);
 881                 }
 882                 else
 883                 {
 884                     rRect = aR;
 885                     bFnd = sal_True;
 886                 }
 887             }
 888         }
 889     }
 890
 891     return bFnd;
 892 }
 893
 894 ////////////////////////////////////////////////////////////////////////////////////////////////////
 895
 896 namespace sdr
 897 {
 898     ViewSelection::ViewSelection()
 899     :   mbEdgesOfMarkedNodesDirty(sal_False)
 900     {
 901     }
 902
 903     void ViewSelection::SetEdgesOfMarkedNodesDirty()
 904     {
 905         if(!mbEdgesOfMarkedNodesDirty)
 906         {
 907             mbEdgesOfMarkedNodesDirty = sal_True;
 908             maEdgesOfMarkedNodes.Clear();
 909             maMarkedEdgesOfMarkedNodes.Clear();
 910             maAllMarkedObjects.Clear();
 911         }
 912     }
 913
 914     const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const
 915     {
 916         if(mbEdgesOfMarkedNodesDirty)
 917         {
 918             ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 919         }
 920
 921         return maEdgesOfMarkedNodes;
 922     }
 923
 924     const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const
 925     {
 926         if(mbEdgesOfMarkedNodesDirty)
 927         {
 928             ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 929         }
 930
 931         return maMarkedEdgesOfMarkedNodes;
 932     }
 933
 934     const List& ViewSelection::GetAllMarkedObjects() const
 935     {
 936         if(mbEdgesOfMarkedNodesDirty)
 937         {
 938             ((ViewSelection*)this)->ImpForceEdgesOfMarkedNodes();
 939         }
 940
 941         return maAllMarkedObjects;
 942     }
 943
 944     void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj)
 945     {
 946         if(pObj)
 947         {
 948             sal_Bool bIsGroup(pObj->IsGroupObject());
 949
 950             if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene))
 951             {
 952                 bIsGroup = sal_False;
 953             }
 954
 955             if(bIsGroup)
 956             {
 957                 SdrObjList* pList = pObj->GetSubList();
 958
 959                 for(ULONG a(0L); a < pList->GetObjCount(); a++)
 960                 {
 961                     SdrObject* pObj2 = pList->GetObj(a);
 962                     ImplCollectCompleteSelection(pObj2);
 963                 }
 964             }
 965
 966             maAllMarkedObjects.Insert(pObj, LIST_APPEND);
 967         }
 968     }
 969
 970     void ViewSelection::ImpForceEdgesOfMarkedNodes()
 971     {
 972         if(mbEdgesOfMarkedNodesDirty)
 973         {
 974             mbEdgesOfMarkedNodesDirty = sal_False;
 975             maMarkedObjectList.ForceSort();
 976             maEdgesOfMarkedNodes.Clear();
 977             maMarkedEdgesOfMarkedNodes.Clear();
 978             maAllMarkedObjects.Clear();
 979
 980             // #126320# GetMarkCount after ForceSort
 981             const ULONG nMarkAnz(maMarkedObjectList.GetMarkCount());
 982
 983             for(ULONG a(0L); a < nMarkAnz; a++)
 984             {
 985                 SdrObject* pCandidate = maMarkedObjectList.GetMark(a)->GetMarkedSdrObj();
 986
 987                 if(pCandidate)
 988                 {
 989                     // build transitive hull
 990                     ImplCollectCompleteSelection(pCandidate);
 991
 992                     if(pCandidate->IsNode())
 993                     {
 994                         // travel over broadcaster/listener to access edges connected to the selected object
 995                         const SfxBroadcaster* pBC = pCandidate->GetBroadcaster();
 996
 997                         if(pBC)
 998                         {
 999                             sal_uInt16 nLstAnz(pBC->GetListenerCount());
1000
1001                             for(sal_uInt16 nl(0); nl < nLstAnz; nl++)
1002                             {
1003                                 SfxListener* pLst = pBC->GetListener(nl);
1004                                 SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, pLst);
1005
1006                                 if(pEdge && pEdge->IsInserted() && pEdge->GetPage() == pCandidate->GetPage())
1007                                 {
1008                                     SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView());
1009
1010                                     if(pEdge->GetConnectedNode(sal_True) == pCandidate)
1011                                     {
1012                                         aM.SetCon1(sal_True);
1013                                     }
1014
1015                                     if(pEdge->GetConnectedNode(sal_False) == pCandidate)
1016                                     {
1017                                         aM.SetCon2(sal_True);
1018                                     }
1019
1020                                     if(CONTAINER_ENTRY_NOTFOUND == maMarkedObjectList.FindObject(pEdge))
1021                                     {
1022                                         // nachsehen, ob er selbst markiert ist
1023                                         maEdgesOfMarkedNodes.InsertEntry(aM);
1024                                     }
1025                                     else
1026                                     {
1027                                         maMarkedEdgesOfMarkedNodes.InsertEntry(aM);
1028                                     }
1029                                 }
1030                             }
1031                         }
1032                     }
1033                 }
1034             }
1035
1036             maEdgesOfMarkedNodes.ForceSort();
1037             maMarkedEdgesOfMarkedNodes.ForceSort();
1038         }
1039     }
1040 } // end of namespace sdr
1041
1042 ////////////////////////////////////////////////////////////////////////////////////////////////////
1043 // eof