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