sd/source/ui/view/OutlinerIterator.cxx

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