summaryrefslogtreecommitdiffstats
path: root/unotools/source/config/saveopt.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--unotools/source/config/saveopt.cxx971
1 files changed, 971 insertions, 0 deletions
diff --git a/unotools/source/config/saveopt.cxx b/unotools/source/config/saveopt.cxx
new file mode 100644
index 000000000..d8f4d37dd
--- /dev/null
+++ b/unotools/source/config/saveopt.cxx
@@ -0,0 +1,971 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <sal/log.hxx>
+#include <unotools/saveopt.hxx>
+#include <rtl/instance.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/configitem.hxx>
+#include <tools/debug.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+
+#include <osl/diagnose.h>
+#include <osl/mutex.hxx>
+#include <officecfg/Office/Recovery.hxx>
+
+using namespace utl;
+using namespace com::sun::star::uno;
+
+namespace {
+
+class SvtSaveOptions_Impl;
+class SvtLoadOptions_Impl;
+
+}
+
+#define CFG_READONLY_DEFAULT false
+
+struct SvtLoadSaveOptions_Impl
+{
+ std::unique_ptr<SvtSaveOptions_Impl> pSaveOpt;
+ std::unique_ptr<SvtLoadOptions_Impl> pLoadOpt;
+};
+
+static std::unique_ptr<SvtLoadSaveOptions_Impl> pOptions;
+static sal_Int32 nRefCount = 0;
+
+namespace {
+
+class SvtSaveOptions_Impl : public utl::ConfigItem
+{
+ sal_Int32 nAutoSaveTime;
+ bool bUseUserData,
+ bBackup,
+ bAutoSave,
+ bAutoSavePrompt,
+ bUserAutoSave,
+ bDocInfSave,
+ bSaveWorkingSet,
+ bSaveDocView,
+ bSaveRelINet,
+ bSaveRelFSys,
+ bDoPrettyPrinting,
+ bWarnAlienFormat,
+ bLoadDocPrinter;
+
+ SvtSaveOptions::ODFDefaultVersion eODFDefaultVersion;
+
+ bool bROAutoSaveTime,
+ bROUseUserData,
+ bROBackup,
+ bROAutoSave,
+ bROAutoSavePrompt,
+ bROUserAutoSave,
+ bRODocInfSave,
+ bROSaveWorkingSet,
+ bROSaveDocView,
+ bROSaveRelINet,
+ bROSaveRelFSys,
+ bROWarnAlienFormat,
+ bRODoPrettyPrinting,
+ bROLoadDocPrinter,
+ bROODFDefaultVersion;
+
+ virtual void ImplCommit() override;
+
+public:
+ SvtSaveOptions_Impl();
+
+ virtual void Notify( const css::uno::Sequence< OUString >& aPropertyNames ) override;
+
+ sal_Int32 GetAutoSaveTime() const { return nAutoSaveTime; }
+ bool IsUseUserData() const { return bUseUserData; }
+ bool IsBackup() const { return bBackup; }
+ bool IsAutoSave() const { return bAutoSave; }
+ bool IsAutoSavePrompt() const { return bAutoSavePrompt; }
+ bool IsUserAutoSave() const { return bUserAutoSave; }
+ bool IsDocInfoSave() const { return bDocInfSave; }
+ bool IsSaveWorkingSet() const { return bSaveWorkingSet; }
+ bool IsSaveDocView() const { return bSaveDocView; }
+ bool IsSaveRelINet() const { return bSaveRelINet; }
+ bool IsSaveRelFSys() const { return bSaveRelFSys; }
+ bool IsPrettyPrintingEnabled( ) const { return bDoPrettyPrinting; }
+ bool IsWarnAlienFormat() const { return bWarnAlienFormat; }
+ bool IsLoadDocPrinter() const { return bLoadDocPrinter; }
+
+ SvtSaveOptions::ODFDefaultVersion
+ GetODFDefaultVersion() const { return eODFDefaultVersion; }
+
+ void SetAutoSaveTime( sal_Int32 n );
+ void SetUseUserData( bool b );
+ void SetBackup( bool b );
+ void SetAutoSave( bool b );
+ void SetAutoSavePrompt( bool b );
+ void SetUserAutoSave( bool b );
+ void SetDocInfoSave( bool b );
+ void SetSaveWorkingSet( bool b );
+ void SetSaveDocView( bool b );
+ void SetSaveRelINet( bool b );
+ void SetSaveRelFSys( bool b );
+ void EnablePrettyPrinting( bool _bDoPP );
+ void SetWarnAlienFormat( bool _bDoPP );
+ void SetLoadDocPrinter( bool bNew );
+ void SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eNew );
+
+ bool IsReadOnly( SvtSaveOptions::EOption eOption ) const;
+};
+
+}
+
+void SvtSaveOptions_Impl::SetAutoSaveTime( sal_Int32 n )
+{
+ if (!bROAutoSaveTime && nAutoSaveTime!=n)
+ {
+ nAutoSaveTime = n;
+ SetModified();
+ Commit();
+ }
+}
+
+void SvtSaveOptions_Impl::SetUseUserData( bool b )
+{
+ if (!bROUseUserData && bUseUserData!=b)
+ {
+ bUseUserData = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetBackup( bool b )
+{
+ if (!bROBackup && bBackup!=b)
+ {
+ bBackup = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetAutoSave( bool b )
+{
+ if (!bROAutoSave && bAutoSave!=b)
+ {
+ bAutoSave = b;
+ SetModified();
+ Commit();
+ }
+}
+
+void SvtSaveOptions_Impl::SetAutoSavePrompt( bool b )
+{
+ if (!bROAutoSavePrompt && bAutoSavePrompt!=b)
+ {
+ bAutoSavePrompt = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetUserAutoSave( bool b )
+{
+ if (!bROUserAutoSave && bUserAutoSave!=b)
+ {
+ bUserAutoSave = b;
+ SetModified();
+ Commit();
+ }
+}
+
+void SvtSaveOptions_Impl::SetDocInfoSave(bool b)
+{
+ if (!bRODocInfSave && bDocInfSave!=b)
+ {
+ bDocInfSave = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetSaveWorkingSet( bool b )
+{
+ if (!bROSaveWorkingSet && bSaveWorkingSet!=b)
+ {
+ bSaveWorkingSet = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetSaveDocView( bool b )
+{
+ if (!bROSaveDocView && bSaveDocView!=b)
+ {
+ bSaveDocView = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetSaveRelINet( bool b )
+{
+ if (!bROSaveRelINet && bSaveRelINet!=b)
+ {
+ bSaveRelINet = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetSaveRelFSys( bool b )
+{
+ if (!bROSaveRelFSys && bSaveRelFSys!=b)
+ {
+ bSaveRelFSys = b;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::EnablePrettyPrinting( bool _bDoPP )
+{
+ if (!bRODoPrettyPrinting && bDoPrettyPrinting!=_bDoPP)
+ {
+ bDoPrettyPrinting = _bDoPP;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetWarnAlienFormat( bool _bDoPP )
+{
+ if (!bROWarnAlienFormat && bWarnAlienFormat!=_bDoPP)
+ {
+ bWarnAlienFormat = _bDoPP;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetLoadDocPrinter( bool bNew )
+{
+ if ( !bROLoadDocPrinter && bLoadDocPrinter != bNew )
+ {
+ bLoadDocPrinter = bNew;
+ SetModified();
+ }
+}
+
+void SvtSaveOptions_Impl::SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eNew )
+{
+ if ( !bROODFDefaultVersion && eODFDefaultVersion != eNew )
+ {
+ eODFDefaultVersion = eNew;
+ SetModified();
+ }
+}
+
+bool SvtSaveOptions_Impl::IsReadOnly( SvtSaveOptions::EOption eOption ) const
+{
+ bool bReadOnly = CFG_READONLY_DEFAULT;
+ switch(eOption)
+ {
+ case SvtSaveOptions::EOption::AutoSaveTime :
+ bReadOnly = bROAutoSaveTime;
+ break;
+ case SvtSaveOptions::EOption::UseUserData :
+ bReadOnly = bROUseUserData;
+ break;
+ case SvtSaveOptions::EOption::Backup :
+ bReadOnly = bROBackup;
+ break;
+ case SvtSaveOptions::EOption::AutoSave :
+ bReadOnly = bROAutoSave;
+ break;
+ case SvtSaveOptions::EOption::AutoSavePrompt :
+ bReadOnly = bROAutoSavePrompt;
+ break;
+ case SvtSaveOptions::EOption::UserAutoSave :
+ bReadOnly = bROUserAutoSave;
+ break;
+ case SvtSaveOptions::EOption::DocInfSave :
+ bReadOnly = bRODocInfSave;
+ break;
+ case SvtSaveOptions::EOption::SaveWorkingSet :
+ bReadOnly = bROSaveWorkingSet;
+ break;
+ case SvtSaveOptions::EOption::SaveDocView :
+ bReadOnly = bROSaveDocView;
+ break;
+ case SvtSaveOptions::EOption::SaveRelInet :
+ bReadOnly = bROSaveRelINet;
+ break;
+ case SvtSaveOptions::EOption::SaveRelFsys :
+ bReadOnly = bROSaveRelFSys;
+ break;
+ case SvtSaveOptions::EOption::DoPrettyPrinting :
+ bReadOnly = bRODoPrettyPrinting;
+ break;
+ case SvtSaveOptions::EOption::WarnAlienFormat :
+ bReadOnly = bROWarnAlienFormat;
+ break;
+ case SvtSaveOptions::EOption::LoadDocPrinter :
+ bReadOnly = bROLoadDocPrinter;
+ break;
+ case SvtSaveOptions::EOption::OdfDefaultVersion :
+ bReadOnly = bROODFDefaultVersion;
+ break;
+ }
+ return bReadOnly;
+}
+
+#define FORMAT 0
+#define TIMEINTERVALL 1
+#define USEUSERDATA 2
+#define CREATEBACKUP 3
+#define AUTOSAVE 4
+#define PROMPT 5
+#define EDITPROPERTY 6
+#define SAVEVIEWINFO 7
+#define PRETTYPRINTING 8
+#define WARNALIENFORMAT 9
+#define LOADDOCPRINTER 10
+#define FILESYSTEM 11
+#define INTERNET 12
+#define SAVEWORKINGSET 13
+#define ODFDEFAULTVERSION 14
+
+static Sequence< OUString > GetPropertyNames()
+{
+ static const char* aPropNames[] =
+ {
+ "Graphic/Format",
+ "Document/AutoSaveTimeIntervall",
+ "Document/UseUserData",
+ "Document/CreateBackup",
+ "Document/AutoSave",
+ "Document/AutoSavePrompt",
+ "Document/EditProperty",
+ "Document/ViewInfo",
+ "Document/PrettyPrinting",
+ "Document/WarnAlienFormat",
+ "Document/LoadPrinter",
+ "URL/FileSystem",
+ "URL/Internet",
+ "WorkingSet",
+ "ODF/DefaultVersion"
+ };
+
+ const int nCount = SAL_N_ELEMENTS( aPropNames );
+ Sequence< OUString > aNames( nCount );
+ OUString* pNames = aNames.getArray();
+ for ( int i = 0; i < nCount; i++ )
+ pNames[i] = OUString::createFromAscii( aPropNames[i] );
+
+ return aNames;
+}
+
+SvtSaveOptions_Impl::SvtSaveOptions_Impl()
+ : ConfigItem( "Office.Common/Save" )
+ , nAutoSaveTime( 0 )
+ , bUseUserData( false )
+ , bBackup( false )
+ , bAutoSave( false )
+ , bAutoSavePrompt( false )
+ , bUserAutoSave( false )
+ , bDocInfSave( false )
+ , bSaveWorkingSet( false )
+ , bSaveDocView( false )
+ , bSaveRelINet( false )
+ , bSaveRelFSys( false )
+ , bDoPrettyPrinting( false )
+ , bWarnAlienFormat( true )
+ , bLoadDocPrinter( true )
+ , eODFDefaultVersion( SvtSaveOptions::ODFVER_LATEST )
+ , bROAutoSaveTime( CFG_READONLY_DEFAULT )
+ , bROUseUserData( CFG_READONLY_DEFAULT )
+ , bROBackup( CFG_READONLY_DEFAULT )
+ , bROAutoSave( CFG_READONLY_DEFAULT )
+ , bROAutoSavePrompt( CFG_READONLY_DEFAULT )
+ , bROUserAutoSave( CFG_READONLY_DEFAULT )
+ , bRODocInfSave( CFG_READONLY_DEFAULT )
+ , bROSaveWorkingSet( CFG_READONLY_DEFAULT )
+ , bROSaveDocView( CFG_READONLY_DEFAULT )
+ , bROSaveRelINet( CFG_READONLY_DEFAULT )
+ , bROSaveRelFSys( CFG_READONLY_DEFAULT )
+ , bROWarnAlienFormat( CFG_READONLY_DEFAULT )
+ , bRODoPrettyPrinting( CFG_READONLY_DEFAULT )
+ , bROLoadDocPrinter( CFG_READONLY_DEFAULT )
+ , bROODFDefaultVersion( CFG_READONLY_DEFAULT )
+{
+ Sequence< OUString > aNames = GetPropertyNames();
+ Sequence< Any > aValues = GetProperties( aNames );
+ Sequence< sal_Bool > aROStates = GetReadOnlyStates( aNames );
+ EnableNotification( aNames );
+ const Any* pValues = aValues.getConstArray();
+ const sal_Bool* pROStates = aROStates.getConstArray();
+ DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
+ DBG_ASSERT( aROStates.getLength() == aNames.getLength(), "GetReadOnlyStates failed" );
+ if ( aValues.getLength() == aNames.getLength() && aROStates.getLength() == aNames.getLength() )
+ {
+ for ( int nProp = 0; nProp < aNames.getLength(); nProp++ )
+ {
+ if ( pValues[nProp].hasValue() )
+ {
+ sal_Int32 nTemp = 0;
+ switch ( nProp )
+ {
+ case FORMAT:
+ // not supported anymore
+ break;
+
+ case TIMEINTERVALL :
+ if ( pValues[nProp] >>= nTemp )
+ nAutoSaveTime = nTemp;
+ else {
+ OSL_FAIL( "Wrong Type!" );
+ };
+ bROAutoSaveTime = pROStates[nProp];
+ break;
+
+ case ODFDEFAULTVERSION :
+ {
+ sal_Int16 nTmp = 0;
+ if ( pValues[nProp] >>= nTmp )
+ {
+ if( nTmp == 3 )
+ eODFDefaultVersion = SvtSaveOptions::ODFVER_LATEST;
+ else
+ eODFDefaultVersion = SvtSaveOptions::ODFDefaultVersion( nTmp );
+ }
+ else {
+ SAL_WARN( "unotools.config", "SvtSaveOptions_Impl::SvtSaveOptions_Impl(): Wrong Type!" );
+ };
+ bROODFDefaultVersion = pROStates[nProp];
+ break;
+ }
+
+ default:
+ {
+ bool bTemp = bool();
+ if ( pValues[nProp] >>= bTemp )
+ {
+ switch ( nProp )
+ {
+ case USEUSERDATA :
+ bUseUserData = bTemp;
+ bROUseUserData = pROStates[nProp];
+ break;
+ case CREATEBACKUP :
+ bBackup = bTemp;
+ bROBackup = pROStates[nProp];
+ break;
+ case AUTOSAVE :
+ bAutoSave = bTemp;
+ bROAutoSave = pROStates[nProp];
+ break;
+ case PROMPT :
+ bAutoSavePrompt = bTemp;
+ bROAutoSavePrompt = pROStates[nProp];
+ break;
+ case EDITPROPERTY :
+ bDocInfSave = bTemp;
+ bRODocInfSave = pROStates[nProp];
+ break;
+ case SAVEWORKINGSET :
+ bSaveWorkingSet = bTemp;
+ bROSaveWorkingSet = pROStates[nProp];
+ break;
+ case SAVEVIEWINFO :
+ bSaveDocView = bTemp;
+ bROSaveDocView = pROStates[nProp];
+ break;
+ case FILESYSTEM :
+ bSaveRelFSys = bTemp;
+ bROSaveRelFSys = pROStates[nProp];
+ break;
+ case INTERNET :
+ bSaveRelINet = bTemp;
+ bROSaveRelINet = pROStates[nProp];
+ break;
+
+ case PRETTYPRINTING:
+ bDoPrettyPrinting = bTemp;
+ bRODoPrettyPrinting = pROStates[nProp];
+ break;
+
+ case WARNALIENFORMAT:
+ bWarnAlienFormat = bTemp;
+ bROWarnAlienFormat = pROStates[nProp];
+ break;
+
+ case LOADDOCPRINTER:
+ bLoadDocPrinter = bTemp;
+ bROLoadDocPrinter = pROStates[nProp];
+ break;
+
+ default :
+ SAL_WARN( "unotools.config", "invalid index to load a path" );
+ }
+ }
+ else
+ {
+ OSL_FAIL( "Wrong Type!" );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (!utl::ConfigManager::IsFuzzing())
+ {
+ bAutoSave = officecfg::Office::Recovery::AutoSave::Enabled::get();
+ nAutoSaveTime = officecfg::Office::Recovery::AutoSave::TimeIntervall::get();
+ bUserAutoSave = officecfg::Office::Recovery::AutoSave::UserAutoSaveEnabled::get();
+ }
+ else
+ {
+ bAutoSave = false;
+ nAutoSaveTime = 0;
+ bUserAutoSave = false;
+ }
+}
+
+void SvtSaveOptions_Impl::ImplCommit()
+{
+ Sequence< OUString > aOrgNames = GetPropertyNames();
+ OUString* pOrgNames = aOrgNames.getArray();
+ sal_Int32 nOrgCount = aOrgNames.getLength();
+
+ Sequence< OUString > aNames( nOrgCount );
+ Sequence< Any > aValues( nOrgCount );
+ OUString* pNames = aNames.getArray();
+ Any* pValues = aValues.getArray();
+ sal_Int32 nRealCount = 0;
+
+ for (sal_Int32 i=0; i<nOrgCount; ++i)
+ {
+ switch (i)
+ {
+ case FORMAT:
+ // not supported anymore
+ break;
+ case TIMEINTERVALL :
+ if (!bROAutoSaveTime)
+ {
+ pValues[nRealCount] <<= nAutoSaveTime;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case USEUSERDATA :
+ if (!bROUseUserData)
+ {
+ pValues[nRealCount] <<= bUseUserData;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case CREATEBACKUP :
+ if (!bROBackup)
+ {
+ pValues[nRealCount] <<= bBackup;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case AUTOSAVE :
+ if (!bROAutoSave)
+ {
+ pValues[nRealCount] <<= bAutoSave;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case PROMPT :
+ if (!bROAutoSavePrompt)
+ {
+ pValues[nRealCount] <<= bAutoSavePrompt;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case EDITPROPERTY :
+ if (!bRODocInfSave)
+ {
+ pValues[nRealCount] <<= bDocInfSave;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case SAVEWORKINGSET :
+ if (!bROSaveWorkingSet)
+ {
+ pValues[nRealCount] <<= bSaveWorkingSet;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case SAVEVIEWINFO :
+ if (!bROSaveDocView)
+ {
+ pValues[nRealCount] <<= bSaveDocView;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case FILESYSTEM :
+ if (!bROSaveRelFSys)
+ {
+ pValues[nRealCount] <<= bSaveRelFSys;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case INTERNET :
+ if (!bROSaveRelINet)
+ {
+ pValues[nRealCount] <<= bSaveRelINet;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case PRETTYPRINTING:
+ if (!bRODoPrettyPrinting)
+ {
+ pValues[nRealCount] <<= bDoPrettyPrinting;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case WARNALIENFORMAT:
+ if (!bROWarnAlienFormat)
+ {
+ pValues[nRealCount] <<= bWarnAlienFormat;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case LOADDOCPRINTER:
+ if (!bROLoadDocPrinter)
+ {
+ pValues[nRealCount] <<= bLoadDocPrinter;
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+ case ODFDEFAULTVERSION:
+ if (!bROODFDefaultVersion)
+ {
+ pValues[nRealCount] <<= (eODFDefaultVersion == SvtSaveOptions::ODFVER_LATEST) ? sal_Int16( 3 ) : sal_Int16( eODFDefaultVersion );
+ pNames[nRealCount] = pOrgNames[i];
+ ++nRealCount;
+ }
+ break;
+
+ default:
+ SAL_WARN( "unotools.config", "invalid index to save a path" );
+ }
+ }
+
+ aNames.realloc(nRealCount);
+ aValues.realloc(nRealCount);
+ PutProperties( aNames, aValues );
+
+ std::shared_ptr< comphelper::ConfigurationChanges > batch(
+ comphelper::ConfigurationChanges::create());
+ officecfg::Office::Recovery::AutoSave::TimeIntervall::set(nAutoSaveTime, batch);
+ officecfg::Office::Recovery::AutoSave::Enabled::set(bAutoSave, batch);
+ officecfg::Office::Recovery::AutoSave::UserAutoSaveEnabled::set(bUserAutoSave, batch);
+ batch->commit();
+}
+
+void SvtSaveOptions_Impl::Notify( const Sequence<OUString>& )
+{
+}
+
+namespace {
+
+class SvtLoadOptions_Impl : public utl::ConfigItem
+{
+private:
+ bool bLoadUserDefinedSettings;
+
+ virtual void ImplCommit() override;
+
+public:
+ SvtLoadOptions_Impl();
+
+ virtual void Notify( const css::uno::Sequence< OUString >& aPropertyNames ) override;
+
+ void SetLoadUserSettings(bool b){bLoadUserDefinedSettings = b; SetModified();}
+ bool IsLoadUserSettings() const {return bLoadUserDefinedSettings;}
+};
+
+}
+
+const char cUserDefinedSettings[] = "UserDefinedSettings";
+
+SvtLoadOptions_Impl::SvtLoadOptions_Impl()
+ : ConfigItem( "Office.Common/Load" )
+ , bLoadUserDefinedSettings( false )
+{
+ Sequence< OUString > aNames { cUserDefinedSettings };
+ Sequence< Any > aValues = GetProperties( aNames );
+ EnableNotification( aNames );
+ const Any* pValues = aValues.getConstArray();
+ DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
+ pValues[0] >>= bLoadUserDefinedSettings;
+}
+
+void SvtLoadOptions_Impl::ImplCommit()
+{
+ PutProperties(
+ {cUserDefinedSettings}, {css::uno::Any(bLoadUserDefinedSettings)});
+}
+
+void SvtLoadOptions_Impl::Notify( const Sequence<OUString>& )
+{
+ SAL_WARN( "unotools.config", "properties have been changed" );
+}
+
+namespace
+{
+ class LocalSingleton : public rtl::Static< osl::Mutex, LocalSingleton >
+ {
+ };
+}
+
+SvtSaveOptions::SvtSaveOptions()
+{
+ // Global access, must be guarded (multithreading)
+ ::osl::MutexGuard aGuard( LocalSingleton::get() );
+ if ( !pOptions )
+ {
+ pOptions.reset(new SvtLoadSaveOptions_Impl);
+ pOptions->pSaveOpt.reset(new SvtSaveOptions_Impl);
+ pOptions->pLoadOpt.reset( new SvtLoadOptions_Impl);
+ }
+ ++nRefCount;
+ pImp = pOptions.get();
+}
+
+SvtSaveOptions::~SvtSaveOptions()
+{
+ // Global access, must be guarded (multithreading)
+ ::osl::MutexGuard aGuard( LocalSingleton::get() );
+ if ( !--nRefCount )
+ {
+ if ( pOptions->pSaveOpt->IsModified() )
+ pOptions->pSaveOpt->Commit();
+ if ( pOptions->pLoadOpt->IsModified() )
+ pOptions->pLoadOpt->Commit();
+
+ pOptions.reset();
+ }
+}
+
+void SvtSaveOptions::SetAutoSaveTime( sal_Int32 n )
+{
+ pImp->pSaveOpt->SetAutoSaveTime( n );
+}
+
+sal_Int32 SvtSaveOptions::GetAutoSaveTime() const
+{
+ return pImp->pSaveOpt->GetAutoSaveTime();
+}
+
+void SvtSaveOptions::SetUseUserData( bool b )
+{
+ pImp->pSaveOpt->SetUseUserData( b );
+}
+
+bool SvtSaveOptions::IsUseUserData() const
+{
+ return pImp->pSaveOpt->IsUseUserData();
+}
+
+void SvtSaveOptions::SetBackup( bool b )
+{
+ pImp->pSaveOpt->SetBackup( b );
+}
+
+bool SvtSaveOptions::IsBackup() const
+{
+ return pImp->pSaveOpt->IsBackup();
+}
+
+void SvtSaveOptions::SetAutoSave( bool b )
+{
+ pImp->pSaveOpt->SetAutoSave( b );
+}
+
+bool SvtSaveOptions::IsAutoSave() const
+{
+ return pImp->pSaveOpt->IsAutoSave();
+}
+
+void SvtSaveOptions::SetAutoSavePrompt( bool b )
+{
+ pImp->pSaveOpt->SetAutoSavePrompt( b );
+}
+
+bool SvtSaveOptions::IsAutoSavePrompt() const
+{
+ return pImp->pSaveOpt->IsAutoSavePrompt();
+}
+
+void SvtSaveOptions::SetUserAutoSave( bool b )
+{
+ pImp->pSaveOpt->SetUserAutoSave( b );
+}
+
+bool SvtSaveOptions::IsUserAutoSave() const
+{
+ return pImp->pSaveOpt->IsUserAutoSave();
+}
+
+void SvtSaveOptions::SetDocInfoSave(bool b)
+{
+ pImp->pSaveOpt->SetDocInfoSave( b );
+}
+
+bool SvtSaveOptions::IsDocInfoSave() const
+{
+ return pImp->pSaveOpt->IsDocInfoSave();
+}
+
+void SvtSaveOptions::SetSaveWorkingSet( bool b )
+{
+ pImp->pSaveOpt->SetSaveWorkingSet( b );
+}
+
+bool SvtSaveOptions::IsSaveWorkingSet() const
+{
+ return pImp->pSaveOpt->IsSaveWorkingSet();
+}
+
+void SvtSaveOptions::SetSaveDocView( bool b )
+{
+ pImp->pSaveOpt->SetSaveDocView( b );
+}
+
+bool SvtSaveOptions::IsSaveDocView() const
+{
+ return pImp->pSaveOpt->IsSaveDocView();
+}
+
+void SvtSaveOptions::SetSaveRelINet( bool b )
+{
+ pImp->pSaveOpt->SetSaveRelINet( b );
+}
+
+bool SvtSaveOptions::IsSaveRelINet() const
+{
+ return pImp->pSaveOpt->IsSaveRelINet();
+}
+
+void SvtSaveOptions::SetSaveRelFSys( bool b )
+{
+ pImp->pSaveOpt->SetSaveRelFSys( b );
+}
+
+bool SvtSaveOptions::IsSaveRelFSys() const
+{
+ return pImp->pSaveOpt->IsSaveRelFSys();
+}
+
+void SvtSaveOptions::SetLoadUserSettings(bool b)
+{
+ pImp->pLoadOpt->SetLoadUserSettings(b);
+}
+
+bool SvtSaveOptions::IsLoadUserSettings() const
+{
+ return pImp->pLoadOpt->IsLoadUserSettings();
+}
+
+void SvtSaveOptions::SetPrettyPrinting( bool _bEnable )
+{
+ pImp->pSaveOpt->EnablePrettyPrinting( _bEnable );
+}
+
+bool SvtSaveOptions::IsPrettyPrinting() const
+{
+ return pImp->pSaveOpt->IsPrettyPrintingEnabled();
+}
+
+void SvtSaveOptions::SetWarnAlienFormat( bool _bEnable )
+{
+ pImp->pSaveOpt->SetWarnAlienFormat( _bEnable );
+}
+
+bool SvtSaveOptions::IsWarnAlienFormat() const
+{
+ return pImp->pSaveOpt->IsWarnAlienFormat();
+}
+
+void SvtSaveOptions::SetLoadDocumentPrinter( bool _bEnable )
+{
+ pImp->pSaveOpt->SetLoadDocPrinter( _bEnable );
+}
+
+bool SvtSaveOptions::IsLoadDocumentPrinter() const
+{
+ return pImp->pSaveOpt->IsLoadDocPrinter();
+}
+
+void SvtSaveOptions::SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eVersion )
+{
+ pImp->pSaveOpt->SetODFDefaultVersion( eVersion );
+}
+
+SvtSaveOptions::ODFDefaultVersion SvtSaveOptions::GetODFDefaultVersion() const
+{
+ auto const nRet = pImp->pSaveOpt->GetODFDefaultVersion();
+ SAL_WARN_IF(nRet == ODFVER_UNKNOWN, "unotools.config", "DefaultVersion is ODFVER_UNKNOWN?");
+ return (nRet == ODFVER_UNKNOWN) ? ODFVER_LATEST : nRet;
+}
+
+SvtSaveOptions::ODFSaneDefaultVersion SvtSaveOptions::GetODFSaneDefaultVersion() const
+{
+ switch (pImp->pSaveOpt->GetODFDefaultVersion())
+ {
+ default:
+ assert(!"map new ODFDefaultVersion to ODFSaneDefaultVersion");
+ break;
+ case ODFVER_UNKNOWN:
+ case ODFVER_LATEST:
+ return ODFSVER_LATEST_EXTENDED;
+ case ODFVER_010:
+ return ODFSVER_010;
+ case ODFVER_011:
+ return ODFSVER_011;
+ case ODFVER_012:
+ return ODFSVER_012;
+ case ODFVER_012_EXT_COMPAT:
+ return ODFSVER_012_EXT_COMPAT;
+ case ODFVER_012_EXTENDED:
+ return ODFSVER_012_EXTENDED;
+ case ODFVER_013:
+ return ODFSVER_013;
+ }
+ return ODFSVER_LATEST_EXTENDED;
+}
+
+bool SvtSaveOptions::IsReadOnly( SvtSaveOptions::EOption eOption ) const
+{
+ return pImp->pSaveOpt->IsReadOnly(eOption);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */