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

Generated by: LCOV version 1.10