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 2252 : bool SdrMarkView::HasMarkablePoints() const
34 : {
35 2252 : ForceUndirtyMrkPnt();
36 2252 : bool bRet=false;
37 2252 : if (!ImpIsFrameHandles()) {
38 2 : const size_t nMarkAnz=GetMarkedObjectCount();
39 2 : if (nMarkAnz<=static_cast<size_t>(nFrameHandlesLimit)) {
40 4 : for (size_t nMarkNum=0; nMarkNum<nMarkAnz && !bRet; ++nMarkNum) {
41 2 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
42 2 : const SdrObject* pObj=pM->GetMarkedSdrObj();
43 2 : bRet=pObj->IsPolyObj();
44 : }
45 : }
46 : }
47 2252 : 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 : const size_t nMarkAnz=GetMarkedObjectCount();
56 0 : if (nMarkAnz<=static_cast<size_t>(nFrameHandlesLimit)) {
57 0 : for (size_t 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 3018 : bool SdrMarkView::HasMarkedPoints() const
70 : {
71 3018 : ForceUndirtyMrkPnt();
72 3018 : bool bRet=false;
73 3018 : if (!ImpIsFrameHandles()) {
74 688 : const size_t nMarkAnz=GetMarkedObjectCount();
75 688 : if (nMarkAnz<=static_cast<size_t>(nFrameHandlesLimit)) {
76 1148 : for (size_t nMarkNum=0; nMarkNum<nMarkAnz && !bRet; ++nMarkNum) {
77 460 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
78 460 : const SdrUShortCont* pPts=pM->GetMarkedPoints();
79 460 : bRet=pPts!=NULL && !pPts->empty();
80 : }
81 : }
82 : }
83 3018 : 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 : size_t nMarkAnz=GetMarkedObjectCount();
92 0 : if (nMarkAnz<=static_cast<size_t>(nFrameHandlesLimit)) {
93 0 : for (size_t 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 16 : bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const
104 : {
105 16 : 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 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 (size_t 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 : 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 212 : bool SdrMarkView::MarkPoints(const Rectangle* pRect, bool bUnmark)
211 : {
212 212 : ForceUndirtyMrkPnt();
213 212 : bool bChgd=false;
214 212 : SortMarkedObjects();
215 212 : const SdrObject* pObj0=NULL;
216 212 : const SdrPageView* pPV0=NULL;
217 212 : SdrMark* pM=NULL;
218 212 : aHdl.Sort();
219 212 : const size_t nHdlAnz=aHdl.GetHdlCount();
220 440 : for (size_t nHdlNum=nHdlAnz; nHdlNum>0;) {
221 16 : --nHdlNum;
222 16 : SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
223 16 : 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 212 : if (bChgd) {
249 0 : MarkListHasChanged();
250 : }
251 :
252 212 : 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 1948 : void SdrMarkView::SetPlusHandlesAlwaysVisible(bool bOn)
270 : { // TODO: Optimize HandlePaint!
271 1948 : ForceUndirtyMrkPnt();
272 1948 : if (bOn!=bPlusHdlAlways) {
273 0 : bPlusHdlAlways=bOn;
274 0 : SetMarkHandles();
275 0 : MarkListHasChanged();
276 : }
277 1948 : }
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=aHdl.GetHdlCount();
288 0 : for (size_t nHdlNum=0; nHdlNum<nHdlAnz; ++nHdlNum) {
289 0 : const SdrHdl* pHdl=aHdl.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 : ((SdrMarkView*)this)->aMarkedPointsRect=aPnts;
305 0 : ((SdrMarkView*)this)->aMarkedGluePointsRect=aGlue;
306 0 : ((SdrMarkView*)this)->bMarkedPointsRectsDirty=false;
307 0 : }
308 :
309 :
310 : // UndirtyMrkPnt() is for PolyPoints and GluePoints!
311 :
312 :
313 8129 : void SdrMarkView::UndirtyMrkPnt() const
314 : {
315 8129 : bool bChg=false;
316 8129 : const size_t nMarkAnz=GetMarkedObjectCount();
317 8204 : for (size_t nMarkNum=0; nMarkNum<nMarkAnz; ++nMarkNum) {
318 75 : SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
319 75 : const SdrObject* pObj=pM->GetMarkedSdrObj();
320 : // PolyPoints
321 75 : SdrUShortCont* pPts=pM->GetMarkedPoints();
322 75 : 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 75 : pPts=pM->GetMarkedGluePoints();
348 75 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
349 75 : 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 : 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 8129 : if (bChg) ((SdrMarkView*)this)->bMarkedPointsRectsDirty=true;
373 8129 : ((SdrMarkView*)this)->bMrkPntDirty=false;
374 8129 : }
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 nMarkAnz=GetMarkedObjectCount();
384 0 : for (size_t nMarkNum=0; nMarkNum<nMarkAnz && !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 3018 : bool SdrMarkView::HasMarkedGluePoints() const
406 : {
407 3018 : ForceUndirtyMrkPnt();
408 3018 : bool bRet=false;
409 3018 : const size_t nMarkAnz=GetMarkedObjectCount();
410 3540 : for (size_t nMarkNum=0; nMarkNum<nMarkAnz && !bRet; ++nMarkNum) {
411 522 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
412 522 : const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
413 522 : bRet=pPts!=NULL && !pPts->empty();
414 : }
415 3018 : 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 nMarkAnz=GetMarkedObjectCount();
425 0 : for (size_t nMarkNum=0; nMarkNum<nMarkAnz; ++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, sal_uIntPtr 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 & SDRSEARCH_BACKWARD) !=0;
477 0 : bool bNext=(nOptions & SDRSEARCH_NEXT) !=0;
478 0 : OutputDevice* pOut=(OutputDevice*)pActualOutDev;
479 0 : if (pOut==NULL) pOut=GetFirstOutputDevice();
480 0 : if (pOut==NULL) return false;
481 0 : SortMarkedObjects();
482 0 : const size_t nMarkAnz=GetMarkedObjectCount();
483 0 : size_t nMarkNum=bBack ? 0 : nMarkAnz;
484 0 : if (bNext) {
485 0 : nMarkNum=((SdrMarkView*)this)->TryToFindMarkedObject(pObj0);
486 0 : if (nMarkNum==SAL_MAX_SIZE) return false;
487 0 : if (!bBack) nMarkNum++;
488 : }
489 0 : while (bBack ? nMarkNum<nMarkAnz : 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=((SdrMarkView*)this)->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=aHdl.GetHdlCount();
568 0 : for (size_t nHdlNum=0; nHdlNum<nHdlAnz; ++nHdlNum) {
569 0 : SdrHdl* pHdl=aHdl.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 651 : }
590 :
591 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
