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 : #include "OutlinerIterator.hxx"
21 : #include "OutlinerIteratorImpl.hxx"
22 : #include <svx/svditer.hxx>
23 : #include <sfx2/dispatch.hxx>
24 : #include <sfx2/viewfrm.hxx>
25 : #include "Outliner.hxx"
26 :
27 : #include "drawdoc.hxx"
28 : #include "DrawViewShell.hxx"
29 : #include "drawview.hxx"
30 : #include "sdpage.hxx"
31 : #include "FrameView.hxx"
32 : #include "DrawDocShell.hxx"
33 : #include "Window.hxx"
34 :
35 : namespace sd { namespace outliner {
36 :
37 : //===== IteratorPosition ======================================================
38 :
39 589 : IteratorPosition::IteratorPosition()
40 : : mnText(0)
41 : , mnPageIndex(-1)
42 : , mePageKind(PK_STANDARD)
43 589 : , meEditMode(EM_PAGE)
44 : {
45 589 : }
46 :
47 3 : IteratorPosition::IteratorPosition (const IteratorPosition& aPosition)
48 : : mxObject(aPosition.mxObject)
49 : , mnText(aPosition.mnText)
50 : , mnPageIndex(aPosition.mnPageIndex)
51 : , mePageKind(aPosition.mePageKind)
52 3 : , meEditMode(aPosition.meEditMode)
53 : {
54 3 : }
55 :
56 582 : IteratorPosition::~IteratorPosition()
57 : {
58 582 : }
59 :
60 81 : IteratorPosition& IteratorPosition::operator= (const IteratorPosition& aPosition)
61 : {
62 81 : mxObject = aPosition.mxObject;
63 81 : mnText = aPosition.mnText;
64 81 : mnPageIndex = aPosition.mnPageIndex;
65 81 : mePageKind = aPosition.mePageKind;
66 81 : meEditMode = aPosition.meEditMode;
67 81 : return *this;
68 : }
69 :
70 65 : bool IteratorPosition::operator== (const IteratorPosition& aPosition) const
71 : {
72 65 : return mxObject.get() == aPosition.mxObject.get()
73 7 : && mnText == aPosition.mnText
74 7 : && mnPageIndex == aPosition.mnPageIndex
75 5 : && mePageKind == aPosition.mePageKind
76 68 : && meEditMode == aPosition.meEditMode;
77 : }
78 :
79 : //===== Iterator ==============================================================
80 :
81 521 : Iterator::Iterator()
82 : {
83 521 : mpIterator = NULL;
84 521 : }
85 :
86 6 : Iterator::Iterator (const Iterator& rIterator)
87 : {
88 6 : mpIterator = rIterator.mpIterator ? rIterator.mpIterator->Clone() : NULL;
89 6 : }
90 :
91 72 : Iterator::Iterator (IteratorImplBase* pObject)
92 : {
93 72 : mpIterator = pObject;
94 72 : }
95 :
96 589 : Iterator::~Iterator()
97 : {
98 589 : delete mpIterator;
99 589 : }
100 :
101 25 : Iterator& Iterator::operator= (const Iterator& rIterator)
102 : {
103 25 : if (this != &rIterator)
104 : {
105 25 : delete mpIterator;
106 25 : if (rIterator.mpIterator != NULL)
107 9 : mpIterator = rIterator.mpIterator->Clone();
108 : else
109 16 : mpIterator = NULL;
110 : }
111 25 : return *this;
112 : }
113 :
114 64 : const IteratorPosition& Iterator::operator* () const
115 : {
116 : DBG_ASSERT (mpIterator!=NULL, "::sd::outliner::Iterator::operator* : missing implementation object");
117 64 : return mpIterator->GetPosition();
118 : }
119 :
120 60 : Iterator& Iterator::operator++ ()
121 : {
122 60 : if (mpIterator!=NULL)
123 60 : mpIterator->GotoNextText();
124 60 : return *this;
125 : }
126 :
127 0 : Iterator Iterator::operator++ (int)
128 : {
129 0 : Iterator aTmp (*this);
130 0 : if (mpIterator!=NULL)
131 0 : mpIterator->GotoNextText();
132 0 : return aTmp;
133 : }
134 :
135 69 : bool Iterator::operator== (const Iterator& rIterator)
136 : {
137 69 : if (mpIterator == NULL || rIterator.mpIterator==NULL)
138 4 : return mpIterator == rIterator.mpIterator;
139 : else
140 65 : return *mpIterator == *rIterator.mpIterator;
141 : }
142 :
143 63 : bool Iterator::operator!= (const Iterator& rIterator)
144 : {
145 63 : return ! operator==(rIterator);
146 : }
147 :
148 0 : void Iterator::Reverse()
149 : {
150 0 : if (mpIterator != NULL)
151 0 : mpIterator->Reverse();
152 0 : }
153 :
154 : //===== IteratorFactory =======================================================
155 :
156 72 : OutlinerContainer::OutlinerContainer (Outliner* pOutliner)
157 72 : : mpOutliner(pOutliner)
158 : {
159 72 : }
160 :
161 2 : Iterator OutlinerContainer::begin()
162 : {
163 2 : return CreateIterator (BEGIN);
164 : }
165 :
166 65 : Iterator OutlinerContainer::end()
167 : {
168 65 : return CreateIterator (END);
169 : }
170 :
171 5 : Iterator OutlinerContainer::current()
172 : {
173 5 : return CreateIterator (CURRENT);
174 : }
175 :
176 72 : Iterator OutlinerContainer::CreateIterator (IteratorLocation aLocation)
177 : {
178 : // Decide on certain features of the outliner which kind of iterator to
179 : // use.
180 72 : if (mpOutliner->mbRestrictSearchToSelection)
181 : // There is a selection. Search only in this.
182 : return CreateSelectionIterator (
183 : mpOutliner->maMarkListCopy,
184 : mpOutliner->mpDrawDocument,
185 : mpOutliner->mpWeakViewShell.lock(),
186 : mpOutliner->mbDirectionIsForward,
187 0 : aLocation);
188 : else
189 : // Search in the whole document.
190 : return CreateDocumentIterator (
191 : mpOutliner->mpDrawDocument,
192 : mpOutliner->mpWeakViewShell.lock(),
193 : mpOutliner->mbDirectionIsForward,
194 72 : aLocation);
195 : }
196 :
197 0 : Iterator OutlinerContainer::CreateSelectionIterator (
198 : const ::std::vector<SdrObjectWeakRef>& rObjectList,
199 : SdDrawDocument* pDocument,
200 : const ::boost::shared_ptr<ViewShell>& rpViewShell,
201 : bool bDirectionIsForward,
202 : IteratorLocation aLocation)
203 : {
204 : OSL_ASSERT(rpViewShell.get());
205 :
206 : sal_Int32 nObjectIndex;
207 :
208 0 : if (bDirectionIsForward)
209 0 : switch (aLocation)
210 : {
211 : case CURRENT:
212 : case BEGIN:
213 : default:
214 0 : nObjectIndex = 0;
215 0 : break;
216 : case END:
217 0 : nObjectIndex = rObjectList.size();
218 0 : break;
219 : }
220 : else
221 0 : switch (aLocation)
222 : {
223 : case CURRENT:
224 : case BEGIN:
225 : default:
226 0 : nObjectIndex = rObjectList.size()-1;
227 0 : break;
228 : case END:
229 0 : nObjectIndex = -1;
230 0 : break;
231 : }
232 :
233 : return Iterator (new SelectionIteratorImpl (
234 0 : rObjectList, nObjectIndex, pDocument, rpViewShell, bDirectionIsForward));
235 : }
236 :
237 72 : Iterator OutlinerContainer::CreateDocumentIterator (
238 : SdDrawDocument* pDocument,
239 : const ::boost::shared_ptr<ViewShell>& rpViewShell,
240 : bool bDirectionIsForward,
241 : IteratorLocation aLocation)
242 : {
243 : OSL_ASSERT(rpViewShell.get());
244 :
245 : PageKind ePageKind;
246 : EditMode eEditMode;
247 :
248 72 : switch (aLocation)
249 : {
250 : case BEGIN:
251 : default:
252 2 : if (bDirectionIsForward)
253 : {
254 2 : ePageKind = PK_STANDARD;
255 2 : eEditMode = EM_PAGE;
256 : }
257 : else
258 : {
259 0 : ePageKind = PK_HANDOUT;
260 0 : eEditMode = EM_MASTERPAGE;
261 : }
262 2 : break;
263 :
264 : case END:
265 65 : if (bDirectionIsForward)
266 : {
267 65 : ePageKind = PK_HANDOUT;
268 65 : eEditMode = EM_MASTERPAGE;
269 : }
270 : else
271 : {
272 0 : ePageKind = PK_STANDARD;
273 0 : eEditMode = EM_PAGE;
274 : }
275 65 : break;
276 :
277 : case CURRENT:
278 : const ::boost::shared_ptr<DrawViewShell> pDrawViewShell(
279 5 : ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShell));
280 5 : if (pDrawViewShell.get())
281 : {
282 5 : ePageKind = pDrawViewShell->GetPageKind();
283 5 : eEditMode = pDrawViewShell->GetEditMode();
284 : }
285 : else
286 : {
287 0 : ePageKind = PK_STANDARD;
288 0 : eEditMode = EM_PAGE;
289 : }
290 5 : break;
291 : }
292 :
293 : sal_Int32 nPageIndex = GetPageIndex (pDocument, rpViewShell,
294 72 : ePageKind, eEditMode, bDirectionIsForward, aLocation);
295 :
296 : return Iterator (
297 : new DocumentIteratorImpl (nPageIndex, ePageKind, eEditMode,
298 72 : pDocument, rpViewShell, bDirectionIsForward));
299 : }
300 :
301 72 : sal_Int32 OutlinerContainer::GetPageIndex (
302 : SdDrawDocument* pDocument,
303 : const ::boost::shared_ptr<ViewShell>& rpViewShell,
304 : PageKind ePageKind,
305 : EditMode eEditMode,
306 : bool bDirectionIsForward,
307 : IteratorLocation aLocation)
308 : {
309 : OSL_ASSERT(rpViewShell);
310 :
311 : sal_Int32 nPageIndex;
312 : sal_Int32 nPageCount;
313 :
314 : const ::boost::shared_ptr<DrawViewShell> pDrawViewShell(
315 72 : ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShell));
316 :
317 72 : switch (eEditMode)
318 : {
319 : case EM_PAGE:
320 7 : nPageCount = pDocument->GetSdPageCount (ePageKind);
321 7 : break;
322 : case EM_MASTERPAGE:
323 65 : nPageCount = pDocument->GetMasterSdPageCount(ePageKind);
324 65 : break;
325 : default:
326 0 : nPageCount = 0;
327 : }
328 :
329 72 : switch (aLocation)
330 : {
331 : case CURRENT:
332 5 : if (pDrawViewShell.get())
333 5 : nPageIndex = pDrawViewShell->GetCurPageId() - 1;
334 : else
335 : {
336 0 : const SdPage* pPage = rpViewShell->GetActualPage();
337 0 : if (pPage != NULL)
338 0 : nPageIndex = (pPage->GetPageNum()-1)/2;
339 : else
340 0 : nPageIndex = 0;
341 : }
342 5 : break;
343 :
344 : case BEGIN:
345 : default:
346 2 : if (bDirectionIsForward)
347 2 : nPageIndex = 0;
348 : else
349 0 : nPageIndex = nPageCount-1;
350 2 : break;
351 :
352 : case END:
353 65 : if (bDirectionIsForward)
354 65 : nPageIndex = nPageCount;
355 : else
356 0 : nPageIndex = -1;
357 65 : break;
358 : }
359 :
360 72 : return nPageIndex;
361 : }
362 :
363 : //===== IteratorImplBase ====================================================
364 :
365 0 : IteratorImplBase::IteratorImplBase(SdDrawDocument* pDocument,
366 : const ::boost::weak_ptr<ViewShell>& rpViewShellWeak,
367 : bool bDirectionIsForward)
368 : : maPosition()
369 : , mpDocument (pDocument)
370 : , mpViewShellWeak (rpViewShellWeak)
371 0 : , mbDirectionIsForward (bDirectionIsForward)
372 : {
373 0 : ::boost::shared_ptr<DrawViewShell> pDrawViewShell;
374 0 : if ( ! mpViewShellWeak.expired())
375 0 : pDrawViewShell = ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShellWeak.lock());
376 :
377 0 : if (pDrawViewShell.get())
378 : {
379 0 : maPosition.mePageKind = pDrawViewShell->GetPageKind();
380 0 : maPosition.meEditMode = pDrawViewShell->GetEditMode();
381 : }
382 : else
383 : {
384 0 : maPosition.mePageKind = PK_STANDARD;
385 0 : maPosition.meEditMode = EM_PAGE;
386 0 : }
387 0 : }
388 :
389 87 : IteratorImplBase::IteratorImplBase( SdDrawDocument* pDocument,
390 : const ::boost::weak_ptr<ViewShell>& rpViewShellWeak,
391 : bool bDirectionIsForward, PageKind ePageKind, EditMode eEditMode)
392 : : maPosition()
393 : , mpDocument (pDocument)
394 : , mpViewShellWeak (rpViewShellWeak)
395 87 : , mbDirectionIsForward (bDirectionIsForward)
396 : {
397 87 : maPosition.mePageKind = ePageKind;
398 87 : maPosition.meEditMode = eEditMode;
399 87 : }
400 :
401 87 : IteratorImplBase::~IteratorImplBase()
402 87 : {}
403 :
404 65 : bool IteratorImplBase::operator== (const IteratorImplBase& rIterator) const
405 : {
406 65 : return maPosition == rIterator.maPosition;
407 : }
408 :
409 0 : bool IteratorImplBase::IsEqual (const IteratorImplBase& rIterator, IteratorType ) const
410 : {
411 : // When this method is executed instead of the ones from derived classes
412 : // then the argument is of another type then the object itself. In this
413 : // just compare the position objects.
414 0 : return maPosition == rIterator.maPosition;
415 : }
416 :
417 64 : const IteratorPosition& IteratorImplBase::GetPosition()
418 : {
419 64 : return maPosition;
420 : }
421 :
422 15 : IteratorImplBase* IteratorImplBase::Clone (IteratorImplBase* pObject) const
423 : {
424 15 : if (pObject != NULL)
425 : {
426 15 : pObject->maPosition = maPosition;
427 15 : pObject->mpDocument = mpDocument;
428 15 : pObject->mpViewShellWeak = mpViewShellWeak;
429 15 : pObject->mbDirectionIsForward = mbDirectionIsForward;
430 : }
431 15 : return pObject;
432 : }
433 :
434 0 : void IteratorImplBase::Reverse()
435 : {
436 0 : mbDirectionIsForward = ! mbDirectionIsForward;
437 0 : }
438 :
439 : //===== SelectionIteratorImpl ===========================================
440 :
441 0 : SelectionIteratorImpl::SelectionIteratorImpl (
442 : const ::std::vector<SdrObjectWeakRef>& rObjectList,
443 : sal_Int32 nObjectIndex,
444 : SdDrawDocument* pDocument,
445 : const ::boost::weak_ptr<ViewShell>& rpViewShellWeak,
446 : bool bDirectionIsForward)
447 : : IteratorImplBase (pDocument, rpViewShellWeak, bDirectionIsForward),
448 : mrObjectList(rObjectList),
449 0 : mnObjectIndex(nObjectIndex)
450 : {
451 0 : }
452 :
453 0 : SelectionIteratorImpl::~SelectionIteratorImpl()
454 0 : {}
455 :
456 0 : IteratorImplBase* SelectionIteratorImpl::Clone (IteratorImplBase* pObject) const
457 : {
458 0 : SelectionIteratorImpl* pIterator = static_cast<SelectionIteratorImpl*>(pObject);
459 0 : if (pIterator == NULL)
460 : pIterator = new SelectionIteratorImpl (
461 0 : mrObjectList, mnObjectIndex, mpDocument, mpViewShellWeak, mbDirectionIsForward);
462 0 : return pIterator;
463 : }
464 :
465 0 : void SelectionIteratorImpl::GotoNextText()
466 : {
467 0 : SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mrObjectList.at(mnObjectIndex).get() );
468 0 : if (mbDirectionIsForward)
469 : {
470 0 : if( pTextObj )
471 : {
472 0 : ++maPosition.mnText;
473 0 : if( maPosition.mnText >= pTextObj->getTextCount() )
474 : {
475 0 : maPosition.mnText = 0;
476 0 : ++mnObjectIndex;
477 : }
478 : }
479 : else
480 : {
481 0 : ++mnObjectIndex;
482 : }
483 : }
484 : else
485 : {
486 0 : if( pTextObj )
487 : {
488 0 : --maPosition.mnText;
489 0 : if( maPosition.mnText < 0 )
490 : {
491 0 : maPosition.mnText = -1;
492 0 : --mnObjectIndex;
493 : }
494 : }
495 : else
496 : {
497 0 : --mnObjectIndex;
498 0 : maPosition.mnText = -1;
499 : }
500 :
501 0 : if( (maPosition.mnText == -1) && (mnObjectIndex >= 0) )
502 : {
503 0 : pTextObj = dynamic_cast< SdrTextObj* >( mrObjectList.at(mnObjectIndex).get() );
504 0 : if( pTextObj )
505 0 : maPosition.mnText = pTextObj->getTextCount() - 1;
506 : }
507 :
508 0 : if( maPosition.mnText == -1 )
509 0 : maPosition.mnText = 0;
510 : }
511 0 : }
512 :
513 0 : const IteratorPosition& SelectionIteratorImpl::GetPosition()
514 : {
515 0 : maPosition.mxObject = mrObjectList.at(mnObjectIndex);
516 :
517 0 : return maPosition;
518 : }
519 :
520 0 : bool SelectionIteratorImpl::operator== (const IteratorImplBase& rIterator) const
521 : {
522 0 : return rIterator.IsEqual (*this, SELECTION);
523 : }
524 :
525 0 : bool SelectionIteratorImpl::IsEqual (
526 : const IteratorImplBase& rIterator,
527 : IteratorType aType) const
528 : {
529 0 : if (aType == SELECTION)
530 : {
531 : const SelectionIteratorImpl* pSelectionIterator =
532 0 : static_cast<const SelectionIteratorImpl*>(&rIterator);
533 0 : return mpDocument == pSelectionIterator->mpDocument
534 0 : && mnObjectIndex == pSelectionIterator->mnObjectIndex;
535 : }
536 : else
537 0 : return false;
538 : }
539 :
540 : //===== ViewIteratorImpl ================================================
541 :
542 0 : ViewIteratorImpl::ViewIteratorImpl (
543 : sal_Int32 nPageIndex,
544 : SdDrawDocument* pDocument,
545 : const ::boost::weak_ptr<ViewShell>& rpViewShellWeak,
546 : bool bDirectionIsForward)
547 : : IteratorImplBase (pDocument, rpViewShellWeak, bDirectionIsForward),
548 : mbPageChangeOccurred(false),
549 : mpPage(NULL),
550 0 : mpObjectIterator(NULL)
551 : {
552 0 : SetPage (nPageIndex);
553 0 : }
554 :
555 87 : ViewIteratorImpl::ViewIteratorImpl (
556 : sal_Int32 nPageIndex,
557 : SdDrawDocument* pDocument,
558 : const ::boost::weak_ptr<ViewShell>& rpViewShellWeak,
559 : bool bDirectionIsForward,
560 : PageKind ePageKind,
561 : EditMode eEditMode)
562 : : IteratorImplBase (pDocument, rpViewShellWeak, bDirectionIsForward, ePageKind, eEditMode),
563 : mbPageChangeOccurred(false),
564 : mpPage(NULL),
565 87 : mpObjectIterator(NULL)
566 : {
567 87 : SetPage (nPageIndex);
568 87 : }
569 :
570 87 : ViewIteratorImpl::~ViewIteratorImpl()
571 : {
572 87 : }
573 :
574 15 : IteratorImplBase* ViewIteratorImpl::Clone (IteratorImplBase* pObject) const
575 : {
576 :
577 15 : ViewIteratorImpl* pIterator = static_cast<ViewIteratorImpl*>(pObject);
578 15 : if (pIterator == NULL)
579 : pIterator = new ViewIteratorImpl (
580 0 : maPosition.mnPageIndex, mpDocument, mpViewShellWeak, mbDirectionIsForward);
581 :
582 15 : IteratorImplBase::Clone (pObject);
583 :
584 15 : if (mpObjectIterator != NULL)
585 : {
586 11 : pIterator->mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, !mbDirectionIsForward);
587 :
588 : // No direct way to set the object iterator to the current object.
589 11 : pIterator->maPosition.mxObject.reset(NULL);
590 65 : while (pIterator->mpObjectIterator->IsMore() && pIterator->maPosition.mxObject!=maPosition.mxObject)
591 43 : pIterator->maPosition.mxObject.reset(pIterator->mpObjectIterator->Next());
592 : }
593 : else
594 4 : pIterator->mpObjectIterator = NULL;
595 :
596 15 : return pIterator;
597 : }
598 :
599 60 : void ViewIteratorImpl::GotoNextText()
600 : {
601 60 : SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() );
602 60 : if( pTextObj )
603 : {
604 40 : if (mbDirectionIsForward)
605 : {
606 40 : ++maPosition.mnText;
607 40 : if( maPosition.mnText < pTextObj->getTextCount() )
608 0 : return;
609 : }
610 : else
611 : {
612 0 : --maPosition.mnText;
613 0 : if( maPosition.mnText >= 0 )
614 0 : return;
615 : }
616 : }
617 :
618 60 : if (mpObjectIterator != NULL && mpObjectIterator->IsMore())
619 42 : maPosition.mxObject.reset(mpObjectIterator->Next());
620 : else
621 18 : maPosition.mxObject.reset(NULL);
622 :
623 60 : if (!maPosition.mxObject.is() )
624 : {
625 18 : if (mbDirectionIsForward)
626 18 : SetPage (maPosition.mnPageIndex+1);
627 : else
628 0 : SetPage (maPosition.mnPageIndex-1);
629 :
630 18 : if (mpPage != NULL)
631 4 : mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, !mbDirectionIsForward);
632 18 : if (mpObjectIterator!=NULL && mpObjectIterator->IsMore())
633 4 : maPosition.mxObject.reset(mpObjectIterator->Next());
634 : else
635 14 : maPosition.mxObject.reset(NULL);
636 : }
637 :
638 60 : maPosition.mnText = 0;
639 60 : if( !mbDirectionIsForward && maPosition.mxObject.is() )
640 : {
641 0 : pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() );
642 0 : if( pTextObj )
643 0 : maPosition.mnText = pTextObj->getTextCount() - 1;
644 : }
645 : }
646 :
647 117 : void ViewIteratorImpl::SetPage (sal_Int32 nPageIndex)
648 : {
649 117 : mbPageChangeOccurred = (maPosition.mnPageIndex!=nPageIndex);
650 117 : if (mbPageChangeOccurred)
651 : {
652 115 : maPosition.mnPageIndex = nPageIndex;
653 :
654 : sal_Int32 nPageCount;
655 115 : if (maPosition.meEditMode == EM_PAGE)
656 24 : nPageCount = mpDocument->GetSdPageCount(maPosition.mePageKind);
657 : else
658 : nPageCount = mpDocument->GetMasterSdPageCount(
659 91 : maPosition.mePageKind);
660 :
661 : // Get page pointer. Here we have three cases: regular pages,
662 : // master pages and invalid page indices. The later ones are not
663 : // errors but the effect of the iterator advancing to the next page
664 : // and going past the last one. This dropping of the rim at the far
665 : // side is detected here and has to be reacted to by the caller.
666 115 : if (nPageIndex>=0 && nPageIndex < nPageCount)
667 : {
668 64 : if (maPosition.meEditMode == EM_PAGE)
669 : mpPage = mpDocument->GetSdPage (
670 : (sal_uInt16)nPageIndex,
671 18 : maPosition.mePageKind);
672 : else
673 : mpPage = mpDocument->GetMasterSdPage (
674 : (sal_uInt16)nPageIndex,
675 14 : maPosition.mePageKind);
676 : }
677 : else
678 83 : mpPage = NULL;
679 : }
680 :
681 : // Set up object list iterator.
682 117 : if (mpPage != NULL)
683 32 : mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, ! mbDirectionIsForward);
684 : else
685 85 : mpObjectIterator = NULL;
686 :
687 : // Get object pointer.
688 117 : if (mpObjectIterator!=NULL && mpObjectIterator->IsMore())
689 30 : maPosition.mxObject.reset( mpObjectIterator->Next() );
690 : else
691 87 : maPosition.mxObject.reset( NULL );
692 :
693 117 : maPosition.mnText = 0;
694 117 : if( !mbDirectionIsForward && maPosition.mxObject.is() )
695 : {
696 0 : SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() );
697 0 : if( pTextObj )
698 0 : maPosition.mnText = pTextObj->getTextCount() - 1;
699 : }
700 :
701 117 : }
702 :
703 0 : void ViewIteratorImpl::Reverse()
704 : {
705 0 : IteratorImplBase::Reverse ();
706 :
707 : // Create reversed object list iterator.
708 0 : if (mpObjectIterator != NULL)
709 0 : delete mpObjectIterator;
710 0 : if (mpPage != NULL)
711 0 : mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, ! mbDirectionIsForward);
712 : else
713 0 : mpObjectIterator = NULL;
714 :
715 : // Move iterator to the current object.
716 0 : SdrObjectWeakRef xObject = maPosition.mxObject;
717 0 : maPosition.mxObject.reset(NULL);
718 :
719 0 : if (!mpObjectIterator)
720 0 : return;
721 :
722 0 : while (mpObjectIterator->IsMore() && maPosition.mxObject != xObject)
723 0 : maPosition.mxObject.reset(mpObjectIterator->Next());
724 : }
725 :
726 : //===== DocumentIteratorImpl ============================================
727 :
728 87 : DocumentIteratorImpl::DocumentIteratorImpl (
729 : sal_Int32 nPageIndex,
730 : PageKind ePageKind, EditMode eEditMode,
731 : SdDrawDocument* pDocument,
732 : const ::boost::weak_ptr<ViewShell>& rpViewShellWeak,
733 : bool bDirectionIsForward)
734 : : ViewIteratorImpl (nPageIndex, pDocument, rpViewShellWeak, bDirectionIsForward,
735 87 : ePageKind, eEditMode)
736 : {
737 87 : if (eEditMode == EM_PAGE)
738 10 : mnPageCount = pDocument->GetSdPageCount (ePageKind);
739 : else
740 77 : mnPageCount = pDocument->GetMasterSdPageCount(ePageKind);
741 87 : }
742 :
743 174 : DocumentIteratorImpl::~DocumentIteratorImpl()
744 174 : {}
745 :
746 15 : IteratorImplBase* DocumentIteratorImpl::Clone (IteratorImplBase* pObject) const
747 : {
748 15 : DocumentIteratorImpl* pIterator = static_cast<DocumentIteratorImpl*>(pObject);
749 15 : if (pIterator == NULL)
750 : pIterator = new DocumentIteratorImpl (
751 : maPosition.mnPageIndex, maPosition.mePageKind, maPosition.meEditMode,
752 15 : mpDocument, mpViewShellWeak, mbDirectionIsForward);
753 : // Finish the cloning.
754 15 : return ViewIteratorImpl::Clone (pIterator);
755 : }
756 :
757 60 : void DocumentIteratorImpl::GotoNextText()
758 : {
759 60 : bool bSetToOnePastLastPage = false;
760 60 : bool bViewChanged = false;
761 :
762 60 : ViewIteratorImpl::GotoNextText();
763 :
764 60 : if (mbDirectionIsForward)
765 : {
766 60 : if (maPosition.mnPageIndex >= mnPageCount)
767 : {
768 : // Switch to master page.
769 12 : if (maPosition.meEditMode == EM_PAGE)
770 : {
771 6 : maPosition.meEditMode = EM_MASTERPAGE;
772 6 : SetPage (0);
773 : }
774 :
775 : // Switch to next view mode.
776 : else
777 : {
778 6 : if (maPosition.mePageKind == PK_HANDOUT)
779 : // Not really necessary but makes things more clear.
780 2 : bSetToOnePastLastPage = true;
781 : else
782 : {
783 4 : maPosition.meEditMode = EM_PAGE;
784 4 : if (maPosition.mePageKind == PK_STANDARD)
785 2 : maPosition.mePageKind = PK_NOTES;
786 2 : else if (maPosition.mePageKind == PK_NOTES)
787 2 : maPosition.mePageKind = PK_HANDOUT;
788 4 : SetPage (0);
789 : }
790 : }
791 12 : bViewChanged = true;
792 : }
793 : }
794 : else
795 0 : if (maPosition.mnPageIndex < 0)
796 : {
797 : // Switch from master pages to draw pages.
798 0 : if (maPosition.meEditMode == EM_MASTERPAGE)
799 : {
800 0 : maPosition.meEditMode = EM_PAGE;
801 0 : bSetToOnePastLastPage = true;
802 : }
803 :
804 : // Switch to previous view mode.
805 : else
806 : {
807 0 : if (maPosition.mePageKind == PK_STANDARD)
808 0 : SetPage (-1);
809 : else
810 : {
811 0 : maPosition.meEditMode = EM_MASTERPAGE;
812 0 : if (maPosition.mePageKind == PK_HANDOUT)
813 0 : maPosition.mePageKind = PK_NOTES;
814 0 : else if (maPosition.mePageKind == PK_NOTES)
815 0 : maPosition.mePageKind = PK_STANDARD;
816 0 : bSetToOnePastLastPage = true;
817 : }
818 : }
819 0 : bViewChanged = true;
820 : }
821 :
822 60 : if (bViewChanged)
823 : {
824 : // Get new page count;
825 : sal_Int32 nPageCount;
826 12 : if (maPosition.meEditMode == EM_PAGE)
827 4 : nPageCount = mpDocument->GetSdPageCount (maPosition.mePageKind);
828 : else
829 8 : nPageCount = mpDocument->GetMasterSdPageCount(maPosition.mePageKind);
830 :
831 : // Now that we know the number of pages we can set the current page index.
832 12 : if (bSetToOnePastLastPage)
833 2 : SetPage (nPageCount);
834 : }
835 60 : }
836 :
837 66 : } } // end of namespace ::sd::outliner
838 :
839 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
