sfx2/source/sidebar/Theme.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 <sfx2/sidebar/Theme.hxx>
  21 #include <sfx2/app.hxx>
  22
  23 #include <vcl/svapp.hxx>
  24 #include <vcl/settings.hxx>
  25 #include <comphelper/diagnose_ex.hxx>
  26
  27 using namespace css;
  28 using namespace css::uno;
  29
  30 namespace sfx2::sidebar {
  31
  32 Theme& Theme::GetCurrentTheme()
  33 {
  34     OSL_ASSERT(SfxGetpApp());
  35     return SfxGetpApp()->GetSidebarTheme();
  36 }
  37
  38 Theme::Theme()
  39     : mbIsHighContrastMode(Application::GetSettings().GetStyleSettings().GetHighContrastMode()),
  40       mbIsHighContrastModeSetManually(false)
  41 {
  42     SetupPropertyMaps();
  43 }
  44
  45 Theme::~Theme()
  46 {
  47 }
  48
  49 Color Theme::GetColor (const ThemeItem eItem)
  50 {
  51     const PropertyType eType (GetPropertyType(eItem));
  52     OSL_ASSERT(eType==PT_Color);
  53     const sal_Int32 nIndex (GetIndex(eItem, eType));
  54     const Theme& rTheme (GetCurrentTheme());
  55     if (eType == PT_Color)
  56         return rTheme.maColors[nIndex];
  57     else
  58         return COL_WHITE;
  59 }
  60
  61 sal_Int32 Theme::GetInteger (const ThemeItem eItem)
  62 {
  63     const PropertyType eType (GetPropertyType(eItem));
  64     OSL_ASSERT(eType==PT_Integer);
  65     const sal_Int32 nIndex (GetIndex(eItem, eType));
  66     const Theme& rTheme (GetCurrentTheme());
  67     return rTheme.maIntegers[nIndex];
  68 }
  69
  70 bool Theme::IsHighContrastMode()
  71 {
  72     const Theme& rTheme (GetCurrentTheme());
  73     return rTheme.mbIsHighContrastMode;
  74 }
  75
  76 void Theme::HandleDataChange()
  77 {
  78     Theme& rTheme (GetCurrentTheme());
  79
  80     if ( ! rTheme.mbIsHighContrastModeSetManually)
  81     {
  82         // Do not modify mbIsHighContrastMode when it was manually set.
  83         GetCurrentTheme().mbIsHighContrastMode = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
  84         rTheme.maRawValues[Bool_IsHighContrastModeActive] <<= GetCurrentTheme().mbIsHighContrastMode;
  85     }
  86
  87     GetCurrentTheme().UpdateTheme();
  88 }
  89
  90 void Theme::InitializeTheme()
  91 {
  92     setPropertyValue(
  93         maPropertyIdToNameMap[Bool_UseSystemColors],
  94         Any(false));
  95 }
  96
  97 void Theme::UpdateTheme()
  98 {
  99     try
 100     {
 101         const StyleSettings& rStyle (Application::GetSettings().GetStyleSettings());
 102
 103         Color aBaseBackgroundColor (rStyle.GetDialogColor());
 104         // UX says this should be a little brighter, but that looks off when compared to the other windows.
 105         //aBaseBackgroundColor.IncreaseLuminance(7);
 106         Color aSecondColor (aBaseBackgroundColor);
 107         aSecondColor.DecreaseLuminance(15);
 108
 109         setPropertyValue(
 110             maPropertyIdToNameMap[Color_DeckBackground],
 111             Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
 112
 113         setPropertyValue(
 114             maPropertyIdToNameMap[Color_DeckTitleBarBackground],
 115             Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
 116         setPropertyValue(
 117             maPropertyIdToNameMap[Int_DeckSeparatorHeight],
 118             Any(sal_Int32(1)));
 119         setPropertyValue(
 120             maPropertyIdToNameMap[Color_PanelBackground],
 121             Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
 122
 123         setPropertyValue(
 124             maPropertyIdToNameMap[Color_PanelTitleBarBackground],
 125             Any(sal_Int32(aSecondColor.GetRGBColor())));
 126         setPropertyValue(
 127             maPropertyIdToNameMap[Color_TabBarBackground],
 128             Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
 129
 130         setPropertyValue(
 131             maPropertyIdToNameMap[Color_Highlight],
 132             Any(sal_Int32(rStyle.GetHighlightColor().GetRGBColor())));
 133         setPropertyValue(
 134             maPropertyIdToNameMap[Color_HighlightText],
 135             Any(sal_Int32(rStyle.GetHighlightTextColor().GetRGBColor())));
 136     }
 137     catch(beans::UnknownPropertyException const &)
 138     {
 139         DBG_UNHANDLED_EXCEPTION("sfx", "unknown property");
 140         OSL_ASSERT(false);
 141     }
 142 }
 143
 144 void Theme::disposing(std::unique_lock<std::mutex>&)
 145 {
 146     SolarMutexGuard aGuard;
 147
 148     ChangeListeners aListeners;
 149     aListeners.swap(maChangeListeners);
 150
 151     const lang::EventObject aEvent (getXWeak());
 152
 153     for (const auto& rContainer : aListeners)
 154     {
 155         for (const auto& rxListener : rContainer.second)
 156         {
 157             try
 158             {
 159                 rxListener->disposing(aEvent);
 160             }
 161             catch(const Exception&)
 162             {
 163             }
 164         }
 165     }
 166 }
 167
 168 Reference<beans::XPropertySet> Theme::GetPropertySet()
 169 {
 170     if (SfxGetpApp())
 171         return Reference<beans::XPropertySet>(&GetCurrentTheme());
 172     else
 173         return Reference<beans::XPropertySet>();
 174 }
 175
 176 Reference<beans::XPropertySetInfo> SAL_CALL Theme::getPropertySetInfo()
 177 {
 178     return Reference<beans::XPropertySetInfo>(this);
 179 }
 180
 181 void SAL_CALL Theme::setPropertyValue (
 182     const OUString& rsPropertyName,
 183     const css::uno::Any& rValue)
 184 {
 185     SolarMutexGuard aGuard;
 186
 187     PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 188     if (iId == maPropertyNameToIdMap.end())
 189         throw beans::UnknownPropertyException(rsPropertyName);
 190
 191     const PropertyType eType (GetPropertyType(iId->second));
 192     if (eType == PT_Invalid)
 193         throw beans::UnknownPropertyException(rsPropertyName);
 194
 195     const ThemeItem eItem (iId->second);
 196
 197     if (rValue == maRawValues[eItem])
 198     {
 199         // Value is not different from the one in the property
 200         // set => nothing to do.
 201         return;
 202     }
 203
 204     const Any aOldValue (maRawValues[eItem]);
 205
 206     const beans::PropertyChangeEvent aEvent(
 207         getXWeak(),
 208         rsPropertyName,
 209         false,
 210         eItem,
 211         aOldValue,
 212         rValue);
 213
 214     if (DoVetoableListenersVeto(GetVetoableListeners(AnyItem_, false), aEvent))
 215         return;
 216     if (DoVetoableListenersVeto(GetVetoableListeners(eItem, false), aEvent))
 217         return;
 218
 219     maRawValues[eItem] = rValue;
 220     ProcessNewValue(rValue, eItem, eType);
 221
 222     BroadcastPropertyChange(GetChangeListeners(AnyItem_, false), aEvent);
 223     BroadcastPropertyChange(GetChangeListeners(eItem, false), aEvent);
 224 }
 225
 226 Any SAL_CALL Theme::getPropertyValue (
 227     const OUString& rsPropertyName)
 228 {
 229     SolarMutexGuard aGuard;
 230
 231     PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 232     if (iId == maPropertyNameToIdMap.end())
 233         throw beans::UnknownPropertyException(rsPropertyName);
 234
 235     const PropertyType eType (GetPropertyType(iId->second));
 236     if (eType == PT_Invalid)
 237         throw beans::UnknownPropertyException(rsPropertyName);
 238
 239     const ThemeItem eItem (iId->second);
 240
 241     return maRawValues[eItem];
 242 }
 243
 244 void SAL_CALL Theme::addPropertyChangeListener(
 245     const OUString& rsPropertyName,
 246     const css::uno::Reference<css::beans::XPropertyChangeListener>& rxListener)
 247 {
 248     SolarMutexGuard aGuard;
 249
 250     ThemeItem eItem (AnyItem_);
 251     if (rsPropertyName.getLength() > 0)
 252     {
 253         PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 254         if (iId == maPropertyNameToIdMap.end())
 255             throw beans::UnknownPropertyException(rsPropertyName);
 256
 257         const PropertyType eType (GetPropertyType(iId->second));
 258         if (eType == PT_Invalid)
 259             throw beans::UnknownPropertyException(rsPropertyName);
 260
 261         eItem = iId->second;
 262     }
 263     ChangeListenerContainer* pListeners = GetChangeListeners(eItem, true);
 264     if (pListeners != nullptr)
 265         pListeners->push_back(rxListener);
 266 }
 267
 268 void SAL_CALL Theme::removePropertyChangeListener(
 269     const OUString& rsPropertyName,
 270     const css::uno::Reference<css::beans::XPropertyChangeListener>& rxListener)
 271 {
 272     SolarMutexGuard aGuard;
 273
 274     ThemeItem eItem (AnyItem_);
 275     if (rsPropertyName.getLength() > 0)
 276     {
 277         PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 278         if (iId == maPropertyNameToIdMap.end())
 279             throw beans::UnknownPropertyException(rsPropertyName);
 280
 281         const PropertyType eType (GetPropertyType(iId->second));
 282         if (eType == PT_Invalid)
 283             throw beans::UnknownPropertyException(rsPropertyName);
 284
 285         eItem = iId->second;
 286     }
 287     ChangeListenerContainer* pContainer = GetChangeListeners(eItem, false);
 288     if (pContainer != nullptr)
 289     {
 290         ChangeListenerContainer::iterator iListener (::std::find(pContainer->begin(), pContainer->end(), rxListener));
 291         if (iListener != pContainer->end())
 292         {
 293             pContainer->erase(iListener);
 294
 295             // Remove the listener container when empty.
 296             if (pContainer->empty())
 297                 maChangeListeners.erase(eItem);
 298         }
 299     }
 300 }
 301
 302 void SAL_CALL Theme::addVetoableChangeListener(
 303     const OUString& rsPropertyName,
 304     const css::uno::Reference<css::beans::XVetoableChangeListener>& rxListener)
 305 {
 306     SolarMutexGuard aGuard;
 307
 308     ThemeItem eItem (AnyItem_);
 309     if (rsPropertyName.getLength() > 0)
 310     {
 311         PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 312         if (iId == maPropertyNameToIdMap.end())
 313             throw beans::UnknownPropertyException(rsPropertyName);
 314
 315         const PropertyType eType (GetPropertyType(iId->second));
 316         if (eType == PT_Invalid)
 317             throw beans::UnknownPropertyException(rsPropertyName);
 318
 319         eItem = iId->second;
 320     }
 321     VetoableListenerContainer* pListeners = GetVetoableListeners(eItem, true);
 322     if (pListeners != nullptr)
 323         pListeners->push_back(rxListener);
 324 }
 325
 326 void SAL_CALL Theme::removeVetoableChangeListener(
 327     const OUString& rsPropertyName,
 328     const css::uno::Reference<css::beans::XVetoableChangeListener>& rxListener)
 329 {
 330     SolarMutexGuard aGuard;
 331
 332     ThemeItem eItem (AnyItem_);
 333     if (rsPropertyName.getLength() > 0)
 334     {
 335         PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 336         if (iId == maPropertyNameToIdMap.end())
 337             throw beans::UnknownPropertyException(rsPropertyName);
 338
 339         const PropertyType eType (GetPropertyType(iId->second));
 340         if (eType == PT_Invalid)
 341             throw beans::UnknownPropertyException(rsPropertyName);
 342
 343         eItem = iId->second;
 344     }
 345     VetoableListenerContainer* pContainer = GetVetoableListeners(eItem, false);
 346     if (pContainer != nullptr)
 347     {
 348         VetoableListenerContainer::iterator iListener (::std::find(pContainer->begin(), pContainer->end(), rxListener));
 349         if (iListener != pContainer->end())
 350         {
 351             pContainer->erase(iListener);
 352             // Remove container when empty.
 353             if (pContainer->empty())
 354                 maVetoableListeners.erase(eItem);
 355         }
 356     }
 357 }
 358
 359 css::uno::Sequence<css::beans::Property> SAL_CALL Theme::getProperties()
 360 {
 361     SolarMutexGuard aGuard;
 362
 363     ::std::vector<beans::Property> aProperties;
 364
 365     sal_Int32 const nEnd(End_);
 366     for (sal_Int32 nItem(Begin_); nItem!=nEnd; ++nItem)
 367     {
 368         const ThemeItem eItem (static_cast<ThemeItem>(nItem));
 369         const PropertyType eType (GetPropertyType(eItem));
 370         if (eType == PT_Invalid)
 371             continue;
 372
 373         const beans::Property aProperty(
 374             maPropertyIdToNameMap[eItem],
 375             eItem,
 376             GetCppuType(eType),
 377             0);
 378         aProperties.push_back(aProperty);
 379     }
 380
 381     return css::uno::Sequence<css::beans::Property>(
 382         aProperties.data(),
 383         aProperties.size());
 384 }
 385
 386 beans::Property SAL_CALL Theme::getPropertyByName (const OUString& rsPropertyName)
 387 {
 388     SolarMutexGuard aGuard;
 389
 390     PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 391     if (iId == maPropertyNameToIdMap.end())
 392         throw beans::UnknownPropertyException(rsPropertyName);
 393
 394     const PropertyType eType (GetPropertyType(iId->second));
 395     if (eType == PT_Invalid)
 396         throw beans::UnknownPropertyException(rsPropertyName);
 397
 398     const ThemeItem eItem (iId->second);
 399
 400     return beans::Property(
 401         rsPropertyName,
 402         eItem,
 403         GetCppuType(eType),
 404         0);
 405 }
 406
 407 sal_Bool SAL_CALL Theme::hasPropertyByName (const OUString& rsPropertyName)
 408 {
 409     SolarMutexGuard aGuard;
 410
 411     PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
 412     if (iId == maPropertyNameToIdMap.end())
 413         return false;
 414
 415     const PropertyType eType (GetPropertyType(iId->second));
 416     if (eType == PT_Invalid)
 417         return false;
 418
 419     return true;
 420 }
 421
 422 void Theme::SetupPropertyMaps()
 423 {
 424     maPropertyIdToNameMap.resize(Post_Bool_);
 425     maColors.resize(Color_Int_ - Pre_Color_ - 1);
 426     maIntegers.resize(Int_Bool_ - Color_Int_ - 1);
 427     maBooleans.resize(Post_Bool_ - Int_Bool_ - 1);
 428
 429     maPropertyNameToIdMap[u"Color_Highlight"_ustr]=Color_Highlight;
 430     maPropertyIdToNameMap[Color_Highlight]="Color_Highlight";
 431
 432     maPropertyNameToIdMap[u"Color_HighlightText"_ustr]=Color_HighlightText;
 433     maPropertyIdToNameMap[Color_HighlightText]="Color_HighlightText";
 434
 435
 436     maPropertyNameToIdMap[u"Color_DeckBackground"_ustr]=Color_DeckBackground;
 437     maPropertyIdToNameMap[Color_DeckBackground]="Color_DeckBackground";
 438
 439     maPropertyNameToIdMap[u"Color_DeckTitleBarBackground"_ustr]=Color_DeckTitleBarBackground;
 440     maPropertyIdToNameMap[Color_DeckTitleBarBackground]="Color_DeckTitleBarBackground";
 441
 442     maPropertyNameToIdMap[u"Color_PanelBackground"_ustr]=Color_PanelBackground;
 443     maPropertyIdToNameMap[Color_PanelBackground]="Color_PanelBackground";
 444
 445     maPropertyNameToIdMap[u"Color_PanelTitleBarBackground"_ustr]=Color_PanelTitleBarBackground;
 446     maPropertyIdToNameMap[Color_PanelTitleBarBackground]="Color_PanelTitleBarBackground";
 447
 448     maPropertyNameToIdMap[u"Color_TabBarBackground"_ustr]=Color_TabBarBackground;
 449     maPropertyIdToNameMap[Color_TabBarBackground]="Color_TabBarBackground";
 450
 451
 452     maPropertyNameToIdMap[u"Int_DeckBorderSize"_ustr]=Int_DeckBorderSize;
 453     maPropertyIdToNameMap[Int_DeckBorderSize]="Int_DeckBorderSize";
 454
 455     maPropertyNameToIdMap[u"Int_DeckSeparatorHeight"_ustr]=Int_DeckSeparatorHeight;
 456     maPropertyIdToNameMap[Int_DeckSeparatorHeight]="Int_DeckSeparatorHeight";
 457
 458     maPropertyNameToIdMap[u"Int_DeckLeftPadding"_ustr]=Int_DeckLeftPadding;
 459     maPropertyIdToNameMap[Int_DeckLeftPadding]="Int_DeckLeftPadding";
 460
 461     maPropertyNameToIdMap[u"Int_DeckTopPadding"_ustr]=Int_DeckTopPadding;
 462     maPropertyIdToNameMap[Int_DeckTopPadding]="Int_DeckTopPadding";
 463
 464     maPropertyNameToIdMap[u"Int_DeckRightPadding"_ustr]=Int_DeckRightPadding;
 465     maPropertyIdToNameMap[Int_DeckRightPadding]="Int_DeckRightPadding";
 466
 467     maPropertyNameToIdMap[u"Int_DeckBottomPadding"_ustr]=Int_DeckBottomPadding;
 468     maPropertyIdToNameMap[Int_DeckBottomPadding]="Int_DeckBottomPadding";
 469
 470
 471     maPropertyNameToIdMap[u"Bool_UseSystemColors"_ustr]=Bool_UseSystemColors;
 472     maPropertyIdToNameMap[Bool_UseSystemColors]="Bool_UseSystemColors";
 473
 474     maPropertyNameToIdMap[u"Bool_IsHighContrastModeActive"_ustr]=Bool_IsHighContrastModeActive;
 475     maPropertyIdToNameMap[Bool_IsHighContrastModeActive]="Bool_IsHighContrastModeActive";
 476
 477     maRawValues.resize(maPropertyIdToNameMap.size());
 478 }
 479
 480 Theme::PropertyType Theme::GetPropertyType (const ThemeItem eItem)
 481 {
 482     switch(eItem)
 483     {
 484         case Color_Highlight:
 485         case Color_HighlightText:
 486         case Color_DeckBackground:
 487         case Color_DeckTitleBarBackground:
 488         case Color_PanelBackground:
 489         case Color_PanelTitleBarBackground:
 490         case Color_TabBarBackground:
 491             return PT_Color;
 492
 493         case Int_DeckBorderSize:
 494         case Int_DeckSeparatorHeight:
 495         case Int_DeckLeftPadding:
 496         case Int_DeckTopPadding:
 497         case Int_DeckRightPadding:
 498         case Int_DeckBottomPadding:
 499             return PT_Integer;
 500
 501         case Bool_UseSystemColors:
 502         case Bool_IsHighContrastModeActive:
 503             return PT_Boolean;
 504
 505         default:
 506             return PT_Invalid;
 507     }
 508 }
 509
 510 css::uno::Type const & Theme::GetCppuType (const PropertyType eType)
 511 {
 512     switch(eType)
 513     {
 514         case PT_Color:
 515             return cppu::UnoType<sal_uInt32>::get();
 516
 517         case PT_Integer:
 518             return cppu::UnoType<sal_Int32>::get();
 519
 520         case PT_Boolean:
 521             return cppu::UnoType<sal_Bool>::get();
 522
 523         case PT_Invalid:
 524         default:
 525             return cppu::UnoType<void>::get();
 526     }
 527 }
 528
 529 sal_Int32 Theme::GetIndex (const ThemeItem eItem, const PropertyType eType)
 530 {
 531     switch(eType)
 532     {
 533         case PT_Color:
 534             return eItem - Pre_Color_-1;
 535         case PT_Integer:
 536             return eItem - Color_Int_-1;
 537         case PT_Boolean:
 538             return eItem - Int_Bool_-1;
 539         default:
 540             OSL_ASSERT(false);
 541             return 0;
 542     }
 543 }
 544
 545 Theme::VetoableListenerContainer* Theme::GetVetoableListeners (
 546     const ThemeItem eItem,
 547     const bool bCreate)
 548 {
 549     VetoableListeners::iterator iContainer (maVetoableListeners.find(eItem));
 550     if (iContainer != maVetoableListeners.end())
 551         return &iContainer->second;
 552     else if (bCreate)
 553     {
 554         maVetoableListeners[eItem] = VetoableListenerContainer();
 555         return &maVetoableListeners[eItem];
 556     }
 557     else
 558         return nullptr;
 559 }
 560
 561 Theme::ChangeListenerContainer* Theme::GetChangeListeners (
 562     const ThemeItem eItem,
 563     const bool bCreate)
 564 {
 565     ChangeListeners::iterator iContainer (maChangeListeners.find(eItem));
 566     if (iContainer != maChangeListeners.end())
 567         return &iContainer->second;
 568     else if (bCreate)
 569     {
 570         maChangeListeners[eItem] = ChangeListenerContainer();
 571         return &maChangeListeners[eItem];
 572     }
 573     else
 574         return nullptr;
 575 }
 576
 577 bool Theme::DoVetoableListenersVeto (
 578     const VetoableListenerContainer* pListeners,
 579     const beans::PropertyChangeEvent& rEvent)
 580 {
 581     if (pListeners == nullptr)
 582         return false;
 583
 584     VetoableListenerContainer aListeners (*pListeners);
 585     try
 586     {
 587         for (const auto& rxListener : aListeners)
 588         {
 589             rxListener->vetoableChange(rEvent);
 590         }
 591     }
 592     catch(const beans::PropertyVetoException&)
 593     {
 594         return true;
 595     }
 596     catch(const Exception&)
 597     {
 598         // Ignore any other errors (such as disposed listeners).
 599     }
 600     return false;
 601 }
 602
 603 void Theme::BroadcastPropertyChange (
 604     const ChangeListenerContainer* pListeners,
 605     const beans::PropertyChangeEvent& rEvent)
 606 {
 607     if (pListeners == nullptr)
 608         return;
 609
 610     const ChangeListenerContainer aListeners (*pListeners);
 611     try
 612     {
 613         for (const auto& rxListener : aListeners)
 614         {
 615             rxListener->propertyChange(rEvent);
 616         }
 617     }
 618     catch(const Exception&)
 619     {
 620         // Ignore any errors (such as disposed listeners).
 621     }
 622 }
 623
 624 void Theme::ProcessNewValue (
 625     const Any& rValue,
 626     const ThemeItem eItem,
 627     const PropertyType eType)
 628 {
 629     const sal_Int32 nIndex (GetIndex (eItem, eType));
 630     switch (eType)
 631     {
 632         case PT_Color:
 633         {
 634             Color nColorValue;
 635             if (rValue >>= nColorValue)
 636                 maColors[nIndex] = nColorValue;
 637             break;
 638         }
 639         case PT_Integer:
 640         {
 641             sal_Int32 nValue (0);
 642             if (rValue >>= nValue)
 643             {
 644                 maIntegers[nIndex] = nValue;
 645             }
 646             break;
 647         }
 648         case PT_Boolean:
 649         {
 650             bool bValue (false);
 651             if (rValue >>= bValue)
 652             {
 653                 maBooleans[nIndex] = bValue;
 654                 if (eItem == Bool_IsHighContrastModeActive)
 655                 {
 656                     mbIsHighContrastModeSetManually = true;
 657                     mbIsHighContrastMode = maBooleans[nIndex];
 658                     HandleDataChange();
 659                 }
 660                 else if (eItem == Bool_UseSystemColors)
 661                 {
 662                     HandleDataChange();
 663                 }
 664             }
 665             break;
 666         }
 667         case PT_Invalid:
 668             OSL_ASSERT(eType != PT_Invalid);
 669             throw RuntimeException();
 670     }
 671 }
 672
 673 } // end of namespace sfx2::sidebar
 674
 675 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */