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 : sal_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 22 : sal_Bool SdrMarkView::HasMarkedPoints() const
70 : {
71 22 : ForceUndirtyMrkPnt();
72 22 : sal_Bool bRet=sal_False;
73 22 : if (!ImpIsFrameHandles()) {
74 10 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
75 10 : if (nMarkAnz<=nFrameHandlesLimit) {
76 20 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
77 10 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
78 10 : const SdrUShortCont* pPts=pM->GetMarkedPoints();
79 10 : bRet=pPts!=NULL && !pPts->empty();
80 : }
81 : }
82 : }
83 22 : 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 : sal_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 : sal_Bool SdrMarkView::MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark)
109 : {
110 0 : return ImpMarkPoint( pHdl, pMark, bUnmark );
111 : }
112 :
113 0 : sal_Bool SdrMarkView::ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark)
114 : {
115 0 : if (pHdl==NULL || pHdl->IsPlusHdl() || pHdl->GetKind()==HDL_GLUE)
116 0 : return sal_False;
117 :
118 0 : if (pHdl->IsSelected() != bUnmark)
119 0 : return sal_False;
120 :
121 0 : SdrObject* pObj=pHdl->GetObj();
122 0 : if (pObj==NULL || !pObj->IsPolyObj())
123 0 : return sal_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 sal_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 sal_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(sal_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 sal_True;
187 : }
188 :
189 :
190 0 : sal_Bool SdrMarkView::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark)
191 : {
192 0 : if (&rHdl==NULL) return sal_False;
193 0 : ForceUndirtyMrkPnt();
194 0 : sal_Bool bRet=sal_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=sal_True;
204 : }
205 : }
206 : }
207 :
208 0 : return bRet;
209 : }
210 :
211 0 : sal_Bool SdrMarkView::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark)
212 : {
213 0 : ForceUndirtyMrkPnt();
214 0 : sal_Bool bChgd=sal_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=sal_True;
246 : }
247 : }
248 : }
249 0 : if (bChgd) {
250 0 : MarkListHasChanged();
251 : }
252 :
253 0 : return bChgd;
254 : }
255 :
256 0 : sal_Bool SdrMarkView::MarkNextPoint(const Point& /*rPnt*/, sal_Bool /*bPrev*/)
257 : {
258 0 : ForceUndirtyMrkPnt();
259 0 : sal_Bool bChgd=sal_False;
260 0 : SortMarkedObjects();
261 : // ...
262 0 : if (bChgd) {
263 0 : MarkListHasChanged();
264 : }
265 0 : return bChgd;
266 : }
267 :
268 0 : const Rectangle& SdrMarkView::GetMarkedPointsRect() const
269 : {
270 0 : ForceUndirtyMrkPnt();
271 0 : if (bMarkedPointsRectsDirty) ImpSetPointsRects();
272 0 : return aMarkedPointsRect;
273 : }
274 :
275 9 : void SdrMarkView::SetPlusHandlesAlwaysVisible(sal_Bool bOn)
276 : { // TODO: Optimize HandlePaint!
277 9 : ForceUndirtyMrkPnt();
278 9 : if (bOn!=bPlusHdlAlways) {
279 0 : bPlusHdlAlways=bOn;
280 0 : SetMarkHandles();
281 0 : MarkListHasChanged();
282 : }
283 9 : }
284 :
285 : ////////////////////////////////////////////////////////////////////////////////////////////////////
286 : // ImpSetPointsRects() is for PolyPoints and GluePoints!
287 : ////////////////////////////////////////////////////////////////////////////////////////////////////
288 :
289 0 : void SdrMarkView::ImpSetPointsRects() const
290 : {
291 0 : Rectangle aPnts;
292 0 : Rectangle aGlue;
293 0 : sal_uIntPtr nHdlAnz=aHdl.GetHdlCount();
294 0 : for (sal_uIntPtr nHdlNum=0; nHdlNum<nHdlAnz; nHdlNum++) {
295 0 : const SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
296 0 : SdrHdlKind eKind=pHdl->GetKind();
297 0 : if ((eKind==HDL_POLY && pHdl->IsSelected()) || eKind==HDL_GLUE) {
298 0 : Point aPt(pHdl->GetPos());
299 0 : Rectangle& rR=eKind==HDL_GLUE ? aGlue : aPnts;
300 0 : if (rR.IsEmpty()) {
301 0 : rR=Rectangle(aPt,aPt);
302 : } else {
303 0 : if (aPt.X()<rR.Left ()) rR.Left ()=aPt.X();
304 0 : if (aPt.X()>rR.Right ()) rR.Right ()=aPt.X();
305 0 : if (aPt.Y()<rR.Top ()) rR.Top ()=aPt.Y();
306 0 : if (aPt.Y()>rR.Bottom()) rR.Bottom()=aPt.Y();
307 : }
308 : }
309 : }
310 0 : ((SdrMarkView*)this)->aMarkedPointsRect=aPnts;
311 0 : ((SdrMarkView*)this)->aMarkedGluePointsRect=aGlue;
312 0 : ((SdrMarkView*)this)->bMarkedPointsRectsDirty=sal_False;
313 0 : }
314 :
315 : ////////////////////////////////////////////////////////////////////////////////////////////////////
316 : // UndirtyMrkPnt() is for PolyPoints and GluePoints!
317 : ////////////////////////////////////////////////////////////////////////////////////////////////////
318 :
319 182 : void SdrMarkView::UndirtyMrkPnt() const
320 : {
321 182 : sal_Bool bChg=sal_False;
322 182 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
323 182 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
324 0 : SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
325 0 : const SdrObject* pObj=pM->GetMarkedSdrObj();
326 : // PolyPoints
327 0 : SdrUShortCont* pPts=pM->GetMarkedPoints();
328 0 : if (pPts!=NULL) {
329 0 : if (pObj->IsPolyObj()) {
330 : // Remove invalid selected points, that is, all
331 : // entries above the number of points in the object.
332 0 : sal_uInt32 nMax(pObj->GetPointCount());
333 :
334 0 : SdrUShortCont::const_iterator it = pPts->lower_bound(nMax);
335 0 : if( it != pPts->end() )
336 : {
337 0 : pPts->erase(it, pPts->end() );
338 0 : bChg = sal_True;
339 : }
340 : }
341 : else
342 : {
343 : OSL_FAIL("SdrMarkView::UndirtyMrkPnt(): Selected points on an object that is not a PolyObj!");
344 0 : if(pPts && !pPts->empty())
345 : {
346 0 : pPts->clear();
347 0 : bChg = sal_True;
348 : }
349 : }
350 : }
351 :
352 : // GluePoints
353 0 : pPts=pM->GetMarkedGluePoints();
354 0 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
355 0 : if (pPts!=NULL) {
356 0 : if (pGPL!=NULL) {
357 : // Remove invalid selected glue points, that is, all entries
358 : // (IDs) that aren't contained in the GluePointList of the
359 : // object
360 0 : for(SdrUShortCont::const_iterator it = pPts->begin(); it != pPts->end(); )
361 : {
362 0 : sal_uInt16 nId=*it;
363 0 : if (pGPL->FindGluePoint(nId)==SDRGLUEPOINT_NOTFOUND) {
364 0 : pPts->erase(it++);
365 0 : bChg=sal_True;
366 : }
367 : else
368 0 : ++it;
369 : }
370 : } else {
371 0 : if (pPts!=NULL && !pPts->empty()) {
372 0 : pPts->clear(); // object doesn't have any glue points (any more)
373 0 : bChg=sal_True;
374 : }
375 : }
376 : }
377 : }
378 182 : if (bChg) ((SdrMarkView*)this)->bMarkedPointsRectsDirty=sal_True;
379 182 : ((SdrMarkView*)this)->bMrkPntDirty=sal_False;
380 182 : }
381 :
382 : ////////////////////////////////////////////////////////////////////////////////////////////////////
383 :
384 0 : sal_Bool SdrMarkView::HasMarkableGluePoints() const
385 : {
386 0 : sal_Bool bRet=sal_False;
387 0 : if (IsGluePointEditMode()) {
388 0 : ForceUndirtyMrkPnt();
389 0 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
390 0 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
391 0 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
392 0 : const SdrObject* pObj=pM->GetMarkedSdrObj();
393 0 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
394 :
395 : // #i38892#
396 0 : if(pGPL && pGPL->GetCount())
397 : {
398 0 : for(sal_uInt16 a(0); !bRet && a < pGPL->GetCount(); a++)
399 : {
400 0 : if((*pGPL)[a].IsUserDefined())
401 : {
402 0 : bRet = sal_True;
403 : }
404 : }
405 : }
406 : }
407 : }
408 0 : return bRet;
409 : }
410 :
411 22 : sal_Bool SdrMarkView::HasMarkedGluePoints() const
412 : {
413 22 : ForceUndirtyMrkPnt();
414 22 : sal_Bool bRet=sal_False;
415 22 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
416 35 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bRet; nMarkNum++) {
417 13 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
418 13 : const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
419 13 : bRet=pPts!=NULL && !pPts->empty();
420 : }
421 22 : return bRet;
422 : }
423 :
424 0 : sal_Bool SdrMarkView::MarkGluePoints(const Rectangle* pRect, sal_Bool bUnmark)
425 : {
426 0 : if (!IsGluePointEditMode() && !bUnmark) return sal_False;
427 0 : ForceUndirtyMrkPnt();
428 0 : sal_Bool bChgd=sal_False;
429 0 : SortMarkedObjects();
430 0 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
431 0 : for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) {
432 0 : SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
433 0 : const SdrObject* pObj=pM->GetMarkedSdrObj();
434 0 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
435 0 : SdrUShortCont* pPts=pM->GetMarkedGluePoints();
436 0 : if (bUnmark && pRect==NULL) { // UnmarkAll
437 0 : if (pPts!=NULL && !pPts->empty()) {
438 0 : pPts->clear();
439 0 : bChgd=sal_True;
440 : }
441 : } else {
442 0 : if (pGPL!=NULL && (pPts!=NULL || !bUnmark)) {
443 0 : sal_uInt16 nGPAnz=pGPL->GetCount();
444 0 : for (sal_uInt16 nGPNum=0; nGPNum<nGPAnz; nGPNum++) {
445 0 : const SdrGluePoint& rGP=(*pGPL)[nGPNum];
446 :
447 : // #i38892#
448 0 : if(rGP.IsUserDefined())
449 : {
450 0 : Point aPos(rGP.GetAbsolutePos(*pObj));
451 0 : if (pRect==NULL || pRect->IsInside(aPos)) {
452 0 : if (pPts==NULL)
453 0 : pPts=pM->ForceMarkedGluePoints();
454 0 : bool bContains = pPts->find( rGP.GetId() ) != pPts->end();
455 0 : if (!bUnmark && !bContains) {
456 0 : bChgd=sal_True;
457 0 : pPts->insert(rGP.GetId());
458 : }
459 0 : if (bUnmark && bContains) {
460 0 : bChgd=sal_True;
461 0 : pPts->erase(rGP.GetId());
462 : }
463 : }
464 : }
465 : }
466 : }
467 : }
468 : }
469 0 : if (bChgd) {
470 0 : AdjustMarkHdl();
471 0 : MarkListHasChanged();
472 : }
473 0 : return bChgd;
474 : }
475 :
476 0 : sal_Bool SdrMarkView::PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, sal_uIntPtr nOptions) const
477 : {
478 0 : SdrObject* pObj0=rpObj;
479 0 : sal_uInt16 nId0=rnId;
480 0 : rpObj=NULL; rpPV=NULL; rnId=0;
481 0 : if (!IsGluePointEditMode()) return sal_False;
482 0 : sal_Bool bBack=(nOptions & SDRSEARCH_BACKWARD) !=0;
483 0 : sal_Bool bNext=(nOptions & SDRSEARCH_NEXT) !=0;
484 0 : OutputDevice* pOut=(OutputDevice*)pActualOutDev;
485 0 : if (pOut==NULL) pOut=GetFirstOutputDevice();
486 0 : if (pOut==NULL) return sal_False;
487 0 : SortMarkedObjects();
488 0 : sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
489 0 : sal_uIntPtr nMarkNum=bBack ? 0 : nMarkAnz;
490 0 : if (bNext) {
491 0 : nMarkNum=((SdrMarkView*)this)->TryToFindMarkedObject(pObj0);
492 0 : if (nMarkNum==CONTAINER_ENTRY_NOTFOUND) return sal_False;
493 0 : if (!bBack) nMarkNum++;
494 : }
495 0 : while (bBack ? nMarkNum<nMarkAnz : nMarkNum>0) {
496 0 : if (!bBack) nMarkNum--;
497 0 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
498 0 : SdrObject* pObj=pM->GetMarkedSdrObj();
499 0 : SdrPageView* pPV=pM->GetPageView();
500 0 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
501 0 : if (pGPL!=NULL) {
502 0 : sal_uInt16 nNum=pGPL->HitTest(rPnt,*pOut,pObj,bBack,bNext,nId0);
503 0 : if (nNum!=SDRGLUEPOINT_NOTFOUND)
504 : {
505 : // #i38892#
506 0 : const SdrGluePoint& rCandidate = (*pGPL)[nNum];
507 :
508 0 : if(rCandidate.IsUserDefined())
509 : {
510 0 : rpObj=pObj;
511 0 : rnId=(*pGPL)[nNum].GetId();
512 0 : rpPV=pPV;
513 0 : return sal_True;
514 : }
515 : }
516 : }
517 0 : bNext=sal_False; // HitNextGluePoint only for the first Obj
518 0 : if (bBack) nMarkNum++;
519 : }
520 0 : return sal_False;
521 : }
522 :
523 0 : sal_Bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* /*pPV*/, sal_Bool bUnmark)
524 : {
525 0 : if (!IsGluePointEditMode()) return sal_False;
526 0 : ForceUndirtyMrkPnt();
527 0 : sal_Bool bChgd=sal_False;
528 0 : if (pObj!=NULL) {
529 0 : sal_uIntPtr nMarkPos=TryToFindMarkedObject(pObj);
530 0 : if (nMarkPos!=CONTAINER_ENTRY_NOTFOUND) {
531 0 : SdrMark* pM=GetSdrMarkByIndex(nMarkPos);
532 0 : SdrUShortCont* pPts=bUnmark ? pM->GetMarkedGluePoints() : pM->ForceMarkedGluePoints();
533 0 : if (pPts!=NULL) {
534 0 : bool bContains = pPts->find( nId ) != pPts->end();
535 0 : if (!bUnmark && !bContains) {
536 0 : bChgd=sal_True;
537 0 : pPts->insert(nId);
538 : }
539 0 : if (bUnmark && bContains) {
540 0 : bChgd=sal_True;
541 0 : pPts->erase(nId);
542 : }
543 : }
544 : } else {
545 : // TODO: implement implicit selection of objects
546 : }
547 : }
548 0 : if (bChgd) {
549 0 : AdjustMarkHdl();
550 0 : MarkListHasChanged();
551 : }
552 0 : return bChgd;
553 : }
554 :
555 0 : sal_Bool SdrMarkView::IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const
556 : {
557 0 : ForceUndirtyMrkPnt();
558 0 : sal_Bool bRet=sal_False;
559 0 : sal_uIntPtr nPos=((SdrMarkView*)this)->TryToFindMarkedObject(pObj); // casting to NonConst
560 0 : if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
561 0 : const SdrMark* pM=GetSdrMarkByIndex(nPos);
562 0 : const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
563 0 : if (pPts!=NULL) {
564 0 : bRet = pPts->find( nId ) != pPts->end();
565 : }
566 : }
567 0 : return bRet;
568 : }
569 :
570 0 : SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const
571 : {
572 0 : ForceUndirtyMrkPnt();
573 0 : sal_uIntPtr nHdlAnz=aHdl.GetHdlCount();
574 0 : for (sal_uIntPtr nHdlNum=0; nHdlNum<nHdlAnz; nHdlNum++) {
575 0 : SdrHdl* pHdl=aHdl.GetHdl(nHdlNum);
576 0 : if (pHdl->GetObj()==pObj &&
577 0 : pHdl->GetKind()==HDL_GLUE &&
578 0 : pHdl->GetObjHdlNum()==nId ) return pHdl;
579 : }
580 0 : return NULL;
581 : }
582 :
583 0 : sal_Bool SdrMarkView::MarkNextGluePoint(const Point& /*rPnt*/, sal_Bool /*bPrev*/)
584 : {
585 0 : ForceUndirtyMrkPnt();
586 0 : sal_Bool bChgd=sal_False;
587 0 : SortMarkedObjects();
588 : // ...
589 0 : if (bChgd) {
590 0 : MarkListHasChanged();
591 : }
592 0 : return bChgd;
593 : }
594 :
595 0 : const Rectangle& SdrMarkView::GetMarkedGluePointsRect() const
596 : {
597 0 : ForceUndirtyMrkPnt();
598 0 : if (bMarkedPointsRectsDirty) ImpSetPointsRects();
599 0 : return aMarkedGluePointsRect;
600 : }
601 :
602 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
