svtools/source/dialogs/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 <svtools/wizardmachine.hxx>
  21 #include <svtools/helpid.hrc>
  22 #include <tools/debug.hxx>
  23 #include <tools/diagnose_ex.h>
  24 #include <vcl/msgbox.hxx>
  25 #include <svtools/svtresid.hxx>
  26 #include <svtools/svtools.hrc>
  27
  28
  29 namespace svt
  30 {
  31
  32
  33
  34     //= WizardPageImplData
  35
  36     struct WizardPageImplData
  37     {
  38         WizardPageImplData()
  39         {
  40         }
  41     };
  42
  43     OWizardPage::OWizardPage(vcl::Window *pParent, const OString& rID,
  44         const OUString& rUIXMLDescription)
  45         : TabPage(pParent, rID, rUIXMLDescription)
  46         , m_pImpl(new WizardPageImplData)
  47     {
  48     }
  49
  50     OWizardPage::~OWizardPage()
  51     {
  52         disposeOnce();
  53     }
  54
  55     void OWizardPage::dispose()
  56     {
  57         delete m_pImpl;
  58         TabPage::dispose();
  59     }
  60
  61     void OWizardPage::initializePage()
  62     {
  63     }
  64
  65     void OWizardPage::ActivatePage()
  66     {
  67         TabPage::ActivatePage();
  68         updateDialogTravelUI();
  69     }
  70
  71     void OWizardPage::updateDialogTravelUI()
  72     {
  73         OWizardMachine* pWizardMachine = dynamic_cast< OWizardMachine* >( GetParent() );
  74         if ( pWizardMachine )
  75             pWizardMachine->updateTravelUI();
  76     }
  77
  78     bool OWizardPage::canAdvance() const
  79     {
  80         return true;
  81     }
  82
  83     bool OWizardPage::commitPage( WizardTypes::CommitPageReason )
  84     {
  85         return true;
  86     }
  87
  88     struct WizardMachineImplData : public WizardTypes
  89     {
  90         OUString                        sTitleBase;         // the base for the title
  91         ::std::stack< WizardState >     aStateHistory;      // the history of all states (used for implementing "Back")
  92
  93         WizardState                     nFirstUnknownPage;
  94             // the WizardDialog does not allow non-linear transitions (e.g. it's
  95             // not possible to add pages in a non-linear order), so we need some own maintenance data
  96
  97         bool                            m_bAutoNextButtonState;
  98
  99         bool                            m_bTravelingSuspended;
 100
 101         WizardMachineImplData()
 102             :nFirstUnknownPage( 0 )
 103             ,m_bAutoNextButtonState( false )
 104             ,m_bTravelingSuspended( false )
 105         {
 106         }
 107     };
 108
 109     OWizardMachine::OWizardMachine(vcl::Window* _pParent, const WinBits i_nStyle, WizardButtonFlags _nButtonFlags )
 110         :WizardDialog( _pParent, i_nStyle )
 111         ,m_pFinish(NULL)
 112         ,m_pCancel(NULL)
 113         ,m_pNextPage(NULL)
 114         ,m_pPrevPage(NULL)
 115         ,m_pHelp(NULL)
 116         ,m_pImpl( new WizardMachineImplData )
 117     {
 118         implConstruct( _nButtonFlags );
 119     }
 120
 121     OWizardMachine::OWizardMachine(vcl::Window* _pParent, WizardButtonFlags _nButtonFlags )
 122         :WizardDialog( _pParent, "WizardDialog", "svt/ui/wizarddialog.ui" )
 123         ,m_pFinish(NULL)
 124         ,m_pCancel(NULL)
 125         ,m_pNextPage(NULL)
 126         ,m_pPrevPage(NULL)
 127         ,m_pHelp(NULL)
 128         ,m_pImpl( new WizardMachineImplData )
 129     {
 130         implConstruct( _nButtonFlags );
 131     }
 132
 133
 134     void OWizardMachine::implConstruct( const WizardButtonFlags _nButtonFlags )
 135     {
 136         m_pImpl->sTitleBase = GetText();
 137
 138         // create the buttons according to the wizard button flags
 139         // the help button
 140         if (_nButtonFlags & WizardButtonFlags::HELP)
 141         {
 142             m_pHelp= VclPtr<HelpButton>::Create(this, WB_TABSTOP);
 143             m_pHelp->SetSizePixel( LogicToPixel( Size( 50, 14 ), MAP_APPFONT ) );
 144             m_pHelp->Show();
 145             AddButton( m_pHelp, WIZARDDIALOG_BUTTON_STDOFFSET_X);
 146         }
 147
 148         // the previous button
 149         if (_nButtonFlags & WizardButtonFlags::PREVIOUS)
 150         {
 151             m_pPrevPage = VclPtr<PushButton>::Create(this, WB_TABSTOP);
 152             m_pPrevPage->SetHelpId( HID_WIZARD_PREVIOUS );
 153             m_pPrevPage->SetSizePixel( LogicToPixel( Size( 50, 14 ), MAP_APPFONT ) );
 154             m_pPrevPage->SetText(SVT_RESSTR(STR_WIZDLG_PREVIOUS));
 155             m_pPrevPage->Show();
 156
 157             if (_nButtonFlags & WizardButtonFlags::NEXT)
 158                 AddButton( m_pPrevPage, ( WIZARDDIALOG_BUTTON_SMALLSTDOFFSET_X) );      // half x-offset to the next button
 159             else
 160                 AddButton( m_pPrevPage, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 161             SetPrevButton( m_pPrevPage );
 162             m_pPrevPage->SetClickHdl( LINK( this, OWizardMachine, OnPrevPage ) );
 163         }
 164
 165         // the next button
 166         if (_nButtonFlags & WizardButtonFlags::NEXT)
 167         {
 168             m_pNextPage = VclPtr<PushButton>::Create(this, WB_TABSTOP);
 169             m_pNextPage->SetHelpId( HID_WIZARD_NEXT );
 170             m_pNextPage->SetSizePixel( LogicToPixel( Size( 50, 14 ), MAP_APPFONT ) );
 171             m_pNextPage->SetText(OUString(SVT_RESSTR(STR_WIZDLG_NEXT)));
 172             m_pNextPage->Show();
 173
 174             AddButton( m_pNextPage, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 175             SetNextButton( m_pNextPage );
 176             m_pNextPage->SetClickHdl( LINK( this, OWizardMachine, OnNextPage ) );
 177         }
 178
 179         // the finish button
 180         if (_nButtonFlags & WizardButtonFlags::FINISH)
 181         {
 182             m_pFinish = VclPtr<OKButton>::Create(this, WB_TABSTOP);
 183             m_pFinish->SetSizePixel( LogicToPixel( Size( 50, 14 ), MAP_APPFONT ) );
 184             m_pFinish->SetText(SVT_RESSTR(STR_WIZDLG_FINISH));
 185             m_pFinish->Show();
 186
 187             AddButton( m_pFinish, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 188             m_pFinish->SetClickHdl( LINK( this, OWizardMachine, OnFinish ) );
 189         }
 190
 191         // the cancel button
 192         if (_nButtonFlags & WizardButtonFlags::CANCEL)
 193         {
 194             m_pCancel = VclPtr<CancelButton>::Create(this, WB_TABSTOP);
 195             m_pCancel->SetSizePixel( LogicToPixel( Size( 50, 14 ), MAP_APPFONT ) );
 196             m_pCancel->Show();
 197
 198             AddButton( m_pCancel, WIZARDDIALOG_BUTTON_STDOFFSET_X );
 199         }
 200     }
 201
 202
 203     OWizardMachine::~OWizardMachine()
 204     {
 205         disposeOnce();
 206     }
 207
 208     void OWizardMachine::dispose()
 209     {
 210         m_pFinish.disposeAndClear();
 211         m_pCancel.disposeAndClear();
 212         m_pNextPage.disposeAndClear();
 213         m_pPrevPage.disposeAndClear();
 214         m_pHelp.disposeAndClear();
 215
 216         if (m_pImpl)
 217         {
 218             for (WizardState i = 0; i < m_pImpl->nFirstUnknownPage; ++i)
 219             {
 220                 TabPage *pPage = GetPage(i);
 221                 if (pPage)
 222                     pPage->disposeOnce();
 223             }
 224             delete m_pImpl;
 225             m_pImpl = NULL;
 226         }
 227
 228         WizardDialog::dispose();
 229     }
 230
 231
 232     void OWizardMachine::implUpdateTitle()
 233     {
 234         OUString sCompleteTitle(m_pImpl->sTitleBase);
 235
 236         // append the page title
 237         TabPage* pCurrentPage = GetPage(getCurrentState());
 238         if ( pCurrentPage && !pCurrentPage->GetText().isEmpty() )
 239         {
 240             sCompleteTitle += (" - " + pCurrentPage->GetText());
 241         }
 242
 243         SetText(sCompleteTitle);
 244     }
 245
 246
 247     void OWizardMachine::setTitleBase(const OUString& _rTitleBase)
 248     {
 249         m_pImpl->sTitleBase = _rTitleBase;
 250         implUpdateTitle();
 251     }
 252
 253
 254     TabPage* OWizardMachine::GetOrCreatePage( const WizardState i_nState )
 255     {
 256         if ( NULL == GetPage( i_nState ) )
 257         {
 258             TabPage* pNewPage = createPage( i_nState );
 259             DBG_ASSERT( pNewPage, "OWizardMachine::GetOrCreatePage: invalid new page (NULL)!" );
 260
 261             // fill up the page sequence of our base class (with dummies)
 262             while ( m_pImpl->nFirstUnknownPage < i_nState )
 263             {
 264                 AddPage( NULL );
 265                 ++m_pImpl->nFirstUnknownPage;
 266             }
 267
 268             if ( m_pImpl->nFirstUnknownPage == i_nState )
 269             {
 270                 // encountered this page number the first time
 271                 AddPage( pNewPage );
 272                 ++m_pImpl->nFirstUnknownPage;
 273             }
 274             else
 275                 // already had this page - just change it
 276                 SetPage( i_nState, pNewPage );
 277         }
 278         return GetPage( i_nState );
 279     }
 280
 281
 282     void OWizardMachine::ActivatePage()
 283     {
 284         WizardDialog::ActivatePage();
 285
 286         WizardState nCurrentLevel = GetCurLevel();
 287         GetOrCreatePage( nCurrentLevel );
 288
 289         enterState( nCurrentLevel );
 290     }
 291
 292
 293     bool OWizardMachine::DeactivatePage()
 294     {
 295         WizardState nCurrentState = getCurrentState();
 296         if (!leaveState(nCurrentState) || !WizardDialog::DeactivatePage())
 297             return false;
 298         return true;
 299     }
 300
 301
 302     void OWizardMachine::defaultButton(WizardButtonFlags _nWizardButtonFlags)
 303     {
 304         // the new default button
 305         PushButton* pNewDefButton = NULL;
 306         if (m_pFinish && (_nWizardButtonFlags & WizardButtonFlags::FINISH))
 307             pNewDefButton = m_pFinish;
 308         if (m_pNextPage && (_nWizardButtonFlags & WizardButtonFlags::NEXT))
 309             pNewDefButton = m_pNextPage;
 310         if (m_pPrevPage && (_nWizardButtonFlags & WizardButtonFlags::PREVIOUS))
 311             pNewDefButton = m_pPrevPage;
 312         if (m_pHelp && (_nWizardButtonFlags & WizardButtonFlags::HELP))
 313             pNewDefButton = m_pHelp;
 314         if (m_pCancel && (_nWizardButtonFlags & WizardButtonFlags::CANCEL))
 315             pNewDefButton = m_pCancel;
 316
 317         if ( pNewDefButton )
 318             defaultButton( pNewDefButton );
 319         else
 320             implResetDefault( this );
 321     }
 322
 323
 324     void OWizardMachine::implResetDefault(vcl::Window* _pWindow)
 325     {
 326         vcl::Window* pChildLoop = _pWindow->GetWindow(GetWindowType::FirstChild);
 327         while (pChildLoop)
 328         {
 329             // does the window participate in the tabbing order?
 330             if (pChildLoop->GetStyle() & WB_DIALOGCONTROL)
 331                 implResetDefault(pChildLoop);
 332
 333             // is it a button?
 334             WindowType eType = pChildLoop->GetType();
 335             if  (   (WINDOW_BUTTON == eType)
 336                 ||  (WINDOW_PUSHBUTTON == eType)
 337                 ||  (WINDOW_OKBUTTON == eType)
 338                 ||  (WINDOW_CANCELBUTTON == eType)
 339                 ||  (WINDOW_HELPBUTTON == eType)
 340                 ||  (WINDOW_IMAGEBUTTON == eType)
 341                 ||  (WINDOW_MENUBUTTON == eType)
 342                 ||  (WINDOW_MOREBUTTON == eType)
 343                 )
 344             {
 345                 pChildLoop->SetStyle(pChildLoop->GetStyle() & ~WB_DEFBUTTON);
 346             }
 347
 348             // the next one ...
 349             pChildLoop = pChildLoop->GetWindow(GetWindowType::Next);
 350         }
 351     }
 352
 353
 354     void OWizardMachine::defaultButton(PushButton* _pNewDefButton)
 355     {
 356         // loop through all (direct and indirect) descendants which participate in our tabbing order, and
 357         // reset the WB_DEFBUTTON for every window which is a button
 358         implResetDefault(this);
 359
 360         // set it's new style
 361         if (_pNewDefButton)
 362             _pNewDefButton->SetStyle(_pNewDefButton->GetStyle() | WB_DEFBUTTON);
 363     }
 364
 365
 366     void OWizardMachine::enableButtons(WizardButtonFlags _nWizardButtonFlags, bool _bEnable)
 367     {
 368         if (m_pFinish && (_nWizardButtonFlags & WizardButtonFlags::FINISH))
 369             m_pFinish->Enable(_bEnable);
 370         if (m_pNextPage && (_nWizardButtonFlags & WizardButtonFlags::NEXT))
 371             m_pNextPage->Enable(_bEnable);
 372         if (m_pPrevPage && (_nWizardButtonFlags & WizardButtonFlags::PREVIOUS))
 373             m_pPrevPage->Enable(_bEnable);
 374         if (m_pHelp && (_nWizardButtonFlags & WizardButtonFlags::HELP))
 375             m_pHelp->Enable(_bEnable);
 376         if (m_pCancel && (_nWizardButtonFlags & WizardButtonFlags::CANCEL))
 377             m_pCancel->Enable(_bEnable);
 378     }
 379
 380
 381     void OWizardMachine::enterState(WizardState _nState)
 382     {
 383         // tell the page
 384         IWizardPageController* pController = getPageController( GetPage( _nState ) );
 385         OSL_ENSURE( pController, "OWizardMachine::enterState: no controller for the given page!" );
 386         if ( pController )
 387             pController->initializePage();
 388
 389         if ( isAutomaticNextButtonStateEnabled() )
 390             enableButtons( WizardButtonFlags::NEXT, canAdvance() );
 391
 392         enableButtons( WizardButtonFlags::PREVIOUS, !m_pImpl->aStateHistory.empty() );
 393
 394         // set the new title - it depends on the current page (i.e. state)
 395         implUpdateTitle();
 396     }
 397
 398
 399     bool OWizardMachine::leaveState(WizardState)
 400     {
 401         // no need to ask the page here.
 402         // If we reach this point, we already gave the current page the chance to commit it's data,
 403         // and it was allowed to commit it's data
 404
 405         return true;
 406     }
 407
 408
 409     bool OWizardMachine::onFinish()
 410     {
 411         return Finish( RET_OK );
 412     }
 413
 414
 415     IMPL_LINK_NOARG(OWizardMachine, OnFinish)
 416     {
 417         if ( isTravelingSuspended() )
 418             return 0;
 419         WizardTravelSuspension aTravelGuard( *this );
 420         if ( !prepareLeaveCurrentState( eFinish ) )
 421         {
 422             return 0L;
 423         }
 424         return onFinish() ? 1L : 0L;
 425     }
 426
 427
 428     OWizardMachine::WizardState OWizardMachine::determineNextState( WizardState _nCurrentState ) const
 429     {
 430         return _nCurrentState + 1;
 431     }
 432
 433
 434     bool OWizardMachine::prepareLeaveCurrentState( CommitPageReason _eReason )
 435     {
 436         IWizardPageController* pController = getPageController( GetPage( getCurrentState() ) );
 437         ENSURE_OR_RETURN( pController != NULL, "OWizardMachine::prepareLeaveCurrentState: no controller for the current page!", true );
 438         return pController->commitPage( _eReason );
 439     }
 440
 441
 442     bool OWizardMachine::skipBackwardUntil( WizardState _nTargetState )
 443     {
 444         // allowed to leave the current page?
 445         if ( !prepareLeaveCurrentState( eTravelBackward ) )
 446             return false;
 447
 448         // don't travel directly on m_pImpl->aStateHistory, in case something goes wrong
 449         ::std::stack< WizardState > aTravelVirtually = m_pImpl->aStateHistory;
 450         ::std::stack< WizardState > aOldStateHistory = m_pImpl->aStateHistory;
 451
 452         WizardState nCurrentRollbackState = getCurrentState();
 453         while ( nCurrentRollbackState != _nTargetState )
 454         {
 455             DBG_ASSERT( !aTravelVirtually.empty(), "OWizardMachine::skipBackwardUntil: this target state does not exist in the history!" );
 456             nCurrentRollbackState = aTravelVirtually.top();
 457             aTravelVirtually.pop();
 458         }
 459         m_pImpl->aStateHistory = aTravelVirtually;
 460         if ( !ShowPage( _nTargetState ) )
 461         {
 462             m_pImpl->aStateHistory = aOldStateHistory;
 463             return false;
 464         }
 465         return true;
 466     }
 467
 468
 469     bool OWizardMachine::skipUntil( WizardState _nTargetState )
 470     {
 471         WizardState nCurrentState = getCurrentState();
 472
 473         // allowed to leave the current page?
 474         if ( !prepareLeaveCurrentState( nCurrentState < _nTargetState ? eTravelForward : eTravelBackward ) )
 475             return false;
 476
 477         // don't travel directly on m_pImpl->aStateHistory, in case something goes wrong
 478         ::std::stack< WizardState > aTravelVirtually = m_pImpl->aStateHistory;
 479         ::std::stack< WizardState > aOldStateHistory = m_pImpl->aStateHistory;
 480         while ( nCurrentState != _nTargetState )
 481         {
 482             WizardState nNextState = determineNextState( nCurrentState );
 483             if ( WZS_INVALID_STATE == nNextState )
 484             {
 485                 OSL_FAIL( "OWizardMachine::skipUntil: the given target state does not exist!" );
 486                 return false;
 487             }
 488
 489             // remember the skipped state in the history
 490             aTravelVirtually.push( nCurrentState );
 491
 492             // get the next state
 493             nCurrentState = nNextState;
 494         }
 495         m_pImpl->aStateHistory = aTravelVirtually;
 496         // show the target page
 497         if ( !ShowPage( nCurrentState ) )
 498         {
 499             // argh! prepareLeaveCurrentPage succeeded, determineNextState succeeded,
 500             // but ShowPage doesn't? Somebody behaves very strange here ....
 501             OSL_FAIL( "OWizardMachine::skipUntil: very unpolite ...." );
 502             m_pImpl->aStateHistory = aOldStateHistory;
 503             return false;
 504         }
 505         return true;
 506     }
 507
 508
 509     bool OWizardMachine::skip(sal_Int32 _nSteps)
 510     {
 511         DBG_ASSERT(_nSteps > 0, "OWizardMachine::skip: invalid number of steps!");
 512         // allowed to leave the current page?
 513         if ( !prepareLeaveCurrentState( eTravelForward ) )
 514             return false;
 515
 516         WizardState nCurrentState = getCurrentState();
 517         WizardState nNextState = determineNextState(nCurrentState);
 518         // loop _nSteps steps
 519         while (_nSteps-- > 0)
 520         {
 521             if (WZS_INVALID_STATE == nNextState)
 522                 return false;
 523
 524             // remember the skipped state in the history
 525             m_pImpl->aStateHistory.push(nCurrentState);
 526
 527             // get the next state
 528             nCurrentState = nNextState;
 529             nNextState = determineNextState(nCurrentState);
 530         }
 531
 532         // show the (n+1)th page
 533         if (!ShowPage(nCurrentState))
 534         {
 535             // TODO: this leaves us in a state where we have no current page and an inconsistent state history.
 536             // Perhaps we should rollback the skipping here ....
 537             OSL_FAIL("OWizardMachine::skip: very unpolite ....");
 538                 // if somebody does a skip and then does not allow to leave ...
 539                 // (can't be a commit error, as we've already committed the current page. So if ShowPage fails here,
 540                 // somebody behaves really strange ...)
 541             return false;
 542         }
 543
 544         // all fine
 545         return true;
 546     }
 547
 548
 549     bool OWizardMachine::travelNext()
 550     {
 551         // allowed to leave the current page?
 552         if ( !prepareLeaveCurrentState( eTravelForward ) )
 553             return false;
 554
 555         // determine the next state to travel to
 556         WizardState nCurrentState = getCurrentState();
 557         WizardState nNextState = determineNextState(nCurrentState);
 558         if (WZS_INVALID_STATE == nNextState)
 559             return false;
 560
 561         // the state history is used by the enterState method
 562         // all fine
 563         m_pImpl->aStateHistory.push(nCurrentState);
 564         if (!ShowPage(nNextState))
 565         {
 566             m_pImpl->aStateHistory.pop();
 567             return false;
 568         }
 569
 570         return true;
 571     }
 572
 573
 574     bool OWizardMachine::travelPrevious()
 575     {
 576         DBG_ASSERT(m_pImpl->aStateHistory.size() > 0, "OWizardMachine::travelPrevious: have no previous page!");
 577
 578         // allowed to leave the current page?
 579         if ( !prepareLeaveCurrentState( eTravelBackward ) )
 580             return false;
 581
 582         // the next state to switch to
 583         WizardState nPreviousState = m_pImpl->aStateHistory.top();
 584
 585         // the state history is used by the enterState method
 586         m_pImpl->aStateHistory.pop();
 587         // show this page
 588         if (!ShowPage(nPreviousState))
 589         {
 590             m_pImpl->aStateHistory.push(nPreviousState);
 591             return false;
 592         }
 593
 594         // all fine
 595         return true;
 596     }
 597
 598
 599     void  OWizardMachine::removePageFromHistory( WizardState nToRemove )
 600     {
 601
 602         ::std::stack< WizardState > aTemp;
 603         while(!m_pImpl->aStateHistory.empty())
 604         {
 605             WizardState nPreviousState = m_pImpl->aStateHistory.top();
 606             m_pImpl->aStateHistory.pop();
 607             if(nPreviousState != nToRemove)
 608                 aTemp.push( nPreviousState );
 609             else
 610                 break;
 611         }
 612         while(!aTemp.empty())
 613         {
 614             m_pImpl->aStateHistory.push( aTemp.top() );
 615             aTemp.pop();
 616         }
 617     }
 618
 619
 620     void OWizardMachine::enableAutomaticNextButtonState( bool _bEnable )
 621     {
 622         m_pImpl->m_bAutoNextButtonState = _bEnable;
 623     }
 624
 625
 626     bool OWizardMachine::isAutomaticNextButtonStateEnabled() const
 627     {
 628         return m_pImpl->m_bAutoNextButtonState;
 629     }
 630
 631
 632     IMPL_LINK_NOARG(OWizardMachine, OnPrevPage)
 633     {
 634         if ( isTravelingSuspended() )
 635             return 0;
 636         WizardTravelSuspension aTravelGuard( *this );
 637         bool nRet = travelPrevious();
 638         return nRet ? 1 : 0;
 639     }
 640
 641
 642     IMPL_LINK_NOARG(OWizardMachine, OnNextPage)
 643     {
 644         if ( isTravelingSuspended() )
 645             return 0;
 646         WizardTravelSuspension aTravelGuard( *this );
 647         bool nRet = travelNext();
 648         return nRet ? 1 : 0;
 649     }
 650
 651
 652     IWizardPageController* OWizardMachine::getPageController( TabPage* _pCurrentPage ) const
 653     {
 654         IWizardPageController* pController = dynamic_cast< IWizardPageController* >( _pCurrentPage );
 655         return pController;
 656     }
 657
 658
 659     void OWizardMachine::getStateHistory( ::std::vector< WizardState >& _out_rHistory )
 660     {
 661         ::std::stack< WizardState > aHistoryCopy( m_pImpl->aStateHistory );
 662         while ( !aHistoryCopy.empty() )
 663         {
 664             _out_rHistory.push_back( aHistoryCopy.top() );
 665             aHistoryCopy.pop();
 666         }
 667     }
 668
 669
 670     bool OWizardMachine::canAdvance() const
 671     {
 672         return WZS_INVALID_STATE != determineNextState( getCurrentState() );
 673     }
 674
 675
 676     void OWizardMachine::updateTravelUI()
 677     {
 678         const IWizardPageController* pController = getPageController( GetPage( getCurrentState() ) );
 679         OSL_ENSURE( pController != NULL, "RoadmapWizard::updateTravelUI: no controller for the current page!" );
 680
 681         bool bCanAdvance =
 682                 ( !pController || pController->canAdvance() )   // the current page allows to advance
 683             &&  canAdvance();                                   // the dialog as a whole allows to advance
 684         enableButtons( WizardButtonFlags::NEXT, bCanAdvance );
 685     }
 686
 687
 688     bool OWizardMachine::isTravelingSuspended() const
 689     {
 690         return m_pImpl->m_bTravelingSuspended;
 691     }
 692
 693
 694     void OWizardMachine::suspendTraveling( AccessGuard )
 695     {
 696         DBG_ASSERT( !m_pImpl->m_bTravelingSuspended, "OWizardMachine::suspendTraveling: already suspended!" );
 697        m_pImpl->m_bTravelingSuspended = true;
 698     }
 699
 700
 701     void OWizardMachine::resumeTraveling( AccessGuard )
 702     {
 703         DBG_ASSERT( m_pImpl->m_bTravelingSuspended, "OWizardMachine::resumeTraveling: nothing to resume!" );
 704        m_pImpl->m_bTravelingSuspended = false;
 705     }
 706
 707
 708 }   // namespace svt
 709
 710
 711 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */