sdext/source/minimizer/configurationaccess.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
  21 #include "configurationaccess.hxx"
  22 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  23 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  24 #include <com/sun/star/util/XChangesBatch.hpp>
  25 #include <com/sun/star/container/XNameContainer.hpp>
  26 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  27 #include <comphelper/propertysequence.hxx>
  28 #include <comphelper/propertyvalue.hxx>
  29 #include <sal/macros.h>
  30 #include <sal/log.hxx>
  31 #include <comphelper/diagnose_ex.hxx>
  32
  33 using namespace ::com::sun::star;
  34 using namespace ::com::sun::star::uno;
  35 using namespace ::com::sun::star::beans;
  36 using namespace ::com::sun::star::container;
  37
  38 static OUString GetPathToConfigurationRoot()
  39 {
  40     return u"org.openoffice.Office.PresentationMinimizer"_ustr;
  41 }
  42
  43 void OptimizerSettings::LoadSettingsFromConfiguration( const Reference< XNameAccess >& rSettings )
  44 {
  45     if ( !rSettings.is() )
  46         return;
  47
  48     const Sequence< OUString > aElements( rSettings->getElementNames() );
  49     for ( const OUString& aPropertyName : aElements )
  50     {
  51         try
  52         {
  53             Any aValue( rSettings->getByName( aPropertyName ) );
  54             switch( TKGet( aPropertyName ) )
  55             {
  56                 case TK_Name :                      aValue >>= maName; break;
  57                 case TK_JPEGCompression :           aValue >>= mbJPEGCompression; break;
  58                 case TK_JPEGQuality :               aValue >>= mnJPEGQuality; break;
  59                 case TK_RemoveCropArea :            aValue >>= mbRemoveCropArea; break;
  60                 case TK_ImageResolution :           aValue >>= mnImageResolution; break;
  61                 case TK_EmbedLinkedGraphics :       aValue >>= mbEmbedLinkedGraphics; break;
  62                 case TK_OLEOptimization :           aValue >>= mbOLEOptimization; break;
  63                 case TK_OLEOptimizationType :       aValue >>= mnOLEOptimizationType; break;
  64                 case TK_DeleteUnusedMasterPages :   aValue >>= mbDeleteUnusedMasterPages; break;
  65                 case TK_DeleteHiddenSlides :        aValue >>= mbDeleteHiddenSlides; break;
  66                 case TK_DeleteNotesPages :          aValue >>= mbDeleteNotesPages ;break;
  67                 case TK_SaveAs :                    aValue >>= mbSaveAs; break;
  68 //                  case TK_SaveAsURL :                 aValue >>= maSaveAsURL; break;      // URL is not saved to configuration
  69 //                  case TK_FilterName :                aValue >>= maFilterName; break;     // URL is not saved to configuration
  70                 case TK_OpenNewDocument :           aValue >>= mbOpenNewDocument; break;
  71                 default: break;
  72             }
  73         }
  74         catch (const Exception&)
  75         {
  76         }
  77     }
  78 }
  79
  80 void OptimizerSettings::SaveSettingsToConfiguration( const Reference< XNameReplace >& rSettings )
  81 {
  82     if ( !rSettings.is() )
  83         return;
  84
  85     OUString pNames[] = {
  86         u"Name"_ustr,
  87         u"JPEGCompression"_ustr,
  88         u"JPEGQuality"_ustr,
  89         u"RemoveCropArea"_ustr,
  90         u"ImageResolution"_ustr,
  91         u"EmbedLinkedGraphics"_ustr,
  92         u"OLEOptimization"_ustr,
  93         u"OLEOptimizationType"_ustr,
  94         u"DeleteUnusedMasterPages"_ustr,
  95         u"DeleteHiddenSlides"_ustr,
  96         u"DeleteNotesPages"_ustr,
  97         u"SaveAs"_ustr,
  98 //          OUString("SaveAsURL"),
  99 //          OUString("FilterName"),
 100         u"OpenNewDocument"_ustr };
 101
 102     Any pValues[] = {
 103         Any( maName ),
 104         Any( mbJPEGCompression ),
 105         Any( mnJPEGQuality ),
 106         Any( mbRemoveCropArea ),
 107         Any( mnImageResolution ),
 108         Any( mbEmbedLinkedGraphics ),
 109         Any( mbOLEOptimization ),
 110         Any( mnOLEOptimizationType ),
 111         Any( mbDeleteUnusedMasterPages ),
 112         Any( mbDeleteHiddenSlides ),
 113         Any( mbDeleteNotesPages ),
 114         Any( mbSaveAs ),
 115 //          Any( maSaveAsURL ),
 116 //          Any( maFilterName ),
 117         Any( mbOpenNewDocument ) };
 118
 119     for ( int i = 0; i < int(SAL_N_ELEMENTS( pNames )); i++ )
 120     {
 121         try
 122         {
 123             rSettings->replaceByName( pNames[ i ], pValues[ i ] );
 124         }
 125         catch (const Exception&)
 126         {
 127         }
 128     }
 129 }
 130
 131 bool OptimizerSettings::operator==( const OptimizerSettings& rOptimizerSettings ) const
 132 {
 133     return ( rOptimizerSettings.mbJPEGCompression == mbJPEGCompression )
 134         && ( rOptimizerSettings.mnJPEGQuality == mnJPEGQuality )
 135         && ( rOptimizerSettings.mbRemoveCropArea == mbRemoveCropArea )
 136         && ( rOptimizerSettings.mnImageResolution == mnImageResolution )
 137         && ( rOptimizerSettings.mbEmbedLinkedGraphics == mbEmbedLinkedGraphics )
 138         && ( rOptimizerSettings.mbOLEOptimization == mbOLEOptimization )
 139         && ( rOptimizerSettings.mnOLEOptimizationType == mnOLEOptimizationType )
 140         && ( rOptimizerSettings.mbDeleteUnusedMasterPages == mbDeleteUnusedMasterPages )
 141         && ( rOptimizerSettings.mbDeleteHiddenSlides == mbDeleteHiddenSlides )
 142         && ( rOptimizerSettings.mbDeleteNotesPages == mbDeleteNotesPages );
 143 }
 144
 145 ConfigurationAccess::ConfigurationAccess( const Reference< uno::XComponentContext >& rxContext ) :
 146     mxContext( rxContext )
 147 {
 148     LoadStrings();
 149     maSettings.emplace_back( );
 150     maSettings.back().maName = "LastUsedSettings";
 151     LoadConfiguration();
 152 };
 153
 154 ConfigurationAccess::~ConfigurationAccess()
 155 {
 156 }
 157
 158 OUString ConfigurationAccess::getString( const PPPOptimizerTokenEnum eToken ) const
 159 {
 160     std::map< PPPOptimizerTokenEnum, OUString >::const_iterator aIter( maStrings.find( eToken ) );
 161     return aIter != maStrings.end() ? ((*aIter).second) : OUString();
 162 }
 163
 164 void ConfigurationAccess::LoadStrings()
 165 {
 166     try
 167     {
 168         do
 169         {
 170             Reference< XInterface > xRoot( OpenConfiguration( true ) );
 171             if ( !xRoot.is() )
 172                 break;
 173             Reference< container::XNameAccess > xSet( GetConfigurationNode( xRoot, u"Strings"_ustr ), UNO_QUERY );
 174             if ( xSet.is() )
 175             {
 176                 const Sequence< OUString > aElements( xSet->getElementNames() );
 177                 for ( const auto& rElement : aElements )
 178                 {
 179                     try
 180                     {
 181                         OUString aString, aPropertyName( rElement );
 182                         if ( xSet->getByName( aPropertyName ) >>= aString )
 183                             maStrings[ TKGet( aPropertyName ) ] = aString;
 184                     }
 185                     catch (const Exception&)
 186                     {
 187                     }
 188                 }
 189             }
 190         }
 191         while( false );
 192     }
 193     catch (const Exception&)
 194     {
 195     }
 196 }
 197
 198 void ConfigurationAccess::LoadConfiguration()
 199 {
 200     try
 201     {
 202         do
 203         {
 204             Reference< XInterface > xRoot( OpenConfiguration( true ) );
 205             if ( !xRoot.is() )
 206                 break;
 207             Reference< container::XNameAccess > xSet( GetConfigurationNode( xRoot, u"LastUsedSettings"_ustr ), UNO_QUERY );
 208             if ( xSet.is() )
 209             {
 210                 OptimizerSettings& rCurrent( maSettings.front() );
 211                 rCurrent.LoadSettingsFromConfiguration( xSet );
 212             }
 213             xSet.set( GetConfigurationNode( xRoot, u"Settings/Templates"_ustr ), UNO_QUERY );
 214             if ( xSet.is() )
 215             {
 216                 const Sequence< OUString > aElements( xSet->getElementNames() );
 217                 for ( const auto& rElement : aElements )
 218                 {
 219                     try
 220                     {
 221                         OUString aPath( "Settings/Templates/" + rElement );
 222                         Reference< container::XNameAccess > xTemplates( GetConfigurationNode( xRoot, aPath ), UNO_QUERY );
 223                         if ( xTemplates.is() )
 224                         {
 225                             maSettings.emplace_back( );
 226                             maSettings.back().LoadSettingsFromConfiguration( xTemplates );
 227                         }
 228                     }
 229                     catch (const Exception&)
 230                     {
 231                     }
 232                 }
 233             }
 234         }
 235         while( false );
 236     }
 237     catch (const Exception&)
 238     {
 239     }
 240 }
 241
 242 void ConfigurationAccess::SaveConfiguration()
 243 {
 244     try
 245     {
 246         do
 247         {
 248             Reference<util::XChangesBatch> xRoot( OpenConfiguration( false ), UNO_QUERY_THROW );
 249
 250             // storing the last used settings
 251             Reference< container::XNameReplace > xSet( GetConfigurationNode( xRoot, u"LastUsedSettings"_ustr ), UNO_QUERY_THROW );
 252             OptimizerSettings& rCurrent( maSettings.front() );
 253             rCurrent.SaveSettingsToConfiguration( xSet );
 254
 255             // updating template elements
 256             xSet.set( GetConfigurationNode( xRoot, u"Settings/Templates"_ustr ), UNO_QUERY_THROW );
 257             Reference< container::XNameContainer > xNameContainer( xSet, UNO_QUERY_THROW );
 258
 259             const Sequence< OUString > aElements( xSet->getElementNames() );
 260             for( const auto& rElement : aElements )
 261                 xNameContainer->removeByName( rElement );
 262
 263             for( std::vector<OptimizerSettings>::size_type k = 1; k < maSettings.size(); k++ )
 264             {
 265                 OptimizerSettings& rSettings( maSettings[ k ] );
 266                 OUString aElementName( "Template" + OUString::number( k ) );
 267                 Reference< lang::XSingleServiceFactory > xChildFactory ( xSet, UNO_QUERY_THROW );
 268                 Reference< container::XNameReplace > xChild( xChildFactory->createInstance(), UNO_QUERY_THROW );
 269                 xNameContainer->insertByName( aElementName, Any( xChild ) );
 270
 271                 OUString aPath( "Settings/Templates/" + aElementName );
 272                 Reference< container::XNameReplace > xTemplates( GetConfigurationNode( xRoot, aPath ), UNO_QUERY );
 273                 rSettings.SaveSettingsToConfiguration( xTemplates );
 274             }
 275             xRoot->commitChanges();
 276         }
 277         while( false );
 278     }
 279     catch (const Exception&)
 280     {
 281     }
 282 }
 283
 284 Reference< XInterface > ConfigurationAccess::OpenConfiguration( bool bReadOnly )
 285 {
 286     Reference< XInterface > xRoot;
 287     try
 288     {
 289         Reference< lang::XMultiServiceFactory > xProvider = configuration::theDefaultProvider::get( mxContext );
 290         uno::Sequence<uno::Any> aCreationArguments(comphelper::InitAnyPropertySequence(
 291         {
 292             {"nodepath",  uno::Any(GetPathToConfigurationRoot())}
 293         }));
 294         OUString sAccessService;
 295         if ( bReadOnly )
 296             sAccessService = "com.sun.star.configuration.ConfigurationAccess";
 297         else
 298             sAccessService =
 299                 "com.sun.star.configuration.ConfigurationUpdateAccess";
 300
 301         xRoot = xProvider->createInstanceWithArguments(
 302             sAccessService, aCreationArguments );
 303     }
 304     catch (const Exception&)
 305     {
 306     }
 307     return xRoot;
 308 }
 309
 310 Reference< XInterface > ConfigurationAccess::GetConfigurationNode(
 311     const Reference< XInterface >& xRoot,
 312     const OUString& sPathToNode )
 313 {
 314     Reference< XInterface > xNode;
 315     try
 316     {
 317         if ( sPathToNode.isEmpty() )
 318             xNode = xRoot;
 319         else
 320         {
 321             Reference< XHierarchicalNameAccess > xHierarchy( xRoot, UNO_QUERY );
 322             if ( xHierarchy.is() )
 323             {
 324                 xHierarchy->getByHierarchicalName( sPathToNode ) >>= xNode;
 325             }
 326         }
 327     }
 328     catch (const Exception&)
 329     {
 330         TOOLS_WARN_EXCEPTION("sdext.minimizer", "caught exception while getting configuration node "
 331                   << sPathToNode);
 332     }
 333     return xNode;
 334 }
 335
 336 css::uno::Any ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken ) const
 337 {
 338     Any aRetValue;
 339     const OptimizerSettings& rSettings( maSettings.front() );
 340     try
 341     {
 342         switch( ePropertyToken )
 343         {
 344             case TK_Name :                      aRetValue <<= rSettings.maName; break;
 345             case TK_JPEGCompression :           aRetValue <<= rSettings.mbJPEGCompression; break;
 346             case TK_JPEGQuality :               aRetValue <<= rSettings.mnJPEGQuality; break;
 347             case TK_RemoveCropArea :            aRetValue <<= rSettings.mbRemoveCropArea; break;
 348             case TK_ImageResolution :           aRetValue <<= rSettings.mnImageResolution; break;
 349             case TK_EmbedLinkedGraphics :       aRetValue <<= rSettings.mbEmbedLinkedGraphics; break;
 350             case TK_OLEOptimization :           aRetValue <<= rSettings.mbOLEOptimization; break;
 351             case TK_OLEOptimizationType :       aRetValue <<= rSettings.mnOLEOptimizationType; break;
 352             case TK_DeleteUnusedMasterPages :   aRetValue <<= rSettings.mbDeleteUnusedMasterPages; break;
 353             case TK_DeleteHiddenSlides :        aRetValue <<= rSettings.mbDeleteHiddenSlides; break;
 354             case TK_DeleteNotesPages :          aRetValue <<= rSettings.mbDeleteNotesPages; break;
 355             case TK_SaveAs :                    aRetValue <<= rSettings.mbSaveAs; break;
 356             case TK_SaveAsURL :                 aRetValue <<= rSettings.maSaveAsURL; break;
 357             case TK_FilterName :                aRetValue <<= rSettings.maFilterName; break;
 358             case TK_OpenNewDocument :           aRetValue <<= rSettings.mbOpenNewDocument; break;
 359             case TK_EstimatedFileSize :         aRetValue <<= rSettings.mnEstimatedFileSize; break;
 360             default:
 361                 break;
 362         }
 363     }
 364     catch (const Exception&)
 365     {
 366     }
 367     return aRetValue;
 368 }
 369
 370 void ConfigurationAccess::SetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const css::uno::Any& rValue )
 371 {
 372     OptimizerSettings& rSettings( maSettings.front() );
 373     try
 374     {
 375         switch( ePropertyToken )
 376         {
 377             case TK_Name :                      rValue >>= rSettings.maName; break;
 378             case TK_JPEGCompression :           rValue >>= rSettings.mbJPEGCompression; break;
 379             case TK_JPEGQuality :               rValue >>= rSettings.mnJPEGQuality; break;
 380             case TK_RemoveCropArea :            rValue >>= rSettings.mbRemoveCropArea; break;
 381             case TK_ImageResolution :           rValue >>= rSettings.mnImageResolution; break;
 382             case TK_EmbedLinkedGraphics :       rValue >>= rSettings.mbEmbedLinkedGraphics; break;
 383             case TK_OLEOptimization :           rValue >>= rSettings.mbOLEOptimization; break;
 384             case TK_OLEOptimizationType :       rValue >>= rSettings.mnOLEOptimizationType; break;
 385             case TK_DeleteUnusedMasterPages :   rValue >>= rSettings.mbDeleteUnusedMasterPages; break;
 386             case TK_DeleteHiddenSlides :        rValue >>= rSettings.mbDeleteHiddenSlides; break;
 387             case TK_DeleteNotesPages :          rValue >>= rSettings.mbDeleteNotesPages; break;
 388             case TK_CustomShowName :            rValue >>= rSettings.maCustomShowName; break;
 389             case TK_SaveAs :                    rValue >>= rSettings.mbSaveAs; break;
 390             case TK_SaveAsURL :                 rValue >>= rSettings.maSaveAsURL; break;
 391             case TK_FilterName :                rValue >>= rSettings.maFilterName; break;
 392             case TK_OpenNewDocument :           rValue >>= rSettings.mbOpenNewDocument; break;
 393             case TK_EstimatedFileSize :         rValue >>= rSettings.mnEstimatedFileSize; break;
 394             default:
 395                 break;
 396         }
 397     }
 398     catch (const Exception&)
 399     {
 400     }
 401 }
 402
 403 bool ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const bool bDefault ) const
 404 {
 405     bool bRetValue = bDefault;
 406     if ( ! ( GetConfigProperty( ePropertyToken ) >>= bRetValue ) )
 407         bRetValue = bDefault;
 408     return bRetValue;
 409 }
 410
 411 sal_Int16 ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const sal_Int16 nDefault ) const
 412 {
 413     sal_Int16 nRetValue = nDefault;
 414     if ( ! ( GetConfigProperty( ePropertyToken ) >>= nRetValue ) )
 415         nRetValue = nDefault;
 416     return nRetValue;
 417 }
 418
 419 sal_Int32 ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const sal_Int32 nDefault ) const
 420 {
 421     sal_Int32 nRetValue = nDefault;
 422     if ( ! ( GetConfigProperty( ePropertyToken ) >>= nRetValue ) )
 423         nRetValue = nDefault;
 424     return nRetValue;
 425 }
 426
 427 Sequence< PropertyValue > ConfigurationAccess::GetConfigurationSequence()
 428 {
 429     OptimizerSettings& rSettings( maSettings.front() );
 430     Sequence< PropertyValue > aRet{
 431         comphelper::makePropertyValue(u"JPEGCompression"_ustr, rSettings.mbJPEGCompression),
 432         comphelper::makePropertyValue(u"JPEGQuality"_ustr, rSettings.mnJPEGQuality),
 433         comphelper::makePropertyValue(u"RemoveCropArea"_ustr, rSettings.mbRemoveCropArea),
 434         comphelper::makePropertyValue(u"ImageResolution"_ustr, rSettings.mnImageResolution),
 435         comphelper::makePropertyValue(u"EmbedLinkedGraphics"_ustr, rSettings.mbEmbedLinkedGraphics),
 436         comphelper::makePropertyValue(u"OLEOptimization"_ustr, rSettings.mbOLEOptimization),
 437         comphelper::makePropertyValue(u"OLEOptimizationType"_ustr, rSettings.mnOLEOptimizationType),
 438         comphelper::makePropertyValue(u"DeleteUnusedMasterPages"_ustr, rSettings.mbDeleteUnusedMasterPages),
 439         comphelper::makePropertyValue(u"DeleteHiddenSlides"_ustr, rSettings.mbDeleteHiddenSlides),
 440         comphelper::makePropertyValue(u"DeleteNotesPages"_ustr, rSettings.mbDeleteNotesPages),
 441         comphelper::makePropertyValue(u"CustomShowName"_ustr, rSettings.maCustomShowName),
 442         comphelper::makePropertyValue(u"SaveAsURL"_ustr, rSettings.maSaveAsURL),
 443         comphelper::makePropertyValue(u"FilterName"_ustr, rSettings.maFilterName),
 444         comphelper::makePropertyValue(u"OpenNewDocument"_ustr, rSettings.mbOpenNewDocument),
 445         comphelper::makePropertyValue(u"EstimatedFileSize"_ustr, rSettings.mnEstimatedFileSize)
 446     };
 447     return aRet;
 448 }
 449
 450 std::vector< OptimizerSettings >::iterator ConfigurationAccess::GetOptimizerSettingsByName( const OUString& rName )
 451 {
 452     return std::find_if(maSettings.begin() + 1, maSettings.end(),
 453         [&rName](const OptimizerSettings& rSettings) { return rSettings.maName == rName; });
 454 }
 455
 456 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */