LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdmrkv1.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 67 341 19.6 %
Date: 2015-06-13 12:38:46 Functions: 9 25 36.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             : #include <svx/svdmrkv.hxx>
      22             : #include <svx/svdetc.hxx>
      23             : #include <svx/svdoedge.hxx>
      24             : #include "svdglob.hxx"
      25             : #include <svx/svdpagv.hxx>
      26             : #include <svx/svdpage.hxx>
      27             : #include "svddrgm1.hxx"
      28             : 
      29             : 
      30             : // Point Selection
      31             : 
      32             : 
      33        1423 : bool SdrMarkView::HasMarkablePoints() const
      34             : {
      35        1423 :     ForceUndirtyMrkPnt();
      36        1423 :     bool bRet=false;
      37        1423 :     if (!ImpIsFrameHandles()) {
      38          13 :         const size_t nMarkCount=GetMarkedObjectCount();
      39          13 :         if (nMarkCount<=static_cast<size_t>(nFrameHandlesLimit)) {
      40          26 :             for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
      41          13 :                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
      42          13 :                 const SdrObject* pObj=pM->GetMarkedSdrObj();
      43          13 :                 bRet=pObj->IsPolyObj();
      44             :             }
      45             :         }
      46             :     }
      47        1423 :     return bRet;
      48             : }
      49             : 
      50           0 : sal_uIntPtr SdrMarkView::GetMarkablePointCount() const
      51             : {
      52           0 :     ForceUndirtyMrkPnt();
      53           0 :     sal_uIntPtr nCount=0;
      54           0 :     if (!ImpIsFrameHandles()) {
      55           0 :         const size_t nMarkCount=GetMarkedObjectCount();
      56           0 :         if (nMarkCount<=static_cast<size_t>(nFrameHandlesLimit)) {
      57           0 :             for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
      58           0 :                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
      59           0 :                 const SdrObject* pObj=pM->GetMarkedSdrObj();
      60           0 :                 if (pObj->IsPolyObj()) {
      61           0 :                     nCount+=pObj->GetPointCount();
      62             :                 }
      63             :             }
      64             :         }
      65             :     }
      66           0 :     return nCount;
      67             : }
      68             : 
      69        3056 : bool SdrMarkView::HasMarkedPoints() const
      70             : {
      71        3056 :     ForceUndirtyMrkPnt();
      72        3056 :     bool bRet=false;
      73        3056 :     if (!ImpIsFrameHandles()) {
      74        1002 :         const size_t nMarkCount=GetMarkedObjectCount();
      75        1002 :         if (nMarkCount<=static_cast<size_t>(nFrameHandlesLimit)) {
      76        1240 :             for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
      77         238 :                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
      78         238 :                 const SdrUShortCont* pPts=pM->GetMarkedPoints();
      79         238 :                 bRet=pPts!=NULL && !pPts->empty();
      80             :             }
      81             :         }
      82             :     }
      83        3056 :     return bRet;
      84             : }
      85             : 
      86           0 : sal_uIntPtr SdrMarkView::GetMarkedPointCount() const
      87             : {
      88           0 :     ForceUndirtyMrkPnt();
      89           0 :     sal_uIntPtr nCount=0;
      90           0 :     if (!ImpIsFrameHandles()) {
      91           0 :         size_t nMarkCount=GetMarkedObjectCount();
      92           0 :         if (nMarkCount<=static_cast<size_t>(nFrameHandlesLimit)) {
      93           0 :             for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
      94           0 :                 const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
      95           0 :                 const SdrUShortCont* pPts=pM->GetMarkedPoints();
      96           0 :                 if (pPts!=NULL) nCount+=pPts->size();
      97             :             }
      98             :         }
      99             :     }
     100           0 :     return nCount;
     101             : }
     102             : 
     103          39 : bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const
     104             : {
     105          39 :     return !ImpIsFrameHandles() && !rHdl.IsPlusHdl() && rHdl.GetKind()!=HDL_GLUE && rHdl.GetKind()!=HDL_SMARTTAG && rHdl.GetObj()!=NULL && rHdl.GetObj()->IsPolyObj();
     106             : }
     107             : 
     108           0 : bool SdrMarkView::MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark)
     109             : {
     110           0 :     return ImpMarkPoint( pHdl, pMark, bUnmark );
     111             : }
     112             : 
     113           0 : bool SdrMarkView::ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark)
     114             : {
     115           0 :     if (pHdl==NULL || pHdl->IsPlusHdl() || pHdl->GetKind()==HDL_GLUE)
     116           0 :         return false;
     117             : 
     118           0 :     if (pHdl->IsSelected() != bUnmark)
     119           0 :         return false;
     120             : 
     121           0 :     SdrObject* pObj=pHdl->GetObj();
     122           0 :     if (pObj==NULL || !pObj->IsPolyObj())
     123           0 :         return false;
     124             : 
     125           0 :     if (pMark==NULL)
     126             :     {
     127           0 :         const size_t nMarkNum=TryToFindMarkedObject(pObj);
     128           0 :         if (nMarkNum==SAL_MAX_SIZE)
     129           0 :             return false;
     130           0 :         pMark=GetSdrMarkByIndex(nMarkNum);
     131             :     }
     132           0 :     const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum());
     133           0 :     SdrUShortCont* pPts=pMark->ForceMarkedPoints();
     134           0 :     if (!bUnmark)
     135             :     {
     136           0 :         pPts->insert((sal_uInt16)nHdlNum);
     137             :     }
     138             :     else
     139             :     {
     140           0 :         SdrUShortCont::const_iterator it = pPts->find( (sal_uInt16)nHdlNum );
     141           0 :         if (it != pPts->end())
     142             :         {
     143           0 :             pPts->erase(it);
     144             :         }
     145             :         else
     146             :         {
     147           0 :             return false; // error case!
     148             :         }
     149             :     }
     150             : 
     151           0 :     pHdl->SetSelected(!bUnmark);
     152           0 :     if (!bPlusHdlAlways)
     153             :     {
     154           0 :         if (!bUnmark)
     155             :         {
     156           0 :             sal_uInt32 nCount(pObj->GetPlusHdlCount(*pHdl));
     157           0 :             for (sal_uInt32 i=0; i<nCount; i++)
     158             :             {
     159           0 :                 SdrHdl* pPlusHdl=pObj->GetPlusHdl(*pHdl,i);
     160           0 :                 if (pPlusHdl!=NULL)
     161             :                 {
     162           0 :                     pPlusHdl->SetObj(pObj);
     163           0 :                     pPlusHdl->SetPageView(pMark->GetPageView());
     164           0 :                     pPlusHdl->SetPlusHdl(true);
     165           0 :                     maHdlList.AddHdl(pPlusHdl);
     166             :                 }
     167             :             }
     168             :         }
     169             :         else
     170             :         {
     171           0 :             for (size_t i = maHdlList.GetHdlCount(); i>0;)
     172             :             {
     173           0 :                 --i;
     174           0 :                 SdrHdl* pPlusHdl=maHdlList.GetHdl(i);
     175           0 :                 if (pPlusHdl->IsPlusHdl() && pPlusHdl->GetSourceHdlNum()==nHdlNum)
     176             :                 {
     177           0 :                     maHdlList.RemoveHdl(i);
     178           0 :                     delete pPlusHdl;
     179             :                 }
     180             :             }
     181             :         }
     182             :     }
     183             : 
     184           0 :     maHdlList.Sort();
     185             : 
     186           0 :     return true;
     187             : }
     188             : 
     189             : 
     190           0 : bool SdrMarkView::MarkPoint(SdrHdl& rHdl, bool bUnmark)
     191             : {
     192           0 :     ForceUndirtyMrkPnt();
     193           0 :     bool bRet=false;
     194           0 :     const SdrObject* pObj=rHdl.GetObj();
     195           0 :     if (IsPointMarkable(rHdl) && rHdl.IsSelected()==bUnmark) {
     196           0 :         const size_t nMarkNum=TryToFindMarkedObject(pObj);
     197           0 :         if (nMarkNum!=SAL_MAX_SIZE) {
     198           0 :             SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
     199           0 :             pM->ForceMarkedPoints();
     200           0 :             if (ImpMarkPoint(&rHdl,pM,bUnmark)) {
     201           0 :                 MarkListHasChanged();
     202           0 :                 bRet=true;
     203             :             }
     204             :         }
     205             :     }
     206             : 
     207           0 :     return bRet;
     208             : }
     209             : 
     210         135 : bool SdrMarkView::MarkPoints(const Rectangle* pRect, bool bUnmark)
     211             : {
     212         135 :     ForceUndirtyMrkPnt();
     213         135 :     bool bChgd=false;
     214         135 :     SortMarkedObjects();
     215         135 :     const SdrObject* pObj0=NULL;
     216         135 :     const SdrPageView* pPV0=NULL;
     217         135 :     SdrMark* pM=NULL;
     218         135 :     maHdlList.Sort();
     219         135 :     const size_t nHdlAnz=maHdlList.GetHdlCount();
     220         306 :     for (size_t nHdlNum=nHdlAnz; nHdlNum>0;) {
     221          36 :         --nHdlNum;
     222          36 :         SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum);
     223          36 :         if (IsPointMarkable(*pHdl) && pHdl->IsSelected()==bUnmark) {
     224           0 :             const SdrObject* pObj=pHdl->GetObj();
     225           0 :             const SdrPageView* pPV=pHdl->GetPageView();
     226           0 :             if (pObj!=pObj0 || pPV!=pPV0 || pM==NULL) { // This section is for optimization,
     227           0 :                 const size_t nMarkNum=TryToFindMarkedObject(pObj);  // so ImpMarkPoint() doesn't always
     228           0 :                 if (nMarkNum!=SAL_MAX_SIZE) { // have to search the object in the MarkList.
     229           0 :                     pM=GetSdrMarkByIndex(nMarkNum);
     230           0 :                     pObj0=pObj;
     231           0 :                     pPV0=pPV;
     232           0 :                     pM->ForceMarkedPoints();
     233             :                 } else {
     234             : #ifdef DBG_UTIL
     235             :                     if (pObj->IsInserted()) {
     236             :                         OSL_FAIL("SdrMarkView::MarkPoints(const Rectangle* pRect): Selected object not found.");
     237             :                     }
     238             : #endif
     239           0 :                     pM=NULL;
     240             :                 }
     241             :             }
     242           0 :             Point aPos(pHdl->GetPos());
     243           0 :             if (pM!=NULL && (pRect==NULL || pRect->IsInside(aPos))) {
     244           0 :                 if (ImpMarkPoint(pHdl,pM,bUnmark)) bChgd=true;
     245             :             }
     246             :         }
     247             :     }
     248         135 :     if (bChgd) {
     249           0 :         MarkListHasChanged();
     250             :     }
     251             : 
     252         135 :     return bChgd;
     253             : }
     254             : 
     255           0 : bool SdrMarkView::MarkNextPoint(const Point& /*rPnt*/, bool /*bPrev*/)
     256             : {
     257           0 :     ForceUndirtyMrkPnt();
     258           0 :     SortMarkedObjects();
     259           0 :     return false;
     260             : }
     261             : 
     262           0 : const Rectangle& SdrMarkView::GetMarkedPointsRect() const
     263             : {
     264           0 :     ForceUndirtyMrkPnt();
     265           0 :     if (bMarkedPointsRectsDirty) ImpSetPointsRects();
     266           0 :     return aMarkedPointsRect;
     267             : }
     268             : 
     269        1165 : void SdrMarkView::SetPlusHandlesAlwaysVisible(bool bOn)
     270             : { // TODO: Optimize HandlePaint!
     271        1165 :     ForceUndirtyMrkPnt();
     272        1165 :     if (bOn!=bPlusHdlAlways) {
     273           0 :         bPlusHdlAlways=bOn;
     274           0 :         SetMarkHandles();
     275           0 :         MarkListHasChanged();
     276             :     }
     277        1165 : }
     278             : 
     279             : 
     280             : // ImpSetPointsRects() is for PolyPoints and GluePoints!
     281             : 
     282             : 
     283           0 : void SdrMarkView::ImpSetPointsRects() const
     284             : {
     285           0 :     Rectangle aPnts;
     286           0 :     Rectangle aGlue;
     287           0 :     const size_t nHdlAnz=maHdlList.GetHdlCount();
     288           0 :     for (size_t nHdlNum=0; nHdlNum<nHdlAnz; ++nHdlNum) {
     289           0 :         const SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum);
     290           0 :         SdrHdlKind eKind=pHdl->GetKind();
     291           0 :         if ((eKind==HDL_POLY && pHdl->IsSelected()) || eKind==HDL_GLUE) {
     292           0 :             Point aPt(pHdl->GetPos());
     293           0 :             Rectangle& rR=eKind==HDL_GLUE ? aGlue : aPnts;
     294           0 :             if (rR.IsEmpty()) {
     295           0 :                 rR=Rectangle(aPt,aPt);
     296             :             } else {
     297           0 :                 if (aPt.X()<rR.Left  ()) rR.Left  ()=aPt.X();
     298           0 :                 if (aPt.X()>rR.Right ()) rR.Right ()=aPt.X();
     299           0 :                 if (aPt.Y()<rR.Top   ()) rR.Top   ()=aPt.Y();
     300           0 :                 if (aPt.Y()>rR.Bottom()) rR.Bottom()=aPt.Y();
     301             :             }
     302             :         }
     303             :     }
     304           0 :     const_cast<SdrMarkView*>(this)->aMarkedPointsRect=aPnts;
     305           0 :     const_cast<SdrMarkView*>(this)->aMarkedGluePointsRect=aGlue;
     306           0 :     const_cast<SdrMarkView*>(this)->bMarkedPointsRectsDirty=false;
     307           0 : }
     308             : 
     309             : 
     310             : // UndirtyMrkPnt() is for PolyPoints and GluePoints!
     311             : 
     312             : 
     313        3699 : void SdrMarkView::UndirtyMrkPnt() const
     314             : {
     315        3699 :     bool bChg=false;
     316        3699 :     const size_t nMarkCount=GetMarkedObjectCount();
     317        3701 :     for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
     318           2 :         SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
     319           2 :         const SdrObject* pObj=pM->GetMarkedSdrObj();
     320             :         // PolyPoints
     321           2 :         SdrUShortCont* pPts=pM->GetMarkedPoints();
     322           2 :         if (pPts!=NULL) {
     323           0 :             if (pObj->IsPolyObj()) {
     324             :                 // Remove invalid selected points, that is, all
     325             :                 // entries above the number of points in the object.
     326           0 :                 sal_uInt32 nMax(pObj->GetPointCount());
     327             : 
     328           0 :                 SdrUShortCont::const_iterator it = pPts->lower_bound(nMax);
     329           0 :                 if( it != pPts->end() )
     330             :                 {
     331           0 :                     pPts->erase(it, pPts->end() );
     332           0 :                     bChg = true;
     333             :                 }
     334             :             }
     335             :             else
     336             :             {
     337             :                 OSL_FAIL("SdrMarkView::UndirtyMrkPnt(): Selected points on an object that is not a PolyObj!");
     338           0 :                 if(pPts && !pPts->empty())
     339             :                 {
     340           0 :                     pPts->clear();
     341           0 :                     bChg = true;
     342             :                 }
     343             :             }
     344             :         }
     345             : 
     346             :         // GluePoints
     347           2 :         pPts=pM->GetMarkedGluePoints();
     348           2 :         const SdrGluePointList* pGPL=pObj->GetGluePointList();
     349           2 :         if (pPts!=NULL) {
     350           0 :             if (pGPL!=NULL) {
     351             :                 // Remove invalid selected glue points, that is, all entries
     352             :                 // (IDs) that aren't contained in the GluePointList of the
     353             :                 // object
     354           0 :                 for(SdrUShortCont::const_iterator it = pPts->begin(); it != pPts->end(); )
     355             :                 {
     356           0 :                     sal_uInt16 nId=*it;
     357           0 :                     if (pGPL->FindGluePoint(nId)==SDRGLUEPOINT_NOTFOUND) {
     358           0 :                         it = pPts->erase(it);
     359           0 :                         bChg=true;
     360             :                     }
     361             :                     else
     362           0 :                         ++it;
     363             :                 }
     364             :             } else {
     365           0 :                 if (pPts!=NULL && !pPts->empty()) {
     366           0 :                     pPts->clear(); // object doesn't have any glue points (any more)
     367           0 :                     bChg=true;
     368             :                 }
     369             :             }
     370             :         }
     371             :     }
     372        3699 :     if (bChg) const_cast<SdrMarkView*>(this)->bMarkedPointsRectsDirty=true;
     373        3699 :     const_cast<SdrMarkView*>(this)->bMrkPntDirty=false;
     374        3699 : }
     375             : 
     376             : 
     377             : 
     378           0 : bool SdrMarkView::HasMarkableGluePoints() const
     379             : {
     380           0 :     bool bRet=false;
     381           0 :     if (IsGluePointEditMode()) {
     382           0 :         ForceUndirtyMrkPnt();
     383           0 :         const size_t nMarkCount=GetMarkedObjectCount();
     384           0 :         for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
     385           0 :             const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
     386           0 :             const SdrObject* pObj=pM->GetMarkedSdrObj();
     387           0 :             const SdrGluePointList* pGPL=pObj->GetGluePointList();
     388             : 
     389             :             // #i38892#
     390           0 :             if(pGPL && pGPL->GetCount())
     391             :             {
     392           0 :                 for(sal_uInt16 a(0); !bRet && a < pGPL->GetCount(); a++)
     393             :                 {
     394           0 :                     if((*pGPL)[a].IsUserDefined())
     395             :                     {
     396           0 :                         bRet = true;
     397             :                     }
     398             :                 }
     399             :             }
     400             :         }
     401             :     }
     402           0 :     return bRet;
     403             : }
     404             : 
     405        3055 : bool SdrMarkView::HasMarkedGluePoints() const
     406             : {
     407        3055 :     ForceUndirtyMrkPnt();
     408        3055 :     bool bRet=false;
     409        3055 :     const size_t nMarkCount=GetMarkedObjectCount();
     410        3325 :     for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
     411         270 :         const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
     412         270 :         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
     413         270 :         bRet=pPts!=NULL && !pPts->empty();
     414             :     }
     415        3055 :     return bRet;
     416             : }
     417             : 
     418           0 : bool SdrMarkView::MarkGluePoints(const Rectangle* pRect, bool bUnmark)
     419             : {
     420           0 :     if (!IsGluePointEditMode() && !bUnmark) return false;
     421           0 :     ForceUndirtyMrkPnt();
     422           0 :     bool bChgd=false;
     423           0 :     SortMarkedObjects();
     424           0 :     const size_t nMarkCount=GetMarkedObjectCount();
     425           0 :     for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
     426           0 :         SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
     427           0 :         const SdrObject* pObj=pM->GetMarkedSdrObj();
     428           0 :         const SdrGluePointList* pGPL=pObj->GetGluePointList();
     429           0 :         SdrUShortCont* pPts=pM->GetMarkedGluePoints();
     430           0 :         if (bUnmark && pRect==NULL) { // UnmarkAll
     431           0 :             if (pPts!=NULL && !pPts->empty()) {
     432           0 :                 pPts->clear();
     433           0 :                 bChgd=true;
     434             :             }
     435             :         } else {
     436           0 :             if (pGPL!=NULL && (pPts!=NULL || !bUnmark)) {
     437           0 :                 sal_uInt16 nGPAnz=pGPL->GetCount();
     438           0 :                 for (sal_uInt16 nGPNum=0; nGPNum<nGPAnz; nGPNum++) {
     439           0 :                     const SdrGluePoint& rGP=(*pGPL)[nGPNum];
     440             : 
     441             :                     // #i38892#
     442           0 :                     if(rGP.IsUserDefined())
     443             :                     {
     444           0 :                         Point aPos(rGP.GetAbsolutePos(*pObj));
     445           0 :                         if (pRect==NULL || pRect->IsInside(aPos)) {
     446           0 :                             if (pPts==NULL)
     447           0 :                                 pPts=pM->ForceMarkedGluePoints();
     448           0 :                             bool bContains = pPts->find( rGP.GetId() ) != pPts->end();
     449           0 :                             if (!bUnmark && !bContains) {
     450           0 :                                 bChgd=true;
     451           0 :                                 pPts->insert(rGP.GetId());
     452             :                             }
     453           0 :                             if (bUnmark && bContains) {
     454           0 :                                 bChgd=true;
     455           0 :                                 pPts->erase(rGP.GetId());
     456             :                             }
     457             :                         }
     458             :                     }
     459             :                 }
     460             :             }
     461             :         }
     462             :     }
     463           0 :     if (bChgd) {
     464           0 :         AdjustMarkHdl();
     465           0 :         MarkListHasChanged();
     466             :     }
     467           0 :     return bChgd;
     468             : }
     469             : 
     470           0 : bool SdrMarkView::PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, SdrSearchOptions nOptions) const
     471             : {
     472           0 :     SdrObject* pObj0=rpObj;
     473           0 :     sal_uInt16 nId0=rnId;
     474           0 :     rpObj=NULL; rpPV=NULL; rnId=0;
     475           0 :     if (!IsGluePointEditMode()) return false;
     476           0 :     bool bBack(nOptions & SdrSearchOptions::BACKWARD);
     477           0 :     bool bNext(nOptions & SdrSearchOptions::NEXT);
     478           0 :     OutputDevice* pOut=pActualOutDev.get();
     479           0 :     if (pOut==NULL) pOut=GetFirstOutputDevice();
     480           0 :     if (pOut==NULL) return false;
     481           0 :     SortMarkedObjects();
     482           0 :     const size_t nMarkCount=GetMarkedObjectCount();
     483           0 :     size_t nMarkNum=bBack ? 0 : nMarkCount;
     484           0 :     if (bNext) {
     485           0 :         nMarkNum=TryToFindMarkedObject(pObj0);
     486           0 :         if (nMarkNum==SAL_MAX_SIZE) return false;
     487           0 :         if (!bBack) nMarkNum++;
     488             :     }
     489           0 :     while (bBack ? nMarkNum<nMarkCount : nMarkNum>0) {
     490           0 :         if (!bBack) nMarkNum--;
     491           0 :         const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
     492           0 :         SdrObject* pObj=pM->GetMarkedSdrObj();
     493           0 :         SdrPageView* pPV=pM->GetPageView();
     494           0 :         const SdrGluePointList* pGPL=pObj->GetGluePointList();
     495           0 :         if (pGPL!=NULL) {
     496           0 :             sal_uInt16 nNum=pGPL->HitTest(rPnt,*pOut,pObj,bBack,bNext,nId0);
     497           0 :             if (nNum!=SDRGLUEPOINT_NOTFOUND)
     498             :             {
     499             :                 // #i38892#
     500           0 :                 const SdrGluePoint& rCandidate = (*pGPL)[nNum];
     501             : 
     502           0 :                 if(rCandidate.IsUserDefined())
     503             :                 {
     504           0 :                     rpObj=pObj;
     505           0 :                     rnId=(*pGPL)[nNum].GetId();
     506           0 :                     rpPV=pPV;
     507           0 :                     return true;
     508             :                 }
     509             :             }
     510             :         }
     511           0 :         bNext=false; // HitNextGluePoint only for the first Obj
     512           0 :         if (bBack) nMarkNum++;
     513             :     }
     514           0 :     return false;
     515             : }
     516             : 
     517           0 : bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* /*pPV*/, bool bUnmark)
     518             : {
     519           0 :     if (!IsGluePointEditMode()) return false;
     520           0 :     ForceUndirtyMrkPnt();
     521           0 :     bool bChgd=false;
     522           0 :     if (pObj!=NULL) {
     523           0 :         const size_t nMarkPos=TryToFindMarkedObject(pObj);
     524           0 :         if (nMarkPos!=SAL_MAX_SIZE) {
     525           0 :             SdrMark* pM=GetSdrMarkByIndex(nMarkPos);
     526           0 :             SdrUShortCont* pPts=bUnmark ? pM->GetMarkedGluePoints() : pM->ForceMarkedGluePoints();
     527           0 :             if (pPts!=NULL) {
     528           0 :                 bool bContains = pPts->find( nId ) != pPts->end();
     529           0 :                 if (!bUnmark && !bContains) {
     530           0 :                     bChgd=true;
     531           0 :                     pPts->insert(nId);
     532             :                 }
     533           0 :                 if (bUnmark && bContains) {
     534           0 :                     bChgd=true;
     535           0 :                     pPts->erase(nId);
     536             :                 }
     537             :             }
     538             :         } else {
     539             :             // TODO: implement implicit selection of objects
     540             :         }
     541             :     }
     542           0 :     if (bChgd) {
     543           0 :         AdjustMarkHdl();
     544           0 :         MarkListHasChanged();
     545             :     }
     546           0 :     return bChgd;
     547             : }
     548             : 
     549           0 : bool SdrMarkView::IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const
     550             : {
     551           0 :     ForceUndirtyMrkPnt();
     552           0 :     bool bRet=false;
     553           0 :     const size_t nPos=TryToFindMarkedObject(pObj); // casting to NonConst
     554           0 :     if (nPos!=SAL_MAX_SIZE) {
     555           0 :         const SdrMark* pM=GetSdrMarkByIndex(nPos);
     556           0 :         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
     557           0 :         if (pPts!=NULL) {
     558           0 :             bRet = pPts->find( nId ) != pPts->end();
     559             :         }
     560             :     }
     561           0 :     return bRet;
     562             : }
     563             : 
     564           0 : SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const
     565             : {
     566           0 :     ForceUndirtyMrkPnt();
     567           0 :     const size_t nHdlAnz=maHdlList.GetHdlCount();
     568           0 :     for (size_t nHdlNum=0; nHdlNum<nHdlAnz; ++nHdlNum) {
     569           0 :         SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum);
     570           0 :         if (pHdl->GetObj()==pObj &&
     571           0 :             pHdl->GetKind()==HDL_GLUE &&
     572           0 :             pHdl->GetObjHdlNum()==nId ) return pHdl;
     573             :     }
     574           0 :     return NULL;
     575             : }
     576             : 
     577           0 : bool SdrMarkView::MarkNextGluePoint(const Point& /*rPnt*/, bool /*bPrev*/)
     578             : {
     579           0 :     ForceUndirtyMrkPnt();
     580           0 :     SortMarkedObjects();
     581           0 :     return false;
     582             : }
     583             : 
     584           0 : const Rectangle& SdrMarkView::GetMarkedGluePointsRect() const
     585             : {
     586           0 :     ForceUndirtyMrkPnt();
     587           0 :     if (bMarkedPointsRectsDirty) ImpSetPointsRects();
     588           0 :     return aMarkedGluePointsRect;
     589         435 : }
     590             : 
     591             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11