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 :
22 :
23 : #include <svx/svdmark.hxx>
24 : #include <svx/svdetc.hxx>
25 : #include <svx/svdobj.hxx>
26 : #include <svx/svdpage.hxx>
27 : #include "svx/svditer.hxx"
28 : #include <svx/svdpagv.hxx>
29 : #include <svx/svdopath.hxx>
30 : #include <svx/svdogrp.hxx>
31 : #include <svx/svdorect.hxx>
32 : #include "svx/svdstr.hrc"
33 : #include "svdglob.hxx"
34 :
35 :
36 : #include <svx/obj3d.hxx>
37 : #include <svx/scene3d.hxx>
38 : #include <svl/SfxBroadcaster.hxx>
39 : #include <svx/svdoedge.hxx>
40 :
41 :
42 :
43 :
44 618 : SdrMark::SdrMark(SdrObject* pNewObj, SdrPageView* pNewPageView)
45 : : mpSelectedSdrObject(pNewObj),
46 : mpPageView(pNewPageView),
47 : mpPoints(0L),
48 : mpLines(0L),
49 : mpGluePoints(0L),
50 : mbCon1(false),
51 : mbCon2(false),
52 618 : mnUser(0)
53 : {
54 618 : if(mpSelectedSdrObject)
55 : {
56 618 : mpSelectedSdrObject->AddObjectUser( *this );
57 : }
58 618 : }
59 :
60 678 : SdrMark::SdrMark(const SdrMark& rMark)
61 : : ObjectUser(),
62 : mpSelectedSdrObject(0L),
63 : mpPageView(0L),
64 : mpPoints(0L),
65 : mpLines(0L),
66 : mpGluePoints(0L),
67 : mbCon1(false),
68 : mbCon2(false),
69 678 : mnUser(0)
70 : {
71 678 : *this = rMark;
72 678 : }
73 :
74 3267 : SdrMark::~SdrMark()
75 : {
76 1295 : if(mpSelectedSdrObject)
77 : {
78 1294 : mpSelectedSdrObject->RemoveObjectUser( *this );
79 : }
80 :
81 1295 : if(mpPoints)
82 : {
83 0 : delete mpPoints;
84 : }
85 :
86 1295 : if(mpLines)
87 : {
88 0 : delete mpLines;
89 : }
90 :
91 1295 : if(mpGluePoints)
92 : {
93 0 : delete mpGluePoints;
94 : }
95 1972 : }
96 :
97 1 : void SdrMark::ObjectInDestruction(const SdrObject& rObject)
98 : {
99 : (void) rObject; // avoid warnings
100 : OSL_ENSURE(mpSelectedSdrObject && mpSelectedSdrObject == &rObject, "SdrMark::ObjectInDestruction: called form object different from hosted one (!)");
101 : OSL_ENSURE(mpSelectedSdrObject, "SdrMark::ObjectInDestruction: still selected SdrObject is deleted, deselect first (!)");
102 1 : mpSelectedSdrObject = 0L;
103 1 : }
104 :
105 678 : void SdrMark::SetMarkedSdrObj(SdrObject* pNewObj)
106 : {
107 678 : if(mpSelectedSdrObject)
108 : {
109 0 : mpSelectedSdrObject->RemoveObjectUser( *this );
110 : }
111 :
112 678 : mpSelectedSdrObject = pNewObj;
113 :
114 678 : if(mpSelectedSdrObject)
115 : {
116 678 : mpSelectedSdrObject->AddObjectUser( *this );
117 : }
118 678 : }
119 :
120 :
121 678 : SdrMark& SdrMark::operator=(const SdrMark& rMark)
122 : {
123 678 : SetMarkedSdrObj(rMark.mpSelectedSdrObject);
124 678 : mpPageView = rMark.mpPageView;
125 678 : mbCon1 = rMark.mbCon1;
126 678 : mbCon2 = rMark.mbCon2;
127 678 : mnUser = rMark.mnUser;
128 :
129 678 : if(!rMark.mpPoints)
130 : {
131 678 : if(mpPoints)
132 : {
133 0 : delete mpPoints;
134 0 : mpPoints = 0L;
135 : }
136 : }
137 : else
138 : {
139 0 : if(!mpPoints)
140 : {
141 0 : mpPoints = new SdrUShortCont(*rMark.mpPoints);
142 : }
143 : else
144 : {
145 0 : *mpPoints = *rMark.mpPoints;
146 : }
147 : }
148 :
149 678 : if(!rMark.mpLines)
150 : {
151 678 : if(mpLines)
152 : {
153 0 : delete mpLines;
154 0 : mpLines = 0L;
155 : }
156 : }
157 : else
158 : {
159 0 : if(!mpLines)
160 : {
161 0 : mpLines = new SdrUShortCont(*rMark.mpLines);
162 : }
163 : else
164 : {
165 0 : *mpLines = *rMark.mpLines;
166 : }
167 : }
168 :
169 678 : if(!rMark.mpGluePoints)
170 : {
171 678 : if(mpGluePoints)
172 : {
173 0 : delete mpGluePoints;
174 0 : mpGluePoints = 0L;
175 : }
176 : }
177 : else
178 : {
179 0 : if(!mpGluePoints)
180 : {
181 0 : mpGluePoints = new SdrUShortCont(*rMark.mpGluePoints);
182 : }
183 : else
184 : {
185 0 : *mpGluePoints = *rMark.mpGluePoints;
186 : }
187 : }
188 :
189 678 : return *this;
190 : }
191 :
192 0 : bool SdrMark::operator==(const SdrMark& rMark) const
193 : {
194 0 : bool bRet(mpSelectedSdrObject == rMark.mpSelectedSdrObject && mpPageView == rMark.mpPageView && mbCon1 == rMark.mbCon1 && mbCon2 == rMark.mbCon2 && mnUser == rMark.mnUser);
195 :
196 0 : if((mpPoints != 0L) != (rMark.mpPoints != 0L))
197 0 : bRet = false;
198 :
199 0 : if((mpLines != 0L) != (rMark.mpLines != 0L))
200 0 : bRet = false;
201 :
202 0 : if((mpGluePoints != 0L) != (rMark.mpGluePoints != 0L))
203 0 : bRet = false;
204 :
205 0 : if(bRet && mpPoints && *mpPoints != *rMark.mpPoints)
206 0 : bRet = false;
207 :
208 0 : if(bRet && mpLines && *mpLines != *rMark.mpLines)
209 0 : bRet = false;
210 :
211 0 : if(bRet && mpGluePoints && *mpGluePoints != *rMark.mpGluePoints)
212 0 : bRet = false;
213 :
214 0 : return bRet;
215 : }
216 :
217 :
218 :
219 42 : static bool ImpSdrMarkListSorter(SdrMark* const& lhs, SdrMark* const& rhs)
220 : {
221 42 : SdrObject* pObj1 = lhs->GetMarkedSdrObj();
222 42 : SdrObject* pObj2 = rhs->GetMarkedSdrObj();
223 42 : SdrObjList* pOL1 = (pObj1) ? pObj1->GetObjList() : 0L;
224 42 : SdrObjList* pOL2 = (pObj2) ? pObj2->GetObjList() : 0L;
225 :
226 42 : if (pOL1 == pOL2)
227 : {
228 : // AF: Note that I reverted a change from sal_uInt32 to sal_uLong (made
229 : // for 64bit compliance, #i78198#) because internally in SdrObject
230 : // both nOrdNum and mnNavigationPosition are stored as sal_uInt32.
231 42 : sal_uInt32 nObjOrd1((pObj1) ? pObj1->GetNavigationPosition() : 0);
232 42 : sal_uInt32 nObjOrd2((pObj2) ? pObj2->GetNavigationPosition() : 0);
233 :
234 42 : return nObjOrd1 < nObjOrd2;
235 : }
236 : else
237 : {
238 0 : return pOL1 < pOL2;
239 : }
240 : }
241 :
242 :
243 :
244 9933 : void SdrMarkList::ForceSort() const
245 : {
246 9933 : if(!mbSorted)
247 : {
248 3711 : const_cast<SdrMarkList*>(this)->ImpForceSort();
249 : }
250 9933 : }
251 :
252 3711 : void SdrMarkList::ImpForceSort()
253 : {
254 3711 : if(!mbSorted)
255 : {
256 3711 : mbSorted = true;
257 3711 : size_t nCount = maList.size();
258 :
259 : // remove invalid
260 3711 : if(nCount > 0 )
261 : {
262 70 : for(std::vector<SdrMark*>::iterator it = maList.begin(); it != maList.end(); )
263 : {
264 42 : SdrMark* pAkt = *it;
265 42 : if(pAkt->GetMarkedSdrObj() == 0)
266 : {
267 0 : it = maList.erase( it );
268 0 : delete pAkt;
269 : }
270 : else
271 42 : ++it;
272 : }
273 14 : nCount = maList.size();
274 : }
275 :
276 3711 : if(nCount > 1)
277 : {
278 12 : std::sort(maList.begin(), maList.end(), ImpSdrMarkListSorter);
279 :
280 : // remove duplicates
281 12 : if(maList.size() > 1)
282 : {
283 12 : SdrMark* pAkt = maList.back();
284 28 : for (size_t i = maList.size() - 2; i; --i)
285 : {
286 16 : SdrMark* pCmp = maList[i];
287 16 : if(pAkt->GetMarkedSdrObj() == pCmp->GetMarkedSdrObj() && pAkt->GetMarkedSdrObj())
288 : {
289 : // Con1/Con2 Merging
290 0 : if(pCmp->IsCon1())
291 0 : pAkt->SetCon1(true);
292 :
293 0 : if(pCmp->IsCon2())
294 0 : pAkt->SetCon2(true);
295 :
296 : // delete pCmp
297 0 : maList.erase(maList.begin() + i);
298 :
299 0 : delete pCmp;
300 : }
301 : else
302 : {
303 16 : pAkt = pCmp;
304 : }
305 : }
306 : }
307 : }
308 : }
309 3711 : }
310 :
311 59599 : void SdrMarkList::Clear()
312 : {
313 59961 : for(size_t i = 0; i < GetMarkCount(); ++i)
314 : {
315 362 : SdrMark* pMark = GetMark(i);
316 362 : delete pMark;
317 : }
318 :
319 59599 : maList.clear();
320 59599 : SetNameDirty();
321 59599 : }
322 :
323 269 : void SdrMarkList::operator=(const SdrMarkList& rLst)
324 : {
325 269 : Clear();
326 :
327 280 : for(size_t i = 0; i < rLst.GetMarkCount(); ++i)
328 : {
329 11 : SdrMark* pMark = rLst.GetMark(i);
330 11 : SdrMark* pNeuMark = new SdrMark(*pMark);
331 11 : maList.push_back(pNeuMark);
332 : }
333 :
334 269 : maMarkName = rLst.maMarkName;
335 269 : mbNameOk = rLst.mbNameOk;
336 269 : maPointName = rLst.maPointName;
337 269 : mbPointNameOk = rLst.mbPointNameOk;
338 269 : maGluePointName = rLst.maGluePointName;
339 269 : mbGluePointNameOk = rLst.mbGluePointNameOk;
340 269 : mbSorted = rLst.mbSorted;
341 269 : }
342 :
343 9027 : SdrMark* SdrMarkList::GetMark(size_t nNum) const
344 : {
345 9027 : return (nNum < maList.size()) ? maList[nNum] : NULL;
346 : }
347 :
348 16 : size_t SdrMarkList::FindObject(const SdrObject* pObj) const
349 : {
350 : // Since relying on OrdNums is not allowed for the selection because objects in the
351 : // selection may not be inserted in a list if they are e.g. modified ATM, i changed
352 : // this loop to just look if the object pointer is in the selection.
353 :
354 : // Problem is that GetOrdNum() which is const, internally casts to non-const and
355 : // hardly sets the OrdNum member of the object (nOrdNum) to 0 (ZERO) if the object
356 : // is not inserted in a object list.
357 : // Since this may be by purpose and necessary somewhere else i decided that it is
358 : // less dangerous to change this method then changing SdrObject::GetOrdNum().
359 16 : if(pObj && !maList.empty())
360 : {
361 0 : for(size_t a = 0; a < maList.size(); ++a)
362 : {
363 0 : if(maList[a]->GetMarkedSdrObj() == pObj)
364 : {
365 0 : return a;
366 : }
367 : }
368 : }
369 :
370 16 : return SAL_MAX_SIZE;
371 : }
372 :
373 647 : void SdrMarkList::InsertEntry(const SdrMark& rMark, bool bChkSort)
374 : {
375 647 : SetNameDirty();
376 647 : const size_t nCount(maList.size());
377 :
378 647 : if(!bChkSort || !mbSorted || nCount == 0)
379 : {
380 451 : if(!bChkSort)
381 15 : mbSorted = false;
382 :
383 451 : maList.push_back(new SdrMark(rMark));
384 : }
385 : else
386 : {
387 196 : SdrMark* pLast = GetMark(nCount - 1);
388 196 : const SdrObject* pLastObj = pLast->GetMarkedSdrObj();
389 196 : const SdrObject* pNeuObj = rMark.GetMarkedSdrObj();
390 :
391 196 : if(pLastObj == pNeuObj)
392 : {
393 : // This one already exists.
394 : // Con1/Con2 Merging
395 0 : if(rMark.IsCon1())
396 0 : pLast->SetCon1(true);
397 :
398 0 : if(rMark.IsCon2())
399 0 : pLast->SetCon2(true);
400 : }
401 : else
402 : {
403 196 : SdrMark* pKopie = new SdrMark(rMark);
404 196 : maList.push_back(pKopie);
405 :
406 : // now check if the sort is ok
407 196 : const SdrObjList* pLastOL = pLastObj!=0L ? pLastObj->GetObjList() : 0L;
408 196 : const SdrObjList* pNeuOL = pNeuObj !=0L ? pNeuObj ->GetObjList() : 0L;
409 :
410 196 : if(pLastOL == pNeuOL)
411 : {
412 196 : const sal_uLong nLastNum(pLastObj!=0L ? pLastObj->GetOrdNum() : 0);
413 196 : const sal_uLong nNeuNum(pNeuObj !=0L ? pNeuObj ->GetOrdNum() : 0);
414 :
415 196 : if(nNeuNum < nLastNum)
416 : {
417 : // at some point, we have to sort
418 11 : mbSorted = false;
419 : }
420 : }
421 : else
422 : {
423 : // at some point, we have to sort
424 0 : mbSorted = false;
425 : }
426 : }
427 : }
428 :
429 647 : return;
430 : }
431 :
432 136 : void SdrMarkList::DeleteMark(size_t nNum)
433 : {
434 136 : SdrMark* pMark = GetMark(nNum);
435 : DBG_ASSERT(pMark!=0L,"DeleteMark: MarkEntry not found.");
436 :
437 136 : if(pMark)
438 : {
439 136 : maList.erase(maList.begin() + nNum);
440 136 : delete pMark;
441 136 : SetNameDirty();
442 : }
443 136 : }
444 :
445 20 : void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, size_t nNum)
446 : {
447 20 : SdrMark* pMark = GetMark(nNum);
448 : DBG_ASSERT(pMark!=0L,"ReplaceMark: MarkEntry not found.");
449 :
450 20 : if(pMark)
451 : {
452 20 : delete pMark;
453 20 : SetNameDirty();
454 20 : SdrMark* pKopie = new SdrMark(rNewMark);
455 20 : maList[nNum] = pKopie;
456 20 : mbSorted = false;
457 : }
458 20 : }
459 :
460 38 : void SdrMarkList::Merge(const SdrMarkList& rSrcList, bool bReverse)
461 : {
462 38 : const size_t nCount(rSrcList.maList.size());
463 :
464 38 : if(rSrcList.mbSorted)
465 : {
466 : // merge without forcing a Sort in rSrcList
467 33 : bReverse = false;
468 : }
469 :
470 38 : if(!bReverse)
471 : {
472 66 : for(size_t i = 0; i < nCount; ++i)
473 : {
474 33 : SdrMark* pM = rSrcList.maList[i];
475 33 : InsertEntry(*pM);
476 : }
477 : }
478 : else
479 : {
480 25 : for(size_t i = nCount; i > 0;)
481 : {
482 15 : --i;
483 15 : SdrMark* pM = rSrcList.maList[i];
484 15 : InsertEntry(*pM);
485 : }
486 : }
487 38 : }
488 :
489 5037 : bool SdrMarkList::DeletePageView(const SdrPageView& rPV)
490 : {
491 5037 : bool bChgd(false);
492 :
493 10233 : for(std::vector<SdrMark*>::iterator it = maList.begin(); it != maList.end(); )
494 : {
495 159 : SdrMark* pMark = *it;
496 :
497 159 : if(pMark->GetPageView()==&rPV)
498 : {
499 159 : it = maList.erase(it);
500 159 : delete pMark;
501 159 : SetNameDirty();
502 159 : bChgd = true;
503 : }
504 : else
505 0 : ++it;
506 : }
507 :
508 5037 : return bChgd;
509 : }
510 :
511 0 : bool SdrMarkList::InsertPageView(const SdrPageView& rPV)
512 : {
513 0 : bool bChgd(false);
514 0 : DeletePageView(rPV); // delete all of them, then append the entire page
515 0 : const SdrObjList* pOL = rPV.GetObjList();
516 0 : const size_t nObjCount(pOL->GetObjCount());
517 :
518 0 : for(size_t nO = 0; nO < nObjCount; ++nO)
519 : {
520 0 : SdrObject* pObj = pOL->GetObj(nO);
521 0 : bool bDoIt(rPV.IsObjMarkable(pObj));
522 :
523 0 : if(bDoIt)
524 : {
525 0 : SdrMark* pM = new SdrMark(pObj, const_cast<SdrPageView*>(&rPV));
526 0 : maList.push_back(pM);
527 0 : SetNameDirty();
528 0 : bChgd = true;
529 : }
530 : }
531 :
532 0 : return bChgd;
533 : }
534 :
535 53 : const OUString& SdrMarkList::GetMarkDescription() const
536 : {
537 53 : const size_t nCount(GetMarkCount());
538 :
539 53 : if(mbNameOk && 1L == nCount)
540 : {
541 : // if it's a single selection, cache only text frame
542 0 : const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
543 0 : const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj, pObj);
544 :
545 0 : if(!pTextObj || !pTextObj->IsTextFrame())
546 : {
547 0 : const_cast<SdrMarkList*>(this)->mbNameOk = false;
548 : }
549 : }
550 :
551 53 : if(!mbNameOk)
552 : {
553 53 : SdrMark* pMark = GetMark(0);
554 53 : OUString aNam;
555 :
556 53 : if(!nCount)
557 : {
558 0 : const_cast<SdrMarkList*>(this)->maMarkName = ImpGetResStr(STR_ObjNameNoObj);
559 : }
560 53 : else if(1L == nCount)
561 : {
562 8 : if(pMark->GetMarkedSdrObj())
563 : {
564 8 : aNam = pMark->GetMarkedSdrObj()->TakeObjNameSingul();
565 : }
566 : }
567 : else
568 : {
569 45 : if(pMark->GetMarkedSdrObj())
570 : {
571 45 : aNam = pMark->GetMarkedSdrObj()->TakeObjNamePlural();
572 45 : bool bEq(true);
573 :
574 113 : for(size_t i = 1; i < GetMarkCount() && bEq; ++i)
575 : {
576 68 : SdrMark* pMark2 = GetMark(i);
577 68 : OUString aStr1(pMark2->GetMarkedSdrObj()->TakeObjNamePlural());
578 68 : bEq = aNam == aStr1;
579 68 : }
580 :
581 45 : if(!bEq)
582 : {
583 24 : aNam = ImpGetResStr(STR_ObjNamePlural);
584 : }
585 : }
586 :
587 45 : aNam = OUString::number( nCount ) + " " + aNam;
588 : }
589 :
590 53 : const_cast<SdrMarkList*>(this)->maMarkName = aNam;
591 53 : const_cast<SdrMarkList*>(this)->mbNameOk = true;
592 : }
593 :
594 53 : return maMarkName;
595 : }
596 :
597 0 : const OUString& SdrMarkList::GetPointMarkDescription(bool bGlue) const
598 : {
599 0 : bool& rNameOk = (bool&)(bGlue ? mbGluePointNameOk : mbPointNameOk);
600 0 : OUString& rName = const_cast<OUString&>(bGlue ? maGluePointName : maPointName);
601 0 : const size_t nMarkCount(GetMarkCount());
602 0 : size_t nMarkPtAnz(0);
603 0 : size_t nMarkPtObjAnz(0);
604 0 : size_t n1stMarkNum(SAL_MAX_SIZE);
605 :
606 0 : for(size_t nMarkNum = 0; nMarkNum < nMarkCount; ++nMarkNum)
607 : {
608 0 : const SdrMark* pMark = GetMark(nMarkNum);
609 0 : const SdrUShortCont* pPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints();
610 0 : const size_t nCount(pPts ? pPts->size() : 0);
611 :
612 0 : if(nCount)
613 : {
614 0 : if(n1stMarkNum == SAL_MAX_SIZE)
615 : {
616 0 : n1stMarkNum = nMarkNum;
617 : }
618 :
619 0 : nMarkPtAnz += nCount;
620 0 : nMarkPtObjAnz++;
621 : }
622 :
623 0 : if(nMarkPtObjAnz > 1 && rNameOk)
624 : {
625 : // preliminary decision
626 0 : return rName;
627 : }
628 : }
629 :
630 0 : if(rNameOk && 1 == nMarkPtObjAnz)
631 : {
632 : // if it's a single selection, cache only text frame
633 0 : const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj();
634 0 : const SdrTextObj* pTextObj = PTR_CAST(SdrTextObj,pObj);
635 :
636 0 : if(!pTextObj || !pTextObj->IsTextFrame())
637 : {
638 0 : rNameOk = false;
639 : }
640 : }
641 :
642 0 : if(!nMarkPtObjAnz)
643 : {
644 0 : rName.clear();
645 0 : rNameOk = true;
646 : }
647 0 : else if(!rNameOk)
648 : {
649 0 : const SdrMark* pMark = GetMark(n1stMarkNum);
650 0 : OUString aNam;
651 :
652 0 : if(1L == nMarkPtObjAnz)
653 : {
654 0 : if(pMark->GetMarkedSdrObj())
655 : {
656 0 : aNam = pMark->GetMarkedSdrObj()->TakeObjNameSingul();
657 : }
658 : }
659 : else
660 : {
661 0 : if(pMark->GetMarkedSdrObj())
662 : {
663 0 : aNam = pMark->GetMarkedSdrObj()->TakeObjNamePlural();
664 : }
665 :
666 0 : bool bEq(true);
667 :
668 0 : for(size_t i = n1stMarkNum + 1; i < GetMarkCount() && bEq; ++i)
669 : {
670 0 : const SdrMark* pMark2 = GetMark(i);
671 0 : const SdrUShortCont* pPts = bGlue ? pMark2->GetMarkedGluePoints() : pMark2->GetMarkedPoints();
672 :
673 0 : if(pPts && !pPts->empty() && pMark2->GetMarkedSdrObj())
674 : {
675 0 : OUString aStr1(pMark2->GetMarkedSdrObj()->TakeObjNamePlural());
676 0 : bEq = aNam == aStr1;
677 : }
678 : }
679 :
680 0 : if(!bEq)
681 : {
682 0 : aNam = ImpGetResStr(STR_ObjNamePlural);
683 : }
684 :
685 0 : aNam = OUString::number( nMarkPtObjAnz ) + " " + aNam;
686 : }
687 :
688 0 : OUString aStr1;
689 :
690 0 : if(1L == nMarkPtAnz)
691 : {
692 0 : aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint));
693 : }
694 : else
695 : {
696 0 : aStr1 = (ImpGetResStr(bGlue ? STR_ViewMarkedGluePoints : STR_ViewMarkedPoints));
697 0 : aStr1 = aStr1.replaceFirst("%2", OUString::number( nMarkPtAnz ));
698 : }
699 :
700 0 : aStr1 = aStr1.replaceFirst("%1", aNam);
701 0 : rName = aStr1;
702 0 : rNameOk = true;
703 : }
704 :
705 0 : return rName;
706 : }
707 :
708 45114 : bool SdrMarkList::TakeBoundRect(SdrPageView* pPV, Rectangle& rRect) const
709 : {
710 45114 : bool bFnd(false);
711 45114 : Rectangle aR;
712 :
713 45893 : for(size_t i = 0; i < GetMarkCount(); ++i)
714 : {
715 779 : SdrMark* pMark = GetMark(i);
716 :
717 779 : if(!pPV || pMark->GetPageView() == pPV)
718 : {
719 779 : if(pMark->GetMarkedSdrObj())
720 : {
721 779 : aR = pMark->GetMarkedSdrObj()->GetCurrentBoundRect();
722 :
723 779 : if(bFnd)
724 : {
725 272 : rRect.Union(aR);
726 : }
727 : else
728 : {
729 507 : rRect = aR;
730 507 : bFnd = true;
731 : }
732 : }
733 : }
734 : }
735 :
736 45114 : return bFnd;
737 : }
738 :
739 45114 : bool SdrMarkList::TakeSnapRect(SdrPageView* pPV, Rectangle& rRect) const
740 : {
741 45114 : bool bFnd(false);
742 :
743 45893 : for(size_t i = 0; i < GetMarkCount(); ++i)
744 : {
745 779 : SdrMark* pMark = GetMark(i);
746 :
747 779 : if(!pPV || pMark->GetPageView() == pPV)
748 : {
749 779 : if(pMark->GetMarkedSdrObj())
750 : {
751 779 : Rectangle aR(pMark->GetMarkedSdrObj()->GetSnapRect());
752 :
753 779 : if(bFnd)
754 : {
755 272 : rRect.Union(aR);
756 : }
757 : else
758 : {
759 507 : rRect = aR;
760 507 : bFnd = true;
761 : }
762 : }
763 : }
764 : }
765 :
766 45114 : return bFnd;
767 : }
768 :
769 :
770 :
771 : namespace sdr
772 : {
773 9504 : ViewSelection::ViewSelection()
774 9504 : : mbEdgesOfMarkedNodesDirty(false)
775 : {
776 9504 : }
777 :
778 4661 : void ViewSelection::SetEdgesOfMarkedNodesDirty()
779 : {
780 4661 : if(!mbEdgesOfMarkedNodesDirty)
781 : {
782 4165 : mbEdgesOfMarkedNodesDirty = true;
783 4165 : maEdgesOfMarkedNodes.Clear();
784 4165 : maMarkedEdgesOfMarkedNodes.Clear();
785 4165 : maAllMarkedObjects.clear();
786 : }
787 4661 : }
788 :
789 2 : const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const
790 : {
791 2 : if(mbEdgesOfMarkedNodesDirty)
792 : {
793 2 : const_cast<ViewSelection*>(this)->ImpForceEdgesOfMarkedNodes();
794 : }
795 :
796 2 : return maEdgesOfMarkedNodes;
797 : }
798 :
799 65 : const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const
800 : {
801 65 : if(mbEdgesOfMarkedNodesDirty)
802 : {
803 0 : const_cast<ViewSelection*>(this)->ImpForceEdgesOfMarkedNodes();
804 : }
805 :
806 65 : return maMarkedEdgesOfMarkedNodes;
807 : }
808 :
809 65 : const std::vector<SdrObject*>& ViewSelection::GetAllMarkedObjects() const
810 : {
811 65 : if(mbEdgesOfMarkedNodesDirty)
812 62 : const_cast<ViewSelection*>(this)->ImpForceEdgesOfMarkedNodes();
813 :
814 65 : return maAllMarkedObjects;
815 : }
816 :
817 296 : void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj)
818 : {
819 296 : if(pObj)
820 : {
821 296 : bool bIsGroup(pObj->IsGroupObject());
822 :
823 296 : if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene))
824 : {
825 0 : bIsGroup = false;
826 : }
827 :
828 296 : if(bIsGroup)
829 : {
830 47 : SdrObjList* pList = pObj->GetSubList();
831 :
832 220 : for(size_t a = 0; a < pList->GetObjCount(); ++a)
833 : {
834 173 : SdrObject* pObj2 = pList->GetObj(a);
835 173 : ImplCollectCompleteSelection(pObj2);
836 : }
837 : }
838 :
839 296 : maAllMarkedObjects.push_back(pObj);
840 : }
841 296 : }
842 :
843 64 : void ViewSelection::ImpForceEdgesOfMarkedNodes()
844 : {
845 64 : if(mbEdgesOfMarkedNodesDirty)
846 : {
847 64 : mbEdgesOfMarkedNodesDirty = false;
848 64 : maMarkedObjectList.ForceSort();
849 64 : maEdgesOfMarkedNodes.Clear();
850 64 : maMarkedEdgesOfMarkedNodes.Clear();
851 64 : maAllMarkedObjects.clear();
852 :
853 : // GetMarkCount after ForceSort
854 64 : const size_t nMarkCount(maMarkedObjectList.GetMarkCount());
855 :
856 187 : for(size_t a = 0; a < nMarkCount; ++a)
857 : {
858 123 : SdrObject* pCandidate = maMarkedObjectList.GetMark(a)->GetMarkedSdrObj();
859 :
860 123 : if(pCandidate)
861 : {
862 : // build transitive hull
863 123 : ImplCollectCompleteSelection(pCandidate);
864 :
865 123 : if(pCandidate->IsNode())
866 : {
867 : // travel over broadcaster/listener to access edges connected to the selected object
868 123 : const SfxBroadcaster* pBC = pCandidate->GetBroadcaster();
869 :
870 123 : if(pBC)
871 : {
872 0 : const size_t nLstAnz(pBC->GetSizeOfVector());
873 :
874 0 : for(size_t nl=0; nl < nLstAnz; ++nl)
875 : {
876 0 : SfxListener* pLst = pBC->GetListener(nl);
877 0 : SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, pLst);
878 :
879 0 : if(pEdge && pEdge->IsInserted() && pEdge->GetPage() == pCandidate->GetPage())
880 : {
881 0 : SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView());
882 :
883 0 : if(pEdge->GetConnectedNode(true) == pCandidate)
884 : {
885 0 : aM.SetCon1(true);
886 : }
887 :
888 0 : if(pEdge->GetConnectedNode(false) == pCandidate)
889 : {
890 0 : aM.SetCon2(true);
891 : }
892 :
893 0 : if(SAL_MAX_SIZE == maMarkedObjectList.FindObject(pEdge))
894 : {
895 : // check if it itself is selected
896 0 : maEdgesOfMarkedNodes.InsertEntry(aM);
897 : }
898 : else
899 : {
900 0 : maMarkedEdgesOfMarkedNodes.InsertEntry(aM);
901 0 : }
902 : }
903 : }
904 : }
905 : }
906 : }
907 : }
908 :
909 64 : maEdgesOfMarkedNodes.ForceSort();
910 64 : maMarkedEdgesOfMarkedNodes.ForceSort();
911 : }
912 64 : }
913 435 : } // end of namespace sdr
914 :
915 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
