vcl/source/control/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 <vcl/toolkit/roadmap.hxx>
  22 #include <tools/debug.hxx>
  23 #include <tools/json_writer.hxx>
  24 #include <osl/diagnose.h>
  25
  26 #include <strings.hrc>
  27 #include <svdata.hxx>
  28 #include <wizdlg.hxx>
  29
  30 #include <vector>
  31
  32 #include "wizimpldata.hxx"
  33 #include <uiobject-internal.hxx>
  34
  35 namespace vcl
  36 {
  37     sal_Int32 RoadmapWizardImpl::getStateIndexInPath( WizardTypes::WizardState _nState, const WizardPath& _rPath )
  38     {
  39         sal_Int32 nStateIndexInPath = 0;
  40         bool bFound = false;
  41         for (auto const& path : _rPath)
  42         {
  43             if (path == _nState)
  44             {
  45                 bFound = true;
  46                 break;
  47             }
  48             ++nStateIndexInPath;
  49         }
  50         if (!bFound)
  51             nStateIndexInPath = -1;
  52         return nStateIndexInPath;
  53     }
  54
  55
  56     sal_Int32 RoadmapWizardImpl::getStateIndexInPath( WizardTypes::WizardState _nState, PathId _nPathId )
  57     {
  58         sal_Int32 nStateIndexInPath = -1;
  59         Paths::const_iterator aPathPos = aPaths.find( _nPathId );
  60         if ( aPathPos != aPaths.end( ) )
  61             nStateIndexInPath = getStateIndexInPath( _nState, aPathPos->second );
  62         return nStateIndexInPath;
  63     }
  64
  65
  66     sal_Int32 RoadmapWizardImpl::getFirstDifferentIndex( const WizardPath& _rLHS, const WizardPath& _rRHS )
  67     {
  68         sal_Int32 nMinLength = ::std::min( _rLHS.size(), _rRHS.size() );
  69         for ( sal_Int32 nCheck = 0; nCheck < nMinLength; ++nCheck )
  70         {
  71             if ( _rLHS[ nCheck ] != _rRHS[ nCheck ] )
  72                 return nCheck;
  73         }
  74         return nMinLength;
  75     }
  76
  77     //= RoadmapWizard
  78     RoadmapWizard::RoadmapWizard(vcl::Window* pParent, WinBits nStyle, InitFlag eFlag)
  79         : Dialog(pParent, nStyle, eFlag)
  80         , maWizardLayoutIdle("vcl RoadmapWizard maWizardLayoutIdle")
  81         , m_pFinish(nullptr)
  82         , m_pCancel(nullptr)
  83         , m_pNextPage(nullptr)
  84         , m_pPrevPage(nullptr)
  85         , m_pHelp(nullptr)
  86         , m_xWizardImpl(new WizardMachineImplData)
  87         , m_xRoadmapImpl(new RoadmapWizardImpl)
  88     {
  89         mpFirstPage     = nullptr;
  90         mpFirstBtn      = nullptr;
  91         mpCurTabPage    = nullptr;
  92         mpPrevBtn       = nullptr;
  93         mpNextBtn       = nullptr;
  94         mpViewWindow    = nullptr;
  95         mnCurLevel      = 0;
  96         mbEmptyViewMargin =  false;
  97         mnLeftAlignCount = 0;
  98
  99         maWizardLayoutIdle.SetPriority(TaskPriority::RESIZE);
 100         maWizardLayoutIdle.SetInvokeHandler( LINK( this, RoadmapWizard, ImplHandleWizardLayoutTimerHdl ) );
 101
 102         implConstruct(WizardButtonFlags::NEXT | WizardButtonFlags::PREVIOUS | WizardButtonFlags::FINISH | WizardButtonFlags::CANCEL | WizardButtonFlags::HELP);
 103
 104         SetLeftAlignedButtonCount( 1 );
 105         mbEmptyViewMargin = true;
 106
 107         m_xRoadmapImpl->pRoadmap.disposeAndReset( VclPtr<ORoadmap>::Create( this, WB_TABSTOP ) );
 108         m_xRoadmapImpl->pRoadmap->SetText( VclResId( STR_WIZDLG_ROADMAP_TITLE ) );
 109         m_xRoadmapImpl->pRoadmap->SetPosPixel( Point( 0, 0 ) );
 110         m_xRoadmapImpl->pRoadmap->SetItemSelectHdl( LINK( this, RoadmapWizard, OnRoadmapItemSelected ) );
 111
 112         Size aRoadmapSize = LogicToPixel(Size(85, 0), MapMode(MapUnit::MapAppFont));
 113         aRoadmapSize.setHeight( GetSizePixel().Height() );
 114         m_xRoadmapImpl->pRoadmap->SetSizePixel( aRoadmapSize );
 115
 116         mpViewWindow = m_xRoadmapImpl->pRoadmap;
 117         m_xRoadmapImpl->pRoadmap->Show();
 118     }
 119
 120     RoadmapWizardMachine::RoadmapWizardMachine(weld::Window* pParent)
 121         : WizardMachine(pParent, WizardButtonFlags::NEXT | WizardButtonFlags::PREVIOUS | WizardButtonFlags::FINISH | WizardButtonFlags::CANCEL | WizardButtonFlags::HELP)
 122         , m_pImpl( new RoadmapWizardImpl )
 123     {
 124         m_xAssistant->connect_jump_page(LINK(this, RoadmapWizardMachine, OnRoadmapItemSelected));
 125     }
 126
 127     void RoadmapWizard::ShowRoadmap(bool bShow)
 128     {
 129         m_xRoadmapImpl->pRoadmap->Show(bShow);
 130         CalcAndSetSize();
 131     }
 132
 133     RoadmapWizard::~RoadmapWizard()
 134     {
 135         disposeOnce();
 136     }
 137
 138     RoadmapWizardMachine::~RoadmapWizardMachine()
 139     {
 140     }
 141
 142     void RoadmapWizard::dispose()
 143     {
 144         m_xRoadmapImpl.reset();
 145
 146         m_pFinish.disposeAndClear();
 147         m_pCancel.disposeAndClear();
 148         m_pNextPage.disposeAndClear();
 149         m_pPrevPage.disposeAndClear();
 150         m_pHelp.disposeAndClear();
 151
 152         if (m_xWizardImpl)
 153         {
 154             for (WizardTypes::WizardState i = 0; i < m_xWizardImpl->nFirstUnknownPage; ++i)
 155             {
 156                 TabPage *pPage = GetPage(i);
 157                 if (pPage)
 158                     pPage->disposeOnce();
 159             }
 160             m_xWizardImpl.reset();
 161         }
 162
 163         maWizardLayoutIdle.Stop();
 164
 165         // Remove all buttons
 166         while ( mpFirstBtn )
 167             RemoveButton( mpFirstBtn->mpButton );
 168
 169         // Remove all pages
 170         while ( mpFirstPage )
 171             RemovePage( mpFirstPage->mpPage );
 172
 173         mpCurTabPage.clear();
 174         mpPrevBtn.clear();
 175         mpNextBtn.clear();
 176         mpViewWindow.clear();
 177         Dialog::dispose();
 178     }
 179
 180     void RoadmapWizard::SetRoadmapHelpId( const OUString& _rId )
 181     {
 182         m_xRoadmapImpl->pRoadmap->SetHelpId( _rId );
 183     }
 184
 185     void RoadmapWizard::SetRoadmapBitmap(const BitmapEx& rBmp)
 186     {
 187         m_xRoadmapImpl->pRoadmap->SetRoadmapBitmap(rBmp);
 188     }
 189
 190     void RoadmapWizardMachine::SetRoadmapHelpId(const OUString& rId)
 191     {
 192         m_xAssistant->set_page_side_help_id(rId);
 193     }
 194
 195     void RoadmapWizardMachine::declarePath( PathId _nPathId, const WizardPath& _lWizardStates)
 196     {
 197         m_pImpl->aPaths.emplace( _nPathId, _lWizardStates );
 198
 199         if ( m_pImpl->aPaths.size() == 1 )
 200             // the very first path -> activate it
 201             activatePath( _nPathId );
 202         else
 203             implUpdateRoadmap( );
 204     }
 205
 206     void RoadmapWizardMachine::activatePath( PathId _nPathId, bool _bDecideForIt )
 207     {
 208         if ( ( _nPathId == m_pImpl->nActivePath ) && ( _bDecideForIt == m_pImpl->bActivePathIsDefinite ) )
 209             // nothing to do
 210             return;
 211
 212         // does the given path exist?
 213         Paths::const_iterator aNewPathPos = m_pImpl->aPaths.find( _nPathId );
 214         DBG_ASSERT( aNewPathPos != m_pImpl->aPaths.end(), "RoadmapWizard::activate: there is no such path!" );
 215         if ( aNewPathPos == m_pImpl->aPaths.end() )
 216             return;
 217
 218         // determine the index of the current state in the current path
 219         sal_Int32 nCurrentStatePathIndex = -1;
 220         if ( m_pImpl->nActivePath != -1 )
 221             nCurrentStatePathIndex = m_pImpl->getStateIndexInPath( getCurrentState(), m_pImpl->nActivePath );
 222
 223         DBG_ASSERT( static_cast<sal_Int32>(aNewPathPos->second.size()) > nCurrentStatePathIndex,
 224             "RoadmapWizard::activate: you cannot activate a path which has less states than we've already advanced!" );
 225             // If this asserts, this for instance means that we are already in state number, say, 5
 226             // of our current path, and the caller tries to activate a path which has less than 5
 227             // states
 228         if ( static_cast<sal_Int32>(aNewPathPos->second.size()) <= nCurrentStatePathIndex )
 229             return;
 230
 231         // assert that the current and the new path are equal, up to nCurrentStatePathIndex
 232         Paths::const_iterator aActivePathPos = m_pImpl->aPaths.find( m_pImpl->nActivePath );
 233         if ( aActivePathPos != m_pImpl->aPaths.end() )
 234         {
 235             if ( RoadmapWizardImpl::getFirstDifferentIndex( aActivePathPos->second, aNewPathPos->second ) <= nCurrentStatePathIndex )
 236             {
 237                 OSL_FAIL( "RoadmapWizard::activate: you cannot activate a path which conflicts with the current one *before* the current state!" );
 238                 return;
 239             }
 240         }
 241
 242         m_pImpl->nActivePath = _nPathId;
 243         m_pImpl->bActivePathIsDefinite = _bDecideForIt;
 244
 245         implUpdateRoadmap( );
 246     }
 247
 248     void RoadmapWizard::implUpdateRoadmap( )
 249     {
 250         DBG_ASSERT( m_xRoadmapImpl->aPaths.find( m_xRoadmapImpl->nActivePath ) != m_xRoadmapImpl->aPaths.end(),
 251             "RoadmapWizard::implUpdateRoadmap: there is no such path!" );
 252         const WizardPath& rActivePath( m_xRoadmapImpl->aPaths[ m_xRoadmapImpl->nActivePath ] );
 253
 254         sal_Int32 nCurrentStatePathIndex = RoadmapWizardImpl::getStateIndexInPath( getCurrentState(), rActivePath );
 255         if (nCurrentStatePathIndex < 0)
 256             return;
 257
 258         // determine up to which index (in the new path) we have to display the items
 259         RoadmapTypes::ItemIndex nUpperStepBoundary = static_cast<RoadmapTypes::ItemIndex>(rActivePath.size());
 260         bool bIncompletePath = false;
 261         if ( !m_xRoadmapImpl->bActivePathIsDefinite )
 262         {
 263             for (auto const& path : m_xRoadmapImpl->aPaths)
 264             {
 265                 if ( path.first == m_xRoadmapImpl->nActivePath )
 266                     // it's the path we are just activating -> no need to check anything
 267                     continue;
 268                 // the index from which on both paths differ
 269                 sal_Int32 nDivergenceIndex = RoadmapWizardImpl::getFirstDifferentIndex( rActivePath, path.second );
 270                 if ( nDivergenceIndex <= nCurrentStatePathIndex )
 271                     // they differ in an index which we have already left behind us
 272                     // -> this is no conflict anymore
 273                     continue;
 274
 275                 // the path conflicts with our new path -> don't activate the
 276                 // *complete* new path, but only up to the step which is unambiguous
 277                 nUpperStepBoundary = nDivergenceIndex;
 278                 bIncompletePath = true;
 279             }
 280         }
 281
 282         // now, we have to remove all items after nCurrentStatePathIndex, and insert the items from the active
 283         // path, up to (excluding) nUpperStepBoundary
 284         RoadmapTypes::ItemIndex nLoopUntil = ::std::max( nUpperStepBoundary, m_xRoadmapImpl->pRoadmap->GetItemCount() );
 285         for ( RoadmapTypes::ItemIndex nItemIndex = nCurrentStatePathIndex; nItemIndex < nLoopUntil; ++nItemIndex )
 286         {
 287             bool bExistentItem = ( nItemIndex < m_xRoadmapImpl->pRoadmap->GetItemCount() );
 288             bool bNeedItem = ( nItemIndex < nUpperStepBoundary );
 289
 290             bool bInsertItem = false;
 291             if ( bExistentItem )
 292             {
 293                 if ( !bNeedItem )
 294                 {
 295                     while ( nItemIndex < m_xRoadmapImpl->pRoadmap->GetItemCount() )
 296                         m_xRoadmapImpl->pRoadmap->DeleteRoadmapItem( nItemIndex );
 297                     break;
 298                 }
 299                 else
 300                 {
 301                     // there is an item with this index in the roadmap - does it match what is requested by
 302                     // the respective state in the active path?
 303                     RoadmapTypes::ItemId nPresentItemId = m_xRoadmapImpl->pRoadmap->GetItemID( nItemIndex );
 304                     WizardTypes::WizardState nRequiredState = rActivePath[ nItemIndex ];
 305                     if ( nPresentItemId != nRequiredState )
 306                     {
 307                         m_xRoadmapImpl->pRoadmap->DeleteRoadmapItem( nItemIndex );
 308                         bInsertItem = true;
 309                     }
 310                 }
 311             }
 312             else
 313             {
 314                 DBG_ASSERT( bNeedItem, "RoadmapWizard::implUpdateRoadmap: ehm - none needed, none present - why did the loop not terminate?" );
 315                 bInsertItem = bNeedItem;
 316             }
 317
 318             WizardTypes::WizardState nState( rActivePath[ nItemIndex ] );
 319             if ( bInsertItem )
 320             {
 321                 m_xRoadmapImpl->pRoadmap->InsertRoadmapItem(
 322                     nItemIndex,
 323                     getStateDisplayName( nState ),
 324                     nState,
 325                     true
 326                 );
 327             }
 328
 329             const bool bEnable = m_xRoadmapImpl->aDisabledStates.find( nState ) == m_xRoadmapImpl->aDisabledStates.end();
 330             m_xRoadmapImpl->pRoadmap->EnableRoadmapItem( m_xRoadmapImpl->pRoadmap->GetItemID( nItemIndex ), bEnable );
 331         }
 332
 333         m_xRoadmapImpl->pRoadmap->SetRoadmapComplete( !bIncompletePath );
 334     }
 335
 336     void RoadmapWizardMachine::implUpdateRoadmap( )
 337     {
 338
 339         DBG_ASSERT( m_pImpl->aPaths.find( m_pImpl->nActivePath ) != m_pImpl->aPaths.end(),
 340             "RoadmapWizard::implUpdateRoadmap: there is no such path!" );
 341         const WizardPath& rActivePath( m_pImpl->aPaths[ m_pImpl->nActivePath ] );
 342
 343         sal_Int32 nCurrentStatePathIndex = RoadmapWizardImpl::getStateIndexInPath( getCurrentState(), rActivePath );
 344         if (nCurrentStatePathIndex < 0)
 345             return;
 346
 347         // determine up to which index (in the new path) we have to display the items
 348         RoadmapTypes::ItemIndex nUpperStepBoundary = static_cast<RoadmapTypes::ItemIndex>(rActivePath.size());
 349         if ( !m_pImpl->bActivePathIsDefinite )
 350         {
 351             for (auto const& path : m_pImpl->aPaths)
 352             {
 353                 if ( path.first == m_pImpl->nActivePath )
 354                     // it's the path we are just activating -> no need to check anything
 355                     continue;
 356                 // the index from which on both paths differ
 357                 sal_Int32 nDivergenceIndex = RoadmapWizardImpl::getFirstDifferentIndex( rActivePath, path.second );
 358                 if ( nDivergenceIndex <= nCurrentStatePathIndex )
 359                     // they differ in an index which we have already left behind us
 360                     // -> this is no conflict anymore
 361                     continue;
 362
 363                 // the path conflicts with our new path -> don't activate the
 364                 // *complete* new path, but only up to the step which is unambiguous
 365                 nUpperStepBoundary = nDivergenceIndex;
 366             }
 367         }
 368
 369         // can we advance from the current page?
 370         bool bCurrentPageCanAdvance = true;
 371         BuilderPage* pCurrentPage = GetPage( getCurrentState() );
 372         if ( pCurrentPage )
 373         {
 374             const IWizardPageController* pController = getPageController( GetPage( getCurrentState() ) );
 375             OSL_ENSURE( pController != nullptr, "RoadmapWizard::implUpdateRoadmap: no controller for the current page!" );
 376             bCurrentPageCanAdvance = !pController || pController->canAdvance();
 377         }
 378
 379         // now, we have to remove all items after nCurrentStatePathIndex, and insert the items from the active
 380         // path, up to (excluding) nUpperStepBoundary
 381         RoadmapTypes::ItemIndex nRoadmapItems = m_xAssistant->get_n_pages();
 382         RoadmapTypes::ItemIndex nLoopUntil = ::std::max( nUpperStepBoundary, nRoadmapItems );
 383         for ( RoadmapTypes::ItemIndex nItemIndex = nCurrentStatePathIndex; nItemIndex < nLoopUntil; ++nItemIndex )
 384         {
 385             bool bExistentItem = ( nItemIndex < nRoadmapItems );
 386             bool bNeedItem = ( nItemIndex < nUpperStepBoundary );
 387
 388             bool bInsertItem = false;
 389             if ( bExistentItem )
 390             {
 391                 if ( !bNeedItem )
 392                 {
 393                     int nPages = nRoadmapItems;
 394                     for (int i = nPages - 1; i >= nItemIndex; --i)
 395                     {
 396                         m_xAssistant->set_page_title(m_xAssistant->get_page_ident(i), "");
 397                         --nRoadmapItems;
 398                     }
 399                     break;
 400                 }
 401                 else
 402                 {
 403                     // there is an item with this index in the roadmap - does it match what is requested by
 404                     // the respective state in the active path?
 405                     RoadmapTypes::ItemId nPresentItemId = m_xAssistant->get_page_ident(nItemIndex).toInt32();
 406                     WizardTypes::WizardState nRequiredState = rActivePath[ nItemIndex ];
 407                     if ( nPresentItemId != nRequiredState )
 408                     {
 409                         m_xAssistant->set_page_title(OUString::number(nPresentItemId), "");
 410                         bInsertItem = true;
 411                     }
 412                 }
 413             }
 414             else
 415             {
 416                 DBG_ASSERT( bNeedItem, "RoadmapWizard::implUpdateRoadmap: ehm - none needed, none present - why did the loop not terminate?" );
 417                 bInsertItem = bNeedItem;
 418             }
 419
 420             WizardTypes::WizardState nState( rActivePath[ nItemIndex ] );
 421
 422             if ( bInsertItem )
 423             {
 424                 GetOrCreatePage(nState);
 425             }
 426
 427             OUString sIdent(getPageIdentForState(nState));
 428             m_xAssistant->set_page_index(sIdent, nItemIndex);
 429             m_xAssistant->set_page_title(sIdent, getStateDisplayName(nState));
 430
 431             // if the item is *after* the current state, but the current page does not
 432             // allow advancing, the disable the state. This relieves derived classes
 433             // from disabling all future states just because the current state does not
 434             // (yet) allow advancing.
 435             const bool bUnconditionedDisable = !bCurrentPageCanAdvance && ( nItemIndex > nCurrentStatePathIndex );
 436             const bool bEnable = !bUnconditionedDisable && ( m_pImpl->aDisabledStates.find( nState ) == m_pImpl->aDisabledStates.end() );
 437             m_xAssistant->set_page_sensitive(sIdent, bEnable);
 438         }
 439     }
 440
 441     WizardTypes::WizardState RoadmapWizard::determineNextState( WizardTypes::WizardState _nCurrentState ) const
 442     {
 443         sal_Int32 nCurrentStatePathIndex = -1;
 444
 445         Paths::const_iterator aActivePathPos = m_xRoadmapImpl->aPaths.find( m_xRoadmapImpl->nActivePath );
 446         if ( aActivePathPos != m_xRoadmapImpl->aPaths.end() )
 447             nCurrentStatePathIndex = RoadmapWizardImpl::getStateIndexInPath( _nCurrentState, aActivePathPos->second );
 448
 449         DBG_ASSERT( nCurrentStatePathIndex != -1, "RoadmapWizard::determineNextState: ehm - how can we travel if there is no (valid) active path?" );
 450         if ( nCurrentStatePathIndex == -1 )
 451             return WZS_INVALID_STATE;
 452
 453         sal_Int32 nNextStateIndex = nCurrentStatePathIndex + 1;
 454
 455         while   (   ( nNextStateIndex < static_cast<sal_Int32>(aActivePathPos->second.size()) )
 456                 &&  ( m_xRoadmapImpl->aDisabledStates.find( aActivePathPos->second[ nNextStateIndex ] ) != m_xRoadmapImpl->aDisabledStates.end() )
 457                 )
 458         {
 459             ++nNextStateIndex;
 460         }
 461
 462         if ( nNextStateIndex >= static_cast<sal_Int32>(aActivePathPos->second.size()) )
 463             // there is no next state in the current path (at least none which is enabled)
 464             return WZS_INVALID_STATE;
 465
 466         return aActivePathPos->second[ nNextStateIndex ];
 467     }
 468
 469     WizardTypes::WizardState RoadmapWizardMachine::determineNextState( WizardTypes::WizardState _nCurrentState ) const
 470     {
 471         sal_Int32 nCurrentStatePathIndex = -1;
 472
 473         Paths::const_iterator aActivePathPos = m_pImpl->aPaths.find( m_pImpl->nActivePath );
 474         if ( aActivePathPos != m_pImpl->aPaths.end() )
 475             nCurrentStatePathIndex = RoadmapWizardImpl::getStateIndexInPath( _nCurrentState, aActivePathPos->second );
 476
 477         DBG_ASSERT( nCurrentStatePathIndex != -1, "RoadmapWizard::determineNextState: ehm - how can we travel if there is no (valid) active path?" );
 478         if ( nCurrentStatePathIndex == -1 )
 479             return WZS_INVALID_STATE;
 480
 481         sal_Int32 nNextStateIndex = nCurrentStatePathIndex + 1;
 482
 483         while   (   ( nNextStateIndex < static_cast<sal_Int32>(aActivePathPos->second.size()) )
 484                 &&  ( m_pImpl->aDisabledStates.find( aActivePathPos->second[ nNextStateIndex ] ) != m_pImpl->aDisabledStates.end() )
 485                 )
 486         {
 487             ++nNextStateIndex;
 488         }
 489
 490         if ( nNextStateIndex >= static_cast<sal_Int32>(aActivePathPos->second.size()) )
 491             // there is no next state in the current path (at least none which is enabled)
 492             return WZS_INVALID_STATE;
 493
 494         return aActivePathPos->second[ nNextStateIndex ];
 495     }
 496
 497     bool RoadmapWizardMachine::canAdvance() const
 498     {
 499         if ( !m_pImpl->bActivePathIsDefinite )
 500         {
 501             // check how many paths are still allowed
 502             const WizardPath& rActivePath( m_pImpl->aPaths[ m_pImpl->nActivePath ] );
 503
 504             // if current path has only the base item, it is not possible to proceed without activating another path
 505             if(rActivePath.size()<=1)
 506                 return false;
 507
 508             sal_Int32 nCurrentStatePathIndex = RoadmapWizardImpl::getStateIndexInPath( getCurrentState(), rActivePath );
 509
 510             size_t nPossiblePaths(0);
 511             for (auto const& path : m_pImpl->aPaths)
 512             {
 513                 // the index from which on both paths differ
 514                 sal_Int32 nDivergenceIndex = RoadmapWizardImpl::getFirstDifferentIndex( rActivePath, path.second );
 515
 516                 if ( nDivergenceIndex > nCurrentStatePathIndex )
 517                     // this path is still a possible path
 518                     nPossiblePaths += 1;
 519             }
 520
 521             // if we have more than one path which is still possible, then we assume
 522             // to always have a next state. Though there might be scenarios where this
 523             // is not true, but this is too sophisticated (means not really needed) right now.
 524             if ( nPossiblePaths > 1 )
 525                 return true;
 526         }
 527
 528         const WizardPath& rPath = m_pImpl->aPaths[ m_pImpl->nActivePath ];
 529         return *rPath.rbegin() != getCurrentState();
 530     }
 531
 532     void RoadmapWizardMachine::updateTravelUI()
 533     {
 534         WizardMachine::updateTravelUI();
 535
 536         // disable the "Previous" button if all states in our history are disabled
 537         std::vector< WizardTypes::WizardState > aHistory;
 538         getStateHistory( aHistory );
 539         bool bHaveEnabledState = false;
 540         for (auto const& state : aHistory)
 541         {
 542             if ( isStateEnabled(state) )
 543             {
 544                 bHaveEnabledState = true;
 545                 break;
 546             }
 547         }
 548
 549         enableButtons( WizardButtonFlags::PREVIOUS, bHaveEnabledState );
 550
 551         implUpdateRoadmap();
 552     }
 553
 554     IMPL_LINK_NOARG(RoadmapWizard, OnRoadmapItemSelected, LinkParamNone*, void)
 555     {
 556         RoadmapTypes::ItemId nCurItemId = m_xRoadmapImpl->pRoadmap->GetCurrentRoadmapItemID();
 557         if ( nCurItemId == getCurrentState() )
 558             // nothing to do
 559             return;
 560
 561         if ( isTravelingSuspended() )
 562             return;
 563
 564         RoadmapWizardTravelSuspension aTravelGuard( *this );
 565
 566         sal_Int32 nCurrentIndex = m_xRoadmapImpl->getStateIndexInPath( getCurrentState(), m_xRoadmapImpl->nActivePath );
 567         sal_Int32 nNewIndex     = m_xRoadmapImpl->getStateIndexInPath( nCurItemId, m_xRoadmapImpl->nActivePath );
 568
 569         DBG_ASSERT( ( nCurrentIndex != -1 ) && ( nNewIndex != -1 ),
 570             "RoadmapWizard::OnRoadmapItemSelected: something's wrong here!" );
 571         if ( ( nCurrentIndex == -1 ) || ( nNewIndex == -1 ) )
 572         {
 573             return;
 574         }
 575
 576         bool bResult = true;
 577         if ( nNewIndex > nCurrentIndex )
 578         {
 579             bResult = skipUntil( static_cast<WizardTypes::WizardState>(nCurItemId) );
 580             WizardTypes::WizardState nTemp = static_cast<WizardTypes::WizardState>(nCurItemId);
 581             while( nTemp )
 582             {
 583                 if( m_xRoadmapImpl->aDisabledStates.find( --nTemp ) != m_xRoadmapImpl->aDisabledStates.end() )
 584                     removePageFromHistory( nTemp );
 585             }
 586         }
 587         else
 588             bResult = skipBackwardUntil( static_cast<WizardTypes::WizardState>(nCurItemId) );
 589
 590         if ( !bResult )
 591             m_xRoadmapImpl->pRoadmap->SelectRoadmapItemByID( getCurrentState() );
 592     }
 593
 594     IMPL_LINK(RoadmapWizardMachine, OnRoadmapItemSelected, const OUString&, rCurItemId, bool)
 595     {
 596         WizardTypes::WizardState nSelectedState = getStateFromPageIdent(rCurItemId);
 597
 598         if (nSelectedState == getCurrentState())
 599             // nothing to do
 600             return false;
 601
 602         if ( isTravelingSuspended() )
 603             return false;
 604
 605         WizardTravelSuspension aTravelGuard( *this );
 606
 607         sal_Int32 nCurrentIndex = m_pImpl->getStateIndexInPath( getCurrentState(), m_pImpl->nActivePath );
 608         sal_Int32 nNewIndex     = m_pImpl->getStateIndexInPath( nSelectedState, m_pImpl->nActivePath );
 609
 610         DBG_ASSERT( ( nCurrentIndex != -1 ) && ( nNewIndex != -1 ),
 611             "RoadmapWizard::OnRoadmapItemSelected: something's wrong here!" );
 612         if ( ( nCurrentIndex == -1 ) || ( nNewIndex == -1 ) )
 613         {
 614             return false;
 615         }
 616
 617         bool bResult = true;
 618         if ( nNewIndex > nCurrentIndex )
 619         {
 620             bResult = skipUntil(nSelectedState);
 621             WizardTypes::WizardState nTemp = nSelectedState;
 622             while( nTemp )
 623             {
 624                 if( m_pImpl->aDisabledStates.find( --nTemp ) != m_pImpl->aDisabledStates.end() )
 625                     removePageFromHistory( nTemp );
 626             }
 627         }
 628         else
 629             bResult = skipBackwardUntil(nSelectedState);
 630
 631         return bResult;
 632     }
 633
 634     void RoadmapWizard::enterState(WizardTypes::WizardState /*nState*/)
 635     {
 636         // synchronize the roadmap
 637         implUpdateRoadmap( );
 638         m_xRoadmapImpl->pRoadmap->SelectRoadmapItemByID( getCurrentState() );
 639     }
 640
 641     void RoadmapWizardMachine::enterState( WizardTypes::WizardState _nState )
 642     {
 643         WizardMachine::enterState( _nState );
 644
 645         // synchronize the roadmap
 646         implUpdateRoadmap();
 647     }
 648
 649     OUString RoadmapWizard::getStateDisplayName( WizardTypes::WizardState _nState ) const
 650     {
 651         OUString sDisplayName;
 652
 653         StateDescriptions::const_iterator pos = m_xRoadmapImpl->aStateDescriptors.find( _nState );
 654         OSL_ENSURE( pos != m_xRoadmapImpl->aStateDescriptors.end(),
 655             "RoadmapWizard::getStateDisplayName: no default implementation available for this state!" );
 656         if ( pos != m_xRoadmapImpl->aStateDescriptors.end() )
 657             sDisplayName = pos->second.first;
 658
 659         return sDisplayName;
 660     }
 661
 662     OUString RoadmapWizardMachine::getStateDisplayName( WizardTypes::WizardState _nState ) const
 663     {
 664         OUString sDisplayName;
 665
 666         StateDescriptions::const_iterator pos = m_pImpl->aStateDescriptors.find( _nState );
 667         OSL_ENSURE( pos != m_pImpl->aStateDescriptors.end(),
 668             "RoadmapWizard::getStateDisplayName: no default implementation available for this state!" );
 669         if ( pos != m_pImpl->aStateDescriptors.end() )
 670             sDisplayName = pos->second.first;
 671
 672         return sDisplayName;
 673     }
 674
 675     VclPtr<TabPage> RoadmapWizard::createPage( WizardTypes::WizardState _nState )
 676     {
 677         VclPtr<TabPage> pPage;
 678
 679         StateDescriptions::const_iterator pos = m_xRoadmapImpl->aStateDescriptors.find( _nState );
 680         OSL_ENSURE( pos != m_xRoadmapImpl->aStateDescriptors.end(),
 681             "RoadmapWizard::createPage: no default implementation available for this state!" );
 682         if ( pos != m_xRoadmapImpl->aStateDescriptors.end() )
 683         {
 684             RoadmapPageFactory pFactory = pos->second.second;
 685             pPage = (*pFactory)( *this );
 686         }
 687
 688         return pPage;
 689     }
 690
 691     void RoadmapWizardMachine::enableState( WizardTypes::WizardState _nState, bool _bEnable )
 692     {
 693         // remember this (in case the state appears in the roadmap later on)
 694         if ( _bEnable )
 695             m_pImpl->aDisabledStates.erase( _nState );
 696         else
 697         {
 698             m_pImpl->aDisabledStates.insert( _nState );
 699             removePageFromHistory( _nState );
 700         }
 701
 702         // if the state is currently in the roadmap, reflect it's new status
 703         m_xAssistant->set_page_sensitive(getPageIdentForState(_nState), _bEnable);
 704     }
 705
 706     bool RoadmapWizardMachine::knowsState( WizardTypes::WizardState i_nState ) const
 707     {
 708         for (auto const& path : m_pImpl->aPaths)
 709         {
 710             for (auto const& state : path.second)
 711             {
 712                 if ( state == i_nState )
 713                     return true;
 714             }
 715         }
 716         return false;
 717     }
 718
 719     bool RoadmapWizardMachine::isStateEnabled( WizardTypes::WizardState _nState ) const
 720     {
 721         return m_pImpl->aDisabledStates.find( _nState ) == m_pImpl->aDisabledStates.end();
 722     }
 723
 724     void RoadmapWizard::InsertRoadmapItem(int nItemIndex, const OUString& rText, int nItemId, bool bEnable)
 725     {
 726         m_xRoadmapImpl->pRoadmap->InsertRoadmapItem(nItemIndex, rText, nItemId, bEnable);
 727     }
 728
 729     void RoadmapWizard::SelectRoadmapItemByID(int nItemId, bool bGrabFocus)
 730     {
 731         m_xRoadmapImpl->pRoadmap->SelectRoadmapItemByID(nItemId, bGrabFocus);
 732     }
 733
 734     void RoadmapWizard::DeleteRoadmapItems()
 735     {
 736         while (m_xRoadmapImpl->pRoadmap->GetItemCount())
 737             m_xRoadmapImpl->pRoadmap->DeleteRoadmapItem(0);
 738     }
 739
 740     void RoadmapWizard::SetItemSelectHdl( const Link<LinkParamNone*,void>& _rHdl )
 741     {
 742         m_xRoadmapImpl->pRoadmap->SetItemSelectHdl(_rHdl);
 743     }
 744
 745     int RoadmapWizard::GetCurrentRoadmapItemID() const
 746     {
 747         return m_xRoadmapImpl->pRoadmap->GetCurrentRoadmapItemID();
 748     }
 749
 750     FactoryFunction RoadmapWizard::GetUITestFactory() const
 751     {
 752         return RoadmapWizardUIObject::create;
 753     }
 754
 755     namespace
 756     {
 757         bool isButton(WindowType eType)
 758         {
 759             return eType == WindowType::PUSHBUTTON || eType == WindowType::OKBUTTON
 760                 || eType == WindowType::CANCELBUTTON || eType == WindowType::HELPBUTTON;
 761         }
 762     }
 763
 764     void RoadmapWizard::DumpAsPropertyTree(tools::JsonWriter& rJsonWriter)
 765     {
 766         rJsonWriter.put("id", get_id());
 767         rJsonWriter.put("type", "dialog");
 768         rJsonWriter.put("title", GetText());
 769
 770         OUString sDialogId = GetHelpId();
 771         sal_Int32 nStartPos = sDialogId.lastIndexOf('/');
 772         nStartPos = nStartPos >= 0 ? nStartPos + 1 : 0;
 773         rJsonWriter.put("dialogid", sDialogId.copy(nStartPos));
 774         {
 775             auto aResponses = rJsonWriter.startArray("responses");
 776             for (const auto& rResponse : m_xRoadmapImpl->maResponses)
 777             {
 778                 auto aResponse = rJsonWriter.startStruct();
 779                 rJsonWriter.put("id", rResponse.first->get_id());
 780                 rJsonWriter.put("response", rResponse.second);
 781             }
 782         }
 783
 784         vcl::Window* pFocusControl = GetFirstControlForFocus();
 785         if (pFocusControl)
 786             rJsonWriter.put("init_focus_id", pFocusControl->get_id());
 787
 788         {
 789             auto childrenNode = rJsonWriter.startArray("children");
 790
 791             auto containerNode = rJsonWriter.startStruct();
 792             rJsonWriter.put("id", "container");
 793             rJsonWriter.put("type", "container");
 794             rJsonWriter.put("vertical", true);
 795
 796             {
 797                 auto containerChildrenNode = rJsonWriter.startArray("children");
 798
 799                 // tabpages
 800                 for (int i = 0; i < GetChildCount(); i++)
 801                 {
 802                     vcl::Window* pChild = GetChild(i);
 803
 804                     if (!isButton(pChild->GetType()) && pChild != mpViewWindow)
 805                     {
 806                         auto childNode = rJsonWriter.startStruct();
 807                         pChild->DumpAsPropertyTree(rJsonWriter);
 808                     }
 809                 }
 810
 811                 // buttons
 812                 {
 813                     auto buttonsNode = rJsonWriter.startStruct();
 814                     rJsonWriter.put("id", "buttons");
 815                     rJsonWriter.put("type", "buttonbox");
 816                     rJsonWriter.put("layoutstyle", "end");
 817                     {
 818                         auto buttonsChildrenNode = rJsonWriter.startArray("children");
 819                         for (int i = 0; i < GetChildCount(); i++)
 820                         {
 821                             vcl::Window* pChild = GetChild(i);
 822
 823                             if (isButton(pChild->GetType()))
 824                             {
 825                                 auto childNode = rJsonWriter.startStruct();
 826                                 pChild->DumpAsPropertyTree(rJsonWriter);
 827                             }
 828                         }
 829                     }
 830                 }
 831             }
 832         }
 833     }
 834
 835 }   // namespace vcl
 836
 837 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */