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