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 776 : bool SdrMarkView::HasMarkablePoints() const
34 : {
35 776 : ForceUndirtyMrkPnt();
36 776 : bool bRet=false;
37 776 : 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 776 : 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 1477 : bool SdrMarkView::HasMarkedPoints() const
70 : {
71 1477 : ForceUndirtyMrkPnt();
72 1477 : bool bRet=false;
73 1477 : if (!ImpIsFrameHandles()) {
74 502 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
75 502 : if (nMarkAnz<=nFrameHandlesLimit) {
76 638 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
77 136 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
78 136 : const SdrUShortCont* pPts=pM->GetMarkedPoints();
79 136 : bRet=pPts!=NULL && !pPts->empty();
80 : }
81 : }
82 : }
83 1477 : 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 8 : bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const
104 : {
105 8 : 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 73 : bool SdrMarkView::MarkPoints(const Rectangle* pRect, bool bUnmark)
212 : {
213 73 : ForceUndirtyMrkPnt();
214 73 : bool bChgd=false;
215 73 : SortMarkedObjects();
216 73 : const SdrObject* pObj0=NULL;
217 73 : const SdrPageView* pPV0=NULL;
218 73 : SdrMark* pM=NULL;
219 73 : aHdl.Sort();
220 73 : sal_uIntPtr nHdlAnz=aHdl.GetHdlCount();
221 154 : for (sal_uIntPtr nHdlNum=nHdlAnz; nHdlNum>0;) {
222 8 : nHdlNum--;
223 8 : SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
224 8 : 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 73 : if (bChgd) {
250 0 : MarkListHasChanged();
251 : }
252 :
253 73 : 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 712 : void SdrMarkView::SetPlusHandlesAlwaysVisible(bool bOn)
271 : { // TODO: Optimize HandlePaint!
272 712 : ForceUndirtyMrkPnt();
273 712 : if (bOn!=bPlusHdlAlways) {
274 0 : bPlusHdlAlways=bOn;
275 0 : SetMarkHandles();
276 0 : MarkListHasChanged();
277 : }
278 712 : }
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 3462 : void SdrMarkView::UndirtyMrkPnt() const
315 : {
316 3462 : bool bChg=false;
317 3462 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
318 3511 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
319 49 : SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
320 49 : const SdrObject* pObj=pM->GetMarkedSdrObj();
321 : // PolyPoints
322 49 : SdrUShortCont* pPts=pM->GetMarkedPoints();
323 49 : 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 49 : pPts=pM->GetMarkedGluePoints();
349 49 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
350 49 : 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 3462 : if (bChg) ((SdrMarkView*)this)->bMarkedPointsRectsDirty=true;
374 3462 : ((SdrMarkView*)this)->bMrkPntDirty=false;
375 3462 : }
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 1476 : bool SdrMarkView::HasMarkedGluePoints() const
407 : {
408 1476 : ForceUndirtyMrkPnt();
409 1476 : bool bRet=false;
410 1476 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
411 1640 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
412 164 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
413 164 : const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
414 164 : bRet=pPts!=NULL && !pPts->empty();
415 : }
416 1476 : 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: */
|
