svtools/source/control/roadmap.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: roadmap.cxx,v $
  10  * $Revision: 1.16.56.1 $
  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 #include <roadmap.hxx>
  34
  35 #ifndef _STRING_HXX
  36 #define _STRING_HXX
  37 #endif
  38
  39 #ifndef __SGI_STL_VECTOR
  40 #include <vector>
  41 #endif
  42
  43 #include <algorithm>
  44 #include <vcl/bitmap.hxx>
  45 #include <tools/color.hxx>
  46
  47 #ifndef _RTL_USTRING_HXX_
  48 #include <rtl/OUString.hxx>
  49 #endif
  50 #include <memory>
  51
  52 #define RMENTRYPOINT_X      4
  53 #define RMENTRYPOINT_Y      27
  54 #define RMITEMDISTANCE_Y    6
  55 #define RMINCOMPLETE        -1
  56 #define NREMOVERMITEM       -1
  57 #define NADDITEM            1
  58 #define INCOMPLETELABEL     ::String::CreateFromAscii("...")        // TODO: Cast to String
  59
  60 //.........................................................................
  61 namespace svt
  62 {
  63 //.........................................................................
  64
  65     typedef std::vector< ::rtl::OUString > S_Vector;
  66     typedef std::vector< ORoadmapHyperLabel* > HL_Vector;
  67
  68     //=====================================================================
  69     //= FontChanger
  70     //=====================================================================
  71 //      class FontChanger
  72 //      {
  73 //      protected:
  74 //              OutputDevice*   m_pDev;
  75 //
  76 //      public:
  77 //              FontChanger( OutputDevice* _pDev, const Font& _rNewFont )
  78 //                      :m_pDev( _pDev )
  79 //              {
  80 //                      m_pDev->Push( PUSH_FONT );
  81 //                      m_pDev->SetFont( _rNewFont );
  82 //              }
  83 //
  84 //              ~FontChanger()
  85 //              {
  86 //                      m_pDev->Pop( );
  87 //              }
  88 //      };
  89
  90
  91     //=====================================================================
  92     //= ColorChanger
  93     //=====================================================================
  94     class ColorChanger
  95     {
  96     protected:
  97         OutputDevice*   m_pDev;
  98
  99     public:
 100         ColorChanger( OutputDevice* _pDev, const Color& _rNewLineColor, const Color& _rNewFillColor )
 101             :m_pDev( _pDev )
 102         {
 103             m_pDev->Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
 104             m_pDev->SetLineColor( _rNewLineColor );
 105             m_pDev->SetFillColor( _rNewFillColor );
 106         }
 107
 108         ~ColorChanger()
 109         {
 110             m_pDev->Pop();
 111         }
 112     };
 113
 114
 115     //=====================================================================
 116     //= RoadmapImpl
 117     //=====================================================================
 118     class RoadmapImpl : public RoadmapTypes
 119     {
 120     protected:
 121         Link                m_aSelectHdl;
 122         BitmapEx                m_aPicture;
 123         HL_Vector           m_aRoadmapSteps;
 124         ItemId              m_iCurItemID;
 125         sal_Bool            m_bInteractive;
 126         sal_Bool            m_bComplete;
 127
 128     public:
 129         RoadmapImpl() :
 130             m_bInteractive( sal_True ),
 131             m_bComplete( sal_True ) {}
 132
 133         Size aHyperLabelPixelSize;
 134         ORoadmapHyperLabel* InCompleteHyperLabel;
 135
 136         void                        addHyperLabel( ORoadmapHyperLabel*  _rRoadmapStep ) { m_aRoadmapSteps.push_back(_rRoadmapStep); }
 137
 138         HL_Vector&              getHyperLabels() { return m_aRoadmapSteps; }
 139         const HL_Vector&        getHyperLabels() const { return m_aRoadmapSteps; }
 140
 141         void                insertHyperLabel( ItemIndex _Index, ORoadmapHyperLabel* _rRoadmapStep ) { m_aRoadmapSteps.insert( m_aRoadmapSteps.begin() + _Index, _rRoadmapStep ); }
 142
 143         ItemIndex           getItemCount() const { return m_aRoadmapSteps.size();}
 144
 145         void                setCurItemID( ItemId i ) {m_iCurItemID = i; }
 146         ItemId              getCurItemID() const { return m_iCurItemID; }
 147
 148         void                setInteractive(const sal_Bool _bInteractive) {m_bInteractive = _bInteractive; }
 149         sal_Bool            isInteractive() const { return m_bInteractive; };
 150
 151         void                setComplete(const sal_Bool _bComplete) {m_bComplete = _bComplete; }
 152         sal_Bool            isComplete() const { return m_bComplete; };
 153
 154         void                        setPicture( const BitmapEx& _rPic ) { m_aPicture = _rPic; }
 155         const BitmapEx&     getPicture( ) const { return m_aPicture; }
 156
 157         void                        setSelectHdl( const Link& _rHdl ) { m_aSelectHdl = _rHdl; }
 158         const Link&             getSelectHdl( ) const { return m_aSelectHdl; }
 159
 160         void removeHyperLabel( ItemIndex _Index )
 161         {
 162             if ( ( _Index > -1 ) && ( _Index < getItemCount() ) )
 163             {
 164                 delete m_aRoadmapSteps[_Index];
 165                 m_aRoadmapSteps.erase( m_aRoadmapSteps.begin() + _Index);
 166             }
 167         }
 168     };
 169
 170
 171     //=====================================================================
 172     //= Roadmap
 173     //=====================================================================
 174     //---------------------------------------------------------------------
 175     ORoadmap::ORoadmap( Window* _pParent, const ResId& _rId ):Control( _pParent, _rId )
 176                                                             ,m_pImpl( new RoadmapImpl() )
 177     {
 178         implInit();
 179     }
 180
 181     //---------------------------------------------------------------------
 182     ORoadmap::ORoadmap( Window* _pParent, WinBits _nWinStyle )
 183         :Control( _pParent, _nWinStyle )
 184         , m_pImpl( new RoadmapImpl() )
 185
 186     {
 187         implInit();
 188     }
 189
 190     //---------------------------------------------------------------------
 191     void ORoadmap::implInit()
 192     {
 193         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 194         Color aTextColor = rStyleSettings.GetFieldTextColor();
 195         Font aFont = GetFont( );
 196         aFont.SetColor( aTextColor );
 197         aFont.SetWeight( WEIGHT_BOLD );
 198         aFont.SetUnderline( UNDERLINE_SINGLE );
 199         SetFont( aFont );
 200         SetBackground( Wallpaper( rStyleSettings.GetFieldColor() ) );
 201         m_pImpl->InCompleteHyperLabel = NULL;
 202         m_pImpl->setCurItemID(-1 );
 203         m_pImpl->setComplete( sal_True );
 204
 205         // Roadmap control should be reachable as one unit with a Tab key
 206         // the next Tab key should spring out of the control.
 207         // To reach it the control itself should get focus and set it
 208         // on entries. The entries themself should not be reachable with
 209         // the Tab key directly. So each entry should have WB_NOTABSTOP.
 210         //
 211         // In other words the creator should create the control with the following
 212         // flags:
 213         // SetStyle( ( GetStyle() | WB_TABSTOP ) & ~WB_DIALOGCONTROL );
 214
 215 // TODO: if somebody sets a new font from outside (OutputDevice::SetFont), we would have to react
 216 // on this with calculating a new bold font.
 217 // Unfortunately, the OutputDevice does not offer a notify mechanism for a changed font.
 218 // So settings the font from outside is simply a forbidded scenario at the moment
 219     }
 220
 221     //---------------------------------------------------------------------
 222     ORoadmap::~ORoadmap( )
 223     {
 224         HL_Vector pLocRoadmapItems = m_pImpl->getHyperLabels();
 225         m_pImpl->getHyperLabels().clear();
 226         for ( HL_Vector::iterator i = pLocRoadmapItems.begin(); i< pLocRoadmapItems.end(); i++)
 227         {
 228             delete *i;
 229         }
 230         if ( ! m_pImpl->isComplete() )
 231             delete m_pImpl->InCompleteHyperLabel;
 232         delete m_pImpl;
 233         m_pImpl = NULL;
 234     }
 235
 236
 237     RoadmapTypes::ItemId ORoadmap::GetCurrentRoadmapItemID() const
 238     {
 239         return m_pImpl->getCurItemID();
 240     }
 241
 242
 243     void ORoadmap::InitializeHyperLabelSize()
 244     {
 245         Size aSize = GetSizePixel();
 246         Size aLogicSize = PixelToLogic( aSize, MAP_APPFONT );
 247         aLogicSize.Height() = LABELBASEMAPHEIGHT;
 248         aLogicSize.Width() -= (2*RMENTRYPOINT_X);
 249         m_pImpl->aHyperLabelPixelSize = LogicToPixel( aLogicSize, MAP_APPFONT );
 250         EnableMapMode( sal_False );
 251     }
 252
 253
 254     ORoadmapHyperLabel* ORoadmap::GetPreviousHyperLabel( ItemIndex _Index)
 255     {
 256         ORoadmapHyperLabel* OldHyperLabel = NULL;
 257         if (_Index > 0)
 258             OldHyperLabel = m_pImpl->getHyperLabels().at( _Index - 1 );
 259         return OldHyperLabel;
 260     }
 261
 262
 263        //---------------------------------------------------------------------
 264
 265     ORoadmapHyperLabel* ORoadmap::InsertHyperLabel( ItemIndex _Index, ::rtl::OUString _sLabel, ItemId _RMID, sal_Bool _bEnabled)
 266     {
 267         if (m_pImpl->getItemCount() == 0 )
 268             InitializeHyperLabelSize();
 269         ORoadmapHyperLabel* CurHyperLabel;
 270         ORoadmapHyperLabel* OldHyperLabel = GetPreviousHyperLabel( _Index);
 271
 272         if (_RMID != RMINCOMPLETE )
 273         {
 274             CurHyperLabel = new ORoadmapHyperLabel(this, WB_WORDBREAK);
 275             CurHyperLabel->SetInteractive( m_pImpl->isInteractive() );
 276             m_pImpl->insertHyperLabel(_Index, CurHyperLabel );
 277         }
 278         else
 279         {
 280             CurHyperLabel = new ORoadmapHyperLabel(this);
 281             CurHyperLabel->SetInteractive( sal_False );
 282         }
 283         CurHyperLabel->SetPosition( OldHyperLabel );
 284         CurHyperLabel->SetLabelAndSize( _Index, _sLabel, m_pImpl->aHyperLabelPixelSize );
 285         CurHyperLabel->SetClickHdl(LINK( this, ORoadmap, ImplClickHdl ) );
 286         CurHyperLabel->SetID( _RMID );
 287         CurHyperLabel->SetIndex( _Index );
 288         if (!_bEnabled)
 289             CurHyperLabel->Enable( _bEnabled );
 290         return CurHyperLabel;
 291     }
 292
 293     //---------------------------------------------------------------------
 294     void ORoadmap::SetRoadmapBitmap( const BitmapEx& _rBmp, sal_Bool _bInvalidate )
 295     {
 296         m_pImpl->setPicture( _rBmp );
 297         if ( _bInvalidate )
 298             Invalidate( );
 299     }
 300
 301     //---------------------------------------------------------------------
 302     const BitmapEx& ORoadmap::GetRoadmapBitmap( ) const
 303     {
 304         return m_pImpl->getPicture( );
 305     }
 306
 307     //---------------------------------------------------------------------
 308     void ORoadmap::SetRoadmapInteractive( sal_Bool _bInteractive )
 309     {
 310         m_pImpl->setInteractive( _bInteractive );
 311         ORoadmapHyperLabel* CurHyperLabel;
 312         HL_Vector pLocRoadmapItems = m_pImpl->getHyperLabels();
 313         for ( HL_Vector::iterator i = pLocRoadmapItems.begin(); i< pLocRoadmapItems.end(); i++)
 314         {
 315             CurHyperLabel = *i;
 316             CurHyperLabel->SetInteractive( _bInteractive );
 317         }
 318     }
 319
 320     //---------------------------------------------------------------------
 321     sal_Bool ORoadmap::IsRoadmapInteractive()
 322     {
 323         return m_pImpl->isInteractive();
 324     }
 325
 326     //---------------------------------------------------------------------
 327     void ORoadmap::SetRoadmapComplete( sal_Bool _bComplete )
 328     {
 329         sal_Bool OldbComplete = m_pImpl->isComplete();
 330         m_pImpl->setComplete( _bComplete);
 331         if (_bComplete)
 332         {
 333             if ( m_pImpl->InCompleteHyperLabel != NULL)
 334             {
 335                 if (m_pImpl->getItemCount() > 0)
 336                 {
 337                     HL_Vector pLocRoadmapItems = m_pImpl->getHyperLabels();
 338                     pLocRoadmapItems.pop_back();
 339                     delete m_pImpl->InCompleteHyperLabel;
 340                 }
 341                 m_pImpl->InCompleteHyperLabel = NULL;
 342             }
 343         }
 344         else if (OldbComplete)
 345             m_pImpl->InCompleteHyperLabel = InsertHyperLabel( m_pImpl->getItemCount(), ::String::CreateFromAscii("..."), RMINCOMPLETE );
 346     }
 347
 348     //---------------------------------------------------------------------
 349     void ORoadmap::SetRoadmapLabel(ORoadmapHyperLabel* CurHyperLabel, sal_Int32 _nPrefix, String _sDescription)
 350     {
 351         const xub_StrLen n_Pos = _sDescription.Search( String::CreateFromAscii(".") );
 352         if ( n_Pos != STRING_NOTFOUND )
 353         {
 354             const String sID = ::String::CreateFromInt32( _nPrefix );
 355             _sDescription.Replace(0 , n_Pos, sID );
 356         }
 357         CurHyperLabel->SetLabelAndSize( _nPrefix, _sDescription, m_pImpl->aHyperLabelPixelSize );
 358     }
 359
 360     //---------------------------------------------------------------------
 361     void ORoadmap::UpdatefollowingHyperLabels( ItemIndex _Index, sal_Int16 )
 362     {
 363         if ( _Index < ( m_pImpl->getItemCount() ) )
 364         {
 365             Point aPos;
 366             String sLabel;
 367             HL_Vector pLocRoadmapItems = m_pImpl->getHyperLabels();
 368             ORoadmapHyperLabel* CurHyperLabel = NULL;
 369             ItemIndex n_CurPrefix = _Index + 1 ;
 370             for ( HL_Vector::iterator i = pLocRoadmapItems.begin()+ _Index; i< pLocRoadmapItems.end(); i++)
 371             {
 372                 CurHyperLabel = *i;
 373                 aPos = CurHyperLabel->GetLogicalPosition();
 374                 CurHyperLabel->SetIndex( n_CurPrefix - 1);
 375                 sLabel = CurHyperLabel->GetLabel();
 376                 SetRoadmapLabel(CurHyperLabel, n_CurPrefix, sLabel);
 377                 ORoadmapHyperLabel* OldHyperLabel = GetPreviousHyperLabel( n_CurPrefix-1);
 378                 CurHyperLabel->SetPosition( OldHyperLabel);
 379                 n_CurPrefix++;
 380             }
 381         }
 382         if ( ! m_pImpl->isComplete() )
 383         {
 384             ORoadmapHyperLabel* OldHyperLabel = GetPreviousHyperLabel( m_pImpl->getItemCount());
 385             m_pImpl->InCompleteHyperLabel->SetPosition( OldHyperLabel );
 386             m_pImpl->InCompleteHyperLabel->SetLabelAndSize( m_pImpl->getItemCount(), ::String::CreateFromAscii("..."), m_pImpl->aHyperLabelPixelSize );
 387         }
 388     }
 389
 390     //---------------------------------------------------------------------
 391     void ORoadmap::ReplaceRoadmapItem( ItemIndex _Index, ::rtl::OUString _RoadmapItem, ItemId _RMID, sal_Bool _bEnabled )
 392     {
 393         ORoadmapHyperLabel* CurHyperLabel = GetByIndex( _Index);
 394         if ( CurHyperLabel != NULL )
 395         {
 396             CurHyperLabel->SetLabelAndSize( _Index,  _RoadmapItem, m_pImpl->aHyperLabelPixelSize );
 397             CurHyperLabel->SetID( _RMID );
 398             CurHyperLabel->Enable( _bEnabled );
 399         }
 400     }
 401
 402     //---------------------------------------------------------------------
 403     RoadmapTypes::ItemIndex ORoadmap::GetItemCount() const
 404     {
 405         return m_pImpl->getItemCount();
 406     }
 407
 408     //---------------------------------------------------------------------
 409     RoadmapTypes::ItemId ORoadmap::GetItemID( ItemIndex _nIndex ) const
 410     {
 411         const ORoadmapHyperLabel* pHyperLabel = GetByIndex( _nIndex );
 412         if ( pHyperLabel )
 413             return pHyperLabel->GetID();
 414         return -1;
 415     }
 416
 417     //---------------------------------------------------------------------
 418     RoadmapTypes::ItemIndex ORoadmap::GetItemIndex( ItemId _nID ) const
 419     {
 420         ORoadmapHyperLabel* CurHyperLabel;
 421         ItemId nLocID = 0;
 422         HL_Vector &LocHyperLabels = m_pImpl->getHyperLabels();
 423         ItemIndex nResult = 0;
 424         for ( HL_Vector::iterator i = LocHyperLabels.begin(); i< LocHyperLabels.end(); i++)
 425         {
 426             CurHyperLabel = *i;
 427             nLocID = CurHyperLabel->GetID();
 428             if ( nLocID == _nID )
 429                 return nResult;
 430             nResult++;
 431         }
 432         return -1;
 433     }
 434
 435     //---------------------------------------------------------------------
 436     void ORoadmap::InsertRoadmapItem( ItemIndex _Index, ::rtl::OUString _RoadmapItem, ItemId _nUniqueId, sal_Bool _bEnabled )
 437     {
 438         ORoadmapHyperLabel* CurHyperLabel;
 439         CurHyperLabel = InsertHyperLabel(_Index, _RoadmapItem, _nUniqueId, _bEnabled);
 440             // Todo: YPos is superfluous, if items are always appended
 441         UpdatefollowingHyperLabels( _Index + 1);
 442     }
 443
 444     //---------------------------------------------------------------------
 445     void ORoadmap::DeleteRoadmapItem( ItemIndex _Index )
 446     {
 447         if ( m_pImpl->getItemCount() > 0 && ( _Index > -1)  &&  ( _Index < m_pImpl->getItemCount() ) )
 448         {
 449             m_pImpl->removeHyperLabel( _Index );
 450             UpdatefollowingHyperLabels( _Index, NREMOVERMITEM);
 451         }
 452     }
 453
 454     //---------------------------------------------------------------------
 455     sal_Bool ORoadmap::IsRoadmapComplete( ) const
 456     {
 457         return m_pImpl->isComplete();
 458     }
 459
 460     //---------------------------------------------------------------------
 461     sal_Bool ORoadmap::IsRoadmapItemEnabled( ItemId _nItemId, ItemIndex _nStartIndex  ) const
 462     {
 463         const ORoadmapHyperLabel* _pLabelItem = GetByID( _nItemId, _nStartIndex  );
 464         return _pLabelItem ? _pLabelItem->IsEnabled() : sal_False;
 465     }
 466
 467     //---------------------------------------------------------------------
 468     void ORoadmap::EnableRoadmapItem( ItemId _nItemId, sal_Bool _bEnable, ItemIndex _nStartIndex )
 469     {
 470         ORoadmapHyperLabel* CurHyperLabel = GetByID( _nItemId, _nStartIndex );
 471         if ( CurHyperLabel != NULL )
 472             CurHyperLabel->Enable( _bEnable );
 473     }
 474
 475     //---------------------------------------------------------------------
 476     void ORoadmap::ChangeRoadmapItemLabel( ItemId _nID, ::rtl::OUString _sLabel, ItemIndex _nStartIndex )
 477     {
 478         ORoadmapHyperLabel* CurHyperLabel = GetByID( _nID, _nStartIndex );
 479         if ( CurHyperLabel != NULL )
 480         {
 481             CurHyperLabel->SetLabelAndSize( CurHyperLabel->GetIndex(), _sLabel, m_pImpl->aHyperLabelPixelSize );
 482             HL_Vector pLocRoadmapItems = m_pImpl->getHyperLabels();
 483             ItemIndex Index = _nStartIndex;
 484             for ( HL_Vector::iterator i = pLocRoadmapItems.begin()+ Index; i< pLocRoadmapItems.end(); i++)
 485             {
 486                 CurHyperLabel = *i;
 487                 ORoadmapHyperLabel* OldHyperLabel = GetPreviousHyperLabel( Index );
 488                 CurHyperLabel->SetPosition( OldHyperLabel);
 489                 Index++;
 490             }
 491         }
 492     }
 493
 494     //---------------------------------------------------------------------
 495
 496     ::rtl::OUString ORoadmap::GetRoadmapItemLabel( ItemId _nID, ItemIndex _nStartIndex )
 497     {
 498         ORoadmapHyperLabel* CurHyperLabel = GetByID( _nID, _nStartIndex );
 499         if ( CurHyperLabel != NULL )
 500             return CurHyperLabel->GetLabel();
 501         else
 502             return ::rtl::OUString();
 503     }
 504
 505     //---------------------------------------------------------------------
 506     void ORoadmap::ChangeRoadmapItemID( ItemId _nID, ItemId _NewID, ItemIndex _nStartIndex )
 507     {
 508         ORoadmapHyperLabel* CurHyperLabel = GetByID( _nID, _nStartIndex );
 509         if ( CurHyperLabel != NULL )
 510             CurHyperLabel->SetID( _NewID );
 511     }
 512
 513     //---------------------------------------------------------------------
 514     ORoadmapHyperLabel* ORoadmap::GetByID( ItemId _nID, ItemIndex _nStartIndex)
 515     {
 516         ORoadmapHyperLabel* CurHyperLabel;
 517         ItemId nLocID = 0;
 518         HL_Vector &LocHyperLabels = m_pImpl->getHyperLabels();
 519         for ( HL_Vector::iterator i = LocHyperLabels.begin()+ _nStartIndex; i< LocHyperLabels.end(); i++)
 520         {
 521             CurHyperLabel = *i;
 522             nLocID = CurHyperLabel->GetID();
 523             if ( nLocID == _nID )
 524                 return CurHyperLabel;
 525         }
 526         return NULL;
 527     }
 528
 529     //---------------------------------------------------------------------
 530     const ORoadmapHyperLabel* ORoadmap::GetByID( ItemId _nID, ItemIndex _nStartIndex  ) const
 531     {
 532         return const_cast< ORoadmap* >( this )->GetByID( _nID, _nStartIndex );
 533     }
 534
 535     //---------------------------------------------------------------------
 536     ORoadmapHyperLabel* ORoadmap::GetByIndex( ItemIndex _nItemIndex)
 537     {
 538         HL_Vector &LocHyperLabels = m_pImpl->getHyperLabels();
 539         if ((_nItemIndex > -1) && (_nItemIndex < m_pImpl->getItemCount( ) ) )
 540         {
 541             ORoadmapHyperLabel* CurHyperLabel = LocHyperLabels.at(_nItemIndex);    // Vectors are one-based
 542             return CurHyperLabel;
 543         }
 544         return NULL;
 545     }
 546
 547     //---------------------------------------------------------------------
 548     const ORoadmapHyperLabel* ORoadmap::GetByIndex( ItemIndex _nItemIndex ) const
 549     {
 550         return const_cast< ORoadmap* >( this )->GetByIndex( _nItemIndex );
 551     }
 552
 553     //---------------------------------------------------------------------
 554     RoadmapTypes::ItemId ORoadmap::GetNextAvailableItemId( ItemIndex _nNewIndex )
 555     {
 556         ORoadmapHyperLabel* CurHyperLabel;
 557
 558         ItemIndex searchIndex = ++_nNewIndex;
 559         while ( searchIndex < m_pImpl->getItemCount() )
 560         {
 561             CurHyperLabel = GetByIndex( searchIndex );
 562             if ( CurHyperLabel->IsEnabled() )
 563                 return CurHyperLabel->GetID( );
 564
 565             ++searchIndex;
 566         }
 567         return -1;
 568     }
 569
 570     //---------------------------------------------------------------------
 571     RoadmapTypes::ItemId ORoadmap::GetPreviousAvailableItemId( ItemIndex _nNewIndex )
 572     {
 573         ORoadmapHyperLabel* CurHyperLabel;
 574         ItemIndex searchIndex = --_nNewIndex;
 575         while ( searchIndex > -1 )
 576         {
 577             CurHyperLabel = GetByIndex( searchIndex );
 578             if ( CurHyperLabel->IsEnabled() )
 579                 return CurHyperLabel->GetID( );
 580
 581             searchIndex--;
 582         }
 583         return -1;
 584     }
 585
 586     //---------------------------------------------------------------------
 587     void ORoadmap::DeselectOldRoadmapItems()
 588     {
 589         HL_Vector pLocRoadmapItems = m_pImpl->getHyperLabels();
 590         ORoadmapHyperLabel* CurHyperLabel = NULL;
 591         for ( HL_Vector::iterator i = pLocRoadmapItems.begin(); i< pLocRoadmapItems.end(); i++)
 592         {
 593             CurHyperLabel = *i;
 594             CurHyperLabel->ToggleBackgroundColor( COL_TRANSPARENT );
 595         }
 596     }
 597
 598     //---------------------------------------------------------------------
 599     void ORoadmap::SetItemSelectHdl( const Link& _rHdl )
 600     {
 601         m_pImpl->setSelectHdl( _rHdl );
 602     }
 603
 604     //---------------------------------------------------------------------
 605     Link ORoadmap::GetItemSelectHdl( ) const
 606     {
 607         return m_pImpl->getSelectHdl();
 608     }
 609
 610     //---------------------------------------------------------------------
 611     void ORoadmap::Select()
 612     {
 613         GetItemSelectHdl().Call( this );
 614         CallEventListeners( VCLEVENT_ROADMAP_ITEMSELECTED );
 615     }
 616
 617     //---------------------------------------------------------------------
 618     void ORoadmap::GetFocus()
 619     {
 620         ORoadmapHyperLabel* pCurHyperLabel = GetByID( GetCurrentRoadmapItemID() );
 621         if ( pCurHyperLabel != NULL )
 622             pCurHyperLabel->GrabFocus();
 623     }
 624
 625     //---------------------------------------------------------------------
 626     sal_Bool ORoadmap::SelectRoadmapItemByID( ItemId _nNewID )
 627     {
 628         DeselectOldRoadmapItems();
 629         ORoadmapHyperLabel* CurHyperLabel = GetByID( _nNewID );
 630         if (CurHyperLabel != NULL)
 631         {
 632             if (CurHyperLabel->IsEnabled())
 633             {
 634                 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 635                 CurHyperLabel->ToggleBackgroundColor( rStyleSettings.GetHighlightColor() ); //HighlightColor
 636
 637                 CurHyperLabel->GrabFocus();
 638                 m_pImpl->setCurItemID(_nNewID);
 639
 640                 Select();
 641                 return sal_True;
 642             }
 643         }
 644         return sal_False;
 645     }
 646
 647     //---------------------------------------------------------------------
 648     void ORoadmap::Paint( const Rectangle& _rRect )
 649     {
 650         Control::Paint( _rRect );
 651
 652
 653         // draw the bitmap
 654         if ( !!m_pImpl->getPicture() )
 655         {
 656             Size aBitmapSize = m_pImpl->getPicture().GetSizePixel();
 657             Size aMySize = GetOutputSizePixel();
 658
 659             Point aBitmapPos( aMySize.Width() - aBitmapSize.Width(),  aMySize.Height() - aBitmapSize.Height() );
 660
 661             // draw it
 662             DrawBitmapEx( aBitmapPos, m_pImpl->getPicture() );
 663         }
 664
 665         //.................................................................
 666         // draw the headline
 667         DrawHeadline();
 668     }
 669
 670     //---------------------------------------------------------------------
 671     void ORoadmap::DrawHeadline()
 672     {
 673         Point aTextPos = LogicToPixel( Point( RMENTRYPOINT_X, 8 ), MAP_APPFONT );
 674
 675         Size aOutputSize( GetOutputSizePixel() );
 676
 677         // draw it
 678         DrawText( Rectangle( aTextPos, aOutputSize ), GetText(), TEXT_DRAW_LEFT | TEXT_DRAW_TOP | TEXT_DRAW_MULTILINE | TEXT_DRAW_WORDBREAK );
 679         DrawTextLine( aTextPos, aOutputSize.Width(), STRIKEOUT_NONE, UNDERLINE_SINGLE, UNDERLINE_NONE, sal_False );
 680         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 681         SetLineColor( rStyleSettings.GetFieldTextColor());
 682         SetTextColor(rStyleSettings.GetFieldTextColor());
 683     }
 684
 685     //---------------------------------------------------------------------
 686     ORoadmapHyperLabel* ORoadmap::GetByPointer(Window* pWindow)
 687     {
 688         ORoadmapHyperLabel* CurHyperLabel;
 689         HL_Vector &LocHyperLabels = m_pImpl->getHyperLabels();
 690         for ( HL_Vector::iterator i = LocHyperLabels.begin(); i< LocHyperLabels.end(); i++)
 691         {
 692             CurHyperLabel = *i;
 693             if ( (CurHyperLabel->GetIDLabel() == pWindow) || (CurHyperLabel->GetDescriptionHyperLabel() == pWindow) )
 694                 return CurHyperLabel;
 695         }
 696         return NULL;
 697     }
 698
 699     //---------------------------------------------------------------------
 700     long ORoadmap::PreNotify( NotifyEvent& _rNEvt )
 701     {
 702         // capture KeyEvents for taskpane cycling
 703         if ( _rNEvt.GetType() == EVENT_KEYINPUT )
 704         {
 705             Window* pWindow = _rNEvt.GetWindow();
 706             ORoadmapHyperLabel* CurHyperLabel = GetByPointer( pWindow );
 707             if ( CurHyperLabel != NULL )
 708             {
 709                 sal_Int16 nKeyCode = _rNEvt.GetKeyEvent()->GetKeyCode().GetCode();
 710                 switch( nKeyCode )
 711                 {
 712                     case KEY_UP:
 713                         {   // Note: Performancewhise this is not optimal, because we search for an ID in the labels
 714                             //       and afterwards we search again for a label with the appropriate ID ->
 715                             //       unnecessarily we search twice!!!
 716                             ItemId nPrevItemID = GetPreviousAvailableItemId( CurHyperLabel->GetIndex() );
 717                             if ( nPrevItemID != -1 )
 718                                 return SelectRoadmapItemByID( nPrevItemID );
 719                         }
 720                         break;
 721                     case KEY_DOWN:
 722                         {
 723                             ItemId nNextItemID = GetNextAvailableItemId( CurHyperLabel->GetIndex() );
 724                             if ( nNextItemID != -1 )
 725                                 return SelectRoadmapItemByID( nNextItemID );
 726                         }
 727                         break;
 728                     case KEY_SPACE:
 729                         return SelectRoadmapItemByID( CurHyperLabel->GetID() );
 730                 }
 731             }
 732         }
 733         return Window::PreNotify( _rNEvt );
 734     }
 735
 736     //---------------------------------------------------------------------
 737       IMPL_LINK(ORoadmap, ImplClickHdl, HyperLabel*, _CurHyperLabel)
 738     {
 739         return SelectRoadmapItemByID( _CurHyperLabel->GetID() );
 740     }
 741
 742     void ORoadmap::DataChanged( const DataChangedEvent& rDCEvt )
 743     {
 744         if ((( rDCEvt.GetType() == DATACHANGED_SETTINGS )       ||
 745             ( rDCEvt.GetType() == DATACHANGED_DISPLAY   ))      &&
 746             ( rDCEvt.GetFlags() & SETTINGS_STYLE                ))
 747         {
 748             const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 749             SetBackground( Wallpaper( rStyleSettings.GetFieldColor() ) );
 750             Color aTextColor = rStyleSettings.GetFieldTextColor();
 751             Font aFont = GetFont();
 752             aFont.SetColor( aTextColor );
 753             SetFont( aFont );
 754             RoadmapTypes::ItemId curItemID = GetCurrentRoadmapItemID();
 755             ORoadmapHyperLabel* pLabelItem = GetByID( curItemID );
 756             pLabelItem->ToggleBackgroundColor(rStyleSettings.GetHighlightColor());
 757             Invalidate();
 758         }
 759     }
 760
 761
 762     ORoadmapHyperLabel::ORoadmapHyperLabel( Window* _pParent, const ResId& )
 763     {
 764         mpIDLabel = new ORoadmapIDHyperLabel(_pParent, WB_WORDBREAK);
 765         mpDescHyperLabel = new HyperLabel(_pParent, WB_NOTABSTOP | WB_WORDBREAK);
 766     }
 767
 768
 769     ORoadmapHyperLabel::ORoadmapHyperLabel( Window* _pParent, WinBits )
 770     {
 771         mpIDLabel = new ORoadmapIDHyperLabel(_pParent, WB_WORDBREAK);
 772         mpIDLabel->SetTextColor( mpIDLabel->GetSettings().GetStyleSettings().GetFieldTextColor( ) );
 773         mpDescHyperLabel = new HyperLabel(_pParent, WB_NOTABSTOP | WB_WORDBREAK);
 774     }
 775
 776     //---------------------------------------------------------------------
 777     void ORoadmapHyperLabel::GrabFocus()
 778     {
 779         if ( mpDescHyperLabel )
 780             mpDescHyperLabel->GrabFocus();
 781     }
 782
 783
 784     void ORoadmapHyperLabel::SetInteractive( sal_Bool _bInteractive )
 785     {
 786         if ( mpDescHyperLabel )
 787         mpDescHyperLabel->SetInteractive(_bInteractive);
 788     }
 789
 790     void ORoadmapHyperLabel::SetID( sal_Int16 _ID )
 791     {
 792         if ( mpDescHyperLabel )
 793             mpDescHyperLabel->SetID(_ID);
 794     }
 795
 796     sal_Int16 ORoadmapHyperLabel::GetID() const
 797     {
 798         return mpDescHyperLabel ? mpDescHyperLabel->GetID() : sal_Int16(-1);
 799     }
 800
 801     void ORoadmapHyperLabel::SetIndex( sal_Int32 _Index )
 802     {
 803         if ( mpDescHyperLabel )
 804             mpDescHyperLabel->SetIndex(_Index);
 805     }
 806
 807
 808     sal_Int32 ORoadmapHyperLabel::GetIndex() const
 809     {
 810         return mpDescHyperLabel ? mpDescHyperLabel->GetIndex() : sal_Int32(-1);
 811     }
 812
 813
 814     void ORoadmapHyperLabel::SetLabel( ::rtl::OUString _rText )
 815     {
 816         if ( mpDescHyperLabel )
 817             mpDescHyperLabel->SetText(_rText);
 818     }
 819
 820
 821     ::rtl::OUString ORoadmapHyperLabel::GetLabel( )
 822     {
 823             return mpDescHyperLabel ? mpDescHyperLabel->GetText() : String();
 824     }
 825
 826
 827     void ORoadmapHyperLabel::SetPosition(ORoadmapHyperLabel* OldHyperLabel)
 828     {
 829         Point aNewLogicalPoint;
 830         Point aNewPoint;
 831         if (OldHyperLabel == NULL)
 832         {
 833             aNewLogicalPoint = Point( RMENTRYPOINT_X, RMENTRYPOINT_Y);
 834             aNewPoint = mpIDLabel->LogicToPixel(aNewLogicalPoint, MAP_APPFONT );
 835         }
 836         else
 837         {
 838             Size aOldSize = OldHyperLabel->GetDescriptionHyperLabel()->GetSizePixel();
 839             Point aOldLogicalPoint = OldHyperLabel->GetLogicalPosition();
 840             aNewLogicalPoint = Point(aOldLogicalPoint.X(), (aOldLogicalPoint.Y() + RMITEMDISTANCE_Y));
 841             aNewPoint = mpIDLabel->LogicToPixel(aNewLogicalPoint, MAP_APPFONT );
 842             aNewPoint = Point(aNewPoint.X(),aNewPoint.Y() + aOldSize.Height());
 843         }
 844         mpIDLabel->SetPosPixel( aNewPoint );
 845         sal_Int32 xDescPos = aNewPoint.X() + mpIDLabel->GetSizePixel().Width();
 846         mpDescHyperLabel->SetPosPixel( Point(xDescPos, aNewPoint.Y()) );
 847     }
 848
 849
 850     void ORoadmapHyperLabel::SetZOrder( ORoadmapHyperLabel* pRefRoadmapHyperLabel, USHORT nFlags )
 851     {
 852         if (pRefRoadmapHyperLabel == NULL)
 853             mpDescHyperLabel->SetZOrder( NULL, nFlags); //WINDOW_ZORDER_FIRST );
 854         else
 855             mpDescHyperLabel->SetZOrder( pRefRoadmapHyperLabel->mpDescHyperLabel, nFlags); //, WINDOW_ZORDER_BEHIND );
 856     }
 857
 858
 859     void ORoadmapHyperLabel::Enable( BOOL _bEnable)
 860     {
 861         mpIDLabel->Enable(_bEnable);
 862         mpDescHyperLabel->Enable(_bEnable);
 863     }
 864
 865     BOOL ORoadmapHyperLabel::IsEnabled() const
 866     {
 867         return mpIDLabel->IsEnabled();
 868     }
 869
 870 //      void ORoadmapHyperLabel::GrabFocus()
 871 //      {
 872 //              mpDescHyperLabel->GrabFocus();
 873 //
 874 //      }
 875
 876     void ORoadmapHyperLabel::ToggleBackgroundColor( const Color& _rGBColor )
 877     {
 878         if (_rGBColor == COL_TRANSPARENT)
 879         {
 880             mpIDLabel->SetTextColor( mpIDLabel->GetSettings().GetStyleSettings().GetFieldTextColor( ) );
 881             mpIDLabel->SetControlBackground( COL_TRANSPARENT );
 882         }
 883         else
 884         {
 885             mpIDLabel->SetControlBackground( mpIDLabel->GetSettings().GetStyleSettings().GetHighlightColor() );
 886             mpIDLabel->SetTextColor( mpIDLabel->GetSettings().GetStyleSettings().GetHighlightTextColor( ) );
 887         }
 888         mpDescHyperLabel->ToggleBackgroundColor(_rGBColor);
 889     }
 890
 891
 892     Point ORoadmapHyperLabel::GetLogicalPosition()
 893     {
 894         Point aPoint = mpIDLabel->GetPosPixel( );
 895         Size aSize = Size(aPoint.X(), aPoint.Y());
 896         aSize = mpIDLabel->PixelToLogic( aSize, MAP_APPFONT );
 897         aPoint = Point(aSize.Width(), aSize.Height());
 898         return aPoint;
 899     }
 900
 901
 902     void ORoadmapHyperLabel::SetLabelAndSize( ItemIndex _RMIndex, ::rtl::OUString _rText, const Size& _rNewSize)
 903     {
 904          Size rIDSize = _rNewSize;
 905          ::rtl::OUString aStr = ::rtl::OUString::valueOf( (sal_Int32)( _RMIndex + 1 ) ) +  ::rtl::OUString::createFromAscii( "." );
 906         rIDSize.Width() = (sal_Int32) mpIDLabel->GetTextWidth( aStr );
 907         long nMaxWidth = mpIDLabel->GetTextWidth( ::rtl::OUString::createFromAscii("100.") );
 908         rIDSize.Width() = ::std::min( rIDSize.getWidth(),nMaxWidth );
 909          mpIDLabel->SetSizePixel(mpIDLabel->LogicToPixel( rIDSize));
 910          mpIDLabel->SetText( aStr);
 911          mpIDLabel->Show();
 912         Size rDescSize = _rNewSize;
 913         rDescSize.Width() -= rIDSize.Width();
 914         sal_Int32 xDescPos = mpIDLabel->GetPosPixel().X() + mpIDLabel->GetSizePixel().Width();
 915         sal_Int32 yDescPos = mpIDLabel->GetPosPixel().Y();
 916         Point aPoint = Point(xDescPos, yDescPos);
 917         mpDescHyperLabel->SetPosPixel( aPoint );
 918         mpDescHyperLabel->SetLabelAndSize(_rText, rDescSize);
 919         mpIDLabel->SetSizePixel( Size( mpIDLabel->GetSizePixel().Width(), mpDescHyperLabel->GetSizePixel().Height() ) );
 920     }
 921
 922     ORoadmapHyperLabel::~ORoadmapHyperLabel( )
 923     {
 924         {
 925             ::std::auto_ptr<Control> aTemp(mpIDLabel);
 926             mpIDLabel = NULL;
 927         }
 928         {
 929             ::std::auto_ptr<Control> aTemp(mpDescHyperLabel);
 930             mpDescHyperLabel = NULL;
 931         }
 932     }
 933
 934
 935     void ORoadmapHyperLabel::SetClickHdl( const Link& rLink )
 936     {
 937         if ( mpDescHyperLabel )
 938             mpDescHyperLabel->SetClickHdl( rLink);
 939     }
 940
 941     const Link& ORoadmapHyperLabel::GetClickHdl( ) const
 942     {
 943         return mpDescHyperLabel->GetClickHdl();
 944     }
 945
 946
 947     ORoadmapIDHyperLabel::ORoadmapIDHyperLabel( Window* _pParent, const ResId& _rId )
 948         :FixedText( _pParent, _rId )
 949     {
 950     }
 951
 952     ORoadmapIDHyperLabel::ORoadmapIDHyperLabel( Window* _pParent, WinBits _nWinStyle )
 953         :FixedText( _pParent, _nWinStyle )
 954     {
 955
 956     }
 957
 958
 959     ORoadmapIDHyperLabel::~ORoadmapIDHyperLabel( )
 960     {
 961     }
 962
 963
 964     void ORoadmapIDHyperLabel::DataChanged( const DataChangedEvent& rDCEvt )
 965     {
 966         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 967         FixedText::DataChanged( rDCEvt );
 968         if ((( rDCEvt.GetType() == DATACHANGED_SETTINGS )       ||
 969             ( rDCEvt.GetType() == DATACHANGED_DISPLAY   ))      &&
 970             ( rDCEvt.GetFlags() & SETTINGS_STYLE                ))
 971         {
 972             const Color& rGBColor = GetControlBackground();
 973             if (rGBColor == COL_TRANSPARENT)
 974                 SetTextColor( rStyleSettings.GetFieldTextColor( ) );
 975             else
 976             {
 977                 SetControlBackground(rStyleSettings.GetHighlightColor());
 978                 SetTextColor( rStyleSettings.GetHighlightTextColor( ) );
 979             }
 980             Invalidate();
 981         }
 982     }
 983
 984
 985
 986
 987 //.........................................................................
 988 }       // namespace svt
 989 //.........................................................................