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