LCOV - code coverage report
Current view: top level - unotools/source/config - saveopt.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 463 0.0 %
Date: 2014-04-14 Functions: 0 86 0.0 %
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 <unotools/saveopt.hxx>
      21             : #include "rtl/instance.hxx"
      22             : #include <unotools/configmgr.hxx>
      23             : #include <unotools/configitem.hxx>
      24             : #include <tools/debug.hxx>
      25             : #include <com/sun/star/uno/Any.hxx>
      26             : #include <com/sun/star/uno/Sequence.hxx>
      27             : 
      28             : #include <osl/mutex.hxx>
      29             : #include <comphelper/processfactory.hxx>
      30             : #include "itemholder1.hxx"
      31             : #include <officecfg/Office/Recovery.hxx>
      32             : 
      33             : using namespace utl;
      34             : using namespace com::sun::star::uno;
      35             : 
      36             : class SvtSaveOptions_Impl;
      37             : class SvtLoadOptions_Impl;
      38             : 
      39             : #define CFG_READONLY_DEFAULT    false
      40             : 
      41             : struct SvtLoadSaveOptions_Impl
      42             : {
      43             :     SvtSaveOptions_Impl* pSaveOpt;
      44             :     SvtLoadOptions_Impl* pLoadOpt;
      45             : };
      46             : 
      47             : static SvtLoadSaveOptions_Impl* pOptions = NULL;
      48             : static sal_Int32           nRefCount = 0;
      49             : 
      50             : class SvtSaveOptions_Impl : public utl::ConfigItem
      51             : {
      52             :     sal_Int32                           nAutoSaveTime;
      53             :     bool                            bUseUserData,
      54             :                                         bBackup,
      55             :                                         bAutoSave,
      56             :                                         bAutoSavePrompt,
      57             :                                         bUserAutoSave,
      58             :                                         bDocInfSave,
      59             :                                         bSaveWorkingSet,
      60             :                                         bSaveDocView,
      61             :                                         bSaveRelINet,
      62             :                                         bSaveRelFSys,
      63             :                                         bSaveUnpacked,
      64             :                                         bDoPrettyPrinting,
      65             :                                         bWarnAlienFormat,
      66             :                                         bLoadDocPrinter,
      67             :                                         bUseSHA1InODF12,
      68             :                                         bUseBlowfishInODF12;
      69             : 
      70             :     SvtSaveOptions::ODFDefaultVersion   eODFDefaultVersion;
      71             : 
      72             :     bool                            bROAutoSaveTime,
      73             :                                         bROUseUserData,
      74             :                                         bROBackup,
      75             :                                         bROAutoSave,
      76             :                                         bROAutoSavePrompt,
      77             :                                         bROUserAutoSave,
      78             :                                         bRODocInfSave,
      79             :                                         bROSaveWorkingSet,
      80             :                                         bROSaveDocView,
      81             :                                         bROSaveRelINet,
      82             :                                         bROSaveRelFSys,
      83             :                                         bROSaveUnpacked,
      84             :                                         bROWarnAlienFormat,
      85             :                                         bRODoPrettyPrinting,
      86             :                                         bROLoadDocPrinter,
      87             :                                         bROODFDefaultVersion,
      88             :                                         bROUseSHA1InODF12,
      89             :                                         bROUseBlowfishInODF12;
      90             : 
      91             : public:
      92             :                             SvtSaveOptions_Impl();
      93             :                             virtual ~SvtSaveOptions_Impl();
      94             : 
      95             :     virtual void            Notify( const com::sun::star::uno::Sequence< OUString >& aPropertyNames ) SAL_OVERRIDE;
      96             :     virtual void            Commit() SAL_OVERRIDE;
      97             : 
      98           0 :     sal_Int32               GetAutoSaveTime() const             { return nAutoSaveTime; }
      99           0 :     bool                    IsUseUserData() const               { return bUseUserData; }
     100           0 :     bool                    IsBackup() const                    { return bBackup; }
     101           0 :     bool                    IsAutoSave() const                  { return bAutoSave; }
     102           0 :     bool                    IsAutoSavePrompt() const            { return bAutoSavePrompt; }
     103           0 :     bool                    IsUserAutoSave() const              { return bUserAutoSave; }
     104           0 :     bool                    IsDocInfoSave() const               { return bDocInfSave; }
     105           0 :     bool                    IsSaveWorkingSet() const            { return bSaveWorkingSet;         }
     106           0 :     bool                    IsSaveDocView() const               { return bSaveDocView; }
     107           0 :     bool                    IsSaveRelINet() const               { return bSaveRelINet; }
     108           0 :     bool                    IsSaveRelFSys() const               { return bSaveRelFSys; }
     109           0 :     bool                    IsSaveUnpacked() const              { return bSaveUnpacked; }
     110           0 :     bool                IsPrettyPrintingEnabled( ) const    { return bDoPrettyPrinting; }
     111           0 :     bool                IsWarnAlienFormat() const           { return bWarnAlienFormat; }
     112           0 :     bool                IsLoadDocPrinter() const            { return bLoadDocPrinter; }
     113           0 :     bool                IsUseSHA1InODF12() const            { return bUseSHA1InODF12; }
     114           0 :     bool                IsUseBlowfishInODF12() const        { return bUseBlowfishInODF12; }
     115             : 
     116             :     SvtSaveOptions::ODFDefaultVersion
     117           0 :                             GetODFDefaultVersion() const        { return eODFDefaultVersion; }
     118             : 
     119             :     void                    SetAutoSaveTime( sal_Int32 n );
     120             :     void                    SetUseUserData( bool b );
     121             :     void                    SetBackup( bool b );
     122             :     void                    SetAutoSave( bool b );
     123             :     void                    SetAutoSavePrompt( bool b );
     124             :     void                    SetUserAutoSave( bool b );
     125             :     void                    SetDocInfoSave( bool b );
     126             :     void                    SetSaveWorkingSet( bool b );
     127             :     void                    SetSaveDocView( bool b );
     128             :     void                    SetSaveRelINet( bool b );
     129             :     void                    SetSaveRelFSys( bool b );
     130             :     void                    EnablePrettyPrinting( bool _bDoPP );
     131             :     void                    SetWarnAlienFormat( bool _bDoPP );
     132             :     void                    SetLoadDocPrinter( bool bNew );
     133             :     void                    SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eNew );
     134             : 
     135             :     bool                IsReadOnly( SvtSaveOptions::EOption eOption ) const;
     136             : };
     137             : 
     138           0 : void SvtSaveOptions_Impl::SetAutoSaveTime( sal_Int32 n )
     139             : {
     140           0 :     if (!bROAutoSaveTime && nAutoSaveTime!=n)
     141             :     {
     142           0 :         nAutoSaveTime = n;
     143           0 :         SetModified();
     144           0 :         Commit();
     145             :     }
     146           0 : }
     147             : 
     148           0 : void SvtSaveOptions_Impl::SetUseUserData( bool b )
     149             : {
     150           0 :     if (!bROUseUserData && bUseUserData!=b)
     151             :     {
     152           0 :         bUseUserData = b;
     153           0 :         SetModified();
     154             :     }
     155           0 : }
     156             : 
     157           0 : void SvtSaveOptions_Impl::SetBackup( bool b )
     158             : {
     159           0 :     if (!bROBackup && bBackup!=b)
     160             :     {
     161           0 :         bBackup = b;
     162           0 :         SetModified();
     163             :     }
     164           0 : }
     165             : 
     166           0 : void SvtSaveOptions_Impl::SetAutoSave( bool b )
     167             : {
     168           0 :     if (!bROAutoSave && bAutoSave!=b)
     169             :     {
     170           0 :         bAutoSave = b;
     171           0 :         SetModified();
     172           0 :         Commit();
     173             :     }
     174           0 : }
     175             : 
     176           0 : void SvtSaveOptions_Impl::SetAutoSavePrompt( bool b )
     177             : {
     178           0 :     if (!bROAutoSavePrompt && bAutoSavePrompt!=b)
     179             :     {
     180           0 :         bAutoSavePrompt = b;
     181           0 :         SetModified();
     182             :     }
     183           0 : }
     184             : 
     185           0 : void SvtSaveOptions_Impl::SetUserAutoSave( bool b )
     186             : {
     187           0 :     if (!bROUserAutoSave && bUserAutoSave!=b)
     188             :     {
     189           0 :         bUserAutoSave = b;
     190           0 :         SetModified();
     191           0 :         Commit();
     192             :     }
     193           0 : }
     194             : 
     195           0 : void SvtSaveOptions_Impl::SetDocInfoSave(bool b)
     196             : {
     197           0 :     if (!bRODocInfSave && bDocInfSave!=b)
     198             :     {
     199           0 :         bDocInfSave = b;
     200           0 :         SetModified();
     201             :     }
     202           0 : }
     203             : 
     204           0 : void SvtSaveOptions_Impl::SetSaveWorkingSet( bool b )
     205             : {
     206           0 :     if (!bROSaveWorkingSet && bSaveWorkingSet!=b)
     207             :     {
     208           0 :         bSaveWorkingSet = b;
     209           0 :         SetModified();
     210             :     }
     211           0 : }
     212             : 
     213           0 : void SvtSaveOptions_Impl::SetSaveDocView( bool b )
     214             : {
     215           0 :     if (!bROSaveDocView && bSaveDocView!=b)
     216             :     {
     217           0 :         bSaveDocView = b;
     218           0 :         SetModified();
     219             :     }
     220           0 : }
     221             : 
     222           0 : void SvtSaveOptions_Impl::SetSaveRelINet( bool b )
     223             : {
     224           0 :     if (!bROSaveRelINet && bSaveRelINet!=b)
     225             :     {
     226           0 :         bSaveRelINet = b;
     227           0 :         SetModified();
     228             :     }
     229           0 : }
     230             : 
     231           0 : void SvtSaveOptions_Impl::SetSaveRelFSys( bool b )
     232             : {
     233           0 :     if (!bROSaveRelFSys && bSaveRelFSys!=b)
     234             :     {
     235           0 :         bSaveRelFSys = b;
     236           0 :         SetModified();
     237             :     }
     238           0 : }
     239             : 
     240           0 : void SvtSaveOptions_Impl::EnablePrettyPrinting( bool _bDoPP )
     241             : {
     242           0 :     if (!bRODoPrettyPrinting && bDoPrettyPrinting!=_bDoPP)
     243             :     {
     244           0 :         bDoPrettyPrinting = _bDoPP;
     245           0 :         SetModified();
     246             :     }
     247           0 : }
     248             : 
     249           0 : void SvtSaveOptions_Impl::SetWarnAlienFormat( bool _bDoPP )
     250             : {
     251           0 :     if (!bROWarnAlienFormat && bWarnAlienFormat!=_bDoPP)
     252             :     {
     253           0 :         bWarnAlienFormat = _bDoPP;
     254           0 :         SetModified();
     255             :     }
     256           0 : }
     257             : 
     258           0 : void SvtSaveOptions_Impl::SetLoadDocPrinter( bool bNew )
     259             : {
     260           0 :     if ( !bROLoadDocPrinter && bLoadDocPrinter != bNew )
     261             :     {
     262           0 :         bLoadDocPrinter = bNew;
     263           0 :         SetModified();
     264             :     }
     265           0 : }
     266             : 
     267           0 : void SvtSaveOptions_Impl::SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eNew )
     268             : {
     269           0 :     if ( !bROODFDefaultVersion && eODFDefaultVersion != eNew )
     270             :     {
     271           0 :         eODFDefaultVersion = eNew;
     272           0 :         SetModified();
     273             :     }
     274           0 : }
     275             : 
     276           0 : bool SvtSaveOptions_Impl::IsReadOnly( SvtSaveOptions::EOption eOption ) const
     277             : {
     278           0 :     bool bReadOnly = CFG_READONLY_DEFAULT;
     279           0 :     switch(eOption)
     280             :     {
     281             :         case SvtSaveOptions::E_AUTOSAVETIME :
     282           0 :             bReadOnly = bROAutoSaveTime;
     283           0 :             break;
     284             :         case SvtSaveOptions::E_USEUSERDATA :
     285           0 :             bReadOnly = bROUseUserData;
     286           0 :             break;
     287             :         case SvtSaveOptions::E_BACKUP :
     288           0 :             bReadOnly = bROBackup;
     289           0 :             break;
     290             :         case SvtSaveOptions::E_AUTOSAVE :
     291           0 :             bReadOnly = bROAutoSave;
     292           0 :             break;
     293             :         case SvtSaveOptions::E_AUTOSAVEPROMPT :
     294           0 :             bReadOnly = bROAutoSavePrompt;
     295           0 :             break;
     296             :         case SvtSaveOptions::E_USERAUTOSAVE :
     297           0 :             bReadOnly = bROUserAutoSave;
     298           0 :             break;
     299             :         case SvtSaveOptions::E_DOCINFSAVE :
     300           0 :             bReadOnly = bRODocInfSave;
     301           0 :             break;
     302             :         case SvtSaveOptions::E_SAVEWORKINGSET :
     303           0 :             bReadOnly = bROSaveWorkingSet;
     304           0 :             break;
     305             :         case SvtSaveOptions::E_SAVEDOCVIEW :
     306           0 :             bReadOnly = bROSaveDocView;
     307           0 :             break;
     308             :         case SvtSaveOptions::E_SAVERELINET :
     309           0 :             bReadOnly = bROSaveRelINet;
     310           0 :             break;
     311             :         case SvtSaveOptions::E_SAVERELFSYS :
     312           0 :             bReadOnly = bROSaveRelFSys;
     313           0 :             break;
     314             :         case SvtSaveOptions::E_SAVEUNPACKED :
     315           0 :             bReadOnly = bROSaveUnpacked;
     316           0 :             break;
     317             :         case SvtSaveOptions::E_DOPRETTYPRINTING :
     318           0 :             bReadOnly = bRODoPrettyPrinting;
     319           0 :             break;
     320             :         case SvtSaveOptions::E_WARNALIENFORMAT :
     321           0 :             bReadOnly = bROWarnAlienFormat;
     322           0 :             break;
     323             :         case SvtSaveOptions::E_LOADDOCPRINTER :
     324           0 :             bReadOnly = bROLoadDocPrinter;
     325           0 :             break;
     326             :         case SvtSaveOptions::E_ODFDEFAULTVERSION :
     327           0 :             bReadOnly = bROLoadDocPrinter;
     328           0 :             break;
     329             :         case SvtSaveOptions::E_USESHA1INODF12:
     330           0 :             bReadOnly = bROUseSHA1InODF12;
     331           0 :             break;
     332             :         case SvtSaveOptions::E_USEBLOWFISHINODF12:
     333           0 :             bReadOnly = bROUseBlowfishInODF12;
     334           0 :             break;
     335             :     }
     336           0 :     return bReadOnly;
     337             : }
     338             : 
     339             : #define FORMAT              0
     340             : #define TIMEINTERVALL       1
     341             : #define USEUSERDATA         2
     342             : #define CREATEBACKUP        3
     343             : #define AUTOSAVE            4
     344             : #define PROMPT              5
     345             : #define EDITPROPERTY        6
     346             : #define SAVEVIEWINFO        7
     347             : #define UNPACKED            8
     348             : #define PRETTYPRINTING      9
     349             : #define WARNALIENFORMAT     10
     350             : #define LOADDOCPRINTER      11
     351             : #define FILESYSTEM          12
     352             : #define INTERNET            13
     353             : #define SAVEWORKINGSET      14
     354             : #define ODFDEFAULTVERSION   15
     355             : #define USESHA1INODF12      16
     356             : #define USEBLOWFISHINODF12  17
     357             : 
     358           0 : Sequence< OUString > GetPropertyNames()
     359             : {
     360             :     static const char* aPropNames[] =
     361             :     {
     362             :         "Graphic/Format",
     363             :         "Document/AutoSaveTimeIntervall",
     364             :         "Document/UseUserData",
     365             :         "Document/CreateBackup",
     366             :         "Document/AutoSave",
     367             :         "Document/AutoSavePrompt",
     368             :         "Document/EditProperty",
     369             :         "Document/ViewInfo",
     370             :         "Document/Unpacked",
     371             :         "Document/PrettyPrinting",
     372             :         "Document/WarnAlienFormat",
     373             :         "Document/LoadPrinter",
     374             :         "URL/FileSystem",
     375             :         "URL/Internet",
     376             :         "WorkingSet",
     377             :         "ODF/DefaultVersion",
     378             :         "ODF/UseSHA1InODF12",
     379             :         "ODF/UseBlowfishInODF12"
     380             :     };
     381             : 
     382           0 :     const int nCount = sizeof( aPropNames ) / sizeof( const char* );
     383           0 :     Sequence< OUString > aNames( nCount );
     384           0 :     OUString* pNames = aNames.getArray();
     385           0 :     for ( int i = 0; i < nCount; i++ )
     386           0 :         pNames[i] = OUString::createFromAscii( aPropNames[i] );
     387             : 
     388           0 :     return aNames;
     389             : }
     390             : 
     391           0 : SvtSaveOptions_Impl::SvtSaveOptions_Impl()
     392             :     : ConfigItem( OUString("Office.Common/Save") )
     393             :     , nAutoSaveTime( 0 )
     394             :     , bUseUserData( false )
     395             :     , bBackup( false )
     396             :     , bAutoSave( false )
     397             :     , bAutoSavePrompt( false )
     398             :     , bUserAutoSave( false )
     399             :     , bDocInfSave( false )
     400             :     , bSaveWorkingSet( false )
     401             :     , bSaveDocView( false )
     402             :     , bSaveRelINet( false )
     403             :     , bSaveRelFSys( false )
     404             :     , bSaveUnpacked( false )
     405             :     , bDoPrettyPrinting( false )
     406             :     , bWarnAlienFormat( true )
     407             :     , bLoadDocPrinter( true )
     408             :     , bUseSHA1InODF12( false )
     409             :     , bUseBlowfishInODF12( false )
     410             :     , eODFDefaultVersion( SvtSaveOptions::ODFVER_LATEST )
     411             :     , bROAutoSaveTime( CFG_READONLY_DEFAULT )
     412             :     , bROUseUserData( CFG_READONLY_DEFAULT )
     413             :     , bROBackup( CFG_READONLY_DEFAULT )
     414             :     , bROAutoSave( CFG_READONLY_DEFAULT )
     415             :     , bROAutoSavePrompt( CFG_READONLY_DEFAULT )
     416             :     , bROUserAutoSave( CFG_READONLY_DEFAULT )
     417             :     , bRODocInfSave( CFG_READONLY_DEFAULT )
     418             :     , bROSaveWorkingSet( CFG_READONLY_DEFAULT )
     419             :     , bROSaveDocView( CFG_READONLY_DEFAULT )
     420             :     , bROSaveRelINet( CFG_READONLY_DEFAULT )
     421             :     , bROSaveRelFSys( CFG_READONLY_DEFAULT )
     422             :     , bROSaveUnpacked( CFG_READONLY_DEFAULT )
     423             :     , bROWarnAlienFormat( CFG_READONLY_DEFAULT )
     424             :     , bRODoPrettyPrinting( CFG_READONLY_DEFAULT )
     425             :     , bROLoadDocPrinter( CFG_READONLY_DEFAULT )
     426             :     , bROODFDefaultVersion( CFG_READONLY_DEFAULT )
     427             :     , bROUseSHA1InODF12( CFG_READONLY_DEFAULT )
     428           0 :     , bROUseBlowfishInODF12( CFG_READONLY_DEFAULT )
     429             : {
     430           0 :     Sequence< OUString > aNames = GetPropertyNames();
     431           0 :     Sequence< Any > aValues = GetProperties( aNames );
     432           0 :     Sequence< sal_Bool > aROStates = GetReadOnlyStates( aNames );
     433           0 :     EnableNotification( aNames );
     434           0 :     const Any* pValues = aValues.getConstArray();
     435           0 :     const sal_Bool* pROStates = aROStates.getConstArray();
     436             :     DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
     437             :     DBG_ASSERT( aROStates.getLength() == aNames.getLength(), "GetReadOnlyStates failed" );
     438           0 :     if ( aValues.getLength() == aNames.getLength() && aROStates.getLength() == aNames.getLength() )
     439             :     {
     440           0 :         for ( int nProp = 0; nProp < aNames.getLength(); nProp++ )
     441             :         {
     442           0 :             if ( pValues[nProp].hasValue() )
     443             :             {
     444           0 :                 sal_Int32 nTemp = 0;
     445           0 :                 switch ( nProp )
     446             :                 {
     447             :                     case FORMAT:
     448             :                         // not supported anymore
     449           0 :                         break;
     450             : 
     451             :                     case TIMEINTERVALL :
     452           0 :                         if ( pValues[nProp] >>= nTemp )
     453           0 :                             nAutoSaveTime = nTemp;
     454             :                         else {
     455             :                             OSL_FAIL( "Wrong Type!" );
     456             :                         };
     457           0 :                         bROAutoSaveTime = pROStates[nProp];
     458           0 :                         break;
     459             : 
     460             :                     case ODFDEFAULTVERSION :
     461             :                     {
     462           0 :                         sal_Int16 nTmp = 0;
     463           0 :                         if ( pValues[nProp] >>= nTmp )
     464             :                         {
     465           0 :                             if( nTmp == 3 )
     466           0 :                                 eODFDefaultVersion = SvtSaveOptions::ODFVER_LATEST;
     467             :                             else
     468           0 :                                 eODFDefaultVersion = SvtSaveOptions::ODFDefaultVersion( nTmp );
     469             :                         }
     470             :                         else {
     471             :                             SAL_WARN( "unotools.config", "SvtSaveOptions_Impl::SvtSaveOptions_Impl(): Wrong Type!" );
     472             :                         };
     473           0 :                         bROODFDefaultVersion = pROStates[nProp];
     474           0 :                         break;
     475             :                     }
     476             : 
     477             :                     default:
     478             :                     {
     479           0 :                         bool bTemp = bool();
     480           0 :                         if ( pValues[nProp] >>= bTemp )
     481             :                         {
     482           0 :                             switch ( nProp )
     483             :                             {
     484             :                                 case USEUSERDATA :
     485           0 :                                     bUseUserData = bTemp;
     486           0 :                                     bROUseUserData = pROStates[nProp];
     487           0 :                                     break;
     488             :                                 case CREATEBACKUP :
     489           0 :                                     bBackup = bTemp;
     490           0 :                                     bROBackup = pROStates[nProp];
     491           0 :                                     break;
     492             :                                 case AUTOSAVE :
     493           0 :                                     bAutoSave = bTemp;
     494           0 :                                     bROAutoSave = pROStates[nProp];
     495           0 :                                     break;
     496             :                                 case PROMPT :
     497           0 :                                     bAutoSavePrompt = bTemp;
     498           0 :                                     bROAutoSavePrompt = pROStates[nProp];
     499           0 :                                     break;
     500             :                                 case EDITPROPERTY :
     501           0 :                                     bDocInfSave = bTemp;
     502           0 :                                     bRODocInfSave = pROStates[nProp];
     503           0 :                                     break;
     504             :                                 case SAVEWORKINGSET :
     505           0 :                                     bSaveWorkingSet = bTemp;
     506           0 :                                     bROSaveWorkingSet = pROStates[nProp];
     507           0 :                                     break;
     508             :                                 case SAVEVIEWINFO :
     509           0 :                                     bSaveDocView = bTemp;
     510           0 :                                     bROSaveDocView = pROStates[nProp];
     511           0 :                                     break;
     512             :                                 case FILESYSTEM :
     513           0 :                                     bSaveRelFSys = bTemp;
     514           0 :                                     bROSaveRelFSys = pROStates[nProp];
     515           0 :                                     break;
     516             :                                 case INTERNET :
     517           0 :                                     bSaveRelINet = bTemp;
     518           0 :                                     bROSaveRelINet = pROStates[nProp];
     519           0 :                                     break;
     520             :                                 case UNPACKED :
     521           0 :                                     bSaveUnpacked = bTemp;
     522           0 :                                     bROSaveUnpacked = pROStates[nProp];
     523           0 :                                     break;
     524             : 
     525             :                                 case PRETTYPRINTING:
     526           0 :                                     bDoPrettyPrinting = bTemp;
     527           0 :                                     bRODoPrettyPrinting = pROStates[nProp];
     528           0 :                                     break;
     529             : 
     530             :                                 case WARNALIENFORMAT:
     531           0 :                                     bWarnAlienFormat = bTemp;
     532           0 :                                     bROWarnAlienFormat = pROStates[nProp];
     533           0 :                                     break;
     534             : 
     535             :                                 case LOADDOCPRINTER:
     536           0 :                                     bLoadDocPrinter = bTemp;
     537           0 :                                     bROLoadDocPrinter = pROStates[nProp];
     538           0 :                                     break;
     539             : 
     540             :                                 case USESHA1INODF12:
     541           0 :                                     bUseSHA1InODF12 = bTemp;
     542           0 :                                     bROUseSHA1InODF12 = pROStates[nProp];
     543           0 :                                     break;
     544             : 
     545             :                                 case USEBLOWFISHINODF12:
     546           0 :                                     bUseBlowfishInODF12 = bTemp;
     547           0 :                                     bROUseBlowfishInODF12 = pROStates[nProp];
     548           0 :                                     break;
     549             : 
     550             :                                 default :
     551             :                                     SAL_WARN( "unotools.config", "invalid index to load a path" );
     552             :                             }
     553             :                         }
     554             :                         else
     555             :                         {
     556             :                             OSL_FAIL( "Wrong Type!" );
     557             :                         }
     558             :                     }
     559             :                 }
     560             :             }
     561             :         }
     562             :     }
     563             : 
     564           0 :     bAutoSave = officecfg::Office::Recovery::AutoSave::Enabled::get();
     565           0 :     nAutoSaveTime = officecfg::Office::Recovery::AutoSave::TimeIntervall::get();
     566           0 :     bUserAutoSave = officecfg::Office::Recovery::AutoSave::UserAutoSaveEnabled::get();
     567           0 : }
     568             : 
     569           0 : SvtSaveOptions_Impl::~SvtSaveOptions_Impl()
     570           0 : {}
     571             : 
     572           0 : void SvtSaveOptions_Impl::Commit()
     573             : {
     574           0 :     Sequence< OUString > aOrgNames = GetPropertyNames();
     575           0 :     OUString* pOrgNames = aOrgNames.getArray();
     576           0 :     sal_Int32 nOrgCount = aOrgNames.getLength();
     577             : 
     578           0 :     Sequence< OUString > aNames( nOrgCount );
     579           0 :     Sequence< Any > aValues( nOrgCount );
     580           0 :     OUString* pNames = aNames.getArray();
     581           0 :     Any* pValues = aValues.getArray();
     582           0 :     sal_Int32 nRealCount = 0;
     583             : 
     584           0 :     for (sal_Int32 i=0; i<nOrgCount; ++i)
     585             :     {
     586           0 :         switch (i)
     587             :         {
     588             :             case FORMAT:
     589             :                 // not supported anymore
     590           0 :                 break;
     591             :             case TIMEINTERVALL :
     592           0 :                 if (!bROAutoSaveTime)
     593             :                 {
     594           0 :                     pValues[nRealCount] <<= nAutoSaveTime;
     595           0 :                     pNames[nRealCount] = pOrgNames[i];
     596           0 :                     ++nRealCount;
     597             :                 }
     598           0 :                 break;
     599             :             case USEUSERDATA :
     600           0 :                 if (!bROUseUserData)
     601             :                 {
     602           0 :                     pValues[nRealCount] <<= bUseUserData;
     603           0 :                     pNames[nRealCount] = pOrgNames[i];
     604           0 :                     ++nRealCount;
     605             :                 }
     606           0 :                 break;
     607             :             case CREATEBACKUP :
     608           0 :                 if (!bROBackup)
     609             :                 {
     610           0 :                     pValues[nRealCount] <<= bBackup;
     611           0 :                     pNames[nRealCount] = pOrgNames[i];
     612           0 :                     ++nRealCount;
     613             :                 }
     614           0 :                 break;
     615             :             case AUTOSAVE :
     616           0 :                 if (!bROAutoSave)
     617             :                 {
     618           0 :                     pValues[nRealCount] <<= bAutoSave;
     619           0 :                     pNames[nRealCount] = pOrgNames[i];
     620           0 :                     ++nRealCount;
     621             :                 }
     622           0 :                 break;
     623             :             case PROMPT :
     624           0 :                 if (!bROAutoSavePrompt)
     625             :                 {
     626           0 :                     pValues[nRealCount] <<= bAutoSavePrompt;
     627           0 :                     pNames[nRealCount] = pOrgNames[i];
     628           0 :                     ++nRealCount;
     629             :                 }
     630           0 :                 break;
     631             :             case EDITPROPERTY :
     632           0 :                 if (!bRODocInfSave)
     633             :                 {
     634           0 :                     pValues[nRealCount] <<= bDocInfSave;
     635           0 :                     pNames[nRealCount] = pOrgNames[i];
     636           0 :                     ++nRealCount;
     637             :                 }
     638           0 :                 break;
     639             :             case SAVEWORKINGSET :
     640           0 :                 if (!bROSaveWorkingSet)
     641             :                 {
     642           0 :                     pValues[nRealCount] <<= bSaveWorkingSet;
     643           0 :                     pNames[nRealCount] = pOrgNames[i];
     644           0 :                     ++nRealCount;
     645             :                 }
     646           0 :                 break;
     647             :             case SAVEVIEWINFO :
     648           0 :                 if (!bROSaveDocView)
     649             :                 {
     650           0 :                     pValues[nRealCount] <<= bSaveDocView;
     651           0 :                     pNames[nRealCount] = pOrgNames[i];
     652           0 :                     ++nRealCount;
     653             :                 }
     654           0 :                 break;
     655             :             case FILESYSTEM :
     656           0 :                 if (!bROSaveRelFSys)
     657             :                 {
     658           0 :                     pValues[nRealCount] <<= bSaveRelFSys;
     659           0 :                     pNames[nRealCount] = pOrgNames[i];
     660           0 :                     ++nRealCount;
     661             :                 }
     662           0 :                 break;
     663             :             case INTERNET :
     664           0 :                 if (!bROSaveRelINet)
     665             :                 {
     666           0 :                     pValues[nRealCount] <<= bSaveRelINet;
     667           0 :                     pNames[nRealCount] = pOrgNames[i];
     668           0 :                     ++nRealCount;
     669             :                 }
     670           0 :                 break;
     671             :             case UNPACKED :
     672           0 :                 if (!bROSaveUnpacked)
     673             :                 {
     674           0 :                     pValues[nRealCount] <<= bSaveUnpacked;
     675           0 :                     pNames[nRealCount] = pOrgNames[i];
     676           0 :                     ++nRealCount;
     677             :                 }
     678           0 :                 break;
     679             :             case PRETTYPRINTING:
     680           0 :                 if (!bRODoPrettyPrinting)
     681             :                 {
     682           0 :                     pValues[nRealCount] <<= bDoPrettyPrinting;
     683           0 :                     pNames[nRealCount] = pOrgNames[i];
     684           0 :                     ++nRealCount;
     685             :                 }
     686           0 :                 break;
     687             :             case WARNALIENFORMAT:
     688           0 :                 if (!bROWarnAlienFormat)
     689             :                 {
     690           0 :                     pValues[nRealCount] <<= bWarnAlienFormat;
     691           0 :                     pNames[nRealCount] = pOrgNames[i];
     692           0 :                     ++nRealCount;
     693             :                 }
     694           0 :                 break;
     695             :             case LOADDOCPRINTER:
     696           0 :                 if (!bROLoadDocPrinter)
     697             :                 {
     698           0 :                     pValues[nRealCount] <<= bLoadDocPrinter;
     699           0 :                     pNames[nRealCount] = pOrgNames[i];
     700           0 :                     ++nRealCount;
     701             :                 }
     702           0 :                 break;
     703             :             case ODFDEFAULTVERSION:
     704           0 :                 if (!bROODFDefaultVersion)
     705             :                 {
     706           0 :                     pValues[nRealCount] <<= (eODFDefaultVersion == SvtSaveOptions::ODFVER_LATEST) ? sal_Int16( 3 ) : sal_Int16( eODFDefaultVersion );
     707           0 :                     pNames[nRealCount] = pOrgNames[i];
     708           0 :                     ++nRealCount;
     709             :                 }
     710           0 :                 break;
     711             :             case USESHA1INODF12:
     712           0 :                 if (!bROUseSHA1InODF12)
     713             :                 {
     714           0 :                     pValues[nRealCount] <<= bUseSHA1InODF12;
     715           0 :                     pNames[nRealCount] = pOrgNames[i];
     716           0 :                     ++nRealCount;
     717             :                 }
     718           0 :                 break;
     719             :             case USEBLOWFISHINODF12:
     720           0 :                 if (!bROUseBlowfishInODF12)
     721             :                 {
     722           0 :                     pValues[nRealCount] <<= bUseBlowfishInODF12;
     723           0 :                     pNames[nRealCount] = pOrgNames[i];
     724           0 :                     ++nRealCount;
     725             :                 }
     726           0 :                 break;
     727             : 
     728             :             default:
     729             :                 SAL_WARN( "unotools.config", "invalid index to save a path" );
     730             :         }
     731             :     }
     732             : 
     733           0 :     aNames.realloc(nRealCount);
     734           0 :     aValues.realloc(nRealCount);
     735           0 :     PutProperties( aNames, aValues );
     736             : 
     737             :     boost::shared_ptr< comphelper::ConfigurationChanges > batch(
     738           0 :     comphelper::ConfigurationChanges::create());
     739           0 :     officecfg::Office::Recovery::AutoSave::TimeIntervall::set(nAutoSaveTime, batch);
     740           0 :     officecfg::Office::Recovery::AutoSave::Enabled::set(bAutoSave, batch);
     741           0 :     officecfg::Office::Recovery::AutoSave::UserAutoSaveEnabled::set(bUserAutoSave, batch);
     742           0 :     batch->commit();
     743           0 : }
     744             : 
     745           0 : void SvtSaveOptions_Impl::Notify( const Sequence<OUString>& )
     746             : {
     747           0 : }
     748             : 
     749             : class SvtLoadOptions_Impl : public utl::ConfigItem
     750             : {
     751             : 
     752             :     bool                            bLoadUserDefinedSettings;
     753             : 
     754             : public:
     755             :                             SvtLoadOptions_Impl();
     756             :                             virtual ~SvtLoadOptions_Impl();
     757             : 
     758             :     virtual void            Notify( const com::sun::star::uno::Sequence< OUString >& aPropertyNames ) SAL_OVERRIDE;
     759             :     virtual void            Commit() SAL_OVERRIDE;
     760             : 
     761           0 :     void                    SetLoadUserSettings(bool b){bLoadUserDefinedSettings = b; SetModified();}
     762           0 :     bool                IsLoadUserSettings() const {return bLoadUserDefinedSettings;}
     763             : };
     764             : 
     765             : const sal_Char cUserDefinedSettings[] = "UserDefinedSettings";
     766             : 
     767           0 : SvtLoadOptions_Impl::SvtLoadOptions_Impl()
     768             :     : ConfigItem( OUString("Office.Common/Load") )
     769           0 :     , bLoadUserDefinedSettings( false )
     770             : {
     771           0 :     Sequence< OUString > aNames(1);
     772           0 :     aNames[0] = OUString::createFromAscii(cUserDefinedSettings);
     773           0 :     Sequence< Any > aValues = GetProperties( aNames );
     774           0 :     EnableNotification( aNames );
     775           0 :     const Any* pValues = aValues.getConstArray();
     776             :     DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
     777           0 :     if (pValues[0].getValueTypeClass() == ::com::sun::star::uno::TypeClass_BOOLEAN)
     778           0 :          bLoadUserDefinedSettings = *(sal_Bool *)pValues[0].getValue();
     779           0 : }
     780             : 
     781           0 : SvtLoadOptions_Impl::~SvtLoadOptions_Impl()
     782             : {
     783           0 : }
     784             : 
     785           0 : void SvtLoadOptions_Impl::Commit()
     786             : {
     787           0 :     Sequence< OUString > aNames(1);
     788           0 :     aNames[0] = OUString::createFromAscii(cUserDefinedSettings);
     789           0 :     Sequence< Any > aValues( 1 );
     790           0 :     aValues[0].setValue(&bLoadUserDefinedSettings, ::getBooleanCppuType());
     791           0 :     PutProperties( aNames, aValues );
     792           0 : }
     793             : 
     794           0 : void SvtLoadOptions_Impl::Notify( const Sequence<OUString>& )
     795             : {
     796             :     SAL_WARN( "unotools.config", "properties have been changed" );
     797           0 : }
     798             : 
     799             : namespace
     800             : {
     801             :     class LocalSingleton : public rtl::Static< osl::Mutex, LocalSingleton >
     802             :     {
     803             :     };
     804             : }
     805             : 
     806           0 : SvtSaveOptions::SvtSaveOptions()
     807             : {
     808             :     // Global access, must be guarded (multithreading)
     809           0 :     ::osl::MutexGuard aGuard( LocalSingleton::get() );
     810           0 :     if ( !pOptions )
     811             :     {
     812           0 :         pOptions = new SvtLoadSaveOptions_Impl;
     813           0 :         pOptions->pSaveOpt = new SvtSaveOptions_Impl;
     814           0 :         pOptions->pLoadOpt = new SvtLoadOptions_Impl;
     815             : 
     816           0 :         ItemHolder1::holdConfigItem(E_SAVEOPTIONS);
     817             :    }
     818           0 :    ++nRefCount;
     819           0 :     pImp = pOptions;
     820           0 : }
     821             : 
     822           0 : SvtSaveOptions::~SvtSaveOptions()
     823             : {
     824             :     // Global access, must be guarded (multithreading)
     825           0 :     ::osl::MutexGuard aGuard( LocalSingleton::get() );
     826           0 :     if ( !--nRefCount )
     827             :     {
     828           0 :         if ( pOptions->pSaveOpt->IsModified() )
     829           0 :             pOptions->pSaveOpt->Commit();
     830           0 :         if ( pOptions->pLoadOpt->IsModified() )
     831           0 :             pOptions->pLoadOpt->Commit();
     832             : 
     833           0 :         DELETEZ( pOptions->pLoadOpt );
     834           0 :         DELETEZ( pOptions->pSaveOpt );
     835           0 :         DELETEZ( pOptions );
     836           0 :     }
     837           0 : }
     838             : 
     839           0 : void SvtSaveOptions::SetAutoSaveTime( sal_Int32 n )
     840             : {
     841           0 :     pImp->pSaveOpt->SetAutoSaveTime( n );
     842           0 : }
     843             : 
     844           0 : sal_Int32 SvtSaveOptions::GetAutoSaveTime() const
     845             : {
     846           0 :     return pImp->pSaveOpt->GetAutoSaveTime();
     847             : }
     848             : 
     849           0 : void SvtSaveOptions::SetUseUserData( bool b )
     850             : {
     851           0 :     pImp->pSaveOpt->SetUseUserData( b );
     852           0 : }
     853             : 
     854           0 : bool SvtSaveOptions::IsUseUserData() const
     855             : {
     856           0 :     return pImp->pSaveOpt->IsUseUserData();
     857             : }
     858             : 
     859           0 : void SvtSaveOptions::SetBackup( bool b )
     860             : {
     861           0 :     pImp->pSaveOpt->SetBackup( b );
     862           0 : }
     863             : 
     864           0 : bool SvtSaveOptions::IsBackup() const
     865             : {
     866           0 :     return pImp->pSaveOpt->IsBackup();
     867             : }
     868             : 
     869           0 : void SvtSaveOptions::SetAutoSave( bool b )
     870             : {
     871           0 :     pImp->pSaveOpt->SetAutoSave( b );
     872           0 : }
     873             : 
     874           0 : bool SvtSaveOptions::IsAutoSave() const
     875             : {
     876           0 :     return pImp->pSaveOpt->IsAutoSave();
     877             : }
     878             : 
     879           0 : void SvtSaveOptions::SetAutoSavePrompt( bool b )
     880             : {
     881           0 :     pImp->pSaveOpt->SetAutoSavePrompt( b );
     882           0 : }
     883             : 
     884           0 : bool SvtSaveOptions::IsAutoSavePrompt() const
     885             : {
     886           0 :     return pImp->pSaveOpt->IsAutoSavePrompt();
     887             : }
     888             : 
     889           0 : void SvtSaveOptions::SetUserAutoSave( bool b )
     890             : {
     891           0 :     pImp->pSaveOpt->SetUserAutoSave( b );
     892           0 : }
     893             : 
     894           0 : bool SvtSaveOptions::IsUserAutoSave() const
     895             : {
     896           0 :     return pImp->pSaveOpt->IsUserAutoSave();
     897             : }
     898             : 
     899           0 : void SvtSaveOptions::SetDocInfoSave(bool b)
     900             : {
     901           0 :     pImp->pSaveOpt->SetDocInfoSave( b );
     902           0 : }
     903             : 
     904           0 : bool SvtSaveOptions::IsDocInfoSave() const
     905             : {
     906           0 :     return pImp->pSaveOpt->IsDocInfoSave();
     907             : }
     908             : 
     909           0 : void SvtSaveOptions::SetSaveWorkingSet( bool b )
     910             : {
     911           0 :     pImp->pSaveOpt->SetSaveWorkingSet( b );
     912           0 : }
     913             : 
     914           0 : bool SvtSaveOptions::IsSaveWorkingSet() const
     915             : {
     916           0 :     return pImp->pSaveOpt->IsSaveWorkingSet();
     917             : }
     918             : 
     919           0 : void SvtSaveOptions::SetSaveDocView( bool b )
     920             : {
     921           0 :     pImp->pSaveOpt->SetSaveDocView( b );
     922           0 : }
     923             : 
     924           0 : bool SvtSaveOptions::IsSaveDocView() const
     925             : {
     926           0 :     return pImp->pSaveOpt->IsSaveDocView();
     927             : }
     928             : 
     929           0 : void SvtSaveOptions::SetSaveRelINet( bool b )
     930             : {
     931           0 :     pImp->pSaveOpt->SetSaveRelINet( b );
     932           0 : }
     933             : 
     934           0 : bool SvtSaveOptions::IsSaveRelINet() const
     935             : {
     936           0 :     return pImp->pSaveOpt->IsSaveRelINet();
     937             : }
     938             : 
     939           0 : void SvtSaveOptions::SetSaveRelFSys( bool b )
     940             : {
     941           0 :     pImp->pSaveOpt->SetSaveRelFSys( b );
     942           0 : }
     943             : 
     944           0 : bool SvtSaveOptions::IsSaveRelFSys() const
     945             : {
     946           0 :     return pImp->pSaveOpt->IsSaveRelFSys();
     947             : }
     948             : 
     949           0 : bool SvtSaveOptions::IsSaveUnpacked() const
     950             : {
     951           0 :     return pImp->pSaveOpt->IsSaveUnpacked();
     952             : }
     953             : 
     954           0 : void SvtSaveOptions::SetLoadUserSettings(bool b)
     955             : {
     956           0 :     pImp->pLoadOpt->SetLoadUserSettings(b);
     957           0 : }
     958             : 
     959           0 : bool   SvtSaveOptions::IsLoadUserSettings() const
     960             : {
     961           0 :     return pImp->pLoadOpt->IsLoadUserSettings();
     962             : }
     963             : 
     964           0 : void SvtSaveOptions::SetPrettyPrinting( bool _bEnable )
     965             : {
     966           0 :     pImp->pSaveOpt->EnablePrettyPrinting( _bEnable );
     967           0 : }
     968             : 
     969           0 : bool SvtSaveOptions::IsPrettyPrinting() const
     970             : {
     971           0 :     return pImp->pSaveOpt->IsPrettyPrintingEnabled();
     972             : }
     973             : 
     974           0 : void SvtSaveOptions::SetWarnAlienFormat( bool _bEnable )
     975             : {
     976           0 :     pImp->pSaveOpt->SetWarnAlienFormat( _bEnable );
     977           0 : }
     978             : 
     979           0 : bool SvtSaveOptions::IsWarnAlienFormat() const
     980             : {
     981           0 :     return pImp->pSaveOpt->IsWarnAlienFormat();
     982             : }
     983             : 
     984           0 : void SvtSaveOptions::SetLoadDocumentPrinter( bool _bEnable )
     985             : {
     986           0 :     pImp->pSaveOpt->SetLoadDocPrinter( _bEnable );
     987           0 : }
     988             : 
     989           0 : bool SvtSaveOptions::IsLoadDocumentPrinter() const
     990             : {
     991           0 :     return pImp->pSaveOpt->IsLoadDocPrinter();
     992             : }
     993             : 
     994           0 : void SvtSaveOptions::SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eVersion )
     995             : {
     996           0 :     pImp->pSaveOpt->SetODFDefaultVersion( eVersion );
     997           0 : }
     998             : 
     999           0 : SvtSaveOptions::ODFDefaultVersion SvtSaveOptions::GetODFDefaultVersion() const
    1000             : {
    1001           0 :     return pImp->pSaveOpt->GetODFDefaultVersion();
    1002             : }
    1003             : 
    1004           0 : bool SvtSaveOptions::IsUseSHA1InODF12() const
    1005             : {
    1006           0 :     return pImp->pSaveOpt->IsUseSHA1InODF12();
    1007             : }
    1008             : 
    1009           0 : bool SvtSaveOptions::IsUseBlowfishInODF12() const
    1010             : {
    1011           0 :     return pImp->pSaveOpt->IsUseBlowfishInODF12();
    1012             : }
    1013             : 
    1014           0 : bool SvtSaveOptions::IsReadOnly( SvtSaveOptions::EOption eOption ) const
    1015             : {
    1016           0 :     return pImp->pSaveOpt->IsReadOnly(eOption);
    1017             : }
    1018             : 
    1019             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10