svtools/source/dialogs/roadmapwizard.cxx

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