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