svtools/source/dialogs/roadmapwizard.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <svtools/roadmapwizard.hxx>
  22 #include <svtools/svtools.hrc>
  23 #include <svtools/svtresid.hxx>
  24 #include <svtools/roadmap.hxx>
  25 #include <tools/debug.hxx>
  26
  27 #include <stdarg.h>
  28
  29 #include <vector>
  30 #include <map>
  31 #include <set>
  32
  33 //........................................................................
  34 namespace svt
  35 {
  36 //........................................................................
  37
  38     namespace
  39     {
  40         typedef ::std::set< WizardTypes::WizardState >          StateSet;
  41
  42         typedef ::std::map<
  43                     RoadmapWizardTypes::PathId,
  44                     RoadmapWizardTypes::WizardPath
  45                 >                                               Paths;
  46
  47         typedef ::std::map<
  48                     WizardTypes::WizardState,
  49                     ::std::pair<
  50                         OUString,
  51                         RoadmapWizardTypes::RoadmapPageFactory
  52                     >
  53                 >                                               StateDescriptions;
  54     }
  55
  56     struct RoadmapWizardImpl : public RoadmapWizardTypes
  57     {
  58         ORoadmap*           pRoadmap;
  59         Paths               aPaths;
  60         PathId              nActivePath;
  61         StateDescriptions   aStateDescriptors;
  62         StateSet            aDisabledStates;
  63         bool                bActivePathIsDefinite;
  64            FixedLine*           pFixedLine;
  65
  66         RoadmapWizardImpl()
  67             :pRoadmap( NULL )
  68             ,nActivePath( -1 )
  69             ,bActivePathIsDefinite( false )
  70             ,pFixedLine(NULL)
  71         {
  72         }
  73
  74         ~RoadmapWizardImpl()
  75         {
  76             delete pRoadmap;
  77             delete pFixedLine;
  78         }
  79
  80         /// returns the index of the current state in given path, or -1
  81         sal_Int32 getStateIndexInPath( WizardTypes::WizardState _nState, const WizardPath& _rPath );
  82         /// returns the index of the current state in the path with the given id, or -1
  83         sal_Int32 getStateIndexInPath( WizardTypes::WizardState _nState, PathId _nPathId );
  84         /// returns the index of the first state in which the two given paths differ
  85         sal_Int32 getFirstDifferentIndex( const WizardPath& _rLHS, const WizardPath& _rRHS );
  86     };
  87
  88     //--------------------------------------------------------------------
  89     sal_Int32 RoadmapWizardImpl::getStateIndexInPath( WizardTypes::WizardState _nState, const WizardPath& _rPath )
  90     {
  91         sal_Int32 nStateIndexInPath = 0;
  92         WizardPath::const_iterator aPathLoop = _rPath.begin();
  93         for ( ; aPathLoop != _rPath.end(); ++aPathLoop, ++nStateIndexInPath )
  94             if ( *aPathLoop == _nState )
  95                 break;
  96         if ( aPathLoop == _rPath.end() )
  97             nStateIndexInPath = -1;
  98         return nStateIndexInPath;
  99     }
 100
 101     //--------------------------------------------------------------------
 102     sal_Int32 RoadmapWizardImpl::getStateIndexInPath( WizardTypes::WizardState _nState, PathId _nPathId )
 103     {
 104         sal_Int32 nStateIndexInPath = -1;
 105         Paths::const_iterator aPathPos = aPaths.find( _nPathId );
 106         if ( aPathPos != aPaths.end( ) )
 107             nStateIndexInPath = getStateIndexInPath( _nState, aPathPos->second );
 108         return nStateIndexInPath;
 109     }
 110
 111     //--------------------------------------------------------------------
 112     sal_Int32 RoadmapWizardImpl::getFirstDifferentIndex( const WizardPath& _rLHS, const WizardPath& _rRHS )
 113     {
 114         sal_Int32 nMinLength = ::std::min( _rLHS.size(), _rRHS.size() );
 115         for ( sal_Int32 nCheck = 0; nCheck < nMinLength; ++nCheck )
 116         {
 117             if ( _rLHS[ nCheck ] != _rRHS[ nCheck ] )
 118                 return nCheck;
 119         }
 120         return nMinLength;
 121     }
 122
 123     //====================================================================
 124     //= RoadmapWizard
 125     //====================================================================
 126     DBG_NAME( RoadmapWizard )
 127     //--------------------------------------------------------------------
 128 #ifdef DBG_UTIL
 129     const char* CheckInvariants( const void* pVoid )
 130     {
 131         return static_cast< const RoadmapWizard* >( pVoid )->checkInvariants();
 132     }
 133
 134     //--------------------------------------------------------------------
 135     const sal_Char* RoadmapWizard::checkInvariants() const
 136     {
 137         // all paths have to start with the same state
 138         WizardState nSharedFirstState = WZS_INVALID_STATE;
 139         for ( Paths::const_iterator aPath = m_pImpl->aPaths.begin();
 140               aPath != m_pImpl->aPaths.end();
 141               ++aPath
 142             )
 143         {
 144             if ( aPath->second.empty() )
 145                 return "RoadmapWizard::checkInvariants: paths should not be empty!";
 146
 147             if ( nSharedFirstState == WZS_INVALID_STATE )
 148                 // first path
 149                 nSharedFirstState = aPath->second[ 0 ];
 150             else
 151                 if ( nSharedFirstState != aPath->second[ 0 ] )
 152                     return "RoadmapWizard::checkInvariants: alls paths must start with the same state!";
 153         }
 154
 155         if ( !m_pImpl->aPaths.empty() )
 156         {
 157             Paths::const_iterator aCurrentPathPos = m_pImpl->aPaths.find( m_pImpl->nActivePath );
 158             if ( aCurrentPathPos == m_pImpl->aPaths.end() )
 159                 return "RoadmapWizard::checkInvariants: invalid active path!";
 160
 161             if ( -1 == m_pImpl->getStateIndexInPath( getCurrentState(), m_pImpl->nActivePath ) )
 162                 return "RoadmapWizard::checkInvariants: the current state is not part of the current path!";
 163         }
 164
 165         return NULL;
 166     }
 167 #endif
 168
 169     //--------------------------------------------------------------------
 170     RoadmapWizard::RoadmapWizard( Window* _pParent, const ResId& _rRes, sal_uInt32 _nButtonFlags )
 171         :OWizardMachine( _pParent, _rRes, _nButtonFlags )
 172         ,m_pImpl( new RoadmapWizardImpl )
 173     {
 174         DBG_CTOR( RoadmapWizard, CheckInvariants );
 175         impl_construct();
 176     }
 177
 178     //--------------------------------------------------------------------
 179     RoadmapWizard::RoadmapWizard( Window* _pParent, const WinBits i_nStyle, sal_uInt32 _nButtonFlags )
 180         :OWizardMachine( _pParent, i_nStyle, _nButtonFlags )
 181         ,m_pImpl( new RoadmapWizardImpl )
 182     {
 183         DBG_CTOR( RoadmapWizard, CheckInvariants );
 184         impl_construct();
 185     }
 186
 187     //--------------------------------------------------------------------
 188     void RoadmapWizard::impl_construct()
 189     {
 190         SetLeftAlignedButtonCount( 1 );
 191         SetEmptyViewMargin();
 192
 193         m_pImpl->pRoadmap = new ORoadmap( this, WB_TABSTOP );
 194         m_pImpl->pRoadmap->SetText( SVT_RESSTR( STR_WIZDLG_ROADMAP_TITLE ) );
 195         m_pImpl->pRoadmap->SetPosPixel( Point( 0, 0 ) );
 196         m_pImpl->pRoadmap->SetItemSelectHdl( LINK( this, RoadmapWizard, OnRoadmapItemSelected ) );
 197
 198         Size aRoadmapSize =( LogicToPixel( Size( 85, 0 ), MAP_APPFONT ) );
 199         aRoadmapSize.Height() = GetSizePixel().Height();
 200         m_pImpl->pRoadmap->SetSizePixel( aRoadmapSize );
 201
 202         m_pImpl->pFixedLine = new FixedLine( this, WB_VERT );
 203         m_pImpl->pFixedLine->Show();
 204         m_pImpl->pFixedLine->SetPosPixel( Point( aRoadmapSize.Width() + 1, 0 ) );
 205         m_pImpl->pFixedLine->SetSizePixel( Size( LogicToPixel( Size( 2, 0 ) ).Width(), aRoadmapSize.Height() ) );
 206
 207         SetViewWindow( m_pImpl->pRoadmap );
 208         SetViewAlign( WINDOWALIGN_LEFT );
 209         m_pImpl->pRoadmap->Show();
 210     }
 211
 212     //--------------------------------------------------------------------
 213     RoadmapWizard::~RoadmapWizard()
 214     {
 215         delete m_pImpl;
 216         DBG_DTOR( RoadmapWizard, CheckInvariants );
 217     }
 218
 219     //--------------------------------------------------------------------
 220     void RoadmapWizard::SetRoadmapHelpId( const OString& _rId )
 221     {
 222         m_pImpl->pRoadmap->SetHelpId( _rId );
 223     }
 224
 225     //--------------------------------------------------------------------
 226     void RoadmapWizard::SetRoadmapInteractive( sal_Bool _bInteractive )
 227     {
 228         m_pImpl->pRoadmap->SetRoadmapInteractive( _bInteractive );
 229     }
 230
 231     //--------------------------------------------------------------------
 232     void RoadmapWizard::declarePath( PathId _nPathId, const WizardPath& _lWizardStates)
 233     {
 234         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 235
 236         m_pImpl->aPaths.insert( Paths::value_type( _nPathId, _lWizardStates ) );
 237
 238         if ( m_pImpl->aPaths.size() == 1 )
 239             // the very first path -> activate it
 240             activatePath( _nPathId, false );
 241         else
 242             implUpdateRoadmap( );
 243     }
 244
 245     //--------------------------------------------------------------------
 246     void RoadmapWizard::declarePath( PathId _nPathId, WizardState _nFirstState, ... )
 247     {
 248         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 249
 250         DBG_ASSERT( _nFirstState != WZS_INVALID_STATE, "RoadmapWizard::declarePath: there should be at least one state in the path!" );
 251         if ( _nFirstState == WZS_INVALID_STATE )
 252             return;
 253
 254         WizardPath aNewPath;
 255
 256         // collect the elements of the path
 257         va_list aStateList;
 258         va_start( aStateList, _nFirstState );
 259
 260         WizardState nState = _nFirstState;
 261         while ( nState != WZS_INVALID_STATE )
 262         {
 263             aNewPath.push_back( nState );
 264             nState = sal::static_int_cast< WizardState >(
 265                 va_arg( aStateList, int ));
 266         }
 267         va_end( aStateList );
 268
 269         DBG_ASSERT( _nFirstState == 0, "RoadmapWizard::declarePath: first state must be NULL." );
 270             // The WizardDialog (our very base class) always starts with a mnCurLevel == 0
 271
 272         declarePath( _nPathId, aNewPath );
 273     }
 274
 275     //--------------------------------------------------------------------
 276     void RoadmapWizard::describeState( WizardState _nState, const OUString& _rStateDisplayName, RoadmapPageFactory _pPageFactory )
 277     {
 278         OSL_ENSURE( m_pImpl->aStateDescriptors.find( _nState ) == m_pImpl->aStateDescriptors.end(),
 279             "RoadmapWizard::describeState: there already is a descriptor for this state!" );
 280         m_pImpl->aStateDescriptors[ _nState ] = StateDescriptions::mapped_type( _rStateDisplayName, _pPageFactory );
 281     }
 282
 283     //--------------------------------------------------------------------
 284     void RoadmapWizard::activatePath( PathId _nPathId, bool _bDecideForIt )
 285     {
 286         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 287
 288         if ( ( _nPathId == m_pImpl->nActivePath ) && ( _bDecideForIt == m_pImpl->bActivePathIsDefinite ) )
 289             // nothing to do
 290             return;
 291
 292         // does the given path exist?
 293         Paths::const_iterator aNewPathPos = m_pImpl->aPaths.find( _nPathId );
 294         DBG_ASSERT( aNewPathPos != m_pImpl->aPaths.end(), "RoadmapWizard::activate: there is no such path!" );
 295         if ( aNewPathPos == m_pImpl->aPaths.end() )
 296             return;
 297
 298         // determine the index of the current state in the current path
 299         sal_Int32 nCurrentStatePathIndex = -1;
 300         if ( m_pImpl->nActivePath != -1 )
 301             nCurrentStatePathIndex = m_pImpl->getStateIndexInPath( getCurrentState(), m_pImpl->nActivePath );
 302
 303         DBG_ASSERT( (sal_Int32)aNewPathPos->second.size() > nCurrentStatePathIndex,
 304             "RoadmapWizard::activate: you cannot activate a path which has less states than we've already advanced!" );
 305             // If this asserts, this for instance means that we are already in state number, say, 5
 306             // of our current path, and the caller tries to activate a path which has less than 5
 307             // states
 308         if ( (sal_Int32)aNewPathPos->second.size() <= nCurrentStatePathIndex )
 309             return;
 310
 311         // assert that the current and the new path are equal, up to nCurrentStatePathIndex
 312         Paths::const_iterator aActivePathPos = m_pImpl->aPaths.find( m_pImpl->nActivePath );
 313         if ( aActivePathPos != m_pImpl->aPaths.end() )
 314         {
 315             if ( m_pImpl->getFirstDifferentIndex( aActivePathPos->second, aNewPathPos->second ) <= nCurrentStatePathIndex )
 316             {
 317                 OSL_FAIL( "RoadmapWizard::activate: you cannot activate a path which conflicts with the current one *before* the current state!" );
 318                 return;
 319             }
 320         }
 321
 322         m_pImpl->nActivePath = _nPathId;
 323         m_pImpl->bActivePathIsDefinite = _bDecideForIt;
 324
 325         implUpdateRoadmap( );
 326     }
 327
 328     //--------------------------------------------------------------------
 329     void RoadmapWizard::implUpdateRoadmap( )
 330     {
 331         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 332
 333         DBG_ASSERT( m_pImpl->aPaths.find( m_pImpl->nActivePath ) != m_pImpl->aPaths.end(),
 334             "RoadmapWizard::implUpdateRoadmap: there is no such path!" );
 335         const WizardPath& rActivePath( m_pImpl->aPaths[ m_pImpl->nActivePath ] );
 336
 337         sal_Int32 nCurrentStatePathIndex = m_pImpl->getStateIndexInPath( getCurrentState(), rActivePath );
 338
 339         // determine up to which index (in the new path) we have to display the items
 340         RoadmapTypes::ItemIndex nUpperStepBoundary = (RoadmapTypes::ItemIndex)rActivePath.size();
 341         sal_Bool bIncompletePath = sal_False;
 342         if ( !m_pImpl->bActivePathIsDefinite )
 343         {
 344             for ( Paths::const_iterator aPathPos = m_pImpl->aPaths.begin();
 345                   aPathPos != m_pImpl->aPaths.end();
 346                   ++aPathPos
 347                 )
 348             {
 349                 if ( aPathPos->first == m_pImpl->nActivePath )
 350                     // it's the path we are just activating -> no need to check anything
 351                     continue;
 352                 // the index from which on both paths differ
 353                 sal_Int32 nDivergenceIndex = m_pImpl->getFirstDifferentIndex( rActivePath, aPathPos->second );
 354                 if ( nDivergenceIndex <= nCurrentStatePathIndex )
 355                     // they differ in an index which we have already left behind us
 356                     // -> this is no conflict anymore
 357                     continue;
 358
 359                 // the path conflicts with our new path -> don't activate the
 360                 // *complete* new path, but only up to the step which is unambiguous
 361                 nUpperStepBoundary = nDivergenceIndex;
 362                 bIncompletePath = sal_True;
 363             }
 364         }
 365
 366         // can we advance from the current page?
 367         bool bCurrentPageCanAdvance = true;
 368         TabPage* pCurrentPage = GetPage( getCurrentState() );
 369         if ( pCurrentPage )
 370         {
 371             const IWizardPageController* pController = getPageController( GetPage( getCurrentState() ) );
 372             OSL_ENSURE( pController != NULL, "RoadmapWizard::implUpdateRoadmap: no controller for the current page!" );
 373             bCurrentPageCanAdvance = !pController || pController->canAdvance();
 374         }
 375
 376         // now, we have to remove all items after nCurrentStatePathIndex, and insert the items from the active
 377         // path, up to (excluding) nUpperStepBoundary
 378         RoadmapTypes::ItemIndex nLoopUntil = ::std::max( (RoadmapTypes::ItemIndex)nUpperStepBoundary, m_pImpl->pRoadmap->GetItemCount() );
 379         for ( RoadmapTypes::ItemIndex nItemIndex = nCurrentStatePathIndex; nItemIndex < nLoopUntil; ++nItemIndex )
 380         {
 381             bool bExistentItem = ( nItemIndex < m_pImpl->pRoadmap->GetItemCount() );
 382             bool bNeedItem = ( nItemIndex < nUpperStepBoundary );
 383
 384             bool bInsertItem = false;
 385             if ( bExistentItem )
 386             {
 387                 if ( !bNeedItem )
 388                 {
 389                     while ( nItemIndex < m_pImpl->pRoadmap->GetItemCount() )
 390                         m_pImpl->pRoadmap->DeleteRoadmapItem( nItemIndex );
 391                     break;
 392                 }
 393                 else
 394                 {
 395                     // there is an item with this index in the roadmap - does it match what is requested by
 396                     // the respective state in the active path?
 397                     RoadmapTypes::ItemId nPresentItemId = m_pImpl->pRoadmap->GetItemID( nItemIndex );
 398                     WizardState nRequiredState = rActivePath[ nItemIndex ];
 399                     if ( nPresentItemId != nRequiredState )
 400                     {
 401                         m_pImpl->pRoadmap->DeleteRoadmapItem( nItemIndex );
 402                         bInsertItem = true;
 403                     }
 404                 }
 405             }
 406             else
 407             {
 408                 DBG_ASSERT( bNeedItem, "RoadmapWizard::implUpdateRoadmap: ehm - none needed, none present - why did the loop not terminate?" );
 409                 bInsertItem = bNeedItem;
 410             }
 411
 412             WizardState nState( rActivePath[ nItemIndex ] );
 413             if ( bInsertItem )
 414             {
 415                 m_pImpl->pRoadmap->InsertRoadmapItem(
 416                     nItemIndex,
 417                     getStateDisplayName( nState ),
 418                     nState
 419                 );
 420             }
 421
 422             // if the item is *after* the current state, but the current page does not
 423             // allow advancing, the disable the state. This relieves derived classes
 424             // from disabling all future states just because the current state does not
 425             // (yet) allow advancing.
 426             const bool nUnconditionedDisable = !bCurrentPageCanAdvance && ( nItemIndex > nCurrentStatePathIndex );
 427             const bool bEnable = !nUnconditionedDisable && ( m_pImpl->aDisabledStates.find( nState ) == m_pImpl->aDisabledStates.end() );
 428
 429             m_pImpl->pRoadmap->EnableRoadmapItem( m_pImpl->pRoadmap->GetItemID( nItemIndex ), bEnable );
 430         }
 431
 432         m_pImpl->pRoadmap->SetRoadmapComplete( !bIncompletePath );
 433     }
 434
 435     //--------------------------------------------------------------------
 436     WizardTypes::WizardState RoadmapWizard::determineNextState( WizardState _nCurrentState ) const
 437     {
 438         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 439
 440         sal_Int32 nCurrentStatePathIndex = -1;
 441
 442         Paths::const_iterator aActivePathPos = m_pImpl->aPaths.find( m_pImpl->nActivePath );
 443         if ( aActivePathPos != m_pImpl->aPaths.end() )
 444             nCurrentStatePathIndex = m_pImpl->getStateIndexInPath( _nCurrentState, aActivePathPos->second );
 445
 446         DBG_ASSERT( nCurrentStatePathIndex != -1, "RoadmapWizard::determineNextState: ehm - how can we travel if there is no (valid) active path?" );
 447         if ( nCurrentStatePathIndex == -1 )
 448             return WZS_INVALID_STATE;
 449
 450         sal_Int32 nNextStateIndex = nCurrentStatePathIndex + 1;
 451
 452         while   (   ( nNextStateIndex < (sal_Int32)aActivePathPos->second.size() )
 453                 &&  ( m_pImpl->aDisabledStates.find( aActivePathPos->second[ nNextStateIndex ] ) != m_pImpl->aDisabledStates.end() )
 454                 )
 455         {
 456             ++nNextStateIndex;
 457         }
 458
 459         if ( nNextStateIndex >= (sal_Int32)aActivePathPos->second.size() )
 460             // there is no next state in the current path (at least none which is enabled)
 461             return WZS_INVALID_STATE;
 462
 463         return aActivePathPos->second[ nNextStateIndex ];
 464     }
 465
 466     //---------------------------------------------------------------------
 467     bool RoadmapWizard::canAdvance() const
 468     {
 469         if ( !m_pImpl->bActivePathIsDefinite )
 470         {
 471             // check how many paths are still allowed
 472             const WizardPath& rActivePath( m_pImpl->aPaths[ m_pImpl->nActivePath ] );
 473             sal_Int32 nCurrentStatePathIndex = m_pImpl->getStateIndexInPath( getCurrentState(), rActivePath );
 474
 475             size_t nPossiblePaths(0);
 476             for (   Paths::const_iterator aPathPos = m_pImpl->aPaths.begin();
 477                     aPathPos != m_pImpl->aPaths.end();
 478                     ++aPathPos
 479                 )
 480             {
 481                 // the index from which on both paths differ
 482                 sal_Int32 nDivergenceIndex = m_pImpl->getFirstDifferentIndex( rActivePath, aPathPos->second );
 483
 484                 if ( nDivergenceIndex > nCurrentStatePathIndex )
 485                     // this path is still a possible path
 486                     nPossiblePaths += 1;
 487             }
 488
 489             // if we have more than one path which is still possible, then we assume
 490             // to always have a next state. Though there might be scenarios where this
 491             // is not true, but this is too sophisticated (means not really needed) right now.
 492             if ( nPossiblePaths > 1 )
 493                 return true;
 494         }
 495
 496         const WizardPath& rPath = m_pImpl->aPaths[ m_pImpl->nActivePath ];
 497         if ( *rPath.rbegin() == getCurrentState() )
 498             return false;
 499
 500         return true;
 501     }
 502
 503     //---------------------------------------------------------------------
 504     void RoadmapWizard::updateTravelUI()
 505     {
 506         OWizardMachine::updateTravelUI();
 507
 508         // disable the "Previous" button if all states in our history are disabled
 509         ::std::vector< WizardState > aHistory;
 510         getStateHistory( aHistory );
 511         bool bHaveEnabledState = false;
 512         for (   ::std::vector< WizardState >::const_iterator state = aHistory.begin();
 513                 state != aHistory.end() && !bHaveEnabledState;
 514                 ++state
 515             )
 516         {
 517             if ( isStateEnabled( *state ) )
 518                 bHaveEnabledState = true;
 519         }
 520
 521         enableButtons( WZB_PREVIOUS, bHaveEnabledState );
 522
 523         implUpdateRoadmap();
 524     }
 525
 526     //--------------------------------------------------------------------
 527     IMPL_LINK_NOARG(RoadmapWizard, OnRoadmapItemSelected)
 528     {
 529         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 530
 531         RoadmapTypes::ItemId nCurItemId = m_pImpl->pRoadmap->GetCurrentRoadmapItemID();
 532         if ( nCurItemId == getCurrentState() )
 533             // nothing to do
 534             return 1L;
 535
 536         if ( isTravelingSuspended() )
 537             return 0;
 538
 539         WizardTravelSuspension aTravelGuard( *this );
 540
 541         sal_Int32 nCurrentIndex = m_pImpl->getStateIndexInPath( getCurrentState(), m_pImpl->nActivePath );
 542         sal_Int32 nNewIndex     = m_pImpl->getStateIndexInPath( nCurItemId, m_pImpl->nActivePath );
 543
 544         DBG_ASSERT( ( nCurrentIndex != -1 ) && ( nNewIndex != -1 ),
 545             "RoadmapWizard::OnRoadmapItemSelected: something's wrong here!" );
 546         if ( ( nCurrentIndex == -1 ) || ( nNewIndex == -1 ) )
 547         {
 548             return 0L;
 549         }
 550
 551         sal_Bool bResult = sal_True;
 552         if ( nNewIndex > nCurrentIndex )
 553         {
 554             bResult = skipUntil( (WizardState)nCurItemId );
 555             WizardState nTemp = (WizardState)nCurItemId;
 556             while( nTemp )
 557             {
 558                 if( m_pImpl->aDisabledStates.find( --nTemp ) != m_pImpl->aDisabledStates.end() )
 559                     removePageFromHistory( nTemp );
 560             }
 561         }
 562         else
 563             bResult = skipBackwardUntil( (WizardState)nCurItemId );
 564
 565         if ( !bResult )
 566             m_pImpl->pRoadmap->SelectRoadmapItemByID( getCurrentState() );
 567
 568         return 1L;
 569     }
 570
 571     //--------------------------------------------------------------------
 572     void RoadmapWizard::enterState( WizardState _nState )
 573     {
 574         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 575
 576         OWizardMachine::enterState( _nState );
 577
 578         // synchronize the roadmap
 579         implUpdateRoadmap( );
 580         m_pImpl->pRoadmap->SelectRoadmapItemByID( getCurrentState() );
 581     }
 582
 583     //--------------------------------------------------------------------
 584     OUString RoadmapWizard::getStateDisplayName( WizardState _nState ) const
 585     {
 586         OUString sDisplayName;
 587
 588         StateDescriptions::const_iterator pos = m_pImpl->aStateDescriptors.find( _nState );
 589         OSL_ENSURE( pos != m_pImpl->aStateDescriptors.end(),
 590             "RoadmapWizard::getStateDisplayName: no default implementation available for this state!" );
 591         if ( pos != m_pImpl->aStateDescriptors.end() )
 592             sDisplayName = pos->second.first;
 593
 594         return sDisplayName;
 595     }
 596
 597     //--------------------------------------------------------------------
 598     TabPage* RoadmapWizard::createPage( WizardState _nState )
 599     {
 600         TabPage* pPage( NULL );
 601
 602         StateDescriptions::const_iterator pos = m_pImpl->aStateDescriptors.find( _nState );
 603         OSL_ENSURE( pos != m_pImpl->aStateDescriptors.end(),
 604             "RoadmapWizard::createPage: no default implementation available for this state!" );
 605         if ( pos != m_pImpl->aStateDescriptors.end() )
 606         {
 607             RoadmapPageFactory pFactory = pos->second.second;
 608             pPage = (*pFactory)( *this );
 609         }
 610
 611         return pPage;
 612     }
 613
 614     //--------------------------------------------------------------------
 615     void RoadmapWizard::enableState( WizardState _nState, bool _bEnable )
 616     {
 617         DBG_CHKTHIS( RoadmapWizard, CheckInvariants );
 618
 619         // remember this (in case the state appears in the roadmap later on)
 620         if ( _bEnable )
 621             m_pImpl->aDisabledStates.erase( _nState );
 622         else
 623         {
 624             m_pImpl->aDisabledStates.insert( _nState );
 625             removePageFromHistory( _nState );
 626         }
 627
 628         // if the state is currently in the roadmap, reflect it's new status
 629         m_pImpl->pRoadmap->EnableRoadmapItem( (RoadmapTypes::ItemId)_nState, _bEnable );
 630     }
 631
 632     //--------------------------------------------------------------------
 633     bool RoadmapWizard::knowsState( WizardState i_nState ) const
 634     {
 635         for (   Paths::const_iterator path = m_pImpl->aPaths.begin();
 636                 path != m_pImpl->aPaths.end();
 637                 ++path
 638             )
 639         {
 640             for (   WizardPath::const_iterator state = path->second.begin();
 641                     state != path->second.end();
 642                     ++state
 643                 )
 644             {
 645                 if ( *state == i_nState )
 646                     return true;
 647             }
 648         }
 649         return false;
 650     }
 651
 652     //--------------------------------------------------------------------
 653     bool RoadmapWizard::isStateEnabled( WizardState _nState ) const
 654     {
 655         return m_pImpl->aDisabledStates.find( _nState ) == m_pImpl->aDisabledStates.end();
 656     }
 657
 658     //--------------------------------------------------------------------
 659     void RoadmapWizard::Resize()
 660     {
 661         OWizardMachine::Resize();
 662
 663         if ( IsReallyShown() && !IsInInitShow() )
 664             ResizeFixedLine();
 665     }
 666
 667
 668     //--------------------------------------------------------------------
 669     void RoadmapWizard::StateChanged( StateChangedType nType )
 670     {
 671         WizardDialog::StateChanged( nType );
 672
 673         if ( nType == STATE_CHANGE_INITSHOW )
 674             ResizeFixedLine();
 675     }
 676
 677     //--------------------------------------------------------------------
 678     void RoadmapWizard::ResizeFixedLine()
 679     {
 680         Size aSize( m_pImpl->pRoadmap->GetSizePixel() );
 681         aSize.Width() = m_pImpl->pFixedLine->GetSizePixel().Width();
 682         m_pImpl->pFixedLine->SetSizePixel( aSize );
 683     }
 684
 685     //--------------------------------------------------------------------
 686     void RoadmapWizard::updateRoadmapItemLabel( WizardState _nState )
 687     {
 688         const WizardPath& rActivePath( m_pImpl->aPaths[ m_pImpl->nActivePath ] );
 689         RoadmapTypes::ItemIndex nUpperStepBoundary = (RoadmapTypes::ItemIndex)rActivePath.size();
 690         RoadmapTypes::ItemIndex nLoopUntil = ::std::max( (RoadmapTypes::ItemIndex)nUpperStepBoundary, m_pImpl->pRoadmap->GetItemCount() );
 691         sal_Int32 nCurrentStatePathIndex = -1;
 692         if ( m_pImpl->nActivePath != -1 )
 693             nCurrentStatePathIndex = m_pImpl->getStateIndexInPath( getCurrentState(), m_pImpl->nActivePath );
 694         for ( RoadmapTypes::ItemIndex nItemIndex = nCurrentStatePathIndex; nItemIndex < nLoopUntil; ++nItemIndex )
 695         {
 696             bool bExistentItem = ( nItemIndex < m_pImpl->pRoadmap->GetItemCount() );
 697             if ( bExistentItem )
 698             {
 699                 // there is an item with this index in the roadmap - does it match what is requested by
 700                 // the respective state in the active path?
 701                 RoadmapTypes::ItemId nPresentItemId = m_pImpl->pRoadmap->GetItemID( nItemIndex );
 702                 WizardState nRequiredState = rActivePath[ nItemIndex ];
 703                 if ( _nState == nRequiredState )
 704                 {
 705                     m_pImpl->pRoadmap->ChangeRoadmapItemLabel( nPresentItemId, getStateDisplayName( nRequiredState ) );
 706                     break;
 707                 }
 708             }
 709         }
 710     }
 711
 712 //........................................................................
 713 }   // namespace svt
 714 //........................................................................
 715
 716 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */