vcl/source/control/wizardmachine.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 <comphelper/lok.hxx>
  21 #include <officecfg/Office/Common.hxx>
  22 #include <vcl/event.hxx>
  23 #include <tools/debug.hxx>
  24 #include <comphelper/diagnose_ex.hxx>
  25 #include <strings.hrc>
  26 #include <svdata.hxx>
  27 #include <wizdlg.hxx>
  28 #include <stack>
  29 #include "wizimpldata.hxx"
  30
  31 constexpr OUString HID_WIZARD_NEXT = u"SVT_HID_WIZARD_NEXT"_ustr;
  32 constexpr OUString HID_WIZARD_PREVIOUS = u"SVT_HID_WIZARD_PREVIOUS"_ustr;
  33
  34 #define WIZARDDIALOG_BUTTON_OFFSET_Y        6
  35 #define WIZARDDIALOG_BUTTON_DLGOFFSET_X     6
  36 #define WIZARDDIALOG_VIEW_DLGOFFSET_X       6
  37 #define WIZARDDIALOG_VIEW_DLGOFFSET_Y       6
  38
  39 namespace vcl
  40 {
  41     //= WizardPageImplData
  42     OWizardPage::OWizardPage(weld::Container* pPage, weld::DialogController* pController, const OUString& rUIXMLDescription, const OUString& rID)
  43         : BuilderPage(pPage, pController, rUIXMLDescription, rID)
  44     {
  45     }
  46
  47     OWizardPage::~OWizardPage()
  48     {
  49     }
  50
  51     void OWizardPage::initializePage()
  52     {
  53     }
  54
  55     void OWizardPage::Activate()
  56     {
  57         BuilderPage::Activate();
  58         updateDialogTravelUI();
  59     }
  60
  61     void OWizardPage::updateDialogTravelUI()
  62     {
  63         auto pWizardMachine = dynamic_cast<RoadmapWizardMachine*>(m_pDialogController);
  64         if (pWizardMachine)
  65             pWizardMachine->updateTravelUI();
  66     }
  67
  68     bool OWizardPage::canAdvance() const
  69     {
  70         return true;
  71     }
  72
  73     bool OWizardPage::commitPage( WizardTypes::CommitPageReason )
  74     {
  75         return true;
  76     }
  77
  78     void RoadmapWizard::SetLeftAlignedButtonCount( sal_Int16 _nCount )
  79     {
  80         mnLeftAlignCount = _nCount;
  81     }
  82
  83     void RoadmapWizard::ImplCalcSize( Size& rSize )
  84     {
  85         // calculate ButtonBar height and width
  86         tools::Long                nMaxHeight = 0;
  87         tools::Long                nBarWidth = WIZARDDIALOG_BUTTON_DLGOFFSET_X * 2 + LogicalCoordinateToPixel(6);
  88         ImplWizButtonData*  pBtnData = mpFirstBtn;
  89         while (pBtnData)
  90         {
  91             auto nBtnHeight = pBtnData->mpButton->GetSizePixel().Height();
  92             auto nBtnWidth = pBtnData->mpButton->GetSizePixel().Width();
  93             if (pBtnData->mpButton->IsVisible())
  94             {
  95                 nBarWidth += nBtnWidth;
  96                 nBarWidth += pBtnData->mnOffset;
  97             }
  98             if ( nBtnHeight > nMaxHeight )
  99                 nMaxHeight = nBtnHeight;
 100             pBtnData = pBtnData->mpNext;
 101         }
 102         if ( nMaxHeight )
 103             nMaxHeight += WIZARDDIALOG_BUTTON_OFFSET_Y*2;
 104         rSize.AdjustHeight(nMaxHeight);
 105
 106         // add in the view window size
 107         if ( mpViewWindow && mpViewWindow->IsVisible() )
 108         {
 109             Size aViewSize = mpViewWindow->GetSizePixel();
 110             // align left
 111             rSize.AdjustWidth(aViewSize.Width() );
 112         }
 113
 114         if (nBarWidth > rSize.Width())
 115             rSize.setWidth(nBarWidth);
 116     }
 117
 118     void RoadmapWizard::queue_resize(StateChangedType /*eReason*/)
 119     {
 120         if (maWizardLayoutIdle.IsActive())
 121             return;
 122         if (IsInClose())
 123             return;
 124         maWizardLayoutIdle.Start();
 125     }
 126
 127     IMPL_LINK_NOARG(RoadmapWizard, ImplHandleWizardLayoutTimerHdl, Timer*, void)
 128     {
 129         ImplPosCtrls();
 130         ImplPosTabPage();
 131     }
 132
 133     void RoadmapWizard::ImplPosCtrls()
 134     {
 135         Size    aDlgSize = GetOutputSizePixel();
 136         tools::Long    nBtnWidth = 0;
 137         tools::Long    nMaxHeight = 0;
 138         tools::Long    nOffY = aDlgSize.Height();
 139
 140         ImplWizButtonData* pBtnData = mpFirstBtn;
 141         int j = 0;
 142         while ( pBtnData )
 143         {
 144             if (j >= mnLeftAlignCount)
 145             {
 146                 Size aBtnSize = pBtnData->mpButton->GetSizePixel();
 147                 tools::Long nBtnHeight = aBtnSize.Height();
 148                 if ( nBtnHeight > nMaxHeight )
 149                     nMaxHeight = nBtnHeight;
 150                 nBtnWidth += aBtnSize.Width();
 151                 nBtnWidth += pBtnData->mnOffset;
 152             }
 153             pBtnData = pBtnData->mpNext;
 154             j++;
 155         }
 156
 157         if ( nMaxHeight )
 158         {
 159             tools::Long nOffX = aDlgSize.Width()-nBtnWidth-WIZARDDIALOG_BUTTON_DLGOFFSET_X;
 160             tools::Long nOffLeftAlignX = LogicalCoordinateToPixel(6);
 161             nOffY -= WIZARDDIALOG_BUTTON_OFFSET_Y+nMaxHeight;
 162
 163             pBtnData = mpFirstBtn;
 164             int i = 0;
 165             while ( pBtnData )
 166             {
 167                 Size aBtnSize = pBtnData->mpButton->GetSizePixel();
 168                 if (i >= mnLeftAlignCount)
 169                 {
 170                     Point aPos( nOffX, nOffY+((nMaxHeight-aBtnSize.Height())/2) );
 171                     pBtnData->mpButton->SetPosPixel( aPos );
 172                     nOffX += aBtnSize.Width();
 173                     nOffX += pBtnData->mnOffset;
 174                 }
 175                 else
 176                 {
 177                     Point aPos( nOffLeftAlignX, nOffY+((nMaxHeight-aBtnSize.Height())/2) );
 178                     pBtnData->mpButton->SetPosPixel( aPos );
 179                     nOffLeftAlignX += aBtnSize.Width();
 180                     nOffLeftAlignX += pBtnData->mnOffset;
 181                 }
 182
 183                 pBtnData = pBtnData->mpNext;
 184                 i++;
 185             }
 186
 187             nOffY -= WIZARDDIALOG_BUTTON_OFFSET_Y;
 188         }
 189
 190         if ( !(mpViewWindow && mpViewWindow->IsVisible()) )
 191             return;
 192
 193         tools::Long    nViewOffX = 0;
 194         tools::Long    nViewOffY = 0;
 195         tools::Long    nViewWidth = 0;
 196         tools::Long    nViewHeight = 0;
 197         tools::Long    nDlgHeight = nOffY;
 198         PosSizeFlags nViewPosFlags = PosSizeFlags::Pos;
 199         // align left
 200         {
 201             if ( mbEmptyViewMargin )
 202             {
 203                 nViewOffX       = 0;
 204                 nViewOffY       = 0;
 205                 nViewHeight     = nDlgHeight;
 206             }
 207             else
 208             {
 209                 nViewOffX       = WIZARDDIALOG_VIEW_DLGOFFSET_X;
 210                 nViewOffY       = WIZARDDIALOG_VIEW_DLGOFFSET_Y;
 211                 nViewHeight     = nDlgHeight-(WIZARDDIALOG_VIEW_DLGOFFSET_Y*2);
 212             }
 213             nViewPosFlags  |= PosSizeFlags::Height;
 214         }
 215         mpViewWindow->setPosSizePixel( nViewOffX, nViewOffY,
 216                                        nViewWidth, nViewHeight,
 217                                        nViewPosFlags );
 218     }
 219
 220     tools::Long RoadmapWizard::LogicalCoordinateToPixel(int iCoordinate) const
 221     {
 222         Size aLocSize = LogicToPixel(Size(iCoordinate, 0), MapMode(MapUnit::MapAppFont));
 223         int iPixelCoordinate =  aLocSize.Width();
 224         return iPixelCoordinate;
 225     }
 226
 227     void RoadmapWizard::ImplPosTabPage()
 228     {
 229         if ( !mpCurTabPage )
 230             return;
 231
 232         if ( !IsInInitShow() )
 233         {
 234             // #100199# - On Unix initial size is equal to screen size, on Windows
 235             // it's 0,0. One cannot calculate the size unless dialog is visible.
 236             if ( !IsReallyVisible() )
 237                 return;
 238         }
 239
 240         // calculate height of ButtonBar
 241         tools::Long                nMaxHeight = 0;
 242         ImplWizButtonData*  pBtnData = mpFirstBtn;
 243         while ( pBtnData )
 244         {
 245             tools::Long nBtnHeight = pBtnData->mpButton->GetSizePixel().Height();
 246             if ( nBtnHeight > nMaxHeight )
 247                 nMaxHeight = nBtnHeight;
 248             pBtnData = pBtnData->mpNext;
 249         }
 250         if ( nMaxHeight )
 251             nMaxHeight += WIZARDDIALOG_BUTTON_OFFSET_Y*2;
 252
 253         // position TabPage
 254         Size aDlgSize = GetOutputSizePixel();
 255         aDlgSize.AdjustHeight( -nMaxHeight );
 256         tools::Long nOffX = 0;
 257         tools::Long nOffY = 0;
 258         if ( mpViewWindow && mpViewWindow->IsVisible() )
 259         {
 260             Size aViewSize = mpViewWindow->GetSizePixel();
 261             // align left
 262             tools::Long nViewOffset = mbEmptyViewMargin ? 0 : WIZARDDIALOG_VIEW_DLGOFFSET_X;
 263             nOffX += aViewSize.Width() + nViewOffset;
 264             aDlgSize.AdjustWidth( -nOffX );
 265         }
 266         Point aPos( nOffX, nOffY );
 267         mpCurTabPage->SetPosSizePixel( aPos, aDlgSize );
 268     }
 269
 270     void RoadmapWizard::ImplShowTabPage( TabPage* pTabPage )
 271     {
 272         if ( mpCurTabPage == pTabPage )
 273             return;
 274
 275         TabPage* pOldTabPage = mpCurTabPage;
 276
 277         mpCurTabPage = pTabPage;
 278         if ( pTabPage )
 279         {
 280             ImplPosTabPage();
 281             pTabPage->Show();
 282         }
 283
 284         if ( pOldTabPage )
 285             pOldTabPage->Hide();
 286     }
 287
 288     TabPage* RoadmapWizard::ImplGetPage( sal_uInt16 nLevel ) const
 289     {
 290         sal_uInt16              nTempLevel = 0;
 291         ImplWizPageData*    pPageData = mpFirstPage;
 292         while ( pPageData )
 293         {
 294             if ( (nTempLevel == nLevel) || !pPageData->mpNext )
 295                 break;
 296
 297             nTempLevel++;
 298             pPageData = pPageData->mpNext;
 299         }
 300
 301         if ( pPageData )
 302             return pPageData->mpPage;
 303         return nullptr;
 304     }
 305
 306     void RoadmapWizard::AddButtonResponse( Button* pButton, int response)
 307     {
 308         m_xRoadmapImpl->maResponses[pButton] = response;
 309     }
 310
 311     void RoadmapWizard::implConstruct( const WizardButtonFlags _nButtonFlags )
 312     {
 313         m_xWizardImpl->sTitleBase = GetText();
 314
 315         // create the buttons according to the wizard button flags
 316         // the help button
 317         if (_nButtonFlags & WizardButtonFlags::HELP)
 318         {
 319             m_pHelp= VclPtr<HelpButton>::Create(this, WB_TABSTOP);
 320             m_pHelp->SetSizePixel(LogicToPixel(Size(50, 14), MapMode(MapUnit::MapAppFont)));
 321             m_pHelp->Show();
 322             m_pHelp->set_id(u"help"_ustr);
 323             AddButtonResponse(m_pHelp, RET_HELP);
 324             AddButton( m_pHelp, WIZARDDIALOG_BUTTON_STDOFFSET_X);
 325         }
 326
 327         // the previous button
 328         if (_nButtonFlags & WizardButtonFlags::PREVIOUS)
 329         {
 330             m_pPrevPage = VclPtr<PushButton>::Create(this, WB_TABSTOP);
 331             m_pPrevPage->SetHelpId( HID_WIZARD_PREVIOUS );
 332             m_pPrevPage->SetSizePixel(LogicToPixel(Size(50, 14), MapMode(MapUnit::MapAppFont)));
 333             m_pPrevPage->SetText(VclResId(STR_WIZDLG_PREVIOUS));
 334             m_pPrevPage->Show();
 335             m_pPrevPage->set_id(u"previous"_ustr);
 336
 337             if (_nButtonFlags & WizardButtonFlags::NEXT)
 338                 AddButton( m_pPrevPage, ( WIZARDDIALOG_BUTTON_SMALLSTDOFFSET_X) );      // half x-offset to the next button
 339             else
 340                 AddButton( m_pPrevPage, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 341             mpPrevBtn = m_pPrevPage;
 342             m_pPrevPage->SetClickHdl( LINK( this, RoadmapWizard, OnPrevPage ) );
 343         }
 344
 345         // the next button
 346         if (_nButtonFlags & WizardButtonFlags::NEXT)
 347         {
 348             m_pNextPage = VclPtr<PushButton>::Create(this, WB_TABSTOP);
 349             m_pNextPage->SetHelpId( HID_WIZARD_NEXT );
 350             m_pNextPage->SetSizePixel(LogicToPixel(Size(50, 14), MapMode(MapUnit::MapAppFont)));
 351             m_pNextPage->SetText(VclResId(STR_WIZDLG_NEXT));
 352             m_pNextPage->Show();
 353             m_pNextPage->set_id(u"next"_ustr);
 354
 355             AddButton( m_pNextPage, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 356             mpNextBtn = m_pNextPage;
 357             m_pNextPage->SetClickHdl( LINK( this, RoadmapWizard, OnNextPage ) );
 358         }
 359
 360         // the finish button
 361         if (_nButtonFlags & WizardButtonFlags::FINISH)
 362         {
 363             m_pFinish = VclPtr<OKButton>::Create(this, WB_TABSTOP);
 364             m_pFinish->SetSizePixel(LogicToPixel(Size(50, 14), MapMode(MapUnit::MapAppFont)));
 365             m_pFinish->SetText(VclResId(STR_WIZDLG_FINISH));
 366             m_pFinish->Show();
 367             m_pFinish->set_id(u"finish"_ustr);
 368
 369             AddButton( m_pFinish, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 370             m_pFinish->SetClickHdl( LINK( this, RoadmapWizard, OnFinish ) );
 371         }
 372
 373         // the cancel button
 374         if (_nButtonFlags & WizardButtonFlags::CANCEL)
 375         {
 376             m_pCancel = VclPtr<CancelButton>::Create(this, WB_TABSTOP);
 377             m_pCancel->SetSizePixel(LogicToPixel(Size(50, 14), MapMode(MapUnit::MapAppFont)));
 378             m_pCancel->Show();
 379
 380             AddButton( m_pCancel, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 381         }
 382     }
 383
 384     void RoadmapWizard::Resize()
 385     {
 386         if ( IsReallyShown() && !IsInInitShow() )
 387         {
 388             ImplPosCtrls();
 389             ImplPosTabPage();
 390         }
 391
 392         Dialog::Resize();
 393     }
 394
 395     void RoadmapWizard::CalcAndSetSize()
 396     {
 397         Size aDlgSize = GetPageSizePixel();
 398         if ( !aDlgSize.Width() || !aDlgSize.Height() )
 399         {
 400             ImplWizPageData*  pPageData = mpFirstPage;
 401             while ( pPageData )
 402             {
 403                 if ( pPageData->mpPage )
 404                 {
 405                     Size aPageSize = pPageData->mpPage->GetSizePixel();
 406                     if ( aPageSize.Width() > aDlgSize.Width() )
 407                         aDlgSize.setWidth( aPageSize.Width() );
 408                     if ( aPageSize.Height() > aDlgSize.Height() )
 409                         aDlgSize.setHeight( aPageSize.Height() );
 410                 }
 411
 412                 pPageData = pPageData->mpNext;
 413             }
 414         }
 415         ImplCalcSize( aDlgSize );
 416         SetMinOutputSizePixel( aDlgSize );
 417         SetOutputSizePixel( aDlgSize );
 418     }
 419
 420     void RoadmapWizard::StateChanged( StateChangedType nType )
 421     {
 422         if ( nType == StateChangedType::InitShow )
 423         {
 424             if ( IsDefaultSize() )
 425             {
 426                 CalcAndSetSize();
 427             }
 428
 429             ImplPosCtrls();
 430             ImplPosTabPage();
 431             ImplShowTabPage( ImplGetPage( mnCurLevel ) );
 432         }
 433
 434         Dialog::StateChanged( nType );
 435     }
 436
 437     bool RoadmapWizard::EventNotify( NotifyEvent& rNEvt )
 438     {
 439         if ( (rNEvt.GetType() == NotifyEventType::KEYINPUT) && mpPrevBtn && mpNextBtn )
 440         {
 441             const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 442             vcl::KeyCode aKeyCode = pKEvt->GetKeyCode();
 443             sal_uInt16 nKeyCode = aKeyCode.GetCode();
 444
 445             if ( aKeyCode.IsMod1() )
 446             {
 447                 if ( aKeyCode.IsShift() || (nKeyCode == KEY_PAGEUP) )
 448                 {
 449                     if ( (nKeyCode == KEY_TAB) || (nKeyCode == KEY_PAGEUP) )
 450                     {
 451                         if ( mpPrevBtn->IsVisible() &&
 452                              mpPrevBtn->IsEnabled() && mpPrevBtn->IsInputEnabled() )
 453                         {
 454                             mpPrevBtn->SetPressed( true );
 455                             mpPrevBtn->SetPressed( false );
 456                             mpPrevBtn->Click();
 457                         }
 458                         return true;
 459                     }
 460                 }
 461                 else
 462                 {
 463                     if ( (nKeyCode == KEY_TAB) || (nKeyCode == KEY_PAGEDOWN) )
 464                     {
 465                         if ( mpNextBtn->IsVisible() &&
 466                              mpNextBtn->IsEnabled() && mpNextBtn->IsInputEnabled() )
 467                         {
 468                             mpNextBtn->SetPressed( true );
 469                             mpNextBtn->SetPressed( false );
 470                             mpNextBtn->Click();
 471                         }
 472                         return true;
 473                     }
 474                 }
 475             }
 476         }
 477
 478         return Dialog::EventNotify( rNEvt );
 479     }
 480
 481     void RoadmapWizard::GetOrCreatePage( const WizardTypes::WizardState i_nState )
 482     {
 483         if ( nullptr != GetPage( i_nState ) )
 484             return;
 485
 486         VclPtr<TabPage> pNewPage = createPage( i_nState );
 487         DBG_ASSERT( pNewPage, "RoadmapWizard::GetOrCreatePage: invalid new page (NULL)!" );
 488
 489         // fill up the page sequence of our base class (with dummies)
 490         while ( m_xWizardImpl->nFirstUnknownPage < i_nState )
 491         {
 492             AddPage( nullptr );
 493             ++m_xWizardImpl->nFirstUnknownPage;
 494         }
 495
 496         if ( m_xWizardImpl->nFirstUnknownPage == i_nState )
 497         {
 498             // encountered this page number the first time
 499             AddPage( pNewPage );
 500             ++m_xWizardImpl->nFirstUnknownPage;
 501         }
 502         else
 503             // already had this page - just change it
 504             SetPage( i_nState, pNewPage );
 505     }
 506
 507     void RoadmapWizard::ActivatePage()
 508     {
 509         WizardTypes::WizardState nCurrentLevel = GetCurLevel();
 510         GetOrCreatePage( nCurrentLevel );
 511
 512         enterState( nCurrentLevel );
 513     }
 514
 515     bool RoadmapWizard::ShowPage( sal_uInt16 nLevel )
 516     {
 517         mnCurLevel = nLevel;
 518         ActivatePage();
 519         ImplShowTabPage( ImplGetPage( mnCurLevel ) );
 520         return true;
 521     }
 522
 523     void RoadmapWizard::Finish( tools::Long nResult )
 524     {
 525         if ( IsInExecute() )
 526             EndDialog( nResult );
 527         else if ( GetStyle() & WB_CLOSEABLE )
 528             Close();
 529     }
 530
 531     void RoadmapWizard::AddPage( TabPage* pPage )
 532     {
 533         ImplWizPageData* pNewPageData = new ImplWizPageData;
 534         pNewPageData->mpNext    = nullptr;
 535         pNewPageData->mpPage    = pPage;
 536
 537         if ( !mpFirstPage )
 538             mpFirstPage = pNewPageData;
 539         else
 540         {
 541             pPage->Hide();
 542             ImplWizPageData* pPageData = mpFirstPage;
 543             while ( pPageData->mpNext )
 544                 pPageData = pPageData->mpNext;
 545             pPageData->mpNext = pNewPageData;
 546         }
 547     }
 548
 549     void RoadmapWizard::RemovePage( TabPage* pPage )
 550     {
 551         ImplWizPageData*  pPrevPageData = nullptr;
 552         ImplWizPageData*  pPageData = mpFirstPage;
 553         while ( pPageData )
 554         {
 555             if ( pPageData->mpPage == pPage )
 556             {
 557                 if ( pPrevPageData )
 558                     pPrevPageData->mpNext = pPageData->mpNext;
 559                 else
 560                     mpFirstPage = pPageData->mpNext;
 561                 if ( pPage == mpCurTabPage )
 562                     mpCurTabPage = nullptr;
 563                 delete pPageData;
 564                 return;
 565             }
 566
 567             pPrevPageData = pPageData;
 568             pPageData = pPageData->mpNext;
 569         }
 570
 571         OSL_FAIL( "RoadmapWizard::RemovePage() - Page not in list" );
 572     }
 573
 574     void RoadmapWizard::SetPage( sal_uInt16 nLevel, TabPage* pPage )
 575     {
 576         sal_uInt16              nTempLevel = 0;
 577         ImplWizPageData*    pPageData = mpFirstPage;
 578         while ( pPageData )
 579         {
 580             if ( (nTempLevel == nLevel) || !pPageData->mpNext )
 581                 break;
 582
 583             nTempLevel++;
 584             pPageData = pPageData->mpNext;
 585         }
 586
 587         if ( pPageData )
 588         {
 589             if ( pPageData->mpPage == mpCurTabPage )
 590                 mpCurTabPage = nullptr;
 591             pPageData->mpPage = pPage;
 592         }
 593     }
 594
 595     TabPage* RoadmapWizard::GetPage( sal_uInt16 nLevel ) const
 596     {
 597         sal_uInt16 nTempLevel = 0;
 598
 599         for (ImplWizPageData* pPageData = mpFirstPage; pPageData;
 600              pPageData = pPageData->mpNext)
 601         {
 602             if ( nTempLevel == nLevel )
 603                 return pPageData->mpPage;
 604             nTempLevel++;
 605         }
 606
 607         return nullptr;
 608     }
 609
 610     void RoadmapWizard::AddButton( Button* pButton, tools::Long nOffset )
 611     {
 612         ImplWizButtonData* pNewBtnData = new ImplWizButtonData;
 613         pNewBtnData->mpNext     = nullptr;
 614         pNewBtnData->mpButton   = pButton;
 615         pNewBtnData->mnOffset   = nOffset;
 616
 617         if ( !mpFirstBtn )
 618             mpFirstBtn = pNewBtnData;
 619         else
 620         {
 621             ImplWizButtonData* pBtnData = mpFirstBtn;
 622             while ( pBtnData->mpNext )
 623                 pBtnData = pBtnData->mpNext;
 624             pBtnData->mpNext = pNewBtnData;
 625         }
 626     }
 627
 628     void RoadmapWizard::RemoveButton( Button* pButton )
 629     {
 630         ImplWizButtonData*  pPrevBtnData = nullptr;
 631         ImplWizButtonData*  pBtnData = mpFirstBtn;
 632         while ( pBtnData )
 633         {
 634             if ( pBtnData->mpButton == pButton )
 635             {
 636                 if ( pPrevBtnData )
 637                     pPrevBtnData->mpNext = pBtnData->mpNext;
 638                 else
 639                     mpFirstBtn = pBtnData->mpNext;
 640                 delete pBtnData;
 641                 return;
 642             }
 643
 644             pPrevBtnData = pBtnData;
 645             pBtnData = pBtnData->mpNext;
 646         }
 647
 648         OSL_FAIL( "RoadmapWizard::RemoveButton() - Button not in list" );
 649     }
 650
 651     IMPL_LINK_NOARG(RoadmapWizard, OnFinish, Button*, void)
 652     {
 653         if ( isTravelingSuspended() )
 654             return;
 655         RoadmapWizardTravelSuspension aTravelGuard( *this );
 656         Finish( RET_OK );
 657     }
 658
 659     bool RoadmapWizard::skipBackwardUntil( WizardTypes::WizardState _nTargetState )
 660     {
 661         // don't travel directly on m_xWizardImpl->aStateHistory, in case something goes wrong
 662         std::stack< WizardTypes::WizardState > aTravelVirtually = m_xWizardImpl->aStateHistory;
 663         std::stack< WizardTypes::WizardState > aOldStateHistory = m_xWizardImpl->aStateHistory;
 664
 665         WizardTypes::WizardState nCurrentRollbackState = getCurrentState();
 666         while ( nCurrentRollbackState != _nTargetState )
 667         {
 668             DBG_ASSERT( !aTravelVirtually.empty(), "RoadmapWizard::skipBackwardUntil: this target state does not exist in the history!" );
 669             nCurrentRollbackState = aTravelVirtually.top();
 670             aTravelVirtually.pop();
 671         }
 672         m_xWizardImpl->aStateHistory = std::move(aTravelVirtually);
 673         if ( !ShowPage( _nTargetState ) )
 674         {
 675             m_xWizardImpl->aStateHistory = std::move(aOldStateHistory);
 676             return false;
 677         }
 678         return true;
 679     }
 680
 681     bool RoadmapWizard::skipUntil( WizardTypes::WizardState _nTargetState )
 682     {
 683         WizardTypes::WizardState nCurrentState = getCurrentState();
 684
 685         // don't travel directly on m_xWizardImpl->aStateHistory, in case something goes wrong
 686         std::stack< WizardTypes::WizardState > aTravelVirtually = m_xWizardImpl->aStateHistory;
 687         std::stack< WizardTypes::WizardState > aOldStateHistory = m_xWizardImpl->aStateHistory;
 688         while ( nCurrentState != _nTargetState )
 689         {
 690             WizardTypes::WizardState nNextState = determineNextState( nCurrentState );
 691             if ( WZS_INVALID_STATE == nNextState )
 692             {
 693                 OSL_FAIL( "RoadmapWizard::skipUntil: the given target state does not exist!" );
 694                 return false;
 695             }
 696
 697             // remember the skipped state in the history
 698             aTravelVirtually.push( nCurrentState );
 699
 700             // get the next state
 701             nCurrentState = nNextState;
 702         }
 703         m_xWizardImpl->aStateHistory = std::move(aTravelVirtually);
 704         // show the target page
 705         if ( !ShowPage( nCurrentState ) )
 706         {
 707             // argh! prepareLeaveCurrentPage succeeded, determineNextState succeeded,
 708             // but ShowPage doesn't? Somebody behaves very strange here...
 709             OSL_FAIL( "RoadmapWizard::skipUntil: very unpolite..." );
 710             m_xWizardImpl->aStateHistory = std::move(aOldStateHistory);
 711             return false;
 712         }
 713         return true;
 714     }
 715
 716     void RoadmapWizard::travelNext()
 717     {
 718         // determine the next state to travel to
 719         WizardTypes::WizardState nCurrentState = getCurrentState();
 720         WizardTypes::WizardState nNextState = determineNextState(nCurrentState);
 721         if (WZS_INVALID_STATE == nNextState)
 722             return;
 723
 724         // the state history is used by the enterState method
 725         // all fine
 726         m_xWizardImpl->aStateHistory.push(nCurrentState);
 727         if (!ShowPage(nNextState))
 728         {
 729             m_xWizardImpl->aStateHistory.pop();
 730         }
 731     }
 732
 733     void RoadmapWizard::travelPrevious()
 734     {
 735         DBG_ASSERT(!m_xWizardImpl->aStateHistory.empty(), "RoadmapWizard::travelPrevious: have no previous page!");
 736
 737         // the next state to switch to
 738         WizardTypes::WizardState nPreviousState = m_xWizardImpl->aStateHistory.top();
 739
 740         // the state history is used by the enterState method
 741         m_xWizardImpl->aStateHistory.pop();
 742         // show this page
 743         if (!ShowPage(nPreviousState))
 744         {
 745             m_xWizardImpl->aStateHistory.push(nPreviousState);
 746         }
 747
 748         // all fine
 749     }
 750
 751     void  RoadmapWizard::removePageFromHistory( WizardTypes::WizardState nToRemove )
 752     {
 753
 754         std::stack< WizardTypes::WizardState > aTemp;
 755         while(!m_xWizardImpl->aStateHistory.empty())
 756         {
 757             WizardTypes::WizardState nPreviousState = m_xWizardImpl->aStateHistory.top();
 758             m_xWizardImpl->aStateHistory.pop();
 759             if(nPreviousState != nToRemove)
 760                 aTemp.push( nPreviousState );
 761             else
 762                 break;
 763         }
 764         while(!aTemp.empty())
 765         {
 766             m_xWizardImpl->aStateHistory.push( aTemp.top() );
 767             aTemp.pop();
 768         }
 769     }
 770
 771     IMPL_LINK_NOARG(RoadmapWizard, OnPrevPage, Button*, void)
 772     {
 773         if ( isTravelingSuspended() )
 774             return;
 775         RoadmapWizardTravelSuspension aTravelGuard( *this );
 776         travelPrevious();
 777     }
 778
 779     IMPL_LINK_NOARG(RoadmapWizard, OnNextPage, Button*, void)
 780     {
 781         if ( isTravelingSuspended() )
 782             return;
 783         RoadmapWizardTravelSuspension aTravelGuard( *this );
 784         travelNext();
 785     }
 786
 787     bool RoadmapWizard::isTravelingSuspended() const
 788     {
 789         return m_xWizardImpl->m_bTravelingSuspended;
 790     }
 791
 792     void RoadmapWizard::suspendTraveling( AccessGuard )
 793     {
 794         DBG_ASSERT( !m_xWizardImpl->m_bTravelingSuspended, "RoadmapWizard::suspendTraveling: already suspended!" );
 795         m_xWizardImpl->m_bTravelingSuspended = true;
 796     }
 797
 798     void RoadmapWizard::resumeTraveling( AccessGuard )
 799     {
 800         DBG_ASSERT( m_xWizardImpl->m_bTravelingSuspended, "RoadmapWizard::resumeTraveling: nothing to resume!" );
 801         m_xWizardImpl->m_bTravelingSuspended = false;
 802     }
 803
 804     WizardMachine::WizardMachine(weld::Window* pParent, WizardButtonFlags nButtonFlags)
 805         : AssistantController(pParent, u"vcl/ui/wizard.ui"_ustr, u"Wizard"_ustr)
 806         , m_pCurTabPage(nullptr)
 807         , m_nCurState(0)
 808         , m_pFirstPage(nullptr)
 809         , m_xFinish(m_xAssistant->weld_button_for_response(RET_OK))
 810         , m_xCancel(m_xAssistant->weld_button_for_response(RET_CANCEL))
 811         , m_xNextPage(m_xAssistant->weld_button_for_response(RET_YES))
 812         , m_xPrevPage(m_xAssistant->weld_button_for_response(RET_NO))
 813         , m_xHelp(m_xAssistant->weld_button_for_response(RET_HELP))
 814         , m_pImpl(new WizardMachineImplData)
 815     {
 816         implConstruct(nButtonFlags);
 817     }
 818
 819     void WizardMachine::implConstruct(const WizardButtonFlags nButtonFlags)
 820     {
 821         m_pImpl->sTitleBase = m_xAssistant->get_title();
 822
 823         const bool bHideHelp = comphelper::LibreOfficeKit::isActive() &&
 824             officecfg::Office::Common::Help::HelpRootURL::get().isEmpty();
 825         // create the buttons according to the wizard button flags
 826         // the help button
 827         if (nButtonFlags & WizardButtonFlags::HELP && !bHideHelp)
 828             m_xHelp->show();
 829         else
 830             m_xHelp->hide();
 831
 832         // the previous button
 833         if (nButtonFlags & WizardButtonFlags::PREVIOUS)
 834         {
 835             m_xPrevPage->set_help_id( HID_WIZARD_PREVIOUS );
 836             m_xPrevPage->show();
 837
 838             m_xPrevPage->connect_clicked( LINK( this, WizardMachine, OnPrevPage ) );
 839         }
 840         else
 841             m_xPrevPage->hide();
 842
 843         // the next button
 844         if (nButtonFlags & WizardButtonFlags::NEXT)
 845         {
 846             m_xNextPage->set_help_id( HID_WIZARD_NEXT );
 847             m_xNextPage->show();
 848
 849             m_xNextPage->connect_clicked( LINK( this, WizardMachine, OnNextPage ) );
 850         }
 851         else
 852             m_xNextPage->hide();
 853
 854         // the finish button
 855         if (nButtonFlags & WizardButtonFlags::FINISH)
 856         {
 857             m_xFinish->show();
 858
 859             m_xFinish->connect_clicked( LINK( this, WizardMachine, OnFinish ) );
 860         }
 861         else
 862             m_xFinish->hide();
 863
 864         // the cancel button
 865         if (nButtonFlags & WizardButtonFlags::CANCEL)
 866         {
 867             m_xCancel->show();
 868             m_xCancel->connect_clicked( LINK( this, WizardMachine, OnCancel ) );
 869         }
 870         else
 871             m_xCancel->hide();
 872     }
 873
 874     WizardMachine::~WizardMachine()
 875     {
 876         if (m_pImpl)
 877         {
 878             while (m_pFirstPage)
 879                 RemovePage(m_pFirstPage->mxPage.get());
 880             m_pImpl.reset();
 881         }
 882     }
 883
 884     void WizardMachine::implUpdateTitle()
 885     {
 886         OUString sCompleteTitle(m_pImpl->sTitleBase);
 887
 888         // append the page title
 889         BuilderPage* pCurrentPage = GetPage(getCurrentState());
 890         if ( pCurrentPage && !pCurrentPage->GetPageTitle().isEmpty() )
 891         {
 892             sCompleteTitle += " - " + pCurrentPage->GetPageTitle();
 893         }
 894
 895         m_xAssistant->set_title(sCompleteTitle);
 896     }
 897
 898     void WizardMachine::setTitleBase(const OUString& _rTitleBase)
 899     {
 900         m_pImpl->sTitleBase = _rTitleBase;
 901         implUpdateTitle();
 902     }
 903
 904     OUString WizardMachine::getPageIdentForState(WizardTypes::WizardState nState) const
 905     {
 906         return OUString::number(nState);
 907     }
 908
 909     WizardTypes::WizardState WizardMachine::getStateFromPageIdent(const OUString& rIdent) const
 910     {
 911         return rIdent.toInt32();
 912     }
 913
 914     BuilderPage* WizardMachine::GetOrCreatePage( const WizardTypes::WizardState i_nState )
 915     {
 916         if ( nullptr == GetPage( i_nState ) )
 917         {
 918             std::unique_ptr<BuilderPage> xNewPage = createPage( i_nState );
 919             DBG_ASSERT( xNewPage, "WizardMachine::GetOrCreatePage: invalid new page (NULL)!" );
 920
 921             // fill up the page sequence of our base class (with dummies)
 922             while ( m_pImpl->nFirstUnknownPage < i_nState )
 923             {
 924                 AddPage( nullptr );
 925                 ++m_pImpl->nFirstUnknownPage;
 926             }
 927
 928             if ( m_pImpl->nFirstUnknownPage == i_nState )
 929             {
 930                 // encountered this page number the first time
 931                 AddPage(std::move(xNewPage));
 932                 ++m_pImpl->nFirstUnknownPage;
 933             }
 934             else
 935                 // already had this page - just change it
 936                 SetPage(i_nState, std::move(xNewPage));
 937         }
 938         return GetPage( i_nState );
 939     }
 940
 941     void WizardMachine::ActivatePage()
 942     {
 943         WizardTypes::WizardState nCurrentLevel = m_nCurState;
 944         GetOrCreatePage( nCurrentLevel );
 945
 946         enterState( nCurrentLevel );
 947     }
 948
 949     bool WizardMachine::DeactivatePage()
 950     {
 951         WizardTypes::WizardState nCurrentState = getCurrentState();
 952         return leaveState(nCurrentState);
 953     }
 954
 955     void WizardMachine::defaultButton(WizardButtonFlags _nWizardButtonFlags)
 956     {
 957         // the new default button
 958         weld::Button* pNewDefButton = nullptr;
 959         if (_nWizardButtonFlags & WizardButtonFlags::FINISH)
 960             pNewDefButton = m_xFinish.get();
 961         if (_nWizardButtonFlags & WizardButtonFlags::NEXT)
 962             pNewDefButton = m_xNextPage.get();
 963         if (_nWizardButtonFlags & WizardButtonFlags::PREVIOUS)
 964             pNewDefButton = m_xPrevPage.get();
 965         if (_nWizardButtonFlags & WizardButtonFlags::HELP)
 966             pNewDefButton = m_xHelp.get();
 967         if (_nWizardButtonFlags & WizardButtonFlags::CANCEL)
 968             pNewDefButton = m_xCancel.get();
 969
 970         defaultButton(pNewDefButton);
 971     }
 972
 973     void WizardMachine::defaultButton(weld::Button* _pNewDefButton)
 974     {
 975         // loop through all (direct and indirect) descendants which participate in our tabbing order, and
 976         // reset the WB_DEFBUTTON for every window which is a button and set _pNewDefButton as the new
 977         // WB_DEFBUTTON
 978         m_xAssistant->change_default_widget(nullptr, _pNewDefButton);
 979     }
 980
 981     void WizardMachine::enableButtons(WizardButtonFlags _nWizardButtonFlags, bool _bEnable)
 982     {
 983         if (_nWizardButtonFlags & WizardButtonFlags::FINISH)
 984             m_xFinish->set_sensitive(_bEnable);
 985         if (_nWizardButtonFlags & WizardButtonFlags::NEXT)
 986             m_xNextPage->set_sensitive(_bEnable);
 987         if (_nWizardButtonFlags & WizardButtonFlags::PREVIOUS)
 988             m_xPrevPage->set_sensitive(_bEnable);
 989         if (_nWizardButtonFlags & WizardButtonFlags::HELP)
 990             m_xHelp->set_sensitive(_bEnable);
 991         if (_nWizardButtonFlags & WizardButtonFlags::CANCEL)
 992             m_xCancel->set_sensitive(_bEnable);
 993     }
 994
 995     void WizardMachine::enterState(WizardTypes::WizardState _nState)
 996     {
 997         // tell the page
 998         IWizardPageController* pController = getPageController( GetPage( _nState ) );
 999         OSL_ENSURE( pController, "WizardMachine::enterState: no controller for the given page!" );
1000         if ( pController )
1001             pController->initializePage();
1002
1003         if ( isAutomaticNextButtonStateEnabled() )
1004             enableButtons( WizardButtonFlags::NEXT, canAdvance() );
1005
1006         enableButtons( WizardButtonFlags::PREVIOUS, !m_pImpl->aStateHistory.empty() );
1007
1008         // set the new title - it depends on the current page (i.e. state)
1009         implUpdateTitle();
1010     }
1011
1012     bool WizardMachine::leaveState(WizardTypes::WizardState)
1013     {
1014         // no need to ask the page here.
1015         // If we reach this point, we already gave the current page the chance to commit it's data,
1016         // and it was allowed to commit it's data
1017
1018         return true;
1019     }
1020
1021     bool WizardMachine::onFinish()
1022     {
1023         return Finish(RET_OK);
1024     }
1025
1026     IMPL_LINK_NOARG(WizardMachine, OnFinish, weld::Button&, void)
1027     {
1028         if ( isTravelingSuspended() )
1029             return;
1030
1031         // prevent WizardTravelSuspension from using this instance
1032         // after will be destructed due to onFinish and async response call
1033         {
1034             WizardTravelSuspension aTravelGuard( *this );
1035             if (!prepareLeaveCurrentState(WizardTypes::eFinish))
1036             {
1037                 return;
1038             }
1039         }
1040
1041         onFinish();
1042     }
1043
1044     IMPL_LINK_NOARG(WizardMachine, OnCancel, weld::Button&, void)
1045     {
1046         m_xAssistant->response(RET_CANCEL);
1047     }
1048
1049     WizardTypes::WizardState WizardMachine::determineNextState(WizardTypes::WizardState _nCurrentState ) const
1050     {
1051         return _nCurrentState + 1;
1052     }
1053
1054     bool WizardMachine::prepareLeaveCurrentState( WizardTypes::CommitPageReason _eReason )
1055     {
1056         IWizardPageController* pController = getPageController( GetPage( getCurrentState() ) );
1057         ENSURE_OR_RETURN( pController != nullptr, "WizardMachine::prepareLeaveCurrentState: no controller for the current page!", true );
1058         return pController->commitPage( _eReason );
1059     }
1060
1061     bool WizardMachine::skipBackwardUntil(WizardTypes::WizardState _nTargetState)
1062     {
1063         // allowed to leave the current page?
1064         if ( !prepareLeaveCurrentState( WizardTypes::eTravelBackward ) )
1065             return false;
1066
1067         // don't travel directly on m_pImpl->aStateHistory, in case something goes wrong
1068         std::stack< WizardTypes::WizardState > aTravelVirtually = m_pImpl->aStateHistory;
1069         std::stack< WizardTypes::WizardState > aOldStateHistory = m_pImpl->aStateHistory;
1070
1071         WizardTypes::WizardState nCurrentRollbackState = getCurrentState();
1072         while ( nCurrentRollbackState != _nTargetState )
1073         {
1074             DBG_ASSERT( !aTravelVirtually.empty(), "WizardMachine::skipBackwardUntil: this target state does not exist in the history!" );
1075             nCurrentRollbackState = aTravelVirtually.top();
1076             aTravelVirtually.pop();
1077         }
1078         m_pImpl->aStateHistory = std::move(aTravelVirtually);
1079         if ( !ShowPage( _nTargetState ) )
1080         {
1081             m_pImpl->aStateHistory = std::move(aOldStateHistory);
1082             return false;
1083         }
1084         return true;
1085     }
1086
1087     bool WizardMachine::skipUntil( WizardTypes::WizardState _nTargetState )
1088     {
1089         WizardTypes::WizardState nCurrentState = getCurrentState();
1090
1091         // allowed to leave the current page?
1092         if ( !prepareLeaveCurrentState( nCurrentState < _nTargetState ? WizardTypes::eTravelForward : WizardTypes::eTravelBackward ) )
1093             return false;
1094
1095         // don't travel directly on m_pImpl->aStateHistory, in case something goes wrong
1096         std::stack< WizardTypes::WizardState > aTravelVirtually = m_pImpl->aStateHistory;
1097         std::stack< WizardTypes::WizardState > aOldStateHistory = m_pImpl->aStateHistory;
1098         while ( nCurrentState != _nTargetState )
1099         {
1100             WizardTypes::WizardState nNextState = determineNextState( nCurrentState );
1101             if ( WZS_INVALID_STATE == nNextState )
1102             {
1103                 OSL_FAIL( "WizardMachine::skipUntil: the given target state does not exist!" );
1104                 return false;
1105             }
1106
1107             // remember the skipped state in the history
1108             aTravelVirtually.push( nCurrentState );
1109
1110             // get the next state
1111             nCurrentState = nNextState;
1112         }
1113         m_pImpl->aStateHistory = std::move(aTravelVirtually);
1114         // show the target page
1115         if ( !ShowPage( nCurrentState ) )
1116         {
1117             // argh! prepareLeaveCurrentPage succeeded, determineNextState succeeded,
1118             // but ShowPage doesn't? Somebody behaves very strange here...
1119             OSL_FAIL( "WizardMachine::skipUntil: very unpolite..." );
1120             m_pImpl->aStateHistory = std::move(aOldStateHistory);
1121             return false;
1122         }
1123         return true;
1124     }
1125
1126     void WizardMachine::skip()
1127     {
1128         // allowed to leave the current page?
1129         if ( !prepareLeaveCurrentState( WizardTypes::eTravelForward ) )
1130             return;
1131
1132         WizardTypes::WizardState nCurrentState = getCurrentState();
1133         WizardTypes::WizardState nNextState = determineNextState(nCurrentState);
1134
1135         if (WZS_INVALID_STATE == nNextState)
1136             return;
1137
1138         // remember the skipped state in the history
1139         m_pImpl->aStateHistory.push(nCurrentState);
1140
1141         // get the next state
1142         nCurrentState = nNextState;
1143
1144         // show the (n+1)th page
1145         if (!ShowPage(nCurrentState))
1146         {
1147             // TODO: this leaves us in a state where we have no current page and an inconsistent state history.
1148             // Perhaps we should rollback the skipping here...
1149             OSL_FAIL("RoadmapWizard::skip: very unpolite...");
1150                 // if somebody does a skip and then does not allow to leave...
1151                 // (can't be a commit error, as we've already committed the current page. So if ShowPage fails here,
1152                 // somebody behaves really strange ...)
1153             return;
1154         }
1155
1156         // all fine
1157     }
1158
1159     bool WizardMachine::travelNext()
1160     {
1161         // allowed to leave the current page?
1162         if ( !prepareLeaveCurrentState( WizardTypes::eTravelForward ) )
1163             return false;
1164
1165         // determine the next state to travel to
1166         WizardTypes::WizardState nCurrentState = getCurrentState();
1167         WizardTypes::WizardState nNextState = determineNextState(nCurrentState);
1168         if (WZS_INVALID_STATE == nNextState)
1169             return false;
1170
1171         // the state history is used by the enterState method
1172         // all fine
1173         m_pImpl->aStateHistory.push(nCurrentState);
1174         if (!ShowPage(nNextState))
1175         {
1176             m_pImpl->aStateHistory.pop();
1177             return false;
1178         }
1179
1180         return true;
1181     }
1182
1183     bool WizardMachine::ShowPage(WizardTypes::WizardState nState)
1184     {
1185         if (DeactivatePage())
1186         {
1187             BuilderPage* pOldTabPage = m_pCurTabPage;
1188
1189             m_nCurState = nState;
1190             ActivatePage();
1191
1192             if (pOldTabPage)
1193                 pOldTabPage->Deactivate();
1194
1195             m_xAssistant->set_current_page(getPageIdentForState(nState));
1196
1197             m_pCurTabPage = GetPage(m_nCurState);
1198             m_pCurTabPage->Activate();
1199
1200             return true;
1201         }
1202         return false;
1203     }
1204
1205     bool WizardMachine::ShowNextPage()
1206     {
1207         return ShowPage(m_nCurState + 1);
1208     }
1209
1210     bool WizardMachine::ShowPrevPage()
1211     {
1212         if (!m_nCurState)
1213             return false;
1214         return ShowPage(m_nCurState - 1);
1215     }
1216
1217     bool WizardMachine::travelPrevious()
1218     {
1219         DBG_ASSERT(!m_pImpl->aStateHistory.empty(), "WizardMachine::travelPrevious: have no previous page!");
1220
1221         // allowed to leave the current page?
1222         if ( !prepareLeaveCurrentState( WizardTypes::eTravelBackward ) )
1223             return false;
1224
1225         // the next state to switch to
1226         WizardTypes::WizardState nPreviousState = m_pImpl->aStateHistory.top();
1227
1228         // the state history is used by the enterState method
1229         m_pImpl->aStateHistory.pop();
1230         // show this page
1231         if (!ShowPage(nPreviousState))
1232         {
1233             m_pImpl->aStateHistory.push(nPreviousState);
1234             return false;
1235         }
1236
1237         // all fine
1238         return true;
1239     }
1240
1241
1242     void  WizardMachine::removePageFromHistory( WizardTypes::WizardState nToRemove )
1243     {
1244
1245         std::stack< WizardTypes::WizardState > aTemp;
1246         while(!m_pImpl->aStateHistory.empty())
1247         {
1248             WizardTypes::WizardState nPreviousState = m_pImpl->aStateHistory.top();
1249             m_pImpl->aStateHistory.pop();
1250             if(nPreviousState != nToRemove)
1251                 aTemp.push( nPreviousState );
1252             else
1253                 break;
1254         }
1255         while(!aTemp.empty())
1256         {
1257             m_pImpl->aStateHistory.push( aTemp.top() );
1258             aTemp.pop();
1259         }
1260     }
1261
1262
1263     void WizardMachine::enableAutomaticNextButtonState()
1264     {
1265         m_pImpl->m_bAutoNextButtonState = true;
1266     }
1267
1268
1269     bool WizardMachine::isAutomaticNextButtonStateEnabled() const
1270     {
1271         return m_pImpl->m_bAutoNextButtonState;
1272     }
1273
1274     IMPL_LINK_NOARG(WizardMachine, OnPrevPage, weld::Button&, void)
1275     {
1276         if ( isTravelingSuspended() )
1277             return;
1278         WizardTravelSuspension aTravelGuard( *this );
1279         travelPrevious();
1280     }
1281
1282     IMPL_LINK_NOARG(WizardMachine, OnNextPage, weld::Button&, void)
1283     {
1284         if ( isTravelingSuspended() )
1285             return;
1286         WizardTravelSuspension aTravelGuard( *this );
1287         travelNext();
1288     }
1289
1290     IWizardPageController* WizardMachine::getPageController(BuilderPage* pCurrentPage) const
1291     {
1292         IWizardPageController* pController = dynamic_cast<IWizardPageController*>(pCurrentPage);
1293         return pController;
1294     }
1295
1296     void WizardMachine::getStateHistory( std::vector< WizardTypes::WizardState >& _out_rHistory )
1297     {
1298         std::stack< WizardTypes::WizardState > aHistoryCopy( m_pImpl->aStateHistory );
1299         while ( !aHistoryCopy.empty() )
1300         {
1301             _out_rHistory.push_back( aHistoryCopy.top() );
1302             aHistoryCopy.pop();
1303         }
1304     }
1305
1306     bool WizardMachine::canAdvance() const
1307     {
1308         return WZS_INVALID_STATE != determineNextState( getCurrentState() );
1309     }
1310
1311     void WizardMachine::updateTravelUI()
1312     {
1313         const IWizardPageController* pController = getPageController( GetPage( getCurrentState() ) );
1314         OSL_ENSURE( pController != nullptr, "RoadmapWizard::updateTravelUI: no controller for the current page!" );
1315
1316         bool bCanAdvance =
1317                 ( !pController || pController->canAdvance() )   // the current page allows to advance
1318             &&  canAdvance();                                   // the dialog as a whole allows to advance
1319         enableButtons( WizardButtonFlags::NEXT, bCanAdvance );
1320     }
1321
1322     bool WizardMachine::isTravelingSuspended() const
1323     {
1324         return m_pImpl->m_bTravelingSuspended;
1325     }
1326
1327     void WizardMachine::suspendTraveling( AccessGuard )
1328     {
1329         DBG_ASSERT( !m_pImpl->m_bTravelingSuspended, "WizardMachine::suspendTraveling: already suspended!" );
1330         m_pImpl->m_bTravelingSuspended = true;
1331     }
1332
1333     void WizardMachine::resumeTraveling( AccessGuard )
1334     {
1335         if (!m_pImpl)
1336             return;
1337
1338         DBG_ASSERT( m_pImpl->m_bTravelingSuspended, "WizardMachine::resumeTraveling: nothing to resume!" );
1339         m_pImpl->m_bTravelingSuspended = false;
1340     }
1341
1342     bool WizardMachine::Finish(short nResult)
1343     {
1344         if ( DeactivatePage() )
1345         {
1346             if (m_pCurTabPage)
1347                 m_pCurTabPage->Deactivate();
1348
1349             m_xAssistant->response(nResult);
1350             return true;
1351         }
1352         else
1353             return false;
1354     }
1355
1356     void WizardMachine::AddPage(std::unique_ptr<BuilderPage> xPage)
1357     {
1358         WizPageData* pNewPageData = new WizPageData;
1359         pNewPageData->mpNext = nullptr;
1360         pNewPageData->mxPage = std::move(xPage);
1361
1362         if ( !m_pFirstPage )
1363             m_pFirstPage = pNewPageData;
1364         else
1365         {
1366             WizPageData* pPageData = m_pFirstPage;
1367             while ( pPageData->mpNext )
1368                 pPageData = pPageData->mpNext;
1369             pPageData->mpNext = pNewPageData;
1370         }
1371     }
1372
1373     void WizardMachine::RemovePage(const BuilderPage* pPage)
1374     {
1375         WizPageData* pPrevPageData = nullptr;
1376         WizPageData* pPageData = m_pFirstPage;
1377         while ( pPageData )
1378         {
1379             if (pPageData->mxPage.get() == pPage)
1380             {
1381                 if (pPrevPageData)
1382                     pPrevPageData->mpNext = pPageData->mpNext;
1383                 else
1384                     m_pFirstPage = pPageData->mpNext;
1385                 if (pPage == m_pCurTabPage)
1386                     m_pCurTabPage = nullptr;
1387                 delete pPageData;
1388                 return;
1389             }
1390
1391             pPrevPageData = pPageData;
1392             pPageData = pPageData->mpNext;
1393         }
1394
1395         OSL_FAIL( "WizardMachine::RemovePage() - Page not in list" );
1396     }
1397
1398     void WizardMachine::SetPage(WizardTypes::WizardState nLevel, std::unique_ptr<BuilderPage> xPage)
1399     {
1400         sal_uInt16              nTempLevel = 0;
1401         WizPageData*    pPageData = m_pFirstPage;
1402         while ( pPageData )
1403         {
1404             if ( (nTempLevel == nLevel) || !pPageData->mpNext )
1405                 break;
1406
1407             nTempLevel++;
1408             pPageData = pPageData->mpNext;
1409         }
1410
1411         if ( pPageData )
1412         {
1413             if (pPageData->mxPage.get() == m_pCurTabPage)
1414                 m_pCurTabPage = nullptr;
1415             pPageData->mxPage = std::move(xPage);
1416         }
1417     }
1418
1419     BuilderPage* WizardMachine::GetPage(WizardTypes::WizardState nLevel) const
1420     {
1421         sal_uInt16 nTempLevel = 0;
1422
1423         for (WizPageData* pPageData = m_pFirstPage; pPageData;
1424              pPageData = pPageData->mpNext)
1425         {
1426             if ( nTempLevel == nLevel )
1427                 return pPageData->mxPage.get();
1428             nTempLevel++;
1429         }
1430
1431         return nullptr;
1432     }
1433 }   // namespace svt
1434
1435
1436 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */