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