LCOV - code coverage report
Current view: top level - vcl/source/filter - FilterConfigItem.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 64 208 30.8 %
Date: 2015-06-13 12:38:46 Functions: 9 16 56.2 %
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 <vcl/FilterConfigItem.hxx>
      21             : 
      22             : #include <unotools/configmgr.hxx>
      23             : #include <comphelper/processfactory.hxx>
      24             : #include <comphelper/string.hxx>
      25             : #include <osl/diagnose.h>
      26             : #include <com/sun/star/beans/PropertyValue.hpp>
      27             : #include <com/sun/star/configuration/theDefaultProvider.hpp>
      28             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      29             : #include <com/sun/star/util/XChangesBatch.hpp>
      30             : #include <com/sun/star/beans/XPropertySetInfo.hpp>
      31             : #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
      32             : 
      33             : using namespace ::com::sun::star::lang      ;   // XMultiServiceFactory
      34             : using namespace ::com::sun::star::beans     ;   // PropertyValue
      35             : using namespace ::com::sun::star::uno       ;   // Reference
      36             : using namespace ::com::sun::star::util      ;   // XChangesBatch
      37             : using namespace ::com::sun::star::awt       ;   // Size
      38             : using namespace ::com::sun::star::container ;
      39             : using namespace ::com::sun::star::configuration;
      40             : using namespace ::com::sun::star::task      ;   // XStatusIndicator
      41             : 
      42           0 : static bool ImpIsTreeAvailable( Reference< XMultiServiceFactory >& rXCfgProv, const OUString& rTree )
      43             : {
      44           0 :     bool bAvailable = !rTree.isEmpty();
      45           0 :     if ( bAvailable )
      46             :     {
      47             :         using comphelper::string::getTokenCount;
      48             : 
      49           0 :         sal_Int32 nTokenCount = getTokenCount(rTree, '/');
      50           0 :         sal_Int32 i = 0;
      51             : 
      52           0 :         if ( rTree[0] == '/' )
      53           0 :             ++i;
      54           0 :         if ( rTree.endsWith("/") )
      55           0 :             --nTokenCount;
      56             : 
      57           0 :         Any aAny;
      58           0 :         aAny <<= rTree.getToken(i++, '/');
      59             : 
      60             :         // creation arguments: nodepath
      61           0 :         PropertyValue aPathArgument;
      62           0 :         aPathArgument.Name = "nodepath";
      63           0 :         aPathArgument.Value = aAny;
      64             : 
      65           0 :         Sequence< Any > aArguments( 1 );
      66           0 :         aArguments[ 0 ] <<= aPathArgument;
      67             : 
      68           0 :         Reference< XInterface > xReadAccess;
      69             :         try
      70             :         {
      71           0 :             xReadAccess = rXCfgProv->createInstanceWithArguments(
      72             :                 OUString( "com.sun.star.configuration.ConfigurationAccess" ),
      73           0 :                     aArguments );
      74             :         }
      75           0 :         catch (const ::com::sun::star::uno::Exception&)
      76             :         {
      77           0 :             bAvailable = false;
      78             :         }
      79           0 :         if ( xReadAccess.is() )
      80             :         {
      81           0 :             for ( ; bAvailable && ( i < nTokenCount ); i++ )
      82             :             {
      83             :                 Reference< XHierarchicalNameAccess > xHierarchicalNameAccess
      84           0 :                     ( xReadAccess, UNO_QUERY );
      85             : 
      86           0 :                 if ( !xHierarchicalNameAccess.is() )
      87           0 :                     bAvailable = false;
      88             :                 else
      89             :                 {
      90           0 :                     OUString aNode( rTree.getToken(i, '/') );
      91           0 :                     if ( !xHierarchicalNameAccess->hasByHierarchicalName( aNode ) )
      92           0 :                         bAvailable = false;
      93             :                     else
      94             :                     {
      95           0 :                         Any a( xHierarchicalNameAccess->getByHierarchicalName( aNode ) );
      96           0 :                         bAvailable = (a >>= xReadAccess);
      97           0 :                     }
      98             :                 }
      99           0 :             }
     100           0 :         }
     101             :     }
     102           0 :     return bAvailable;
     103             : }
     104             : 
     105           0 : void FilterConfigItem::ImpInitTree( const OUString& rSubTree )
     106             : {
     107           0 :     bModified = false;
     108             : 
     109           0 :     Reference< XComponentContext > xContext( comphelper::getProcessComponentContext() );
     110             : 
     111           0 :     Reference< XMultiServiceFactory > xCfgProv = theDefaultProvider::get( xContext );
     112             : 
     113           0 :     OUString sTree = "/org.openoffice." + rSubTree;
     114           0 :     if ( ImpIsTreeAvailable(xCfgProv, sTree) )
     115             :     {
     116           0 :         Any aAny;
     117             :         // creation arguments: nodepath
     118           0 :         PropertyValue aPathArgument;
     119           0 :         aAny <<= sTree;
     120           0 :         aPathArgument.Name = "nodepath";
     121           0 :         aPathArgument.Value = aAny;
     122             : 
     123             :         // creation arguments: commit mode
     124           0 :         PropertyValue aModeArgument;
     125           0 :         bool bAsynchron = true;
     126           0 :         aAny <<= bAsynchron;
     127           0 :         aModeArgument.Name = "lazywrite";
     128           0 :         aModeArgument.Value = aAny;
     129             : 
     130           0 :         Sequence< Any > aArguments( 2 );
     131           0 :         aArguments[ 0 ] <<= aPathArgument;
     132           0 :         aArguments[ 1 ] <<= aModeArgument;
     133             : 
     134             :         try
     135             :         {
     136           0 :             xUpdatableView = xCfgProv->createInstanceWithArguments(
     137             :                 OUString( "com.sun.star.configuration.ConfigurationUpdateAccess" ),
     138           0 :                     aArguments );
     139           0 :             if ( xUpdatableView.is() )
     140           0 :                 xPropSet = Reference< XPropertySet >( xUpdatableView, UNO_QUERY );
     141             :         }
     142           0 :         catch ( ::com::sun::star::uno::Exception& )
     143             :         {
     144             :             OSL_FAIL( "FilterConfigItem::FilterConfigItem - Could not access configuration Key" );
     145           0 :         }
     146           0 :     }
     147           0 : }
     148             : 
     149           0 : FilterConfigItem::FilterConfigItem( const OUString& rSubTree )
     150             : {
     151           0 :     ImpInitTree( rSubTree );
     152           0 : }
     153             : 
     154         285 : FilterConfigItem::FilterConfigItem( ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData )
     155         285 :     : bModified(false)
     156             : {
     157         285 :     if ( pFilterData )
     158         112 :         aFilterData = *pFilterData;
     159         285 : }
     160             : 
     161           0 : FilterConfigItem::FilterConfigItem( const OUString& rSubTree,
     162           0 :     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData )
     163             : {
     164           0 :     ImpInitTree( rSubTree );
     165             : 
     166           0 :     if ( pFilterData )
     167           0 :         aFilterData = *pFilterData;
     168           0 : };
     169             : 
     170         570 : FilterConfigItem::~FilterConfigItem()
     171             : {
     172         285 :     WriteModifiedConfig();
     173         285 : }
     174             : 
     175         285 : void FilterConfigItem::WriteModifiedConfig()
     176             : {
     177         285 :     if ( xUpdatableView.is() )
     178             :     {
     179           0 :         if ( xPropSet.is() && bModified )
     180             :         {
     181           0 :             Reference< XChangesBatch > xUpdateControl( xUpdatableView, UNO_QUERY );
     182           0 :             if ( xUpdateControl.is() )
     183             :             {
     184             :                 try
     185             :                 {
     186           0 :                     xUpdateControl->commitChanges();
     187           0 :                     bModified = false;
     188             :                 }
     189           0 :                 catch ( ::com::sun::star::uno::Exception& )
     190             :                 {
     191             :                     OSL_FAIL( "FilterConfigItem::FilterConfigItem - Could not update configuration data" );
     192             :                 }
     193           0 :             }
     194             :         }
     195             :     }
     196         285 : }
     197             : 
     198         981 : bool FilterConfigItem::ImplGetPropertyValue( Any& rAny, const Reference< XPropertySet >& rXPropSet, const OUString& rString, bool bTestPropertyAvailability )
     199             : {
     200         981 :     bool bRetValue = true;
     201             : 
     202         981 :     if ( rXPropSet.is() )
     203             :     {
     204           0 :         if ( bTestPropertyAvailability )
     205             :         {
     206           0 :             bRetValue = false;
     207             :             try
     208             :             {
     209             :                 Reference< XPropertySetInfo >
     210           0 :                     aXPropSetInfo( rXPropSet->getPropertySetInfo() );
     211           0 :                 if ( aXPropSetInfo.is() )
     212           0 :                     bRetValue = aXPropSetInfo->hasPropertyByName( rString );
     213             :             }
     214           0 :             catch( ::com::sun::star::uno::Exception& )
     215             :             {
     216             : 
     217             :             }
     218             :         }
     219           0 :         if ( bRetValue )
     220             :         {
     221             :             try
     222             :             {
     223           0 :                 rAny = rXPropSet->getPropertyValue( rString );
     224           0 :                 if ( !rAny.hasValue() )
     225           0 :                     bRetValue = false;
     226             :             }
     227           0 :             catch( ::com::sun::star::uno::Exception& )
     228             :             {
     229           0 :                 bRetValue = false;
     230             :             }
     231             :         }
     232             :     }
     233             :     else
     234         981 :         bRetValue = false;
     235         981 :     return bRetValue;
     236             : }
     237             : 
     238             : // if property is available it returns a pointer,
     239             : // otherwise the result is null
     240        1042 : PropertyValue* FilterConfigItem::GetPropertyValue( Sequence< PropertyValue >& rPropSeq, const OUString& rName )
     241             : {
     242        1042 :     PropertyValue* pPropValue = NULL;
     243             : 
     244             :     sal_Int32 i, nCount;
     245        3167 :     for ( i = 0, nCount = rPropSeq.getLength(); i < nCount; i++ )
     246             :     {
     247        2186 :         if ( rPropSeq[ i ].Name == rName )
     248             :         {
     249          61 :             pPropValue = &rPropSeq[ i ];
     250          61 :             break;
     251             :         }
     252             :     }
     253        1042 :     return pPropValue;
     254             : }
     255             : 
     256             : /* if PropertySequence already includes a PropertyValue using the same name, the
     257             :     corresponding PropertyValue is replaced, otherwise the given PropertyValue
     258             :     will be appended */
     259             : 
     260        1042 : bool FilterConfigItem::WritePropertyValue( Sequence< PropertyValue >& rPropSeq, const PropertyValue& rPropValue )
     261             : {
     262        1042 :     bool bRet = false;
     263        1042 :     if ( !rPropValue.Name.isEmpty() )
     264             :     {
     265             :         sal_Int32 i, nCount;
     266        3167 :         for ( i = 0, nCount = rPropSeq.getLength(); i < nCount; i++ )
     267             :         {
     268        2186 :             if ( rPropSeq[ i ].Name == rPropValue.Name )
     269          61 :                 break;
     270             :         }
     271        1042 :         if ( i == nCount )
     272         981 :             rPropSeq.realloc( ++nCount );
     273             : 
     274        1042 :         rPropSeq[ i ] = rPropValue;
     275             : 
     276        1042 :         bRet = true;
     277             :     }
     278        1042 :     return bRet;
     279             : }
     280             : 
     281           1 : bool FilterConfigItem::ReadBool( const OUString& rKey, bool bDefault )
     282             : {
     283           1 :     Any aAny;
     284           1 :     bool bRetValue = bDefault;
     285           1 :     PropertyValue* pPropVal = GetPropertyValue( aFilterData, rKey );
     286           1 :     if ( pPropVal )
     287             :     {
     288           0 :         pPropVal->Value >>= bRetValue;
     289             :     }
     290           1 :     else if ( ImplGetPropertyValue( aAny, xPropSet, rKey, true ) )
     291             :     {
     292           0 :         aAny >>= bRetValue;
     293             :     }
     294           2 :     PropertyValue aBool;
     295           1 :     aBool.Name = rKey;
     296           1 :     aBool.Value <<= bRetValue;
     297           1 :     WritePropertyValue( aFilterData, aBool );
     298           2 :     return bRetValue;
     299             : }
     300             : 
     301        1041 : sal_Int32 FilterConfigItem::ReadInt32( const OUString& rKey, sal_Int32 nDefault )
     302             : {
     303        1041 :     Any aAny;
     304        1041 :     sal_Int32 nRetValue = nDefault;
     305        1041 :     PropertyValue* pPropVal = GetPropertyValue( aFilterData, rKey );
     306        1041 :     if ( pPropVal )
     307             :     {
     308          61 :         pPropVal->Value >>= nRetValue;
     309             :     }
     310         980 :     else if ( ImplGetPropertyValue( aAny, xPropSet, rKey, true ) )
     311             :     {
     312           0 :         aAny >>= nRetValue;
     313             :     }
     314        2082 :     PropertyValue aInt32;
     315        1041 :     aInt32.Name = rKey;
     316        1041 :     aInt32.Value <<= nRetValue;
     317        1041 :     WritePropertyValue( aFilterData, aInt32 );
     318        2082 :     return nRetValue;
     319             : }
     320             : 
     321           0 : OUString FilterConfigItem::ReadString( const OUString& rKey, const OUString& rDefault )
     322             : {
     323           0 :     Any aAny;
     324           0 :     OUString aRetValue( rDefault );
     325           0 :     PropertyValue* pPropVal = GetPropertyValue( aFilterData, rKey );
     326           0 :     if ( pPropVal )
     327             :     {
     328           0 :         pPropVal->Value >>= aRetValue;
     329             :     }
     330           0 :     else if ( ImplGetPropertyValue( aAny, xPropSet, rKey, true ) )
     331             :     {
     332           0 :         aAny >>= aRetValue;
     333             :     }
     334           0 :     PropertyValue aString;
     335           0 :     aString.Name = rKey;
     336           0 :     aString.Value <<= aRetValue;
     337           0 :     WritePropertyValue( aFilterData, aString );
     338           0 :     return aRetValue;
     339             : }
     340             : 
     341           0 : void FilterConfigItem::WriteBool( const OUString& rKey, bool bNewValue )
     342             : {
     343           0 :     PropertyValue aBool;
     344           0 :     aBool.Name = rKey;
     345           0 :     aBool.Value <<= bNewValue;
     346           0 :     WritePropertyValue( aFilterData, aBool );
     347             : 
     348           0 :     if ( xPropSet.is() )
     349             :     {
     350           0 :         Any aAny;
     351           0 :         if ( ImplGetPropertyValue( aAny, xPropSet, rKey, true ) )
     352             :         {
     353           0 :             bool bOldValue(true);
     354           0 :             if ( aAny >>= bOldValue )
     355             :             {
     356           0 :                 if ( bOldValue != bNewValue )
     357             :                 {
     358           0 :                     aAny <<= bNewValue;
     359             :                     try
     360             :                     {
     361           0 :                         xPropSet->setPropertyValue( rKey, aAny );
     362           0 :                         bModified = true;
     363             :                     }
     364           0 :                     catch ( ::com::sun::star::uno::Exception& )
     365             :                     {
     366             :                         OSL_FAIL( "FilterConfigItem::WriteBool - could not set PropertyValue" );
     367             :                     }
     368             :                 }
     369             :             }
     370           0 :         }
     371           0 :     }
     372           0 : }
     373             : 
     374           0 : void FilterConfigItem::WriteInt32( const OUString& rKey, sal_Int32 nNewValue )
     375             : {
     376           0 :     PropertyValue aInt32;
     377           0 :     aInt32.Name = rKey;
     378           0 :     aInt32.Value <<= nNewValue;
     379           0 :     WritePropertyValue( aFilterData, aInt32 );
     380             : 
     381           0 :     if ( xPropSet.is() )
     382             :     {
     383           0 :         Any aAny;
     384             : 
     385           0 :         if ( ImplGetPropertyValue( aAny, xPropSet, rKey, true ) )
     386             :         {
     387           0 :             sal_Int32 nOldValue = 0;
     388           0 :             if ( aAny >>= nOldValue )
     389             :             {
     390           0 :                 if ( nOldValue != nNewValue )
     391             :                 {
     392           0 :                     aAny <<= nNewValue;
     393             :                     try
     394             :                     {
     395           0 :                         xPropSet->setPropertyValue( rKey, aAny );
     396           0 :                         bModified = true;
     397             :                     }
     398           0 :                     catch ( ::com::sun::star::uno::Exception& )
     399             :                     {
     400             :                         OSL_FAIL( "FilterConfigItem::WriteInt32 - could not set PropertyValue" );
     401             :                     }
     402             :                 }
     403             :             }
     404           0 :         }
     405           0 :     }
     406           0 : }
     407             : 
     408             : 
     409          35 : Reference< XStatusIndicator > FilterConfigItem::GetStatusIndicator() const
     410             : {
     411          35 :     Reference< XStatusIndicator > xStatusIndicator;
     412          70 :     const OUString sStatusIndicator( "StatusIndicator" );
     413             : 
     414          35 :     sal_Int32 i, nCount = aFilterData.getLength();
     415         144 :     for ( i = 0; i < nCount; i++ )
     416             :     {
     417         109 :         if ( aFilterData[ i ].Name == sStatusIndicator )
     418             :         {
     419           0 :             aFilterData[ i ].Value >>= xStatusIndicator;
     420           0 :             break;
     421             :         }
     422             :     }
     423          70 :     return xStatusIndicator;
     424             : }
     425             : 
     426             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11