LibreOffice Module svx (master)  1
svdmrkv1.cxx
Go to the documentation of this file.
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/svdpagv.hxx>
23 
24 
25 // Point Selection
26 
27 
29 {
31  bool bRet=false;
32  if (!ImpIsFrameHandles()) {
33  const size_t nMarkCount=GetMarkedObjectCount();
34  if (nMarkCount<=static_cast<size_t>(mnFrameHandlesLimit)) {
35  for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
36  const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
37  const SdrObject* pObj=pM->GetMarkedSdrObj();
38  bRet=pObj->IsPolyObj();
39  }
40  }
41  }
42  return bRet;
43 }
44 
46 {
48  sal_Int32 nCount=0;
49  if (!ImpIsFrameHandles()) {
50  const size_t nMarkCount=GetMarkedObjectCount();
51  if (nMarkCount<=static_cast<size_t>(mnFrameHandlesLimit)) {
52  for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
53  const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
54  const SdrObject* pObj=pM->GetMarkedSdrObj();
55  if (pObj->IsPolyObj()) {
56  nCount+=pObj->GetPointCount();
57  }
58  }
59  }
60  }
61  return nCount;
62 }
63 
65 {
67  bool bRet=false;
68  if (!ImpIsFrameHandles()) {
69  const size_t nMarkCount=GetMarkedObjectCount();
70  if (nMarkCount<=static_cast<size_t>(mnFrameHandlesLimit)) {
71  for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
72  const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
73  const SdrUShortCont& rPts = pM->GetMarkedPoints();
74  bRet = !rPts.empty();
75  }
76  }
77  }
78  return bRet;
79 }
80 
81 bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const
82 {
83  return !ImpIsFrameHandles() && !rHdl.IsPlusHdl() && rHdl.GetKind()!=SdrHdlKind::Glue && rHdl.GetKind()!=SdrHdlKind::SmartTag && rHdl.GetObj()!=nullptr && rHdl.GetObj()->IsPolyObj();
84 }
85 
86 bool SdrMarkView::MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark)
87 {
88  return ImpMarkPoint( pHdl, pMark, bUnmark );
89 }
90 
91 bool SdrMarkView::ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark)
92 {
93  if (pHdl==nullptr || pHdl->IsPlusHdl() || pHdl->GetKind()==SdrHdlKind::Glue)
94  return false;
95 
96  if (pHdl->IsSelected() != bUnmark)
97  return false;
98 
99  SdrObject* pObj=pHdl->GetObj();
100  if (pObj==nullptr || !pObj->IsPolyObj())
101  return false;
102 
103  if (pMark==nullptr)
104  {
105  const size_t nMarkNum=TryToFindMarkedObject(pObj);
106  if (nMarkNum==SAL_MAX_SIZE)
107  return false;
108  pMark=GetSdrMarkByIndex(nMarkNum);
109  }
110  const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum());
111  SdrUShortCont& rPts=pMark->GetMarkedPoints();
112  if (!bUnmark)
113  {
114  rPts.insert(static_cast<sal_uInt16>(nHdlNum));
115  }
116  else
117  {
118  SdrUShortCont::const_iterator it = rPts.find( static_cast<sal_uInt16>(nHdlNum) );
119  if (it != rPts.end())
120  {
121  rPts.erase(it);
122  }
123  else
124  {
125  return false; // error case!
126  }
127  }
128 
129  pHdl->SetSelected(!bUnmark);
130  if (!mbPlusHdlAlways)
131  {
132  if (!bUnmark)
133  {
134  SdrHdlList plusList(nullptr);
135  pObj->AddToPlusHdlList(plusList, *pHdl);
136  sal_uInt32 nCount(plusList.GetHdlCount());
137  for (sal_uInt32 i=0; i<nCount; i++)
138  {
139  SdrHdl* pPlusHdl=plusList.GetHdl(i);
140  pPlusHdl->SetObj(pObj);
141  pPlusHdl->SetPageView(pMark->GetPageView());
142  pPlusHdl->SetPlusHdl(true);
143  }
144  plusList.MoveTo(maHdlList);
145  }
146  else
147  {
148  for (size_t i = maHdlList.GetHdlCount(); i>0;)
149  {
150  --i;
151  SdrHdl* pPlusHdl=maHdlList.GetHdl(i);
152  if (pPlusHdl->IsPlusHdl() && pPlusHdl->GetSourceHdlNum()==nHdlNum)
153  {
155  }
156  }
157  }
158  }
159 
160  maHdlList.Sort();
161 
162  return true;
163 }
164 
165 
166 bool SdrMarkView::MarkPoint(SdrHdl& rHdl, bool bUnmark)
167 {
169  bool bRet=false;
170  const SdrObject* pObj=rHdl.GetObj();
171  if (IsPointMarkable(rHdl) && rHdl.IsSelected()==bUnmark) {
172  const size_t nMarkNum=TryToFindMarkedObject(pObj);
173  if (nMarkNum!=SAL_MAX_SIZE) {
174  SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
175  if (ImpMarkPoint(&rHdl,pM,bUnmark)) {
177  bRet=true;
178  }
179  }
180  }
181 
182  return bRet;
183 }
184 
185 bool SdrMarkView::MarkPoints(const tools::Rectangle* pRect, bool bUnmark)
186 {
188  bool bChgd=false;
190  const SdrObject* pObj0=nullptr;
191  const SdrPageView* pPV0=nullptr;
192  SdrMark* pM=nullptr;
193  maHdlList.Sort();
194  const size_t nHdlCnt=maHdlList.GetHdlCount();
195  for (size_t nHdlNum=nHdlCnt; nHdlNum>0;) {
196  --nHdlNum;
197  SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum);
198  if (IsPointMarkable(*pHdl) && pHdl->IsSelected()==bUnmark) {
199  const SdrObject* pObj=pHdl->GetObj();
200  const SdrPageView* pPV=pHdl->GetPageView();
201  if (pObj!=pObj0 || pPV!=pPV0 || pM==nullptr) { // This section is for optimization,
202  const size_t nMarkNum=TryToFindMarkedObject(pObj); // so ImpMarkPoint() doesn't always
203  if (nMarkNum!=SAL_MAX_SIZE) { // have to search the object in the MarkList.
204  pM=GetSdrMarkByIndex(nMarkNum);
205  pObj0=pObj;
206  pPV0=pPV;
207  } else {
208 #ifdef DBG_UTIL
209  if (pObj->IsInserted()) {
210  OSL_FAIL("SdrMarkView::MarkPoints(const Rectangle* pRect): Selected object not found.");
211  }
212 #endif
213  pM=nullptr;
214  }
215  }
216  Point aPos(pHdl->GetPos());
217  if (pM!=nullptr && (pRect==nullptr || pRect->IsInside(aPos))) {
218  if (ImpMarkPoint(pHdl,pM,bUnmark)) bChgd=true;
219  }
220  }
221  }
222  if (bChgd) {
224  }
225 
226  return bChgd;
227 }
228 
230 {
233 }
234 
236 {
239  return maMarkedPointsRect;
240 }
241 
243 { // TODO: Optimize HandlePaint!
245  if (bOn!=mbPlusHdlAlways) {
246  mbPlusHdlAlways=bOn;
247  SetMarkHandles(nullptr);
249  }
250 }
251 
252 
253 // ImpSetPointsRects() is for PolyPoints and GluePoints!
254 
255 
257 {
258  tools::Rectangle aPnts;
259  tools::Rectangle aGlue;
260  const size_t nHdlCnt=maHdlList.GetHdlCount();
261  for (size_t nHdlNum=0; nHdlNum<nHdlCnt; ++nHdlNum) {
262  const SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum);
263  SdrHdlKind eKind=pHdl->GetKind();
264  if ((eKind==SdrHdlKind::Poly && pHdl->IsSelected()) || eKind==SdrHdlKind::Glue) {
265  Point aPt(pHdl->GetPos());
266  tools::Rectangle& rR=eKind==SdrHdlKind::Glue ? aGlue : aPnts;
267  if (rR.IsEmpty()) {
268  rR=tools::Rectangle(aPt,aPt);
269  } else {
270  if (aPt.X()<rR.Left ()) rR.SetLeft(aPt.X() );
271  if (aPt.X()>rR.Right ()) rR.SetRight(aPt.X() );
272  if (aPt.Y()<rR.Top ()) rR.SetTop(aPt.Y() );
273  if (aPt.Y()>rR.Bottom()) rR.SetBottom(aPt.Y() );
274  }
275  }
276  }
277  const_cast<SdrMarkView*>(this)->maMarkedPointsRect=aPnts;
278  const_cast<SdrMarkView*>(this)->maMarkedGluePointsRect=aGlue;
279  const_cast<SdrMarkView*>(this)->mbMarkedPointsRectsDirty=false;
280 }
281 
282 
283 // UndirtyMrkPnt() is for PolyPoints and GluePoints!
284 
285 
287 {
288  bool bChg=false;
289  const size_t nMarkCount=GetMarkedObjectCount();
290  for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
291  SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
292  const SdrObject* pObj=pM->GetMarkedSdrObj();
293  // PolyPoints
294  {
295  SdrUShortCont& rPts = pM->GetMarkedPoints();
296  if (pObj->IsPolyObj()) {
297  // Remove invalid selected points, that is, all
298  // entries above the number of points in the object.
299  sal_uInt32 nMax(pObj->GetPointCount());
300 
302  if( it != rPts.end() )
303  {
304  rPts.erase(it, rPts.end());
305  bChg = true;
306  }
307  }
308  else
309  {
310  OSL_FAIL("SdrMarkView::UndirtyMrkPnt(): Selected points on an object that is not a PolyObj!");
311  if (!rPts.empty())
312  {
313  rPts.clear();
314  bChg = true;
315  }
316  }
317  }
318 
319  // GluePoints
320  {
321  SdrUShortCont& rPts = pM->GetMarkedGluePoints();
322  const SdrGluePointList* pGPL=pObj->GetGluePointList();
323  if (pGPL!=nullptr) {
324  // Remove invalid selected glue points, that is, all entries
325  // (IDs) that aren't contained in the GluePointList of the
326  // object
327  for(SdrUShortCont::const_iterator it = rPts.begin(); it != rPts.end(); )
328  {
329  sal_uInt16 nId=*it;
330  if (pGPL->FindGluePoint(nId)==SDRGLUEPOINT_NOTFOUND) {
331  it = rPts.erase(it);
332  bChg=true;
333  }
334  else
335  ++it;
336  }
337  } else {
338  if (!rPts.empty()) {
339  rPts.clear(); // object doesn't have any glue points (any more)
340  bChg=true;
341  }
342  }
343  }
344  }
345  if (bChg) const_cast<SdrMarkView*>(this)->mbMarkedPointsRectsDirty=true;
346  const_cast<SdrMarkView*>(this)->mbMrkPntDirty=false;
347 }
348 
349 
351 {
352  bool bRet=false;
353  if (IsGluePointEditMode()) {
355  const size_t nMarkCount=GetMarkedObjectCount();
356  for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
357  const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
358  const SdrObject* pObj=pM->GetMarkedSdrObj();
359  const SdrGluePointList* pGPL=pObj->GetGluePointList();
360 
361  // #i38892#
362  if(pGPL && pGPL->GetCount())
363  {
364  for(sal_uInt16 a(0); !bRet && a < pGPL->GetCount(); a++)
365  {
366  if((*pGPL)[a].IsUserDefined())
367  {
368  bRet = true;
369  }
370  }
371  }
372  }
373  }
374  return bRet;
375 }
376 
378 {
380  bool bRet=false;
381  const size_t nMarkCount=GetMarkedObjectCount();
382  for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bRet; ++nMarkNum) {
383  const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
384  const SdrUShortCont& rPts = pM->GetMarkedGluePoints();
385  bRet = !rPts.empty();
386  }
387  return bRet;
388 }
389 
390 bool SdrMarkView::MarkGluePoints(const tools::Rectangle* pRect, bool bUnmark)
391 {
392  if (!IsGluePointEditMode() && !bUnmark) return false;
394  bool bChgd=false;
396  const size_t nMarkCount=GetMarkedObjectCount();
397  for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) {
398  SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
399  const SdrObject* pObj=pM->GetMarkedSdrObj();
400  const SdrGluePointList* pGPL=pObj->GetGluePointList();
401  SdrUShortCont& rPts = pM->GetMarkedGluePoints();
402  if (bUnmark && pRect==nullptr) { // UnmarkAll
403  if (!rPts.empty()) {
404  rPts.clear();
405  bChgd=true;
406  }
407  } else {
408  if (pGPL!=nullptr) {
409  sal_uInt16 nGluePointCnt=pGPL->GetCount();
410  for (sal_uInt16 nGPNum=0; nGPNum<nGluePointCnt; nGPNum++) {
411  const SdrGluePoint& rGP=(*pGPL)[nGPNum];
412 
413  // #i38892#
414  if(rGP.IsUserDefined())
415  {
416  Point aPos(rGP.GetAbsolutePos(*pObj));
417  if (pRect==nullptr || pRect->IsInside(aPos)) {
418  bool bContains = rPts.find( rGP.GetId() ) != rPts.end();
419  if (!bUnmark && !bContains) {
420  bChgd=true;
421  rPts.insert(rGP.GetId());
422  }
423  if (bUnmark && bContains) {
424  bChgd=true;
425  rPts.erase(rGP.GetId());
426  }
427  }
428  }
429  }
430  }
431  }
432  }
433  if (bChgd) {
434  AdjustMarkHdl();
436  }
437  return bChgd;
438 }
439 
440 bool SdrMarkView::PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV) const
441 {
442  rpObj=nullptr; rpPV=nullptr; rnId=0;
443  if (!IsGluePointEditMode()) return false;
445  if (pOut==nullptr) pOut=GetFirstOutputDevice();
446  if (pOut==nullptr) return false;
448  const size_t nMarkCount=GetMarkedObjectCount();
449  size_t nMarkNum=nMarkCount;
450  while (nMarkNum>0) {
451  nMarkNum--;
452  const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
453  SdrObject* pObj=pM->GetMarkedSdrObj();
454  SdrPageView* pPV=pM->GetPageView();
455  const SdrGluePointList* pGPL=pObj->GetGluePointList();
456  if (pGPL!=nullptr) {
457  sal_uInt16 nNum=pGPL->HitTest(rPnt,*pOut,pObj);
458  if (nNum!=SDRGLUEPOINT_NOTFOUND)
459  {
460  // #i38892#
461  const SdrGluePoint& rCandidate = (*pGPL)[nNum];
462 
463  if(rCandidate.IsUserDefined())
464  {
465  rpObj=pObj;
466  rnId=(*pGPL)[nNum].GetId();
467  rpPV=pPV;
468  return true;
469  }
470  }
471  }
472  }
473  return false;
474 }
475 
476 bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, bool bUnmark)
477 {
478  if (!IsGluePointEditMode()) return false;
480  bool bChgd=false;
481  if (pObj!=nullptr) {
482  const size_t nMarkPos=TryToFindMarkedObject(pObj);
483  if (nMarkPos!=SAL_MAX_SIZE) {
484  SdrMark* pM=GetSdrMarkByIndex(nMarkPos);
485  SdrUShortCont& rPts = pM->GetMarkedGluePoints();
486  bool bContains = rPts.find( nId ) != rPts.end();
487  if (!bUnmark && !bContains) {
488  bChgd=true;
489  rPts.insert(nId);
490  }
491  if (bUnmark && bContains) {
492  bChgd=true;
493  rPts.erase(nId);
494  }
495  } else {
496  // TODO: implement implicit selection of objects
497  }
498  }
499  if (bChgd) {
500  AdjustMarkHdl();
502  }
503  return bChgd;
504 }
505 
506 bool SdrMarkView::IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const
507 {
509  bool bRet=false;
510  const size_t nPos=TryToFindMarkedObject(pObj); // casting to NonConst
511  if (nPos!=SAL_MAX_SIZE) {
512  const SdrMark* pM=GetSdrMarkByIndex(nPos);
513  const SdrUShortCont& rPts = pM->GetMarkedGluePoints();
514  bRet = rPts.find( nId ) != rPts.end();
515  }
516  return bRet;
517 }
518 
519 SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const
520 {
522  const size_t nHdlCnt=maHdlList.GetHdlCount();
523  for (size_t nHdlNum=0; nHdlNum<nHdlCnt; ++nHdlNum) {
524  SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum);
525  if (pHdl->GetObj()==pObj &&
526  pHdl->GetKind()==SdrHdlKind::Glue &&
527  pHdl->GetObjHdlNum()==nId ) return pHdl;
528  }
529  return nullptr;
530 }
531 
533 {
536 }
537 
539 {
542  return maMarkedGluePointsRect;
543 }
544 
545 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
std::unique_ptr< SdrHdl > RemoveHdl(size_t nNum)
Definition: svdhdl.cxx:2234
const SdrUShortCont & GetMarkedGluePoints() const
Definition: svdmark.hxx:115
const_iterator lower_bound(const Value &x) const
tools::Rectangle maMarkedGluePointsRect
Definition: svdmrkv.hxx:115
virtual sal_Int32 GetMarkablePointCount() const
Definition: svdmrkv1.cxx:45
virtual void SetMarkHandles(SfxViewShell *pOtherShell)
Definition: svdmrkv.cxx:947
SVX_DLLPRIVATE void ImpSetPointsRects() const
Definition: svdmrkv1.cxx:256
void SortMarkedObjects() const
Definition: svdmrkv.hxx:259
void UndirtyMrkPnt() const
Definition: svdmrkv1.cxx:286
const SdrUShortCont & GetMarkedPoints() const
Definition: svdmark.hxx:110
virtual bool IsPolyObj() const
Definition: svdobj.cxx:1661
SdrHdlKind
Definition: svdhdl.hxx:52
bool ImpIsFrameHandles() const
Definition: svdmrkv.cxx:595
bool IsInserted() const
Definition: svdobj.hxx:793
void SetSelected(bool bJa=true)
Definition: svdhdl.cxx:353
bool mbPlusHdlAlways
Definition: svdmrkv.hxx:125
const tools::Rectangle & GetMarkedGluePointsRect() const
Definition: svdmrkv1.cxx:538
sal_Int16 nId
const_iterator find(const Value &x) const
SdrObject * GetObj() const
Definition: svdhdl.hxx:203
const Point & GetPos() const
Definition: svdhdl.hxx:197
bool HasMarkedGluePoints() const
Definition: svdmrkv1.cxx:377
bool HasMarkableGluePoints() const
Definition: svdmrkv1.cxx:350
size_t TryToFindMarkedObject(const SdrObject *pObj) const
Definition: svdmrkv.hxx:254
virtual sal_uInt32 GetPointCount() const
Definition: svdobj.cxx:1666
sal_uInt16 GetCount() const
Definition: svdglue.hxx:125
bool MarkGluePoints(const tools::Rectangle *pRect, bool bUnmark)
Definition: svdmrkv1.cxx:390
virtual void AddToPlusHdlList(SdrHdlList &rHdlList, SdrHdl &rHdl) const
Definition: svdobj.cxx:1189
virtual void MarkListHasChanged()
Definition: svdmrkv.cxx:2484
sal_uInt16 GetId() const
Definition: svdglue.hxx:86
bool MarkGluePoint(const SdrObject *pObj, sal_uInt16 nId, bool bUnmark)
Definition: svdmrkv1.cxx:476
sal_uInt16 HitTest(const Point &rPnt, const OutputDevice &rOut, const SdrObject *pObj) const
Definition: svdglue.cxx:344
void MarkNextPoint()
Definition: svdmrkv1.cxx:229
int nCount
void SetPlusHandlesAlwaysVisible(bool bOn)
Definition: svdmrkv1.cxx:242
oslFileHandle & pOut
void ForceUndirtyMrkPnt() const
Definition: svdmrkv.hxx:167
OutputDevice * GetFirstOutputDevice() const
Definition: svdpntv.cxx:87
virtual bool HasMarkedPoints() const
Definition: svdmrkv1.cxx:64
void Sort()
Definition: svdhdl.cxx:2257
SdrObject * GetMarkedSdrObj() const
Definition: svdmark.hxx:68
Everything a View needs to know about a selected object.
Definition: svdmark.hxx:44
bool mbMrkPntDirty
Definition: svdmrkv.hxx:128
void MarkNextGluePoint()
Definition: svdmrkv1.cxx:532
virtual const SdrGluePointList * GetGluePointList() const
Definition: svdobj.cxx:2204
void SetObj(SdrObject *pNewObj)
Definition: svdhdl.cxx:377
int i
uno_Any a
#define SDRGLUEPOINT_NOTFOUND
Definition: svdglue.hxx:116
void MoveTo(SdrHdlList &rOther)
Definition: svdhdl.cxx:2327
size_t GetMarkedObjectCount() const
Definition: svdmrkv.hxx:258
bool IsSelected() const
Definition: svdhdl.hxx:206
bool MarkPointHelper(SdrHdl *pHdl, SdrMark *pMark, bool bUnmark)
should only be used from outside svx for special ui elements
Definition: svdmrkv1.cxx:86
SdrPageView * GetPageView() const
Definition: svdmark.hxx:70
bool IsGluePointEditMode() const
Definition: svdmrkv.hxx:233
bool ImpMarkPoint(SdrHdl *pHdl, SdrMark *pMark, bool bUnmark)
Definition: svdmrkv1.cxx:91
bool IsInside(const Point &rPOINT) const
SdrPageView * GetPageView() const
Definition: svdhdl.hxx:200
static constexpr sal_uInt16 mnFrameHandlesLimit
Definition: svdmrkv.hxx:117
const_iterator end() const
bool empty() const
Abstract DrawObject.
Definition: svdobj.hxx:312
bool PickGluePoint(const Point &rPnt, SdrObject *&rpObj, sal_uInt16 &rnId, SdrPageView *&rpPV) const
Definition: svdmrkv1.cxx:440
Point GetAbsolutePos(const SdrObject &rObj) const
Definition: svdglue.cxx:47
sal_uInt16 FindGluePoint(sal_uInt16 nId) const
Definition: svdglue.cxx:331
const_iterator begin() const
size_t GetHdlCount() const
Definition: svdhdl.hxx:461
SdrHdl * GetHdl(size_t nNum) const
Definition: svdhdl.hxx:462
bool mbMarkedPointsRectsDirty
Definition: svdmrkv.hxx:129
sal_uInt32 GetObjHdlNum() const
Definition: svdhdl.hxx:216
void SetPageView(SdrPageView *pNewPV)
Definition: svdhdl.hxx:201
void AdjustMarkHdl(SfxViewShell *pOtherShell=nullptr)
Definition: svdmrkv.cxx:2390
bool IsPlusHdl() const
Definition: svdhdl.hxx:225
SdrHdl * GetGluePointHdl(const SdrObject *pObj, sal_uInt16 nId) const
Definition: svdmrkv1.cxx:519
virtual bool MarkPoints(const tools::Rectangle *pRect, bool bUnmark)
Definition: svdmrkv1.cxx:185
tools::Rectangle maMarkedPointsRect
Definition: svdmrkv.hxx:114
void SetPlusHdl(bool bOn)
Definition: svdhdl.hxx:224
const tools::Rectangle & GetMarkedPointsRect() const
Definition: svdmrkv1.cxx:235
bool IsGluePointMarked(const SdrObject *pObj, sal_uInt16 nId) const
Definition: svdmrkv1.cxx:506
OutputDevice * get() const
SdrHdlList maHdlList
Definition: svdmrkv.hxx:108
bool IsUserDefined() const
Definition: svdglue.hxx:94
SdrMark * GetSdrMarkByIndex(size_t nNum) const
Definition: svdmrkv.hxx:256
bool IsPointMarkable(const SdrHdl &rHdl) const
Definition: svdmrkv1.cxx:81
virtual bool MarkPoint(SdrHdl &rHdl, bool bUnmark=false)
Definition: svdmrkv1.cxx:166
std::pair< const_iterator, bool > insert(Value &&x)
sal_uInt32 GetSourceHdlNum() const
Definition: svdhdl.hxx:228
VclPtr< OutputDevice > mpActualOutDev
Definition: svdpntv.hxx:127
sal_uInt16 nPos
std::vector< sal_uInt16 >::const_iterator const_iterator
SdrHdlKind GetKind() const
Definition: svdhdl.hxx:194
size_type erase(const Value &x)
virtual bool HasMarkablePoints() const
Definition: svdmrkv1.cxx:28