svtools/source/control/roadmap.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <roadmap.hxx>
  21
  22 #include <vector>
  23 #include <algorithm>
  24 #include <vcl/bitmap.hxx>
  25 #include <vcl/settings.hxx>
  26 #include <tools/color.hxx>
  27 #include <rtl/ustring.hxx>
  28 #include <boost/scoped_ptr.hpp>
  29
  30 #define ROADMAP_INDENT_X        4
  31 #define ROADMAP_INDENT_Y        27
  32 #define ROADMAP_ITEM_DISTANCE_Y 6
  33
  34 namespace svt
  35 {
  36
  37 typedef std::vector< RoadmapItem* > HL_Vector;
  38
  39 //= ColorChanger
  40
  41 class IDLabel :  public FixedText
  42 {
  43 public:
  44     IDLabel( vcl::Window* _pParent, WinBits _nWinStyle = 0 );
  45     virtual void    DataChanged( const DataChangedEvent& rDCEvt ) SAL_OVERRIDE;
  46 };
  47
  48 class RoadmapItem : public RoadmapTypes
  49 {
  50 private:
  51     VclPtr<IDLabel>         mpID;
  52     VclPtr<HyperLabel>      mpDescription;
  53     const Size              m_aItemPlayground;
  54
  55 public:
  56     RoadmapItem( ORoadmap& _rParent, const Size& _rItemPlayground );
  57     ~RoadmapItem();
  58
  59     void                    SetID( sal_Int16 _ID );
  60     sal_Int16               GetID() const;
  61
  62     void                    SetIndex( ItemIndex _Index );
  63     ItemIndex               GetIndex() const;
  64
  65     void                    Update( ItemIndex _RMIndex, const OUString& _rText );
  66
  67     void                    SetPosition( RoadmapItem* OldHyperLabel );
  68
  69     void                    ToggleBackgroundColor( const Color& _rGBColor );
  70     void                    SetInteractive( bool _bInteractive );
  71
  72     void                    SetClickHdl( const Link<>& rLink );
  73     void                    Enable( bool bEnable = true);
  74     bool                    IsEnabled() const;
  75     void                    GrabFocus();
  76
  77     bool                    Contains( const vcl::Window* _pWindow ) const;
  78
  79     HyperLabel*             GetDescriptionHyperLabel() const { return mpDescription; }
  80
  81 private:
  82     void                    ImplUpdateIndex( const ItemIndex _nIndex );
  83     void                    ImplUpdatePosSize();
  84 };
  85
  86 //= RoadmapImpl
  87
  88 class RoadmapImpl : public RoadmapTypes
  89 {
  90 protected:
  91     const ORoadmap&     m_rAntiImpl;
  92     Link<>              m_aSelectHdl;
  93     BitmapEx            m_aPicture;
  94     HL_Vector           m_aRoadmapSteps;
  95     ItemId              m_iCurItemID;
  96     bool                m_bInteractive : 1;
  97     bool                m_bComplete : 1;
  98     Size                m_aItemSizePixel;
  99 public:
 100     bool                m_bPaintInitialized : 1;
 101
 102 public:
 103     RoadmapImpl(const ORoadmap& rAntiImpl)
 104         : m_rAntiImpl(rAntiImpl)
 105         , m_iCurItemID(-1)
 106         , m_bInteractive(true)
 107         , m_bComplete(true)
 108         , m_bPaintInitialized(false)
 109         , InCompleteHyperLabel(NULL)
 110     {}
 111
 112     RoadmapItem* InCompleteHyperLabel;
 113
 114     HL_Vector& getHyperLabels()
 115     {
 116         return m_aRoadmapSteps;
 117     }
 118
 119     void insertHyperLabel(ItemIndex _Index, RoadmapItem* _rRoadmapStep)
 120     {
 121         m_aRoadmapSteps.insert(m_aRoadmapSteps.begin() + _Index, _rRoadmapStep);
 122     }
 123
 124     ItemIndex getItemCount() const
 125     {
 126         return m_aRoadmapSteps.size();
 127     }
 128
 129     void setCurItemID(ItemId i)
 130     {
 131         m_iCurItemID = i;
 132     }
 133     ItemId getCurItemID() const
 134     {
 135         return m_iCurItemID;
 136     }
 137
 138     void setInteractive(const bool _bInteractive)
 139     {
 140         m_bInteractive = _bInteractive;
 141     }
 142     bool isInteractive() const
 143     {
 144         return m_bInteractive;
 145     }
 146
 147     void setComplete(const bool _bComplete)
 148     {
 149         m_bComplete = _bComplete;
 150     }
 151     bool isComplete() const
 152     {
 153         return m_bComplete;
 154     }
 155
 156     void setPicture(const BitmapEx& _rPic)
 157     {
 158         m_aPicture = _rPic;
 159     }
 160     const BitmapEx& getPicture() const
 161     {
 162         return m_aPicture;
 163     }
 164
 165     void setSelectHdl(const Link<>& _rHdl)
 166     {
 167         m_aSelectHdl = _rHdl;
 168     }
 169     const Link<>& getSelectHdl() const
 170     {
 171         return m_aSelectHdl;
 172     }
 173
 174     void initItemSize();
 175     const Size& getItemSize() const
 176     {
 177         return m_aItemSizePixel;
 178     }
 179
 180     void removeHyperLabel(ItemIndex _Index)
 181     {
 182         if ((_Index > -1) && (_Index < getItemCount()))
 183         {
 184             delete m_aRoadmapSteps[_Index];
 185             m_aRoadmapSteps.erase(m_aRoadmapSteps.begin() + _Index);
 186         }
 187     }
 188 };
 189
 190 void RoadmapImpl::initItemSize()
 191 {
 192     Size aLabelSize( m_rAntiImpl.GetOutputSizePixel() );
 193     aLabelSize.Height() = m_rAntiImpl.LogicToPixel( Size( 0, LABELBASEMAPHEIGHT ), MAP_APPFONT ).Height();
 194     aLabelSize.Width() -= m_rAntiImpl.LogicToPixel( Size( 2 * ROADMAP_INDENT_X, 0 ), MAP_APPFONT ).Width();
 195     m_aItemSizePixel = aLabelSize;
 196 }
 197
 198 //= Roadmap
 199
 200 ORoadmap::ORoadmap(vcl::Window* _pParent, WinBits _nWinStyle)
 201     : Control(_pParent, _nWinStyle)
 202     , m_pImpl(new RoadmapImpl(*this))
 203 {
 204 }
 205
 206 void ORoadmap::implInit(vcl::RenderContext& rRenderContext)
 207 {
 208     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 209     Color aTextColor = rStyleSettings.GetFieldTextColor();
 210     vcl::Font aFont = rRenderContext.GetFont();
 211     aFont.SetColor(aTextColor);
 212     aFont.SetWeight(WEIGHT_BOLD);
 213     aFont.SetUnderline(UNDERLINE_SINGLE);
 214     rRenderContext.SetFont(aFont);
 215     rRenderContext.SetBackground(Wallpaper(rStyleSettings.GetFieldColor()));
 216     m_pImpl->InCompleteHyperLabel = NULL;
 217     m_pImpl->setCurItemID(-1);
 218     m_pImpl->setComplete(true);
 219     m_pImpl->m_bPaintInitialized = true;
 220
 221     // Roadmap control should be reachable as one unit with a Tab key
 222     // the next Tab key should spring out of the control.
 223     // To reach it the control itself should get focus and set it
 224     // on entries. The entries themself should not be reachable with
 225     // the Tab key directly. So each entry should have WB_NOTABSTOP.
 226
 227     // In other words the creator should create the control with the following
 228     // flags:
 229     // SetStyle( ( GetStyle() | WB_TABSTOP ) & ~WB_DIALOGCONTROL );
 230
 231 // TODO: if somebody sets a new font from outside (OutputDevice::SetFont), we would have to react
 232 // on this with calculating a new bold font.
 233 // Unfortunately, the OutputDevice does not offer a notify mechanism for a changed font.
 234 // So settings the font from outside is simply a forbidded scenario at the moment
 235     rRenderContext.EnableMapMode(false);
 236 }
 237
 238 ORoadmap::~ORoadmap()
 239 {
 240     disposeOnce();
 241 }
 242
 243 void ORoadmap::dispose()
 244 {
 245     HL_Vector aItemsCopy = m_pImpl->getHyperLabels();
 246     m_pImpl->getHyperLabels().clear();
 247     for ( HL_Vector::iterator i = aItemsCopy.begin(); i != aItemsCopy.end(); ++i )
 248     {
 249         delete *i;
 250     }
 251     if ( ! m_pImpl->isComplete() )
 252         delete m_pImpl->InCompleteHyperLabel;
 253     delete m_pImpl;
 254     m_pImpl = NULL;
 255     Control::dispose();
 256 }
 257
 258 RoadmapTypes::ItemId ORoadmap::GetCurrentRoadmapItemID() const
 259 {
 260     return m_pImpl->getCurItemID();
 261 }
 262
 263 RoadmapItem* ORoadmap::GetPreviousHyperLabel(ItemIndex _Index)
 264 {
 265     RoadmapItem* pOldItem = NULL;
 266     if ( _Index > 0 )
 267         pOldItem = m_pImpl->getHyperLabels().at( _Index - 1 );
 268     return pOldItem;
 269 }
 270
 271 RoadmapItem* ORoadmap::InsertHyperLabel(ItemIndex _Index, const OUString& _sLabel, ItemId _RMID, bool _bEnabled, bool _bIncomplete)
 272 {
 273     if (m_pImpl->getItemCount() == 0)
 274         m_pImpl->initItemSize();
 275
 276     RoadmapItem* pItem = NULL;
 277     RoadmapItem* pOldItem = GetPreviousHyperLabel( _Index );
 278
 279     pItem = new RoadmapItem( *this, m_pImpl->getItemSize() );
 280     if ( _bIncomplete )
 281     {
 282         pItem->SetInteractive( false );
 283     }
 284     else
 285     {
 286         pItem->SetInteractive( m_pImpl->isInteractive() );
 287         m_pImpl->insertHyperLabel( _Index, pItem );
 288     }
 289     pItem->SetPosition( pOldItem );
 290     pItem->Update( _Index, _sLabel );
 291     pItem->SetClickHdl(LINK( this, ORoadmap, ImplClickHdl ) );
 292     pItem->SetID( _RMID );
 293     pItem->SetIndex( _Index );
 294     if (!_bEnabled)
 295         pItem->Enable( _bEnabled );
 296     return pItem;
 297 }
 298
 299 void ORoadmap::SetRoadmapBitmap(const BitmapEx& _rBmp, bool _bInvalidate)
 300 {
 301     m_pImpl->setPicture( _rBmp );
 302     if ( _bInvalidate )
 303         Invalidate( );
 304 }
 305
 306 void ORoadmap::SetRoadmapInteractive(bool _bInteractive)
 307 {
 308     m_pImpl->setInteractive( _bInteractive );
 309
 310     const HL_Vector& rItems = m_pImpl->getHyperLabels();
 311     for (   HL_Vector::const_iterator i = rItems.begin();
 312             i != rItems.end();
 313             ++i
 314         )
 315     {
 316         (*i)->SetInteractive( _bInteractive );
 317     }
 318 }
 319
 320 bool ORoadmap::IsRoadmapInteractive()
 321 {
 322     return m_pImpl->isInteractive();
 323 }
 324
 325 void ORoadmap::SetRoadmapComplete(bool _bComplete)
 326 {
 327     bool bWasComplete = m_pImpl->isComplete();
 328     m_pImpl->setComplete( _bComplete );
 329     if (_bComplete)
 330     {
 331         if (m_pImpl->InCompleteHyperLabel != NULL)
 332         {
 333             delete m_pImpl->InCompleteHyperLabel;
 334             m_pImpl->InCompleteHyperLabel = NULL;
 335         }
 336     }
 337     else if (bWasComplete)
 338         m_pImpl->InCompleteHyperLabel = InsertHyperLabel(m_pImpl->getItemCount(), OUString("..."), -1, true/*bEnabled*/, true/*bIncomplete*/ );
 339 }
 340
 341 void ORoadmap::UpdatefollowingHyperLabels(ItemIndex _nIndex)
 342 {
 343     const HL_Vector& rItems = m_pImpl->getHyperLabels();
 344     if ( _nIndex < (ItemIndex)rItems.size() )
 345     {
 346         for (   HL_Vector::const_iterator i = rItems.begin() + _nIndex;
 347                 i != rItems.end();
 348                 ++i, ++_nIndex
 349             )
 350         {
 351             RoadmapItem* pItem = *i;
 352
 353             pItem->SetIndex( _nIndex );
 354             pItem->SetPosition( GetPreviousHyperLabel( _nIndex ) );
 355         }
 356     }
 357     if ( ! m_pImpl->isComplete() )
 358     {
 359         RoadmapItem* pOldItem = GetPreviousHyperLabel( m_pImpl->getItemCount() );
 360         m_pImpl->InCompleteHyperLabel->SetPosition( pOldItem );
 361         m_pImpl->InCompleteHyperLabel->Update( m_pImpl->getItemCount(), OUString("...") );
 362     }
 363 }
 364
 365 void ORoadmap::ReplaceRoadmapItem(ItemIndex _Index, const OUString& _RoadmapItem, ItemId _RMID, bool _bEnabled)
 366 {
 367     RoadmapItem* pItem = GetByIndex( _Index);
 368     if ( pItem != NULL )
 369     {
 370         pItem->Update( _Index,  _RoadmapItem );
 371         pItem->SetID( _RMID );
 372         pItem->Enable( _bEnabled );
 373     }
 374 }
 375
 376 RoadmapTypes::ItemIndex ORoadmap::GetItemCount() const
 377 {
 378     return m_pImpl->getItemCount();
 379 }
 380
 381 RoadmapTypes::ItemId ORoadmap::GetItemID(ItemIndex _nIndex) const
 382 {
 383     const RoadmapItem* pHyperLabel = GetByIndex( _nIndex );
 384     if ( pHyperLabel )
 385         return pHyperLabel->GetID();
 386     return -1;
 387 }
 388
 389 void ORoadmap::InsertRoadmapItem(ItemIndex _Index, const OUString& _RoadmapItem, ItemId _nUniqueId, bool _bEnabled)
 390 {
 391     InsertHyperLabel( _Index, _RoadmapItem, _nUniqueId, _bEnabled, false/*bIncomplete*/ );
 392     // TODO YPos is superfluous, if items are always appended
 393     UpdatefollowingHyperLabels( _Index + 1 );
 394 }
 395
 396 void ORoadmap::DeleteRoadmapItem(ItemIndex _Index)
 397 {
 398     if ( m_pImpl->getItemCount() > 0 && ( _Index > -1)  &&  ( _Index < m_pImpl->getItemCount() ) )
 399     {
 400         m_pImpl->removeHyperLabel( _Index );
 401         UpdatefollowingHyperLabels( _Index );
 402     }
 403 }
 404
 405 bool ORoadmap::IsRoadmapComplete() const
 406 {
 407     return m_pImpl->isComplete();
 408 }
 409
 410 void ORoadmap::EnableRoadmapItem( ItemId _nItemId, bool _bEnable, ItemIndex _nStartIndex )
 411 {
 412     RoadmapItem* pItem = GetByID( _nItemId, _nStartIndex );
 413     if ( pItem != NULL )
 414         pItem->Enable( _bEnable );
 415 }
 416
 417 void ORoadmap::ChangeRoadmapItemLabel( ItemId _nID, const OUString& _sLabel, ItemIndex _nStartIndex )
 418 {
 419     RoadmapItem* pItem = GetByID( _nID, _nStartIndex );
 420     if ( pItem != NULL )
 421     {
 422         pItem->Update( pItem->GetIndex(), _sLabel );
 423
 424         const HL_Vector& rItems = m_pImpl->getHyperLabels();
 425         for (   HL_Vector::const_iterator i = rItems.begin() + _nStartIndex;
 426                 i != rItems.end();
 427                 ++i
 428             )
 429         {
 430             (*i)->SetPosition( GetPreviousHyperLabel( i - rItems.begin() ) );
 431         }
 432     }
 433 }
 434
 435 void ORoadmap::ChangeRoadmapItemID(ItemId _nID, ItemId _NewID, ItemIndex _nStartIndex)
 436 {
 437     RoadmapItem* pItem = GetByID( _nID, _nStartIndex );
 438     if ( pItem != NULL )
 439         pItem->SetID( _NewID );
 440 }
 441
 442 RoadmapItem* ORoadmap::GetByID(ItemId _nID, ItemIndex _nStartIndex)
 443 {
 444     ItemId nLocID = 0;
 445     const HL_Vector& rItems = m_pImpl->getHyperLabels();
 446     for (   HL_Vector::const_iterator i = rItems.begin() + _nStartIndex;
 447             i != rItems.end();
 448             ++i
 449         )
 450     {
 451         nLocID = (*i)->GetID();
 452         if ( nLocID == _nID )
 453             return *i;
 454     }
 455     return NULL;
 456 }
 457
 458 const RoadmapItem* ORoadmap::GetByID(ItemId _nID, ItemIndex _nStartIndex) const
 459 {
 460     return const_cast< ORoadmap* >( this )->GetByID( _nID, _nStartIndex );
 461 }
 462
 463 RoadmapItem* ORoadmap::GetByIndex(ItemIndex _nItemIndex)
 464 {
 465     const HL_Vector& rItems = m_pImpl->getHyperLabels();
 466     if ( ( _nItemIndex > -1 ) && ( _nItemIndex < (ItemIndex)rItems.size() ) )
 467     {
 468         return rItems.at( _nItemIndex );
 469     }
 470     return NULL;
 471 }
 472
 473 const RoadmapItem* ORoadmap::GetByIndex(ItemIndex _nItemIndex) const
 474 {
 475     return const_cast< ORoadmap* >( this )->GetByIndex( _nItemIndex );
 476 }
 477
 478 RoadmapTypes::ItemId ORoadmap::GetNextAvailableItemId(ItemIndex _nNewIndex)
 479 {
 480     ItemIndex searchIndex = ++_nNewIndex;
 481     while ( searchIndex < m_pImpl->getItemCount() )
 482     {
 483         RoadmapItem* pItem = GetByIndex( searchIndex );
 484         if ( pItem->IsEnabled() )
 485             return pItem->GetID( );
 486
 487         ++searchIndex;
 488     }
 489     return -1;
 490 }
 491
 492 RoadmapTypes::ItemId ORoadmap::GetPreviousAvailableItemId(ItemIndex _nNewIndex)
 493 {
 494     ItemIndex searchIndex = --_nNewIndex;
 495     while ( searchIndex > -1 )
 496     {
 497         RoadmapItem* pItem = GetByIndex( searchIndex );
 498         if ( pItem->IsEnabled() )
 499             return pItem->GetID( );
 500
 501         searchIndex--;
 502     }
 503     return -1;
 504 }
 505
 506 void ORoadmap::DeselectOldRoadmapItems()
 507 {
 508     const HL_Vector& rItems = m_pImpl->getHyperLabels();
 509     for (   HL_Vector::const_iterator i = rItems.begin();
 510             i != rItems.end();
 511             ++i
 512         )
 513     {
 514         (*i)->ToggleBackgroundColor( COL_TRANSPARENT );
 515     }
 516 }
 517
 518 void ORoadmap::SetItemSelectHdl(const Link<>& _rHdl)
 519 {
 520     m_pImpl->setSelectHdl(_rHdl);
 521 }
 522
 523 Link<> ORoadmap::GetItemSelectHdl() const
 524 {
 525     return m_pImpl->getSelectHdl();
 526 }
 527
 528 void ORoadmap::Select()
 529 {
 530     GetItemSelectHdl().Call( this );
 531     CallEventListeners( VCLEVENT_ROADMAP_ITEMSELECTED );
 532 }
 533
 534 void ORoadmap::GetFocus()
 535 {
 536     RoadmapItem* pCurHyperLabel = GetByID( GetCurrentRoadmapItemID() );
 537     if ( pCurHyperLabel != NULL )
 538         pCurHyperLabel->GrabFocus();
 539 }
 540
 541 bool ORoadmap::SelectRoadmapItemByID( ItemId _nNewID )
 542 {
 543     DeselectOldRoadmapItems();
 544     RoadmapItem* pItem = GetByID( _nNewID );
 545     if ( pItem != NULL )
 546     {
 547         if ( pItem->IsEnabled() )
 548         {
 549             const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 550             pItem->ToggleBackgroundColor( rStyleSettings.GetHighlightColor() ); //HighlightColor
 551
 552             pItem->GrabFocus();
 553             m_pImpl->setCurItemID(_nNewID);
 554
 555             Select();
 556             return true;
 557         }
 558     }
 559     return false;
 560 }
 561
 562 void ORoadmap::Paint(vcl::RenderContext& rRenderContext, const Rectangle& _rRect)
 563 {
 564     if (!m_pImpl->m_bPaintInitialized)
 565         implInit(rRenderContext);
 566     Control::Paint(rRenderContext, _rRect);
 567
 568     // draw the bitmap
 569     if (!!m_pImpl->getPicture())
 570     {
 571         Size aBitmapSize = m_pImpl->getPicture().GetSizePixel();
 572         Size aMySize(GetOutputSizePixel());
 573
 574         Point aBitmapPos(aMySize.Width() - aBitmapSize.Width(),  aMySize.Height() - aBitmapSize.Height());
 575
 576         // draw it
 577         rRenderContext.DrawBitmapEx( aBitmapPos, m_pImpl->getPicture() );
 578     }
 579
 580     // draw the headline
 581     DrawHeadline(rRenderContext);
 582 }
 583
 584 void ORoadmap::DrawHeadline(vcl::RenderContext& rRenderContext)
 585 {
 586     Point aTextPos = LogicToPixel(Point(ROADMAP_INDENT_X, 8), MAP_APPFONT);
 587
 588     Size aOutputSize(GetOutputSizePixel());
 589
 590     // draw it
 591     rRenderContext.DrawText(Rectangle(aTextPos, aOutputSize), GetText(),
 592                             DrawTextFlags::Left | DrawTextFlags::Top | DrawTextFlags::MultiLine | DrawTextFlags::WordBreak);
 593     rRenderContext.DrawTextLine(aTextPos, aOutputSize.Width(), STRIKEOUT_NONE, UNDERLINE_SINGLE, UNDERLINE_NONE, false);
 594     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 595     rRenderContext.SetLineColor(rStyleSettings.GetFieldTextColor());
 596     rRenderContext.SetTextColor(rStyleSettings.GetFieldTextColor());
 597 }
 598
 599 RoadmapItem* ORoadmap::GetByPointer(vcl::Window* pWindow)
 600 {
 601     const HL_Vector& rItems = m_pImpl->getHyperLabels();
 602     for (   HL_Vector::const_iterator i = rItems.begin();
 603             i != rItems.end();
 604             ++i
 605         )
 606     {
 607         if ( (*i)->Contains( pWindow ) )
 608             return *i;
 609     }
 610     return NULL;
 611 }
 612
 613 bool ORoadmap::PreNotify(NotifyEvent& _rNEvt)
 614 {
 615     // capture KeyEvents for taskpane cycling
 616     if ( _rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
 617     {
 618         vcl::Window* pWindow = _rNEvt.GetWindow();
 619         RoadmapItem* pItem = GetByPointer( pWindow );
 620         if ( pItem != NULL )
 621         {
 622             sal_Int16 nKeyCode = _rNEvt.GetKeyEvent()->GetKeyCode().GetCode();
 623             switch( nKeyCode )
 624             {
 625                 case KEY_UP:
 626                     {   // Note: Performancewise this is not optimal, because we search for an ID in the labels
 627                         //       and afterwards we search again for a label with the appropriate ID ->
 628                         //       unnecessarily we search twice!!!
 629                         ItemId nPrevItemID = GetPreviousAvailableItemId( pItem->GetIndex() );
 630                         if ( nPrevItemID != -1 )
 631                             return SelectRoadmapItemByID( nPrevItemID );
 632                     }
 633                     break;
 634                 case KEY_DOWN:
 635                     {
 636                         ItemId nNextItemID = GetNextAvailableItemId( pItem->GetIndex() );
 637                         if ( nNextItemID != -1 )
 638                             return SelectRoadmapItemByID( nNextItemID );
 639                     }
 640                     break;
 641                 case KEY_SPACE:
 642                     return SelectRoadmapItemByID( pItem->GetID() );
 643             }
 644         }
 645     }
 646     return Window::PreNotify( _rNEvt );
 647 }
 648
 649 IMPL_LINK(ORoadmap, ImplClickHdl, HyperLabel*, _CurHyperLabel)
 650 {
 651    return SelectRoadmapItemByID( _CurHyperLabel->GetID() ) ? 1 : 0;
 652 }
 653
 654 void ORoadmap::DataChanged(const DataChangedEvent& rDCEvt)
 655 {
 656     if ((( rDCEvt.GetType() == DataChangedEventType::SETTINGS )   ||
 657         ( rDCEvt.GetType() == DataChangedEventType::DISPLAY   ))  &&
 658         ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE        ))
 659     {
 660         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 661         SetBackground( Wallpaper( rStyleSettings.GetFieldColor() ) );
 662         Color aTextColor = rStyleSettings.GetFieldTextColor();
 663         vcl::Font aFont = GetFont();
 664         aFont.SetColor( aTextColor );
 665         SetFont( aFont );
 666         RoadmapTypes::ItemId curItemID = GetCurrentRoadmapItemID();
 667         RoadmapItem* pLabelItem = GetByID( curItemID );
 668         if (pLabelItem != NULL)
 669         {
 670             pLabelItem->ToggleBackgroundColor(rStyleSettings.GetHighlightColor());
 671         }
 672         Invalidate();
 673     }
 674 }
 675
 676 RoadmapItem::RoadmapItem(ORoadmap& _rParent, const Size& _rItemPlayground)
 677     : m_aItemPlayground(_rItemPlayground)
 678 {
 679     mpID = VclPtr<IDLabel>::Create( &_rParent, WB_WORDBREAK );
 680     mpID->SetTextColor( mpID->GetSettings().GetStyleSettings().GetFieldTextColor( ) );
 681     mpID->Show();
 682     mpDescription = VclPtr<HyperLabel>::Create( &_rParent, WB_NOTABSTOP | WB_WORDBREAK );
 683     mpDescription->Show();
 684 }
 685
 686 RoadmapItem::~RoadmapItem()
 687 {
 688     mpID.disposeAndClear();
 689     mpDescription.disposeAndClear();
 690 }
 691
 692 bool RoadmapItem::Contains(const vcl::Window* _pWindow) const
 693 {
 694     return ( mpID == _pWindow ) || ( mpDescription == _pWindow );
 695 }
 696
 697 void RoadmapItem::GrabFocus()
 698 {
 699     if ( mpDescription )
 700         mpDescription->GrabFocus();
 701 }
 702
 703 void RoadmapItem::SetInteractive(bool _bInteractive)
 704 {
 705     if ( mpDescription )
 706     mpDescription->SetInteractive(_bInteractive);
 707 }
 708
 709 void RoadmapItem::SetID(sal_Int16 _ID)
 710 {
 711     if ( mpDescription )
 712         mpDescription->SetID(_ID);
 713 }
 714
 715 sal_Int16 RoadmapItem::GetID() const
 716 {
 717     return mpDescription ? mpDescription->GetID() : sal_Int16(-1);
 718 }
 719
 720 void RoadmapItem::ImplUpdateIndex(const ItemIndex _nIndex)
 721 {
 722     mpDescription->SetIndex( _nIndex );
 723
 724     OUString aIDText = OUString::number( _nIndex + 1 ) + ".";
 725     mpID->SetText( aIDText );
 726
 727     // update the geometry of both controls
 728     ImplUpdatePosSize();
 729 }
 730
 731 void RoadmapItem::SetIndex(ItemIndex _Index)
 732 {
 733     ImplUpdateIndex(_Index);
 734 }
 735
 736 RoadmapTypes::ItemIndex RoadmapItem::GetIndex() const
 737 {
 738     return mpDescription ? mpDescription->GetIndex() : ItemIndex(-1);
 739 }
 740
 741 void RoadmapItem::SetPosition(RoadmapItem* _pOldItem)
 742 {
 743     Point aIDPos;
 744     if ( _pOldItem == NULL )
 745     {
 746         aIDPos = mpID->LogicToPixel( Point( ROADMAP_INDENT_X, ROADMAP_INDENT_Y ), MAP_APPFONT );
 747     }
 748     else
 749     {
 750         Size aOldSize = _pOldItem->GetDescriptionHyperLabel()->GetSizePixel();
 751
 752         aIDPos = _pOldItem->mpID->GetPosPixel();
 753         aIDPos.Y() += aOldSize.Height();
 754         aIDPos.Y() += mpID->GetParent()->LogicToPixel( Size( 0, ROADMAP_ITEM_DISTANCE_Y ) ).Height();
 755     }
 756     mpID->SetPosPixel( aIDPos );
 757
 758     sal_Int32 nDescPos = aIDPos.X() + mpID->GetSizePixel().Width();
 759     mpDescription->SetPosPixel( Point( nDescPos, aIDPos.Y() ) );
 760 }
 761
 762 void RoadmapItem::Enable(bool _bEnable)
 763 {
 764     mpID->Enable(_bEnable);
 765     mpDescription->Enable(_bEnable);
 766 }
 767
 768 bool RoadmapItem::IsEnabled() const
 769 {
 770     return mpID->IsEnabled();
 771 }
 772
 773 void RoadmapItem::ToggleBackgroundColor(const Color& _rGBColor)
 774 {
 775     if (_rGBColor == COL_TRANSPARENT)
 776     {
 777         mpID->SetTextColor( mpID->GetSettings().GetStyleSettings().GetFieldTextColor( ) );
 778         mpID->SetControlBackground( COL_TRANSPARENT );
 779     }
 780     else
 781     {
 782         mpID->SetControlBackground( mpID->GetSettings().GetStyleSettings().GetHighlightColor() );
 783         mpID->SetTextColor( mpID->GetSettings().GetStyleSettings().GetHighlightTextColor( ) );
 784     }
 785     mpDescription->ToggleBackgroundColor(_rGBColor);
 786 }
 787
 788 void RoadmapItem::ImplUpdatePosSize()
 789 {
 790     // calculate widths
 791     long nIDWidth = mpID->GetTextWidth( mpID->GetText() );
 792     long nMaxIDWidth = mpID->GetTextWidth( OUString( "100." ) );
 793     nIDWidth = ::std::min( nIDWidth, nMaxIDWidth );
 794
 795     // check how many space the description would need
 796     Size aDescriptionSize = mpDescription->CalcMinimumSize( m_aItemPlayground.Width() - nIDWidth );
 797
 798     // position and size both controls
 799     Size aIDSize( nIDWidth, aDescriptionSize.Height() );
 800      mpID->SetSizePixel( aIDSize );
 801
 802     Point aIDPos = mpID->GetPosPixel();
 803     mpDescription->SetPosPixel( Point( aIDPos.X() + nIDWidth, aIDPos.Y() ) );
 804     mpDescription->SetSizePixel( aDescriptionSize );
 805 }
 806
 807 void RoadmapItem::Update(ItemIndex _RMIndex, const OUString& _rText)
 808 {
 809     // update description label
 810     mpDescription->SetLabel( _rText );
 811
 812     // update the index in both controls, which triggers updating the geometry of both
 813     ImplUpdateIndex( _RMIndex );
 814 }
 815
 816 void RoadmapItem::SetClickHdl(const Link<>& rLink)
 817 {
 818     if ( mpDescription )
 819         mpDescription->SetClickHdl( rLink);
 820 }
 821
 822 IDLabel::IDLabel(vcl::Window* _pParent, WinBits _nWinStyle)
 823     : FixedText(_pParent, _nWinStyle)
 824 {
 825 }
 826
 827 void IDLabel::DataChanged(const DataChangedEvent& rDCEvt)
 828 {
 829     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 830     FixedText::DataChanged( rDCEvt );
 831     if ((( rDCEvt.GetType() == DataChangedEventType::SETTINGS )   ||
 832         ( rDCEvt.GetType() == DataChangedEventType::DISPLAY   ))  &&
 833         ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE        ))
 834     {
 835         const Color& rGBColor = GetControlBackground();
 836         if (rGBColor == COL_TRANSPARENT)
 837             SetTextColor( rStyleSettings.GetFieldTextColor( ) );
 838         else
 839         {
 840             SetControlBackground(rStyleSettings.GetHighlightColor());
 841             SetTextColor( rStyleSettings.GetHighlightTextColor( ) );
 842         }
 843         Invalidate();
 844     }
 845 }
 846
 847 }   // namespace svt
 848
 849 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */