LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdmark.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 399 0.0 %
Date: 2014-04-14 Functions: 0 33 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10