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