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