LCOV - code coverage report
Current view: top level - svtools/source/config - extcolorcfg.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 1 368 0.3 %
Date: 2014-11-03 Functions: 2 58 3.4 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <sal/config.h>
      21             : 
      22             : #include <map>
      23             : 
      24             : #include <svtools/extcolorcfg.hxx>
      25             : #include <com/sun/star/uno/Any.hxx>
      26             : #include <com/sun/star/uno/Sequence.hxx>
      27             : #include <com/sun/star/lang/Locale.hpp>
      28             : #include <com/sun/star/beans/PropertyValue.hpp>
      29             : #include <tools/color.hxx>
      30             : #include <unotools/configitem.hxx>
      31             : #include <unotools/configpaths.hxx>
      32             : #include <com/sun/star/uno/Sequence.h>
      33             : #include <svl/poolitem.hxx>
      34             : #include <svl/smplhint.hxx>
      35             : #include <osl/mutex.hxx>
      36             : 
      37             : #include <vcl/svapp.hxx>
      38             : #include <vcl/settings.hxx>
      39             : #include <vcl/event.hxx>
      40             : #include <rtl/instance.hxx>
      41             : #include <rtl/strbuf.hxx>
      42             : 
      43             : 
      44             : using namespace utl;
      45             : using namespace com::sun::star;
      46             : 
      47             : 
      48             : namespace svtools
      49             : {
      50             : 
      51             : sal_Int32            nExtendedColorRefCount_Impl = 0;
      52             : namespace
      53             : {
      54             :     struct ColorMutex_Impl
      55             :         : public rtl::Static< ::osl::Mutex, ColorMutex_Impl > {};
      56             : }
      57             : 
      58             : ExtendedColorConfig_Impl*    ExtendedColorConfig::m_pImpl = NULL;
      59             : 
      60             : class ExtendedColorConfig_Impl : public utl::ConfigItem, public SfxBroadcaster
      61             : {
      62             :     typedef std::map<OUString, OUString> TDisplayNames;
      63             :     typedef std::map<OUString, ExtendedColorConfigValue> TConfigValues;
      64             :     typedef ::std::vector<TConfigValues::iterator> TMapPos;
      65             :     typedef ::std::pair< TConfigValues, TMapPos > TComponentMapping;
      66             :     typedef std::map<OUString, TComponentMapping> TComponents;
      67             :     TComponents         m_aConfigValues;
      68             :     TDisplayNames       m_aComponentDisplayNames;
      69             :     ::std::vector<TComponents::iterator> m_aConfigValuesPos;
      70             : 
      71             :     bool            m_bEditMode;
      72             :     OUString        m_sLoadedScheme;
      73             :     bool            m_bIsBroadcastEnabled;
      74             :     static bool     m_bLockBroadcast;
      75             :     static bool     m_bBroadcastWhenUnlocked;
      76             : 
      77             :     uno::Sequence< OUString> GetPropertyNames(const OUString& rScheme);
      78             :     void FillComponentColors(uno::Sequence < OUString >& _rComponents,const TDisplayNames& _rDisplayNames);
      79             : public:
      80             :     ExtendedColorConfig_Impl(bool bEditMode = false);
      81             :     virtual ~ExtendedColorConfig_Impl();
      82             : 
      83             :     void                            Load(const OUString& rScheme);
      84             :     void                            CommitCurrentSchemeName();
      85             :     //changes the name of the current scheme but doesn't load it!
      86           0 :     void                            SetCurrentSchemeName(const OUString& rSchemeName) {m_sLoadedScheme = rSchemeName;}
      87             :     bool                            ExistsScheme(const OUString& _sSchemeName);
      88             :     virtual void                    Commit() SAL_OVERRIDE;
      89             :     virtual void                    Notify( const uno::Sequence<OUString>& aPropertyNames) SAL_OVERRIDE;
      90             : 
      91             :     sal_Int32                       GetComponentCount() const;
      92             :     OUString                 GetComponentName(sal_uInt32 _nPos) const;
      93             :     OUString                 GetComponentDisplayName(const OUString& _sComponentName) const;
      94             :     sal_Int32                       GetComponentColorCount(const OUString& _sName) const;
      95             :     ExtendedColorConfigValue        GetComponentColorConfigValue(const OUString& _sName,sal_uInt32 _nPos) const;
      96             : 
      97           0 :     ExtendedColorConfigValue GetColorConfigValue(const OUString& _sComponentName,const OUString& _sName)
      98             :     {
      99           0 :         TComponents::iterator aFind = m_aConfigValues.find(_sComponentName);
     100           0 :         if ( aFind != m_aConfigValues.end() )
     101             :         {
     102           0 :             TConfigValues::iterator aFind2 = aFind->second.first.find(_sName);
     103           0 :             if ( aFind2 != aFind->second.first.end() )
     104           0 :                 return aFind2->second;
     105             :         }
     106             : #if OSL_DEBUG_LEVEL > 0
     107             :         OStringBuffer aMessage( "Could find the required config:\n" );
     108             :         aMessage.append( "component: " );
     109             :         aMessage.append( OUStringToOString( _sComponentName, RTL_TEXTENCODING_UTF8 ) );
     110             :         aMessage.append( "\nname: " );
     111             :         aMessage.append( OUStringToOString( _sName, RTL_TEXTENCODING_UTF8 ) );
     112             :         OSL_FAIL( aMessage.makeStringAndClear().getStr() );
     113             : #endif
     114           0 :         return ExtendedColorConfigValue();
     115             :     }
     116             :     void                            SetColorConfigValue(const OUString& _sName,
     117             :                                                             const ExtendedColorConfigValue& rValue );
     118             : 
     119             :     bool                            AddScheme(const OUString& rNode);
     120             :     bool                            RemoveScheme(const OUString& rNode);
     121           0 :     void                            SetModified(){ConfigItem::SetModified();}
     122           0 :     void                            ClearModified(){ConfigItem::ClearModified();}
     123             :     void                            SettingsChanged();
     124             : 
     125             :     static void                     DisableBroadcast();
     126             :     static void                     EnableBroadcast();
     127             :     static bool                     IsEnableBroadcast();
     128             : 
     129             :     static void                     LockBroadcast();
     130             :     static void                     UnlockBroadcast();
     131             : 
     132             :     // #100822#
     133             :     DECL_LINK( DataChangedEventListener, VclWindowEvent* );
     134             : };
     135             : 
     136           0 : uno::Sequence< OUString> ExtendedColorConfig_Impl::GetPropertyNames(const OUString& rScheme)
     137             : {
     138           0 :     uno::Sequence< OUString> aNames(GetNodeNames(rScheme));
     139           0 :     OUString* pIter = aNames.getArray();
     140           0 :     OUString* pEnd    = pIter + aNames.getLength();
     141           0 :     OUString sSep("/");
     142           0 :     for(;pIter != pEnd;++pIter)
     143             :     {
     144           0 :         *pIter = rScheme + sSep + *pIter;
     145             :     }
     146           0 :     return aNames;
     147             : }
     148             : 
     149           0 : sal_Int32 ExtendedColorConfig_Impl::GetComponentCount() const
     150             : {
     151           0 :     return m_aConfigValues.size();
     152             : }
     153             : 
     154           0 : sal_Int32 ExtendedColorConfig_Impl::GetComponentColorCount(const OUString& _sName) const
     155             : {
     156           0 :     sal_Int32 nSize = 0;
     157           0 :     TComponents::const_iterator aFind = m_aConfigValues.find(_sName);
     158           0 :     if ( aFind != m_aConfigValues.end() )
     159             :     {
     160           0 :         nSize = aFind->second.first.size();
     161             :     }
     162           0 :     return nSize;
     163             : }
     164             : 
     165           0 : ExtendedColorConfigValue ExtendedColorConfig_Impl::GetComponentColorConfigValue(const OUString& _sName,sal_uInt32 _nPos) const
     166             : {
     167           0 :     TComponents::const_iterator aFind = m_aConfigValues.find(_sName);
     168           0 :     if ( aFind != m_aConfigValues.end() )
     169             :     {
     170           0 :         if ( _nPos < aFind->second.second.size() )
     171             :         {
     172           0 :             return aFind->second.second[_nPos]->second;
     173             :         }
     174             :     }
     175           0 :     return ExtendedColorConfigValue();
     176             : }
     177             : 
     178           0 : OUString ExtendedColorConfig_Impl::GetComponentDisplayName(const OUString& _sComponentName) const
     179             : {
     180           0 :     OUString sRet;
     181           0 :     TDisplayNames::const_iterator aFind = m_aComponentDisplayNames.find(_sComponentName);
     182           0 :     if ( aFind != m_aComponentDisplayNames.end() )
     183           0 :         sRet = aFind->second;
     184           0 :     return sRet;
     185             : }
     186             : 
     187           0 : OUString ExtendedColorConfig_Impl::GetComponentName(sal_uInt32 _nPos) const
     188             : {
     189           0 :     OUString sRet;
     190           0 :     if ( _nPos < m_aConfigValuesPos.size() )
     191           0 :         sRet = m_aConfigValuesPos[_nPos]->first;
     192           0 :     return sRet;
     193             : }
     194             : 
     195             : bool ExtendedColorConfig_Impl::m_bLockBroadcast = false;
     196             : bool ExtendedColorConfig_Impl::m_bBroadcastWhenUnlocked = false;
     197           0 : ExtendedColorConfig_Impl::ExtendedColorConfig_Impl(bool bEditMode) :
     198             :     ConfigItem(OUString("Office.ExtendedColorScheme")),
     199             :     m_bEditMode(bEditMode),
     200           0 :     m_bIsBroadcastEnabled(true)
     201             : {
     202           0 :     if(!m_bEditMode)
     203             :     {
     204             :         //try to register on the root node - if possible
     205           0 :         uno::Sequence < OUString > aNames(1);
     206           0 :         EnableNotification( aNames );
     207             :     }
     208           0 :     Load(OUString());
     209             : 
     210             :     // #100822#
     211           0 :     ::Application::AddEventListener( LINK(this, ExtendedColorConfig_Impl, DataChangedEventListener) );
     212             : 
     213           0 : }
     214             : 
     215           0 : ExtendedColorConfig_Impl::~ExtendedColorConfig_Impl()
     216             : {
     217             :     // #100822#
     218           0 :     ::Application::RemoveEventListener( LINK(this, ExtendedColorConfig_Impl, DataChangedEventListener) );
     219           0 : }
     220             : 
     221           0 : void ExtendedColorConfig_Impl::DisableBroadcast()
     222             : {
     223           0 :     if ( ExtendedColorConfig::m_pImpl )
     224           0 :         ExtendedColorConfig::m_pImpl->m_bIsBroadcastEnabled = false;
     225           0 : }
     226             : 
     227           0 : void ExtendedColorConfig_Impl::EnableBroadcast()
     228             : {
     229           0 :     if ( ExtendedColorConfig::m_pImpl )
     230           0 :         ExtendedColorConfig::m_pImpl->m_bIsBroadcastEnabled = true;
     231           0 : }
     232             : 
     233           0 : bool ExtendedColorConfig_Impl::IsEnableBroadcast()
     234             : {
     235           0 :     return ExtendedColorConfig::m_pImpl && ExtendedColorConfig::m_pImpl->m_bIsBroadcastEnabled;
     236             : }
     237             : 
     238           0 : void lcl_addString(uno::Sequence < OUString >& _rSeq,const OUString& _sAdd)
     239             : {
     240           0 :     OUString* pIter = _rSeq.getArray();
     241           0 :     OUString* pEnd  = pIter + _rSeq.getLength();
     242           0 :     for(;pIter != pEnd;++pIter)
     243           0 :         *pIter += _sAdd;
     244           0 : }
     245             : 
     246           0 : void ExtendedColorConfig_Impl::Load(const OUString& rScheme)
     247             : {
     248           0 :     m_aComponentDisplayNames.clear();
     249           0 :     m_aConfigValuesPos.clear();
     250           0 :     m_aConfigValues.clear();
     251             : 
     252             :     // fill display names
     253           0 :     TDisplayNames aDisplayNameMap;
     254           0 :     OUString sEntryNames("EntryNames");
     255           0 :     uno::Sequence < OUString > aComponentNames = GetPropertyNames(sEntryNames);
     256           0 :     OUString sDisplayName("/DisplayName");
     257           0 :     OUString* pIter = aComponentNames.getArray();
     258           0 :     OUString* pEnd  = pIter + aComponentNames.getLength();
     259           0 :     for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i)
     260             :     {
     261           0 :         uno::Sequence < OUString > aComponentDisplayNames(1);
     262           0 :         aComponentDisplayNames[0] = *pIter;
     263           0 :         aComponentDisplayNames[0] += sDisplayName;
     264           0 :         uno::Sequence< uno::Any > aComponentDisplayNamesValue = GetProperties( aComponentDisplayNames );
     265           0 :         OUString sComponentDisplayName;
     266           0 :         if ( aComponentDisplayNamesValue.getLength() && (aComponentDisplayNamesValue[0] >>= sComponentDisplayName) )
     267             :         {
     268           0 :             sal_Int32 nIndex = 0;
     269           0 :             m_aComponentDisplayNames.insert(TDisplayNames::value_type(pIter->getToken(1,'/',nIndex),sComponentDisplayName));
     270             :         }
     271             : 
     272           0 :         *pIter += "/Entries";
     273           0 :         uno::Sequence < OUString > aDisplayNames = GetPropertyNames(*pIter);
     274           0 :         lcl_addString(aDisplayNames,sDisplayName);
     275             : 
     276           0 :         uno::Sequence< uno::Any > aDisplayNamesValue = GetProperties( aDisplayNames );
     277             : 
     278           0 :         const OUString* pDispIter = aDisplayNames.getConstArray();
     279           0 :         const OUString* pDispEnd  = pDispIter + aDisplayNames.getLength();
     280           0 :         for(sal_Int32 j = 0;pDispIter != pDispEnd;++pDispIter,++j)
     281             :         {
     282           0 :             sal_Int32 nIndex = 0;
     283           0 :             pDispIter->getToken(0,'/',nIndex);
     284           0 :             OUString sName = pDispIter->copy(nIndex);
     285           0 :             sName = sName.copy(0,sName.lastIndexOf(sDisplayName));
     286           0 :             OUString sCurrentDisplayName;
     287           0 :             aDisplayNamesValue[j] >>= sCurrentDisplayName;
     288           0 :             aDisplayNameMap.insert(TDisplayNames::value_type(sName,sCurrentDisplayName));
     289           0 :         }
     290           0 :     }
     291             : 
     292             :     // load color settings
     293           0 :     OUString sScheme(rScheme);
     294             : 
     295           0 :     if(sScheme.isEmpty())
     296             :     {
     297             :         //detect current scheme name
     298           0 :         uno::Sequence < OUString > aCurrent(1);
     299           0 :         aCurrent.getArray()[0] = "ExtendedColorScheme/CurrentColorScheme";
     300           0 :         uno::Sequence< uno::Any > aCurrentVal = GetProperties( aCurrent );
     301           0 :         aCurrentVal.getConstArray()[0] >>= sScheme;
     302             :     } // if(!sScheme.getLength())
     303             : 
     304           0 :     m_sLoadedScheme = sScheme;
     305           0 :     OUString sBase("ExtendedColorScheme/ColorSchemes/");
     306           0 :     sBase += sScheme;
     307             : 
     308           0 :     bool bFound = ExistsScheme(sScheme);
     309           0 :     if ( bFound )
     310             :     {
     311           0 :         aComponentNames = GetPropertyNames(sBase);
     312           0 :         FillComponentColors(aComponentNames,aDisplayNameMap);
     313             :     }
     314             : 
     315           0 :     if ( m_sLoadedScheme.isEmpty() )
     316           0 :         m_sLoadedScheme = "default";
     317             : 
     318           0 :     if ( sScheme != "default" )
     319             :     {
     320           0 :         OUString sDefault("default");
     321           0 :         if ( ExistsScheme(sDefault) )
     322             :         {
     323           0 :             OUString sBaseDefault("ExtendedColorScheme/ColorSchemes/default");
     324           0 :             aComponentNames = GetPropertyNames(sBaseDefault);
     325           0 :             FillComponentColors(aComponentNames,aDisplayNameMap);
     326           0 :         }
     327             :     }
     328           0 :     if ( !bFound && !sScheme.isEmpty() )
     329             :     {
     330           0 :         AddScheme(sScheme);
     331           0 :         CommitCurrentSchemeName();
     332           0 :     }
     333           0 : }
     334             : 
     335           0 : void ExtendedColorConfig_Impl::FillComponentColors(uno::Sequence < OUString >& _rComponents,const TDisplayNames& _rDisplayNames)
     336             : {
     337           0 :     const OUString sColorEntries("/Entries");
     338           0 :     OUString* pIter = _rComponents.getArray();
     339           0 :     OUString* pEnd  = pIter + _rComponents.getLength();
     340           0 :     for(;pIter != pEnd;++pIter)
     341             :     {
     342           0 :         OUString sComponentName = pIter->copy(pIter->lastIndexOf('/')+1);
     343           0 :         if ( m_aConfigValues.find(sComponentName) == m_aConfigValues.end() )
     344             :         {
     345           0 :             OUString sEntry = *pIter;
     346           0 :             sEntry += sColorEntries;
     347             : 
     348           0 :             uno::Sequence < OUString > aColorNames = GetPropertyNames(sEntry);
     349           0 :             uno::Sequence < OUString > aDefaultColorNames = aColorNames;
     350             : 
     351           0 :             const OUString sColor("/Color");
     352           0 :             const OUString sDefaultColor("/DefaultColor");
     353           0 :             lcl_addString(aColorNames,sColor);
     354           0 :             lcl_addString(aDefaultColorNames,sDefaultColor);
     355           0 :             uno::Sequence< uno::Any > aColors = GetProperties( aColorNames );
     356           0 :             const uno::Any* pColors = aColors.getConstArray();
     357             : 
     358           0 :             uno::Sequence< uno::Any > aDefaultColors = GetProperties( aDefaultColorNames );
     359           0 :             bool bDefaultColorFound = aDefaultColors.getLength() != 0;
     360           0 :             const uno::Any* pDefaultColors = aDefaultColors.getConstArray();
     361             : 
     362           0 :             OUString* pColorIter = aColorNames.getArray();
     363           0 :             OUString* pColorEnd  = pColorIter + aColorNames.getLength();
     364             : 
     365           0 :             m_aConfigValuesPos.push_back(m_aConfigValues.insert(TComponents::value_type(sComponentName,TComponentMapping(TConfigValues(),TMapPos()))).first);
     366           0 :             TConfigValues& aConfigValues = (*m_aConfigValuesPos.rbegin())->second.first;
     367           0 :             TMapPos& aConfigValuesPos = (*m_aConfigValuesPos.rbegin())->second.second;
     368           0 :             for(int i = 0; pColorIter != pColorEnd; ++pColorIter ,++i)
     369             :             {
     370           0 :                 if ( aConfigValues.find(*pColorIter) == aConfigValues.end() )
     371             :                 {
     372           0 :                     sal_Int32 nIndex = 0;
     373           0 :                     pColorIter->getToken(2,'/',nIndex);
     374           0 :                     OUString sName(pColorIter->copy(nIndex)),sDisplayName;
     375           0 :                     OUString sTemp = sName.copy(0,sName.lastIndexOf(sColor));
     376             : 
     377           0 :                     TDisplayNames::const_iterator aFind = _rDisplayNames.find(sTemp);
     378           0 :                     nIndex = 0;
     379           0 :                     sName = sName.getToken(2,'/',nIndex);
     380             :                     OSL_ENSURE(aFind != _rDisplayNames.end(),"DisplayName is not in EntryNames config list!");
     381           0 :                     if ( aFind != _rDisplayNames.end() )
     382           0 :                         sDisplayName = aFind->second;
     383             : 
     384             :                     OSL_ENSURE(pColors[i].hasValue(),"Color config entry has NIL as color value set!");
     385             :                     OSL_ENSURE(pDefaultColors[i].hasValue(),"Color config entry has NIL as color value set!");
     386           0 :                     sal_Int32 nColor = 0,nDefaultColor = 0;
     387           0 :                     pColors[i] >>= nColor;
     388           0 :                     if ( bDefaultColorFound )
     389           0 :                         pDefaultColors[i] >>= nDefaultColor;
     390             :                     else
     391           0 :                         nDefaultColor = nColor;
     392           0 :                     ExtendedColorConfigValue aValue(sName,sDisplayName,nColor,nDefaultColor);
     393           0 :                     aConfigValuesPos.push_back(aConfigValues.insert(TConfigValues::value_type(sName,aValue)).first);
     394             :                 }
     395           0 :             } // for(int i = 0; pColorIter != pColorEnd; ++pColorIter ,++i)
     396             :         }
     397           0 :     }
     398           0 : }
     399             : 
     400           0 : void    ExtendedColorConfig_Impl::Notify( const uno::Sequence<OUString>& /*rPropertyNames*/)
     401             : {
     402             :     //loading via notification always uses the default setting
     403           0 :     Load(OUString());
     404             : 
     405           0 :     SolarMutexGuard aVclGuard;
     406             : 
     407           0 :     if(m_bLockBroadcast)
     408             :     {
     409           0 :         m_bBroadcastWhenUnlocked = true;
     410             :     }
     411             :     else
     412           0 :         Broadcast(SfxSimpleHint(SFX_HINT_COLORS_CHANGED));
     413           0 : }
     414             : 
     415           0 : void ExtendedColorConfig_Impl::Commit()
     416             : {
     417           0 :     if ( m_sLoadedScheme.isEmpty() )
     418           0 :         return;
     419           0 :     const OUString sColorEntries("Entries");
     420           0 :     const OUString sColor("/Color");
     421           0 :     OUString sBase("ExtendedColorScheme/ColorSchemes/");
     422           0 :     const OUString s_sSep("/");
     423           0 :     sBase += m_sLoadedScheme;
     424             : 
     425           0 :     TComponents::iterator aIter = m_aConfigValues.begin();
     426           0 :     TComponents::iterator aEnd = m_aConfigValues.end();
     427           0 :     for( ;aIter != aEnd;++aIter )
     428             :     {
     429           0 :         OUString sEntry = aIter->first;
     430           0 :         sEntry += sColorEntries;
     431             : 
     432           0 :         if ( ConfigItem::AddNode(sBase, aIter->first) )
     433             :         {
     434           0 :             OUString sNode = sBase;
     435           0 :             sNode += s_sSep;
     436           0 :             sNode += aIter->first;
     437             :             //ConfigItem::AddNode(sNode, sColorEntries);
     438           0 :             sNode += s_sSep;
     439           0 :             sNode += sColorEntries;
     440             : 
     441           0 :             uno::Sequence < beans::PropertyValue > aPropValues(aIter->second.first.size());
     442           0 :             beans::PropertyValue* pPropValues = aPropValues.getArray();
     443           0 :             TConfigValues::iterator aConIter = aIter->second.first.begin();
     444           0 :             TConfigValues::iterator aConEnd  = aIter->second.first.end();
     445           0 :             for (; aConIter != aConEnd; ++aConIter,++pPropValues)
     446             :             {
     447           0 :                 pPropValues->Name = sNode + s_sSep + aConIter->first;
     448           0 :                 ConfigItem::AddNode(sNode, aConIter->first);
     449           0 :                 pPropValues->Name += sColor;
     450           0 :                 pPropValues->Value <<= aConIter->second.getColor();
     451             :                 // the default color will never be changed
     452             :             }
     453           0 :             OUString s("ExtendedColorScheme/ColorSchemes");
     454           0 :             SetSetProperties(s, aPropValues);
     455             :         }
     456           0 :     }
     457             : 
     458           0 :     CommitCurrentSchemeName();
     459             : }
     460             : 
     461           0 : void ExtendedColorConfig_Impl::CommitCurrentSchemeName()
     462             : {
     463             :     //save current scheme name
     464           0 :     uno::Sequence < OUString > aCurrent(1);
     465           0 :     aCurrent.getArray()[0] = "ExtendedColorScheme/CurrentColorScheme";
     466           0 :     uno::Sequence< uno::Any > aCurrentVal(1);
     467           0 :     aCurrentVal.getArray()[0] <<= m_sLoadedScheme;
     468           0 :     PutProperties(aCurrent, aCurrentVal);
     469           0 : }
     470             : 
     471           0 : bool ExtendedColorConfig_Impl::ExistsScheme(const OUString& _sSchemeName)
     472             : {
     473           0 :     OUString sBase("ExtendedColorScheme/ColorSchemes");
     474             : 
     475           0 :     uno::Sequence < OUString > aComponentNames = GetPropertyNames(sBase);
     476           0 :     sBase += "/" + _sSchemeName;
     477           0 :     const OUString* pCompIter = aComponentNames.getConstArray();
     478           0 :     const OUString* pCompEnd  = pCompIter + aComponentNames.getLength();
     479           0 :     for(;pCompIter != pCompEnd && *pCompIter != sBase;++pCompIter)
     480             :         ;
     481           0 :     return pCompIter != pCompEnd;
     482             : }
     483             : 
     484           0 : void ExtendedColorConfig_Impl::SetColorConfigValue(const OUString& _sName, const ExtendedColorConfigValue& rValue )
     485             : {
     486           0 :     TComponents::iterator aFind = m_aConfigValues.find(_sName);
     487           0 :     if ( aFind != m_aConfigValues.end() )
     488             :     {
     489           0 :         TConfigValues::iterator aFind2 = aFind->second.first.find(rValue.getName());
     490           0 :         if ( aFind2 != aFind->second.first.end() )
     491           0 :             aFind2->second = rValue;
     492           0 :         SetModified();
     493             :     }
     494           0 : }
     495             : 
     496           0 : bool ExtendedColorConfig_Impl::AddScheme(const OUString& rScheme)
     497             : {
     498           0 :     if(ConfigItem::AddNode(OUString("ExtendedColorScheme/ColorSchemes"), rScheme))
     499             :     {
     500           0 :         m_sLoadedScheme = rScheme;
     501           0 :         Commit();
     502           0 :         return true;
     503             :     }
     504           0 :     return false;
     505             : }
     506             : 
     507           0 : bool ExtendedColorConfig_Impl::RemoveScheme(const OUString& rScheme)
     508             : {
     509           0 :     uno::Sequence< OUString > aElements(1);
     510           0 :     aElements.getArray()[0] = rScheme;
     511           0 :     return ClearNodeElements(OUString("ExtendedColorScheme/ColorSchemes"), aElements);
     512             : }
     513             : 
     514           0 : void ExtendedColorConfig_Impl::SettingsChanged()
     515             : {
     516           0 :     SolarMutexGuard aVclGuard;
     517             : 
     518           0 :     Broadcast( SfxSimpleHint( SFX_HINT_COLORS_CHANGED ) );
     519           0 : }
     520             : 
     521           0 : void ExtendedColorConfig_Impl::LockBroadcast()
     522             : {
     523           0 :     m_bLockBroadcast = true;
     524           0 : }
     525             : 
     526           0 : void ExtendedColorConfig_Impl::UnlockBroadcast()
     527             : {
     528           0 :     if ( m_bBroadcastWhenUnlocked )
     529             :     {
     530           0 :         m_bBroadcastWhenUnlocked = ExtendedColorConfig::m_pImpl != NULL;
     531           0 :         if ( m_bBroadcastWhenUnlocked )
     532             :         {
     533           0 :             if ( ExtendedColorConfig_Impl::IsEnableBroadcast() )
     534             :             {
     535           0 :                 m_bBroadcastWhenUnlocked = false;
     536           0 :                 ExtendedColorConfig::m_pImpl->Broadcast(SfxSimpleHint(SFX_HINT_COLORS_CHANGED));
     537             :             }
     538             :         }
     539             :     }
     540           0 :     m_bLockBroadcast = false;
     541           0 : }
     542             : 
     543           0 : IMPL_LINK( ExtendedColorConfig_Impl, DataChangedEventListener, VclWindowEvent*, pEvent )
     544             : {
     545           0 :     if ( pEvent->GetId() == VCLEVENT_APPLICATION_DATACHANGED )
     546             :     {
     547           0 :         DataChangedEvent* pData = (DataChangedEvent*)(pEvent->GetData());
     548           0 :         if ( (pData->GetType() == DATACHANGED_SETTINGS) &&
     549           0 :              (pData->GetFlags() & SETTINGS_STYLE) )
     550             :         {
     551           0 :             SettingsChanged();
     552           0 :             return 1L;
     553             :         } else
     554           0 :             return 0L;
     555             :     } else
     556           0 :         return 0L;
     557             : }
     558             : 
     559             : 
     560             : 
     561             : 
     562             : 
     563           0 : ExtendedColorConfig::ExtendedColorConfig()
     564             : {
     565           0 :     ::osl::MutexGuard aGuard( ColorMutex_Impl::get() );
     566           0 :     if ( !m_pImpl )
     567           0 :         m_pImpl = new ExtendedColorConfig_Impl;
     568           0 :     ++nExtendedColorRefCount_Impl;
     569           0 :     StartListening( *m_pImpl);
     570           0 : }
     571             : 
     572           0 : ExtendedColorConfig::~ExtendedColorConfig()
     573             : {
     574           0 :     ::osl::MutexGuard aGuard( ColorMutex_Impl::get() );
     575           0 :     EndListening( *m_pImpl);
     576           0 :     if(!--nExtendedColorRefCount_Impl)
     577             :     {
     578           0 :         delete m_pImpl;
     579           0 :         m_pImpl = 0;
     580           0 :     }
     581           0 : }
     582             : 
     583           0 : ExtendedColorConfigValue ExtendedColorConfig::GetColorValue(const OUString& _sComponentName,const OUString& _sName)const
     584             : {
     585           0 :     return m_pImpl->GetColorConfigValue(_sComponentName,_sName);
     586             : }
     587             : 
     588           0 : sal_Int32 ExtendedColorConfig::GetComponentCount() const
     589             : {
     590           0 :     return m_pImpl->GetComponentCount();
     591             : }
     592             : 
     593           0 : sal_Int32 ExtendedColorConfig::GetComponentColorCount(const OUString& _sName) const
     594             : {
     595           0 :     return m_pImpl->GetComponentColorCount(_sName);
     596             : }
     597             : 
     598           0 : ExtendedColorConfigValue ExtendedColorConfig::GetComponentColorConfigValue(const OUString& _sName,sal_uInt32 _nPos) const
     599             : {
     600           0 :     return m_pImpl->GetComponentColorConfigValue(_sName,_nPos);
     601             : }
     602             : 
     603           0 : OUString ExtendedColorConfig::GetComponentName(sal_uInt32 _nPos) const
     604             : {
     605           0 :     return m_pImpl->GetComponentName(_nPos);
     606             : }
     607             : 
     608           0 : OUString ExtendedColorConfig::GetComponentDisplayName(const OUString& _sComponentName) const
     609             : {
     610           0 :     return m_pImpl->GetComponentDisplayName(_sComponentName);
     611             : }
     612             : 
     613           0 : void ExtendedColorConfig::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
     614             : {
     615           0 :     SolarMutexGuard aVclGuard;
     616             : 
     617           0 :     Broadcast( rHint );
     618           0 : }
     619             : 
     620           0 : EditableExtendedColorConfig::EditableExtendedColorConfig() :
     621           0 :     m_pImpl(new ExtendedColorConfig_Impl),
     622           0 :     m_bModified(false)
     623             : {
     624           0 :     ExtendedColorConfig_Impl::LockBroadcast();
     625           0 : }
     626             : 
     627           0 : EditableExtendedColorConfig::~EditableExtendedColorConfig()
     628             : {
     629           0 :     ExtendedColorConfig_Impl::UnlockBroadcast();
     630           0 :     if(m_bModified)
     631           0 :         m_pImpl->SetModified();
     632           0 :     if(m_pImpl->IsModified())
     633           0 :         m_pImpl->Commit();
     634           0 :     delete m_pImpl;
     635           0 : }
     636             : 
     637           0 : void EditableExtendedColorConfig::DeleteScheme(const OUString& rScheme )
     638             : {
     639           0 :     m_pImpl->RemoveScheme(rScheme);
     640           0 : }
     641             : 
     642           0 : void EditableExtendedColorConfig::AddScheme(const OUString& rScheme )
     643             : {
     644           0 :     m_pImpl->AddScheme(rScheme);
     645           0 : }
     646             : 
     647           0 : bool EditableExtendedColorConfig::LoadScheme(const OUString& rScheme )
     648             : {
     649           0 :     if(m_bModified)
     650           0 :         m_pImpl->SetModified();
     651           0 :     if(m_pImpl->IsModified())
     652           0 :         m_pImpl->Commit();
     653           0 :     m_bModified = false;
     654           0 :     m_pImpl->Load(rScheme);
     655             :     //the name of the loaded scheme has to be committed separately
     656           0 :     m_pImpl->CommitCurrentSchemeName();
     657           0 :     return true;
     658             : }
     659             : 
     660             : // Changes the name of the current scheme but doesn't load it!
     661           0 : void EditableExtendedColorConfig::SetCurrentSchemeName(const OUString& rScheme)
     662             : {
     663           0 :     m_pImpl->SetCurrentSchemeName(rScheme);
     664           0 :     m_pImpl->CommitCurrentSchemeName();
     665           0 : }
     666             : 
     667           0 : void EditableExtendedColorConfig::SetColorValue(
     668             :     const OUString& _sName, const ExtendedColorConfigValue& rValue)
     669             : {
     670           0 :     m_pImpl->SetColorConfigValue(_sName, rValue);
     671           0 :     m_pImpl->ClearModified();
     672           0 :     m_bModified = true;
     673           0 : }
     674             : 
     675           0 : void EditableExtendedColorConfig::SetModified()
     676             : {
     677           0 :     m_bModified = true;
     678           0 : }
     679             : 
     680           0 : void EditableExtendedColorConfig::Commit()
     681             : {
     682           0 :     if(m_bModified)
     683           0 :         m_pImpl->SetModified();
     684           0 :     if(m_pImpl->IsModified())
     685           0 :         m_pImpl->Commit();
     686           0 :     m_bModified = false;
     687           0 : }
     688             : 
     689           0 : void EditableExtendedColorConfig::DisableBroadcast()
     690             : {
     691           0 :     ExtendedColorConfig_Impl::DisableBroadcast();
     692           0 : }
     693             : 
     694           0 : void EditableExtendedColorConfig::EnableBroadcast()
     695             : {
     696           0 :     ExtendedColorConfig_Impl::EnableBroadcast();
     697           0 : }
     698             : 
     699           0 : sal_Int32 EditableExtendedColorConfig::GetComponentCount() const
     700             : {
     701           0 :     return m_pImpl->GetComponentCount();
     702             : }
     703             : 
     704           0 : sal_Int32 EditableExtendedColorConfig::GetComponentColorCount(const OUString& _sName) const
     705             : {
     706           0 :     return m_pImpl->GetComponentColorCount(_sName);
     707             : }
     708             : 
     709           0 : ExtendedColorConfigValue EditableExtendedColorConfig::GetComponentColorConfigValue(const OUString& _sName,sal_uInt32 _nPos) const
     710             : {
     711           0 :     return m_pImpl->GetComponentColorConfigValue(_sName,_nPos);
     712             : }
     713             : 
     714           0 : OUString EditableExtendedColorConfig::GetComponentName(sal_uInt32 _nPos) const
     715             : {
     716           0 :     return m_pImpl->GetComponentName(_nPos);
     717             : }
     718        1227 : }//namespace svtools
     719             : 
     720             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10