ca5c9591ba
Change-Id: I6306260d03c1208ec250c2f9a3860fa569f6d9c8 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/167448 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
675 lines
20 KiB
C++
675 lines
20 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <sfx2/sidebar/Theme.hxx>
|
|
#include <sfx2/app.hxx>
|
|
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/settings.hxx>
|
|
#include <comphelper/diagnose_ex.hxx>
|
|
|
|
using namespace css;
|
|
using namespace css::uno;
|
|
|
|
namespace sfx2::sidebar {
|
|
|
|
Theme& Theme::GetCurrentTheme()
|
|
{
|
|
OSL_ASSERT(SfxGetpApp());
|
|
return SfxGetpApp()->GetSidebarTheme();
|
|
}
|
|
|
|
Theme::Theme()
|
|
: mbIsHighContrastMode(Application::GetSettings().GetStyleSettings().GetHighContrastMode()),
|
|
mbIsHighContrastModeSetManually(false)
|
|
{
|
|
SetupPropertyMaps();
|
|
}
|
|
|
|
Theme::~Theme()
|
|
{
|
|
}
|
|
|
|
Color Theme::GetColor (const ThemeItem eItem)
|
|
{
|
|
const PropertyType eType (GetPropertyType(eItem));
|
|
OSL_ASSERT(eType==PT_Color);
|
|
const sal_Int32 nIndex (GetIndex(eItem, eType));
|
|
const Theme& rTheme (GetCurrentTheme());
|
|
if (eType == PT_Color)
|
|
return rTheme.maColors[nIndex];
|
|
else
|
|
return COL_WHITE;
|
|
}
|
|
|
|
sal_Int32 Theme::GetInteger (const ThemeItem eItem)
|
|
{
|
|
const PropertyType eType (GetPropertyType(eItem));
|
|
OSL_ASSERT(eType==PT_Integer);
|
|
const sal_Int32 nIndex (GetIndex(eItem, eType));
|
|
const Theme& rTheme (GetCurrentTheme());
|
|
return rTheme.maIntegers[nIndex];
|
|
}
|
|
|
|
bool Theme::IsHighContrastMode()
|
|
{
|
|
const Theme& rTheme (GetCurrentTheme());
|
|
return rTheme.mbIsHighContrastMode;
|
|
}
|
|
|
|
void Theme::HandleDataChange()
|
|
{
|
|
Theme& rTheme (GetCurrentTheme());
|
|
|
|
if ( ! rTheme.mbIsHighContrastModeSetManually)
|
|
{
|
|
// Do not modify mbIsHighContrastMode when it was manually set.
|
|
GetCurrentTheme().mbIsHighContrastMode = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
|
|
rTheme.maRawValues[Bool_IsHighContrastModeActive] <<= GetCurrentTheme().mbIsHighContrastMode;
|
|
}
|
|
|
|
GetCurrentTheme().UpdateTheme();
|
|
}
|
|
|
|
void Theme::InitializeTheme()
|
|
{
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Bool_UseSystemColors],
|
|
Any(false));
|
|
}
|
|
|
|
void Theme::UpdateTheme()
|
|
{
|
|
try
|
|
{
|
|
const StyleSettings& rStyle (Application::GetSettings().GetStyleSettings());
|
|
|
|
Color aBaseBackgroundColor (rStyle.GetDialogColor());
|
|
// UX says this should be a little brighter, but that looks off when compared to the other windows.
|
|
//aBaseBackgroundColor.IncreaseLuminance(7);
|
|
Color aSecondColor (aBaseBackgroundColor);
|
|
aSecondColor.DecreaseLuminance(15);
|
|
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_DeckBackground],
|
|
Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
|
|
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_DeckTitleBarBackground],
|
|
Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Int_DeckSeparatorHeight],
|
|
Any(sal_Int32(1)));
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_PanelBackground],
|
|
Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
|
|
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_PanelTitleBarBackground],
|
|
Any(sal_Int32(aSecondColor.GetRGBColor())));
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_TabBarBackground],
|
|
Any(sal_Int32(aBaseBackgroundColor.GetRGBColor())));
|
|
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_Highlight],
|
|
Any(sal_Int32(rStyle.GetHighlightColor().GetRGBColor())));
|
|
setPropertyValue(
|
|
maPropertyIdToNameMap[Color_HighlightText],
|
|
Any(sal_Int32(rStyle.GetHighlightTextColor().GetRGBColor())));
|
|
}
|
|
catch(beans::UnknownPropertyException const &)
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION("sfx", "unknown property");
|
|
OSL_ASSERT(false);
|
|
}
|
|
}
|
|
|
|
void Theme::disposing(std::unique_lock<std::mutex>&)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
ChangeListeners aListeners;
|
|
aListeners.swap(maChangeListeners);
|
|
|
|
const lang::EventObject aEvent (getXWeak());
|
|
|
|
for (const auto& rContainer : aListeners)
|
|
{
|
|
for (const auto& rxListener : rContainer.second)
|
|
{
|
|
try
|
|
{
|
|
rxListener->disposing(aEvent);
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Reference<beans::XPropertySet> Theme::GetPropertySet()
|
|
{
|
|
if (SfxGetpApp())
|
|
return Reference<beans::XPropertySet>(&GetCurrentTheme());
|
|
else
|
|
return Reference<beans::XPropertySet>();
|
|
}
|
|
|
|
Reference<beans::XPropertySetInfo> SAL_CALL Theme::getPropertySetInfo()
|
|
{
|
|
return Reference<beans::XPropertySetInfo>(this);
|
|
}
|
|
|
|
void SAL_CALL Theme::setPropertyValue (
|
|
const OUString& rsPropertyName,
|
|
const css::uno::Any& rValue)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const ThemeItem eItem (iId->second);
|
|
|
|
if (rValue == maRawValues[eItem])
|
|
{
|
|
// Value is not different from the one in the property
|
|
// set => nothing to do.
|
|
return;
|
|
}
|
|
|
|
const Any aOldValue (maRawValues[eItem]);
|
|
|
|
const beans::PropertyChangeEvent aEvent(
|
|
getXWeak(),
|
|
rsPropertyName,
|
|
false,
|
|
eItem,
|
|
aOldValue,
|
|
rValue);
|
|
|
|
if (DoVetoableListenersVeto(GetVetoableListeners(AnyItem_, false), aEvent))
|
|
return;
|
|
if (DoVetoableListenersVeto(GetVetoableListeners(eItem, false), aEvent))
|
|
return;
|
|
|
|
maRawValues[eItem] = rValue;
|
|
ProcessNewValue(rValue, eItem, eType);
|
|
|
|
BroadcastPropertyChange(GetChangeListeners(AnyItem_, false), aEvent);
|
|
BroadcastPropertyChange(GetChangeListeners(eItem, false), aEvent);
|
|
}
|
|
|
|
Any SAL_CALL Theme::getPropertyValue (
|
|
const OUString& rsPropertyName)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const ThemeItem eItem (iId->second);
|
|
|
|
return maRawValues[eItem];
|
|
}
|
|
|
|
void SAL_CALL Theme::addPropertyChangeListener(
|
|
const OUString& rsPropertyName,
|
|
const css::uno::Reference<css::beans::XPropertyChangeListener>& rxListener)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
ThemeItem eItem (AnyItem_);
|
|
if (rsPropertyName.getLength() > 0)
|
|
{
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
eItem = iId->second;
|
|
}
|
|
ChangeListenerContainer* pListeners = GetChangeListeners(eItem, true);
|
|
if (pListeners != nullptr)
|
|
pListeners->push_back(rxListener);
|
|
}
|
|
|
|
void SAL_CALL Theme::removePropertyChangeListener(
|
|
const OUString& rsPropertyName,
|
|
const css::uno::Reference<css::beans::XPropertyChangeListener>& rxListener)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
ThemeItem eItem (AnyItem_);
|
|
if (rsPropertyName.getLength() > 0)
|
|
{
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
eItem = iId->second;
|
|
}
|
|
ChangeListenerContainer* pContainer = GetChangeListeners(eItem, false);
|
|
if (pContainer != nullptr)
|
|
{
|
|
ChangeListenerContainer::iterator iListener (::std::find(pContainer->begin(), pContainer->end(), rxListener));
|
|
if (iListener != pContainer->end())
|
|
{
|
|
pContainer->erase(iListener);
|
|
|
|
// Remove the listener container when empty.
|
|
if (pContainer->empty())
|
|
maChangeListeners.erase(eItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SAL_CALL Theme::addVetoableChangeListener(
|
|
const OUString& rsPropertyName,
|
|
const css::uno::Reference<css::beans::XVetoableChangeListener>& rxListener)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
ThemeItem eItem (AnyItem_);
|
|
if (rsPropertyName.getLength() > 0)
|
|
{
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
eItem = iId->second;
|
|
}
|
|
VetoableListenerContainer* pListeners = GetVetoableListeners(eItem, true);
|
|
if (pListeners != nullptr)
|
|
pListeners->push_back(rxListener);
|
|
}
|
|
|
|
void SAL_CALL Theme::removeVetoableChangeListener(
|
|
const OUString& rsPropertyName,
|
|
const css::uno::Reference<css::beans::XVetoableChangeListener>& rxListener)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
ThemeItem eItem (AnyItem_);
|
|
if (rsPropertyName.getLength() > 0)
|
|
{
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
eItem = iId->second;
|
|
}
|
|
VetoableListenerContainer* pContainer = GetVetoableListeners(eItem, false);
|
|
if (pContainer != nullptr)
|
|
{
|
|
VetoableListenerContainer::iterator iListener (::std::find(pContainer->begin(), pContainer->end(), rxListener));
|
|
if (iListener != pContainer->end())
|
|
{
|
|
pContainer->erase(iListener);
|
|
// Remove container when empty.
|
|
if (pContainer->empty())
|
|
maVetoableListeners.erase(eItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
css::uno::Sequence<css::beans::Property> SAL_CALL Theme::getProperties()
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
::std::vector<beans::Property> aProperties;
|
|
|
|
sal_Int32 const nEnd(End_);
|
|
for (sal_Int32 nItem(Begin_); nItem!=nEnd; ++nItem)
|
|
{
|
|
const ThemeItem eItem (static_cast<ThemeItem>(nItem));
|
|
const PropertyType eType (GetPropertyType(eItem));
|
|
if (eType == PT_Invalid)
|
|
continue;
|
|
|
|
const beans::Property aProperty(
|
|
maPropertyIdToNameMap[eItem],
|
|
eItem,
|
|
GetCppuType(eType),
|
|
0);
|
|
aProperties.push_back(aProperty);
|
|
}
|
|
|
|
return css::uno::Sequence<css::beans::Property>(
|
|
aProperties.data(),
|
|
aProperties.size());
|
|
}
|
|
|
|
beans::Property SAL_CALL Theme::getPropertyByName (const OUString& rsPropertyName)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
throw beans::UnknownPropertyException(rsPropertyName);
|
|
|
|
const ThemeItem eItem (iId->second);
|
|
|
|
return beans::Property(
|
|
rsPropertyName,
|
|
eItem,
|
|
GetCppuType(eType),
|
|
0);
|
|
}
|
|
|
|
sal_Bool SAL_CALL Theme::hasPropertyByName (const OUString& rsPropertyName)
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
|
|
PropertyNameToIdMap::const_iterator iId (maPropertyNameToIdMap.find(rsPropertyName));
|
|
if (iId == maPropertyNameToIdMap.end())
|
|
return false;
|
|
|
|
const PropertyType eType (GetPropertyType(iId->second));
|
|
if (eType == PT_Invalid)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void Theme::SetupPropertyMaps()
|
|
{
|
|
maPropertyIdToNameMap.resize(Post_Bool_);
|
|
maColors.resize(Color_Int_ - Pre_Color_ - 1);
|
|
maIntegers.resize(Int_Bool_ - Color_Int_ - 1);
|
|
maBooleans.resize(Post_Bool_ - Int_Bool_ - 1);
|
|
|
|
maPropertyNameToIdMap[u"Color_Highlight"_ustr]=Color_Highlight;
|
|
maPropertyIdToNameMap[Color_Highlight]="Color_Highlight";
|
|
|
|
maPropertyNameToIdMap[u"Color_HighlightText"_ustr]=Color_HighlightText;
|
|
maPropertyIdToNameMap[Color_HighlightText]="Color_HighlightText";
|
|
|
|
|
|
maPropertyNameToIdMap[u"Color_DeckBackground"_ustr]=Color_DeckBackground;
|
|
maPropertyIdToNameMap[Color_DeckBackground]="Color_DeckBackground";
|
|
|
|
maPropertyNameToIdMap[u"Color_DeckTitleBarBackground"_ustr]=Color_DeckTitleBarBackground;
|
|
maPropertyIdToNameMap[Color_DeckTitleBarBackground]="Color_DeckTitleBarBackground";
|
|
|
|
maPropertyNameToIdMap[u"Color_PanelBackground"_ustr]=Color_PanelBackground;
|
|
maPropertyIdToNameMap[Color_PanelBackground]="Color_PanelBackground";
|
|
|
|
maPropertyNameToIdMap[u"Color_PanelTitleBarBackground"_ustr]=Color_PanelTitleBarBackground;
|
|
maPropertyIdToNameMap[Color_PanelTitleBarBackground]="Color_PanelTitleBarBackground";
|
|
|
|
maPropertyNameToIdMap[u"Color_TabBarBackground"_ustr]=Color_TabBarBackground;
|
|
maPropertyIdToNameMap[Color_TabBarBackground]="Color_TabBarBackground";
|
|
|
|
|
|
maPropertyNameToIdMap[u"Int_DeckBorderSize"_ustr]=Int_DeckBorderSize;
|
|
maPropertyIdToNameMap[Int_DeckBorderSize]="Int_DeckBorderSize";
|
|
|
|
maPropertyNameToIdMap[u"Int_DeckSeparatorHeight"_ustr]=Int_DeckSeparatorHeight;
|
|
maPropertyIdToNameMap[Int_DeckSeparatorHeight]="Int_DeckSeparatorHeight";
|
|
|
|
maPropertyNameToIdMap[u"Int_DeckLeftPadding"_ustr]=Int_DeckLeftPadding;
|
|
maPropertyIdToNameMap[Int_DeckLeftPadding]="Int_DeckLeftPadding";
|
|
|
|
maPropertyNameToIdMap[u"Int_DeckTopPadding"_ustr]=Int_DeckTopPadding;
|
|
maPropertyIdToNameMap[Int_DeckTopPadding]="Int_DeckTopPadding";
|
|
|
|
maPropertyNameToIdMap[u"Int_DeckRightPadding"_ustr]=Int_DeckRightPadding;
|
|
maPropertyIdToNameMap[Int_DeckRightPadding]="Int_DeckRightPadding";
|
|
|
|
maPropertyNameToIdMap[u"Int_DeckBottomPadding"_ustr]=Int_DeckBottomPadding;
|
|
maPropertyIdToNameMap[Int_DeckBottomPadding]="Int_DeckBottomPadding";
|
|
|
|
|
|
maPropertyNameToIdMap[u"Bool_UseSystemColors"_ustr]=Bool_UseSystemColors;
|
|
maPropertyIdToNameMap[Bool_UseSystemColors]="Bool_UseSystemColors";
|
|
|
|
maPropertyNameToIdMap[u"Bool_IsHighContrastModeActive"_ustr]=Bool_IsHighContrastModeActive;
|
|
maPropertyIdToNameMap[Bool_IsHighContrastModeActive]="Bool_IsHighContrastModeActive";
|
|
|
|
maRawValues.resize(maPropertyIdToNameMap.size());
|
|
}
|
|
|
|
Theme::PropertyType Theme::GetPropertyType (const ThemeItem eItem)
|
|
{
|
|
switch(eItem)
|
|
{
|
|
case Color_Highlight:
|
|
case Color_HighlightText:
|
|
case Color_DeckBackground:
|
|
case Color_DeckTitleBarBackground:
|
|
case Color_PanelBackground:
|
|
case Color_PanelTitleBarBackground:
|
|
case Color_TabBarBackground:
|
|
return PT_Color;
|
|
|
|
case Int_DeckBorderSize:
|
|
case Int_DeckSeparatorHeight:
|
|
case Int_DeckLeftPadding:
|
|
case Int_DeckTopPadding:
|
|
case Int_DeckRightPadding:
|
|
case Int_DeckBottomPadding:
|
|
return PT_Integer;
|
|
|
|
case Bool_UseSystemColors:
|
|
case Bool_IsHighContrastModeActive:
|
|
return PT_Boolean;
|
|
|
|
default:
|
|
return PT_Invalid;
|
|
}
|
|
}
|
|
|
|
css::uno::Type const & Theme::GetCppuType (const PropertyType eType)
|
|
{
|
|
switch(eType)
|
|
{
|
|
case PT_Color:
|
|
return cppu::UnoType<sal_uInt32>::get();
|
|
|
|
case PT_Integer:
|
|
return cppu::UnoType<sal_Int32>::get();
|
|
|
|
case PT_Boolean:
|
|
return cppu::UnoType<sal_Bool>::get();
|
|
|
|
case PT_Invalid:
|
|
default:
|
|
return cppu::UnoType<void>::get();
|
|
}
|
|
}
|
|
|
|
sal_Int32 Theme::GetIndex (const ThemeItem eItem, const PropertyType eType)
|
|
{
|
|
switch(eType)
|
|
{
|
|
case PT_Color:
|
|
return eItem - Pre_Color_-1;
|
|
case PT_Integer:
|
|
return eItem - Color_Int_-1;
|
|
case PT_Boolean:
|
|
return eItem - Int_Bool_-1;
|
|
default:
|
|
OSL_ASSERT(false);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
Theme::VetoableListenerContainer* Theme::GetVetoableListeners (
|
|
const ThemeItem eItem,
|
|
const bool bCreate)
|
|
{
|
|
VetoableListeners::iterator iContainer (maVetoableListeners.find(eItem));
|
|
if (iContainer != maVetoableListeners.end())
|
|
return &iContainer->second;
|
|
else if (bCreate)
|
|
{
|
|
maVetoableListeners[eItem] = VetoableListenerContainer();
|
|
return &maVetoableListeners[eItem];
|
|
}
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
Theme::ChangeListenerContainer* Theme::GetChangeListeners (
|
|
const ThemeItem eItem,
|
|
const bool bCreate)
|
|
{
|
|
ChangeListeners::iterator iContainer (maChangeListeners.find(eItem));
|
|
if (iContainer != maChangeListeners.end())
|
|
return &iContainer->second;
|
|
else if (bCreate)
|
|
{
|
|
maChangeListeners[eItem] = ChangeListenerContainer();
|
|
return &maChangeListeners[eItem];
|
|
}
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
bool Theme::DoVetoableListenersVeto (
|
|
const VetoableListenerContainer* pListeners,
|
|
const beans::PropertyChangeEvent& rEvent)
|
|
{
|
|
if (pListeners == nullptr)
|
|
return false;
|
|
|
|
VetoableListenerContainer aListeners (*pListeners);
|
|
try
|
|
{
|
|
for (const auto& rxListener : aListeners)
|
|
{
|
|
rxListener->vetoableChange(rEvent);
|
|
}
|
|
}
|
|
catch(const beans::PropertyVetoException&)
|
|
{
|
|
return true;
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
// Ignore any other errors (such as disposed listeners).
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Theme::BroadcastPropertyChange (
|
|
const ChangeListenerContainer* pListeners,
|
|
const beans::PropertyChangeEvent& rEvent)
|
|
{
|
|
if (pListeners == nullptr)
|
|
return;
|
|
|
|
const ChangeListenerContainer aListeners (*pListeners);
|
|
try
|
|
{
|
|
for (const auto& rxListener : aListeners)
|
|
{
|
|
rxListener->propertyChange(rEvent);
|
|
}
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
// Ignore any errors (such as disposed listeners).
|
|
}
|
|
}
|
|
|
|
void Theme::ProcessNewValue (
|
|
const Any& rValue,
|
|
const ThemeItem eItem,
|
|
const PropertyType eType)
|
|
{
|
|
const sal_Int32 nIndex (GetIndex (eItem, eType));
|
|
switch (eType)
|
|
{
|
|
case PT_Color:
|
|
{
|
|
Color nColorValue;
|
|
if (rValue >>= nColorValue)
|
|
maColors[nIndex] = nColorValue;
|
|
break;
|
|
}
|
|
case PT_Integer:
|
|
{
|
|
sal_Int32 nValue (0);
|
|
if (rValue >>= nValue)
|
|
{
|
|
maIntegers[nIndex] = nValue;
|
|
}
|
|
break;
|
|
}
|
|
case PT_Boolean:
|
|
{
|
|
bool bValue (false);
|
|
if (rValue >>= bValue)
|
|
{
|
|
maBooleans[nIndex] = bValue;
|
|
if (eItem == Bool_IsHighContrastModeActive)
|
|
{
|
|
mbIsHighContrastModeSetManually = true;
|
|
mbIsHighContrastMode = maBooleans[nIndex];
|
|
HandleDataChange();
|
|
}
|
|
else if (eItem == Bool_UseSystemColors)
|
|
{
|
|
HandleDataChange();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case PT_Invalid:
|
|
OSL_ASSERT(eType != PT_Invalid);
|
|
throw RuntimeException();
|
|
}
|
|
}
|
|
|
|
} // end of namespace sfx2::sidebar
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|