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 716 : IteratorPosition::IteratorPosition (void)
40 : : mnText(0)
41 : , mnPageIndex(-1)
42 : , mePageKind(PK_STANDARD)
43 716 : , meEditMode(EM_PAGE)
44 : {
45 716 : }
46 :
47 0 : IteratorPosition::IteratorPosition (const IteratorPosition& aPosition)
48 : : mxObject(aPosition.mxObject)
49 : , mnText(aPosition.mnText)
50 : , mnPageIndex(aPosition.mnPageIndex)
51 : , mePageKind(aPosition.mePageKind)
52 0 : , meEditMode(aPosition.meEditMode)
53 : {
54 0 : }
55 :
56 716 : IteratorPosition::~IteratorPosition (void)
57 : {
58 716 : }
59 :
60 0 : IteratorPosition& IteratorPosition::operator= (const IteratorPosition& aPosition)
61 : {
62 0 : mxObject = aPosition.mxObject;
63 0 : mnText = aPosition.mnText;
64 0 : mnPageIndex = aPosition.mnPageIndex;
65 0 : mePageKind = aPosition.mePageKind;
66 0 : meEditMode = aPosition.meEditMode;
67 0 : return *this;
68 : }
69 :
70 0 : bool IteratorPosition::operator== (const IteratorPosition& aPosition) const
71 : {
72 0 : return mxObject.get() == aPosition.mxObject.get()
73 0 : && mnText == aPosition.mnText
74 0 : && mnPageIndex == aPosition.mnPageIndex
75 0 : && mePageKind == aPosition.mePageKind
76 0 : && meEditMode == aPosition.meEditMode;
77 : }
78 :
79 : //===== Iterator ==============================================================
80 :
81 716 : Iterator::Iterator()
82 : {
83 716 : mpIterator = NULL;
84 716 : }
85 :
86 0 : Iterator::Iterator (const Iterator& rIterator)
87 : {
88 0 : mpIterator = rIterator.mpIterator ? rIterator.mpIterator->Clone() : NULL;
89 0 : }
90 :
91 0 : Iterator::Iterator (IteratorImplBase* pObject)
92 : {
93 0 : mpIterator = pObject;
94 0 : }
95 :
96 716 : Iterator::~Iterator()
97 : {
98 716 : delete mpIterator;
99 716 : }
100 :
101 0 : Iterator& Iterator::operator= (const Iterator& rIterator)
102 : {
103 0 : if (this != &rIterator)
104 : {
105 0 : delete mpIterator;
106 0 : if (rIterator.mpIterator != NULL)
107 0 : mpIterator = rIterator.mpIterator->Clone();
108 : else
109 0 : mpIterator = NULL;
110 : }
111 0 : return *this;
112 : }
113 :
114 0 : const IteratorPosition& Iterator::operator* () const
115 : {
116 : DBG_ASSERT (mpIterator!=NULL, "::sd::outliner::Iterator::operator* : missing implementation object");
117 0 : return mpIterator->GetPosition();
118 : }
119 :
120 0 : Iterator& Iterator::operator++ ()
121 : {
122 0 : if (mpIterator!=NULL)
123 0 : mpIterator->GotoNextText();
124 0 : 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 0 : bool Iterator::operator== (const Iterator& rIterator)
136 : {
137 0 : if (mpIterator == NULL || rIterator.mpIterator==NULL)
138 0 : return mpIterator == rIterator.mpIterator;
139 : else
140 0 : return *mpIterator == *rIterator.mpIterator;
141 : }
142 :
143 0 : bool Iterator::operator!= (const Iterator& rIterator)
144 : {
145 0 : return ! operator==(rIterator);
146 : }
147 :
148 0 : void Iterator::Reverse (void)
149 : {
150 0 : if (mpIterator != NULL)
151 0 : mpIterator->Reverse();
152 0 : }
153 :
154 : //===== IteratorFactory =======================================================
155 :
156 0 : OutlinerContainer::OutlinerContainer (Outliner* pOutliner)
157 0 : : mpOutliner(pOutliner)
158 : {
159 0 : }
160 :
161 0 : Iterator OutlinerContainer::begin (void)
162 : {
163 0 : return CreateIterator (BEGIN);
164 : }
165 :
166 0 : Iterator OutlinerContainer::end (void)
167 : {
168 0 : return CreateIterator (END);
169 : }
170 :
171 0 : Iterator OutlinerContainer::current (void)
172 : {
173 0 : return CreateIterator (CURRENT);
174 : }
175 :
176 0 : Iterator OutlinerContainer::CreateIterator (IteratorLocation aLocation)
177 : {
178 : // Decide on certain features of the outliner which kind of iterator to
179 : // use.
180 0 : 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 0 : 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 0 : 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 0 : switch (aLocation)
249 : {
250 : case BEGIN:
251 : default:
252 0 : if (bDirectionIsForward)
253 : {
254 0 : ePageKind = PK_STANDARD;
255 0 : eEditMode = EM_PAGE;
256 : }
257 : else
258 : {
259 0 : ePageKind = PK_HANDOUT;
260 0 : eEditMode = EM_MASTERPAGE;
261 : }
262 0 : break;
263 :
264 : case END:
265 0 : if (bDirectionIsForward)
266 : {
267 0 : ePageKind = PK_HANDOUT;
268 0 : eEditMode = EM_MASTERPAGE;
269 : }
270 : else
271 : {
272 0 : ePageKind = PK_STANDARD;
273 0 : eEditMode = EM_PAGE;
274 : }
275 0 : break;
276 :
277 : case CURRENT:
278 : const ::boost::shared_ptr<DrawViewShell> pDrawViewShell(
279 0 : ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShell));
280 0 : if (pDrawViewShell.get())
281 : {
282 0 : ePageKind = pDrawViewShell->GetPageKind();
283 0 : eEditMode = pDrawViewShell->GetEditMode();
284 : }
285 : else
286 : {
287 0 : ePageKind = PK_STANDARD;
288 0 : eEditMode = EM_PAGE;
289 : }
290 0 : break;
291 : }
292 :
293 : sal_Int32 nPageIndex = GetPageIndex (pDocument, rpViewShell,
294 0 : ePageKind, eEditMode, bDirectionIsForward, aLocation);
295 :
296 : return Iterator (
297 : new DocumentIteratorImpl (nPageIndex, ePageKind, eEditMode,
298 0 : pDocument, rpViewShell, bDirectionIsForward));
299 : }
300 :
301 0 : 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 0 : ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShell));
316 :
317 0 : switch (eEditMode)
318 : {
319 : case EM_PAGE:
320 0 : nPageCount = pDocument->GetSdPageCount (ePageKind);
321 0 : break;
322 : case EM_MASTERPAGE:
323 0 : nPageCount = pDocument->GetMasterSdPageCount(ePageKind);
324 0 : break;
325 : default:
326 0 : nPageCount = 0;
327 : }
328 :
329 0 : switch (aLocation)
330 : {
331 : case CURRENT:
332 0 : if (pDrawViewShell.get())
333 0 : 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 0 : break;
343 :
344 : case BEGIN:
345 : default:
346 0 : if (bDirectionIsForward)
347 0 : nPageIndex = 0;
348 : else
349 0 : nPageIndex = nPageCount-1;
350 0 : break;
351 :
352 : case END:
353 0 : if (bDirectionIsForward)
354 0 : nPageIndex = nPageCount;
355 : else
356 0 : nPageIndex = -1;
357 0 : break;
358 : }
359 :
360 0 : 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 0 : 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 0 : , mbDirectionIsForward (bDirectionIsForward)
396 : {
397 0 : maPosition.mePageKind = ePageKind;
398 0 : maPosition.meEditMode = eEditMode;
399 0 : }
400 :
401 0 : IteratorImplBase::~IteratorImplBase (void)
402 0 : {}
403 :
404 0 : bool IteratorImplBase::operator== (const IteratorImplBase& rIterator) const
405 : {
406 0 : 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 0 : const IteratorPosition& IteratorImplBase::GetPosition (void)
418 : {
419 0 : return maPosition;
420 : }
421 :
422 0 : IteratorImplBase* IteratorImplBase::Clone (IteratorImplBase* pObject) const
423 : {
424 0 : if (pObject != NULL)
425 : {
426 0 : pObject->maPosition = maPosition;
427 0 : pObject->mpDocument = mpDocument;
428 0 : pObject->mpViewShellWeak = mpViewShellWeak;
429 0 : pObject->mbDirectionIsForward = mbDirectionIsForward;
430 : }
431 0 : return pObject;
432 : }
433 :
434 0 : void IteratorImplBase::Reverse (void)
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 (void)
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 (void)
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 (void)
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 0 : 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 0 : mpObjectIterator(NULL)
566 : {
567 0 : SetPage (nPageIndex);
568 0 : }
569 :
570 0 : ViewIteratorImpl::~ViewIteratorImpl (void)
571 : {
572 0 : }
573 :
574 0 : IteratorImplBase* ViewIteratorImpl::Clone (IteratorImplBase* pObject) const
575 : {
576 :
577 0 : ViewIteratorImpl* pIterator = static_cast<ViewIteratorImpl*>(pObject);
578 0 : if (pIterator == NULL)
579 : pIterator = new ViewIteratorImpl (
580 0 : maPosition.mnPageIndex, mpDocument, mpViewShellWeak, mbDirectionIsForward);
581 :
582 0 : IteratorImplBase::Clone (pObject);
583 :
584 0 : if (mpObjectIterator != NULL)
585 : {
586 0 : pIterator->mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, !mbDirectionIsForward);
587 :
588 : // No direct way to set the object iterator to the current object.
589 0 : pIterator->maPosition.mxObject.reset(NULL);
590 0 : while (pIterator->mpObjectIterator->IsMore() && pIterator->maPosition.mxObject!=maPosition.mxObject)
591 0 : pIterator->maPosition.mxObject.reset(pIterator->mpObjectIterator->Next());
592 : }
593 : else
594 0 : pIterator->mpObjectIterator = NULL;
595 :
596 0 : return pIterator;
597 : }
598 :
599 0 : void ViewIteratorImpl::GotoNextText(void)
600 : {
601 0 : SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() );
602 0 : if( pTextObj )
603 : {
604 0 : if (mbDirectionIsForward)
605 : {
606 0 : ++maPosition.mnText;
607 0 : 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 0 : if (mpObjectIterator != NULL && mpObjectIterator->IsMore())
619 0 : maPosition.mxObject.reset(mpObjectIterator->Next());
620 : else
621 0 : maPosition.mxObject.reset(NULL);
622 :
623 0 : if (!maPosition.mxObject.is() )
624 : {
625 0 : if (mbDirectionIsForward)
626 0 : SetPage (maPosition.mnPageIndex+1);
627 : else
628 0 : SetPage (maPosition.mnPageIndex-1);
629 :
630 0 : if (mpPage != NULL)
631 0 : mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, !mbDirectionIsForward);
632 0 : if (mpObjectIterator!=NULL && mpObjectIterator->IsMore())
633 0 : maPosition.mxObject.reset(mpObjectIterator->Next());
634 : else
635 0 : maPosition.mxObject.reset(NULL);
636 : }
637 :
638 0 : maPosition.mnText = 0;
639 0 : 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 0 : void ViewIteratorImpl::SetPage (sal_Int32 nPageIndex)
648 : {
649 0 : mbPageChangeOccurred = (maPosition.mnPageIndex!=nPageIndex);
650 0 : if (mbPageChangeOccurred)
651 : {
652 0 : maPosition.mnPageIndex = nPageIndex;
653 :
654 : sal_Int32 nPageCount;
655 0 : if (maPosition.meEditMode == EM_PAGE)
656 0 : nPageCount = mpDocument->GetSdPageCount(maPosition.mePageKind);
657 : else
658 : nPageCount = mpDocument->GetMasterSdPageCount(
659 0 : 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 0 : if (nPageIndex>=0 && nPageIndex < nPageCount)
667 : {
668 0 : if (maPosition.meEditMode == EM_PAGE)
669 : mpPage = mpDocument->GetSdPage (
670 : (sal_uInt16)nPageIndex,
671 0 : maPosition.mePageKind);
672 : else
673 : mpPage = mpDocument->GetMasterSdPage (
674 : (sal_uInt16)nPageIndex,
675 0 : maPosition.mePageKind);
676 : }
677 : else
678 0 : mpPage = NULL;
679 : }
680 :
681 : // Set up object list iterator.
682 0 : if (mpPage != NULL)
683 0 : mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, ! mbDirectionIsForward);
684 : else
685 0 : mpObjectIterator = NULL;
686 :
687 : // Get object pointer.
688 0 : if (mpObjectIterator!=NULL && mpObjectIterator->IsMore())
689 0 : maPosition.mxObject.reset( mpObjectIterator->Next() );
690 : else
691 0 : maPosition.mxObject.reset( NULL );
692 :
693 0 : maPosition.mnText = 0;
694 0 : 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 0 : }
702 :
703 0 : void ViewIteratorImpl::Reverse (void)
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 0 : 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 0 : ePageKind, eEditMode)
736 : {
737 0 : if (eEditMode == EM_PAGE)
738 0 : mnPageCount = pDocument->GetSdPageCount (ePageKind);
739 : else
740 0 : mnPageCount = pDocument->GetMasterSdPageCount(ePageKind);
741 0 : }
742 :
743 0 : DocumentIteratorImpl::~DocumentIteratorImpl (void)
744 0 : {}
745 :
746 0 : IteratorImplBase* DocumentIteratorImpl::Clone (IteratorImplBase* pObject) const
747 : {
748 0 : DocumentIteratorImpl* pIterator = static_cast<DocumentIteratorImpl*>(pObject);
749 0 : if (pIterator == NULL)
750 : pIterator = new DocumentIteratorImpl (
751 : maPosition.mnPageIndex, maPosition.mePageKind, maPosition.meEditMode,
752 0 : mpDocument, mpViewShellWeak, mbDirectionIsForward);
753 : // Finish the cloning.
754 0 : return ViewIteratorImpl::Clone (pIterator);
755 : }
756 :
757 0 : void DocumentIteratorImpl::GotoNextText (void)
758 : {
759 0 : bool bSetToOnePastLastPage = false;
760 0 : bool bViewChanged = false;
761 :
762 0 : ViewIteratorImpl::GotoNextText();
763 :
764 0 : if (mbDirectionIsForward)
765 : {
766 0 : if (maPosition.mnPageIndex >= mnPageCount)
767 : {
768 : // Switch to master page.
769 0 : if (maPosition.meEditMode == EM_PAGE)
770 : {
771 0 : maPosition.meEditMode = EM_MASTERPAGE;
772 0 : SetPage (0);
773 : }
774 :
775 : // Switch to next view mode.
776 : else
777 : {
778 0 : if (maPosition.mePageKind == PK_HANDOUT)
779 : // Not really necessary but makes things more clear.
780 0 : bSetToOnePastLastPage = true;
781 : else
782 : {
783 0 : maPosition.meEditMode = EM_PAGE;
784 0 : if (maPosition.mePageKind == PK_STANDARD)
785 0 : maPosition.mePageKind = PK_NOTES;
786 0 : else if (maPosition.mePageKind == PK_NOTES)
787 0 : maPosition.mePageKind = PK_HANDOUT;
788 0 : SetPage (0);
789 : }
790 : }
791 0 : 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 0 : if (bViewChanged)
823 : {
824 : // Get new page count;
825 : sal_Int32 nPageCount;
826 0 : if (maPosition.meEditMode == EM_PAGE)
827 0 : nPageCount = mpDocument->GetSdPageCount (maPosition.mePageKind);
828 : else
829 0 : nPageCount = mpDocument->GetMasterSdPageCount(maPosition.mePageKind);
830 :
831 : // Now that we know the number of pages we can set the current page index.
832 0 : if (bSetToOnePastLastPage)
833 0 : SetPage (nPageCount);
834 : }
835 0 : }
836 :
837 114 : } } // end of namespace ::sd::outliner
838 :
839 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
