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