Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 851 insertions, 0 deletions

diff --git a/unotools/source/config/pathoptions.cxx b/unotools/source/config/pathoptions.cxx
new file mode 100644
index 000000000..c1a536270
--- /dev/null
+++ b/unotools/source/config/pathoptions.cxx
@@ -0,0 +1,851 @@
+/* -*- 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/pathoptions.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/urlobj.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <osl/mutex.hxx>
+#include <osl/file.hxx>
+
+#include <unotools/ucbhelper.hxx>
+#include <comphelper/getexpandeduri.hxx>
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/beans/XFastPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/util/thePathSettings.hpp>
+#include <com/sun/star/util/PathSubstitution.hpp>
+#include <com/sun/star/util/XStringSubstitution.hpp>
+#include <com/sun/star/util/theMacroExpander.hpp>
+#include <o3tl/enumarray.hxx>
+#include <o3tl/string_view.hxx>
+
+#include "itemholder1.hxx"
+
+#include <set>
+#include <unordered_map>
+
+using namespace osl;
+using namespace utl;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::util;
+using namespace com::sun::star::lang;
+
+#define SEARCHPATH_DELIMITER  ';'
+#define SIGN_STARTVARIABLE    "$("
+#define SIGN_ENDVARIABLE      ")"
+
+// Supported variables by the old SvtPathOptions implementation
+#define SUBSTITUTE_INSTPATH   "$(instpath)"
+#define SUBSTITUTE_PROGPATH   "$(progpath)"
+#define SUBSTITUTE_USERPATH   "$(userpath)"
+#define SUBSTITUTE_PATH       "$(path)"
+
+#define STRPOS_NOTFOUND       -1
+
+typedef std::unordered_map<OUString, sal_Int32> NameToHandleMap;
+
+typedef std::set<OUString> VarNameSet;
+
+// class SvtPathOptions_Impl ---------------------------------------------
+class SvtPathOptions_Impl
+{
+    private:
+        // Local variables to return const references
+        o3tl::enumarray< SvtPathOptions::Paths, OUString > m_aPathArray;
+        Reference< XFastPropertySet >       m_xPathSettings;
+        Reference< XStringSubstitution >    m_xSubstVariables;
+        Reference< XMacroExpander >         m_xMacroExpander;
+        mutable std::unordered_map<SvtPathOptions::Paths, sal_Int32>
+                                            m_aMapEnumToPropHandle;
+        VarNameSet                          m_aSystemPathVarNames;
+
+        OUString                            m_aEmptyString;
+        mutable std::mutex                  m_aMutex;
+
+    public:
+                        SvtPathOptions_Impl();
+
+        // get the paths, not const because of using a mutex
+        const OUString& GetPath( SvtPathOptions::Paths );
+        const OUString& GetAddinPath() { return GetPath( SvtPathOptions::Paths::AddIn ); }
+        const OUString& GetAutoCorrectPath() { return GetPath( SvtPathOptions::Paths::AutoCorrect ); }
+        const OUString& GetAutoTextPath() { return GetPath( SvtPathOptions::Paths::AutoText ); }
+        const OUString& GetBackupPath() { return GetPath( SvtPathOptions::Paths::Backup ); }
+        const OUString& GetBasicPath() { return GetPath( SvtPathOptions::Paths::Basic ); }
+        const OUString& GetBitmapPath() { return GetPath( SvtPathOptions::Paths::Bitmap ); }
+        const OUString& GetConfigPath() { return GetPath( SvtPathOptions::Paths::Config ); }
+        const OUString& GetDictionaryPath() { return GetPath( SvtPathOptions::Paths::Dictionary ); }
+        const OUString& GetFavoritesPath() { return GetPath( SvtPathOptions::Paths::Favorites ); }
+        const OUString& GetFilterPath() { return GetPath( SvtPathOptions::Paths::Filter ); }
+        const OUString& GetGalleryPath() { return GetPath( SvtPathOptions::Paths::Gallery ); }
+        const OUString& GetGraphicPath() { return GetPath( SvtPathOptions::Paths::Graphic ); }
+        const OUString& GetHelpPath() { return GetPath( SvtPathOptions::Paths::Help ); }
+        const OUString& GetLinguisticPath() { return GetPath( SvtPathOptions::Paths::Linguistic ); }
+        const OUString& GetModulePath() { return GetPath( SvtPathOptions::Paths::Module ); }
+        const OUString& GetPalettePath() { return GetPath( SvtPathOptions::Paths::Palette ); }
+        const OUString& GetIconsetPath() { return GetPath( SvtPathOptions::Paths::IconSet); }
+        const OUString& GetPluginPath() { return GetPath( SvtPathOptions::Paths::Plugin ); }
+        const OUString& GetStoragePath() { return GetPath( SvtPathOptions::Paths::Storage ); }
+        const OUString& GetTempPath() { return GetPath( SvtPathOptions::Paths::Temp ); }
+        const OUString& GetTemplatePath() { return GetPath( SvtPathOptions::Paths::Template ); }
+        const OUString& GetUserConfigPath() { return GetPath( SvtPathOptions::Paths::UserConfig ); }
+        const OUString& GetWorkPath() { return GetPath( SvtPathOptions::Paths::Work ); }
+        const OUString& GetUIConfigPath() { return GetPath( SvtPathOptions::Paths::UIConfig ); }
+        const OUString& GetFingerprintPath() { return GetPath( SvtPathOptions::Paths::Fingerprint ); }
+        const OUString& GetNumbertextPath() { return GetPath( SvtPathOptions::Paths::NumberText ); }
+        const OUString& GetClassificationPath() { return GetPath( SvtPathOptions::Paths::Classification ); }
+
+        // set the paths
+        void            SetPath( SvtPathOptions::Paths, const OUString& rNewPath );
+        void            SetAddinPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::AddIn, rPath ); }
+        void            SetAutoCorrectPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::AutoCorrect, rPath ); }
+        void            SetAutoTextPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::AutoText, rPath ); }
+        void            SetBackupPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Backup, rPath ); }
+        void            SetBasicPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Basic, rPath ); }
+        void            SetBitmapPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Bitmap, rPath ); }
+        void            SetConfigPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Config, rPath ); }
+        void            SetDictionaryPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Dictionary, rPath ); }
+        void            SetFavoritesPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Favorites, rPath ); }
+        void            SetFilterPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Filter, rPath ); }
+        void            SetGalleryPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Gallery, rPath ); }
+        void            SetGraphicPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Graphic, rPath ); }
+        void            SetHelpPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Help, rPath ); }
+        void            SetLinguisticPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Linguistic, rPath ); }
+        void            SetModulePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Module, rPath ); }
+        void            SetPalettePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Palette, rPath ); }
+        void            SetPluginPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Plugin, rPath ); }
+        void            SetStoragePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Storage, rPath ); }
+        void            SetTempPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Temp, rPath ); }
+        void            SetTemplatePath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Template, rPath ); }
+        void            SetUserConfigPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::UserConfig, rPath ); }
+        void            SetWorkPath( const OUString& rPath ) { SetPath( SvtPathOptions::Paths::Work, rPath ); }
+
+        OUString   SubstVar( const OUString& rVar ) const;
+        OUString   ExpandMacros( const OUString& rPath ) const;
+        OUString   UsePathVariables( const OUString& rPath ) const;
+};
+
+// global ----------------------------------------------------------------
+
+static std::weak_ptr<SvtPathOptions_Impl> g_pOptions;
+
+namespace {
+
+// functions -------------------------------------------------------------
+struct PropertyStruct
+{
+    const char*             pPropName;  // The ascii name of the Office path
+    SvtPathOptions::Paths   ePath;      // The enum value used by SvtPathOptions
+};
+
+struct VarNameAttribute
+{
+    const char*             pVarName;       // The name of the path variable
+};
+
+}
+
+const PropertyStruct aPropNames[] =
+{
+    { "Addin",          SvtPathOptions::Paths::AddIn          },
+    { "AutoCorrect",    SvtPathOptions::Paths::AutoCorrect    },
+    { "AutoText",       SvtPathOptions::Paths::AutoText       },
+    { "Backup",         SvtPathOptions::Paths::Backup         },
+    { "Basic",          SvtPathOptions::Paths::Basic          },
+    { "Bitmap",         SvtPathOptions::Paths::Bitmap         },
+    { "Config",         SvtPathOptions::Paths::Config         },
+    { "Dictionary",     SvtPathOptions::Paths::Dictionary     },
+    { "Favorite",       SvtPathOptions::Paths::Favorites      },
+    { "Filter",         SvtPathOptions::Paths::Filter         },
+    { "Gallery",        SvtPathOptions::Paths::Gallery        },
+    { "Graphic",        SvtPathOptions::Paths::Graphic        },
+    { "Help",           SvtPathOptions::Paths::Help           },
+    { "Iconset",        SvtPathOptions::Paths::IconSet        },
+    { "Linguistic",     SvtPathOptions::Paths::Linguistic     },
+    { "Module",         SvtPathOptions::Paths::Module         },
+    { "Palette",        SvtPathOptions::Paths::Palette        },
+    { "Plugin",         SvtPathOptions::Paths::Plugin         },
+    { "Storage",        SvtPathOptions::Paths::Storage        },
+    { "Temp",           SvtPathOptions::Paths::Temp           },
+    { "Template",       SvtPathOptions::Paths::Template       },
+    { "UserConfig",     SvtPathOptions::Paths::UserConfig     },
+    { "Work",           SvtPathOptions::Paths::Work           },
+    { "UIConfig",       SvtPathOptions::Paths::UIConfig       },
+    { "Fingerprint",    SvtPathOptions::Paths::Fingerprint    },
+    { "Numbertext",     SvtPathOptions::Paths::NumberText     },
+    { "Classification", SvtPathOptions::Paths::Classification }
+};
+
+const VarNameAttribute aVarNameAttribute[] =
+{
+    { SUBSTITUTE_INSTPATH },    // $(instpath)
+    { SUBSTITUTE_PROGPATH },    // $(progpath)
+    { SUBSTITUTE_USERPATH },    // $(userpath)
+    { SUBSTITUTE_PATH },    // $(path)
+};
+
+// class SvtPathOptions_Impl ---------------------------------------------
+
+const OUString& SvtPathOptions_Impl::GetPath( SvtPathOptions::Paths ePath )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    try
+    {
+        OUString    aPathValue;
+        sal_Int32   nHandle = m_aMapEnumToPropHandle[ePath];
+
+        // Substitution is done by the service itself using the substitution service
+        Any         a = m_xPathSettings->getFastPropertyValue( nHandle );
+        a >>= aPathValue;
+        if( ePath == SvtPathOptions::Paths::AddIn     ||
+            ePath == SvtPathOptions::Paths::Filter    ||
+            ePath == SvtPathOptions::Paths::Help      ||
+            ePath == SvtPathOptions::Paths::Module    ||
+            ePath == SvtPathOptions::Paths::Plugin    ||
+            ePath == SvtPathOptions::Paths::Storage
+          )
+        {
+            // These office paths have to be converted to system pates
+            OUString    aResult;
+            osl::FileBase::getSystemPathFromFileURL( aPathValue, aResult );
+            aPathValue = aResult;
+        }
+        else if (ePath == SvtPathOptions::Paths::Palette ||
+                 ePath == SvtPathOptions::Paths::IconSet)
+        {
+            auto ctx = comphelper::getProcessComponentContext();
+            OUStringBuffer buf(aPathValue.getLength()*2);
+            for (sal_Int32 i = 0;;)
+            {
+                buf.append(
+                    comphelper::getExpandedUri(
+                        ctx, aPathValue.getToken(0, ';', i)));
+                if (i == -1) {
+                    break;
+                }
+                buf.append(';');
+            }
+            aPathValue = buf.makeStringAndClear();
+        }
+
+        m_aPathArray[ ePath ] = aPathValue;
+        return m_aPathArray[ ePath ];
+    }
+    catch (UnknownPropertyException &)
+    {
+    }
+
+    return m_aEmptyString;
+}
+
+void SvtPathOptions_Impl::SetPath( SvtPathOptions::Paths ePath, const OUString& rNewPath )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    OUString    aResult;
+    OUString    aNewValue;
+    Any         a;
+
+    switch ( ePath )
+    {
+        case SvtPathOptions::Paths::AddIn:
+        case SvtPathOptions::Paths::Filter:
+        case SvtPathOptions::Paths::Help:
+        case SvtPathOptions::Paths::Module:
+        case SvtPathOptions::Paths::Plugin:
+        case SvtPathOptions::Paths::Storage:
+        {
+            // These office paths have to be convert back to UCB-URL's
+            osl::FileBase::getFileURLFromSystemPath( rNewPath, aResult );
+            aNewValue = aResult;
+        }
+        break;
+
+        default:
+            aNewValue = rNewPath;
+    }
+
+    // Resubstitution is done by the service itself using the substitution service
+    a <<= aNewValue;
+    try
+    {
+        m_xPathSettings->setFastPropertyValue( m_aMapEnumToPropHandle[ePath], a );
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("unotools.config", "SetPath");
+    }
+}
+
+OUString SvtPathOptions_Impl::ExpandMacros( const OUString& rPath ) const
+{
+    OUString sExpanded( rPath );
+
+    const INetURLObject aParser( rPath );
+    if ( aParser.GetProtocol() == INetProtocol::VndSunStarExpand )
+        sExpanded = m_xMacroExpander->expandMacros( aParser.GetURLPath( INetURLObject::DecodeMechanism::WithCharset ) );
+
+    return sExpanded;
+}
+
+OUString SvtPathOptions_Impl::UsePathVariables( const OUString& rPath ) const
+{
+    return m_xSubstVariables->reSubstituteVariables( rPath );
+}
+
+OUString SvtPathOptions_Impl::SubstVar( const OUString& rVar ) const
+{
+    // Don't work at parameter-string directly. Copy it.
+    OUString aWorkText = rVar;
+
+    // Convert the returned path to system path!
+    bool bConvertLocal = false;
+
+    // Search for first occurrence of "$(...".
+    sal_Int32 nPosition = aWorkText.indexOf( SIGN_STARTVARIABLE );  // = first position of "$(" in string
+    sal_Int32 nLength   = 0;                                        // = count of letters from "$(" to ")" in string
+
+    // Have we found any variable like "$(...)"?
+    if ( nPosition != STRPOS_NOTFOUND )
+    {
+        // Yes; Get length of found variable.
+        // If no ")" was found - nLength is set to 0 by default! see before.
+        sal_Int32 nEndPosition = aWorkText.indexOf( SIGN_ENDVARIABLE, nPosition );
+        if ( nEndPosition != STRPOS_NOTFOUND )
+            nLength = nEndPosition - nPosition + 1;
+    }
+
+    // Is there another path variable?
+    while ( ( nPosition != STRPOS_NOTFOUND ) && ( nLength > 0 ) )
+    {
+        // YES; Get the next variable for replace.
+        OUString aSubString = aWorkText.copy( nPosition, nLength );
+        aSubString = aSubString.toAsciiLowerCase();
+
+        // Look for special variable that needs a system path.
+        VarNameSet::const_iterator pIter = m_aSystemPathVarNames.find( aSubString );
+        if ( pIter != m_aSystemPathVarNames.end() )
+            bConvertLocal = true;
+
+        nPosition += nLength;
+
+        // We must control index in string before call something at OUString!
+        // The OUString-implementation don't do it for us :-( but the result is not defined otherwise.
+        if ( nPosition + 1 > aWorkText.getLength() )
+        {
+            // Position is out of range. Break loop!
+            nPosition = STRPOS_NOTFOUND;
+            nLength = 0;
+        }
+        else
+        {
+            // Else; Position is valid. Search for next variable.
+            nPosition = aWorkText.indexOf( SIGN_STARTVARIABLE, nPosition );
+            // Have we found any variable like "$(...)"?
+            if ( nPosition != STRPOS_NOTFOUND )
+            {
+                // Yes; Get length of found variable. If no ")" was found - nLength must set to 0!
+                nLength = 0;
+                sal_Int32 nEndPosition = aWorkText.indexOf( SIGN_ENDVARIABLE, nPosition );
+                if ( nEndPosition != STRPOS_NOTFOUND )
+                    nLength = nEndPosition - nPosition + 1;
+            }
+        }
+    }
+
+    aWorkText = m_xSubstVariables->substituteVariables( rVar, false );
+
+    if ( bConvertLocal )
+    {
+        // Convert the URL to a system path for special path variables
+        OUString aReturn;
+        osl::FileBase::getSystemPathFromFileURL( aWorkText, aReturn );
+        return aReturn;
+    }
+
+    return aWorkText;
+}
+
+SvtPathOptions_Impl::SvtPathOptions_Impl()
+{
+    Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
+
+    // Create necessary services
+    Reference< XPathSettings > xPathSettings = thePathSettings::get(xContext);
+    m_xPathSettings.set( xPathSettings, UNO_QUERY_THROW );
+    m_xSubstVariables.set( PathSubstitution::create(xContext) );
+    m_xMacroExpander = theMacroExpander::get(xContext);
+
+    // Create temporary hash map to have a mapping between property names and property handles
+    Reference< XPropertySetInfo > xPropSetInfo = xPathSettings->getPropertySetInfo();
+    const Sequence< Property > aPathPropSeq = xPropSetInfo->getProperties();
+
+    NameToHandleMap aTempHashMap;
+    for ( const css::beans::Property& aProperty : aPathPropSeq )
+    {
+        aTempHashMap.emplace(aProperty.Name, aProperty.Handle);
+    }
+
+    // Create mapping between internal enum (SvtPathOptions::Paths) and property handle
+    for ( auto const & p : aPropNames )
+    {
+        NameToHandleMap::const_iterator pIter =
+            aTempHashMap.find( OUString::createFromAscii( p.pPropName ));
+
+        if ( pIter != aTempHashMap.end() )
+        {
+            sal_Int32 nHandle   = pIter->second;
+            SvtPathOptions::Paths nEnum       = p.ePath;
+            m_aMapEnumToPropHandle.emplace( nEnum, nHandle );
+        }
+    }
+
+    // Create hash map for path variables that need a system path as a return value!
+    for ( auto const & i : aVarNameAttribute )
+    {
+        m_aSystemPathVarNames.insert( OUString::createFromAscii( i.pVarName ) );
+    }
+}
+
+// class SvtPathOptions --------------------------------------------------
+
+namespace
+{
+    std::mutex& lclMutex()
+    {
+        static std::mutex SINGLETON;
+        return SINGLETON;
+    }
+}
+
+SvtPathOptions::SvtPathOptions()
+{
+    // Global access, must be guarded (multithreading)
+    std::unique_lock aGuard( lclMutex() );
+    pImpl = g_pOptions.lock();
+    if ( !pImpl )
+    {
+        pImpl = std::make_shared<SvtPathOptions_Impl>();
+        g_pOptions = pImpl;
+        aGuard.unlock(); // because holdConfigItem will call this constructor
+        ItemHolder1::holdConfigItem(EItem::PathOptions);
+    }
+}
+
+SvtPathOptions::~SvtPathOptions()
+{
+    // Global access, must be guarded (multithreading)
+    std::unique_lock aGuard( lclMutex() );
+
+    pImpl.reset();
+}
+
+const OUString& SvtPathOptions::GetAddinPath() const
+{
+    return pImpl->GetAddinPath();
+}
+
+const OUString& SvtPathOptions::GetAutoCorrectPath() const
+{
+    return pImpl->GetAutoCorrectPath();
+}
+
+const OUString& SvtPathOptions::GetAutoTextPath() const
+{
+    return pImpl->GetAutoTextPath();
+}
+
+const OUString& SvtPathOptions::GetBackupPath() const
+{
+    return pImpl->GetBackupPath();
+}
+
+const OUString& SvtPathOptions::GetBasicPath() const
+{
+    return pImpl->GetBasicPath();
+}
+
+const OUString& SvtPathOptions::GetBitmapPath() const
+{
+    return pImpl->GetBitmapPath();
+}
+
+const OUString& SvtPathOptions::GetConfigPath() const
+{
+    return pImpl->GetConfigPath();
+}
+
+const OUString& SvtPathOptions::GetDictionaryPath() const
+{
+    return pImpl->GetDictionaryPath();
+}
+
+const OUString& SvtPathOptions::GetFavoritesPath() const
+{
+    return pImpl->GetFavoritesPath();
+}
+
+const OUString& SvtPathOptions::GetFilterPath() const
+{
+    return pImpl->GetFilterPath();
+}
+
+const OUString& SvtPathOptions::GetGalleryPath() const
+{
+    return pImpl->GetGalleryPath();
+}
+
+const OUString& SvtPathOptions::GetGraphicPath() const
+{
+    return pImpl->GetGraphicPath();
+}
+
+const OUString& SvtPathOptions::GetHelpPath() const
+{
+    return pImpl->GetHelpPath();
+}
+
+const OUString& SvtPathOptions::GetLinguisticPath() const
+{
+    return pImpl->GetLinguisticPath();
+}
+
+const OUString& SvtPathOptions::GetFingerprintPath() const
+{
+    return pImpl->GetFingerprintPath();
+}
+
+const OUString& SvtPathOptions::GetNumbertextPath() const
+{
+    return pImpl->GetNumbertextPath();
+}
+
+const OUString& SvtPathOptions::GetModulePath() const
+{
+    return pImpl->GetModulePath();
+}
+
+const OUString& SvtPathOptions::GetPalettePath() const
+{
+    return pImpl->GetPalettePath();
+}
+
+const OUString& SvtPathOptions::GetIconsetPath() const
+{
+    return pImpl->GetIconsetPath();
+}
+
+const OUString& SvtPathOptions::GetPluginPath() const
+{
+    return pImpl->GetPluginPath();
+}
+
+const OUString& SvtPathOptions::GetStoragePath() const
+{
+    return pImpl->GetStoragePath();
+}
+
+const OUString& SvtPathOptions::GetTempPath() const
+{
+    return pImpl->GetTempPath();
+}
+
+const OUString& SvtPathOptions::GetTemplatePath() const
+{
+    return pImpl->GetTemplatePath();
+}
+
+const OUString& SvtPathOptions::GetUserConfigPath() const
+{
+    return pImpl->GetUserConfigPath();
+}
+
+const OUString& SvtPathOptions::GetWorkPath() const
+{
+    return pImpl->GetWorkPath();
+}
+
+const OUString& SvtPathOptions::GetClassificationPath() const
+{
+    return pImpl->GetClassificationPath();
+}
+
+void SvtPathOptions::SetAddinPath( const OUString& rPath )
+{
+    pImpl->SetAddinPath( rPath );
+}
+
+void SvtPathOptions::SetAutoCorrectPath( const OUString& rPath )
+{
+    pImpl->SetAutoCorrectPath( rPath );
+}
+
+void SvtPathOptions::SetAutoTextPath( const OUString& rPath )
+{
+    pImpl->SetAutoTextPath( rPath );
+}
+
+void SvtPathOptions::SetBackupPath( const OUString& rPath )
+{
+    pImpl->SetBackupPath( rPath );
+}
+
+void SvtPathOptions::SetBasicPath( const OUString& rPath )
+{
+    pImpl->SetBasicPath( rPath );
+}
+
+void SvtPathOptions::SetBitmapPath( const OUString& rPath )
+{
+    pImpl->SetBitmapPath( rPath );
+}
+
+void SvtPathOptions::SetConfigPath( const OUString& rPath )
+{
+    pImpl->SetConfigPath( rPath );
+}
+
+void SvtPathOptions::SetDictionaryPath( const OUString& rPath )
+{
+    pImpl->SetDictionaryPath( rPath );
+}
+
+void SvtPathOptions::SetFavoritesPath( const OUString& rPath )
+{
+    pImpl->SetFavoritesPath( rPath );
+}
+
+void SvtPathOptions::SetFilterPath( const OUString& rPath )
+{
+    pImpl->SetFilterPath( rPath );
+}
+
+void SvtPathOptions::SetGalleryPath( const OUString& rPath )
+{
+    pImpl->SetGalleryPath( rPath );
+}
+
+void SvtPathOptions::SetGraphicPath( const OUString& rPath )
+{
+    pImpl->SetGraphicPath( rPath );
+}
+
+void SvtPathOptions::SetHelpPath( const OUString& rPath )
+{
+    pImpl->SetHelpPath( rPath );
+}
+
+void SvtPathOptions::SetLinguisticPath( const OUString& rPath )
+{
+    pImpl->SetLinguisticPath( rPath );
+}
+
+void SvtPathOptions::SetModulePath( const OUString& rPath )
+{
+    pImpl->SetModulePath( rPath );
+}
+
+void SvtPathOptions::SetPalettePath( const OUString& rPath )
+{
+    pImpl->SetPalettePath( rPath );
+}
+
+void SvtPathOptions::SetPluginPath( const OUString& rPath )
+{
+    pImpl->SetPluginPath( rPath );
+}
+
+void SvtPathOptions::SetStoragePath( const OUString& rPath )
+{
+    pImpl->SetStoragePath( rPath );
+}
+
+void SvtPathOptions::SetTempPath( const OUString& rPath )
+{
+    pImpl->SetTempPath( rPath );
+}
+
+void SvtPathOptions::SetTemplatePath( const OUString& rPath )
+{
+    pImpl->SetTemplatePath( rPath );
+}
+
+void SvtPathOptions::SetUserConfigPath( const OUString& rPath )
+{
+    pImpl->SetUserConfigPath( rPath );
+}
+
+void SvtPathOptions::SetWorkPath( const OUString& rPath )
+{
+    pImpl->SetWorkPath( rPath );
+}
+
+OUString SvtPathOptions::SubstituteVariable( const OUString& rVar ) const
+{
+    return pImpl->SubstVar( rVar );
+}
+
+OUString SvtPathOptions::ExpandMacros( const OUString& rPath ) const
+{
+    return pImpl->ExpandMacros( rPath );
+}
+
+OUString SvtPathOptions::UseVariable( const OUString& rPath ) const
+{
+    return pImpl->UsePathVariables( rPath );
+}
+
+bool SvtPathOptions::SearchFile( OUString& rIniFile, SvtPathOptions::Paths ePath )
+{
+    // check parameter: empty inifile name?
+    if ( rIniFile.isEmpty() )
+    {
+        SAL_WARN( "unotools.config", "SvtPathOptions::SearchFile(): invalid parameter" );
+        return false;
+    }
+
+    OUString aIniFile = pImpl->SubstVar( rIniFile );
+    bool bRet = false;
+
+    switch ( ePath )
+    {
+        case SvtPathOptions::Paths::UserConfig:
+        {
+            // path is a URL
+            bRet = true;
+            INetURLObject aObj( GetUserConfigPath() );
+
+            sal_Int32 nIniIndex = 0;
+            do
+            {
+                std::u16string_view aToken = o3tl::getToken(aIniFile, 0, '/', nIniIndex );
+                aObj.insertName(aToken);
+            }
+            while ( nIniIndex >= 0 );
+
+            if ( !::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) )
+            {
+                aObj.SetSmartURL( GetConfigPath() );
+                aObj.insertName( aIniFile );
+                bRet = ::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+            }
+
+            if ( bRet )
+                rIniFile = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+            break;
+        }
+
+        default:
+        {
+            OUString aPath;
+            switch ( ePath )
+            {
+                case SvtPathOptions::Paths::AddIn:        aPath = GetAddinPath();         break;
+                case SvtPathOptions::Paths::AutoCorrect:  aPath = GetAutoCorrectPath();   break;
+                case SvtPathOptions::Paths::AutoText:     aPath = GetAutoTextPath();      break;
+                case SvtPathOptions::Paths::Backup:       aPath = GetBackupPath();        break;
+                case SvtPathOptions::Paths::Basic:        aPath = GetBasicPath();         break;
+                case SvtPathOptions::Paths::Bitmap:       aPath = GetBitmapPath();        break;
+                case SvtPathOptions::Paths::Config:       aPath = GetConfigPath();        break;
+                case SvtPathOptions::Paths::Dictionary:   aPath = GetDictionaryPath();    break;
+                case SvtPathOptions::Paths::Favorites:    aPath = GetFavoritesPath();     break;
+                case SvtPathOptions::Paths::Filter:       aPath = GetFilterPath();        break;
+                case SvtPathOptions::Paths::Gallery:      aPath = GetGalleryPath();       break;
+                case SvtPathOptions::Paths::Graphic:      aPath = GetGraphicPath();       break;
+                case SvtPathOptions::Paths::Help:         aPath = GetHelpPath();          break;
+                case SvtPathOptions::Paths::Linguistic:   aPath = GetLinguisticPath();    break;
+                case SvtPathOptions::Paths::Module:       aPath = GetModulePath();        break;
+                case SvtPathOptions::Paths::Palette:      aPath = GetPalettePath();       break;
+                case SvtPathOptions::Paths::IconSet:      aPath = GetIconsetPath();       break;
+                case SvtPathOptions::Paths::Plugin:       aPath = GetPluginPath();        break;
+                case SvtPathOptions::Paths::Storage:      aPath = GetStoragePath();       break;
+                case SvtPathOptions::Paths::Temp:         aPath = GetTempPath();          break;
+                case SvtPathOptions::Paths::Template:     aPath = GetTemplatePath();      break;
+                case SvtPathOptions::Paths::Work:         aPath = GetWorkPath();          break;
+                case SvtPathOptions::Paths::UIConfig:     aPath = pImpl->GetUIConfigPath(); break;
+                case SvtPathOptions::Paths::Fingerprint:  aPath = GetFingerprintPath();   break;
+                case SvtPathOptions::Paths::NumberText:   aPath = GetNumbertextPath();    break;
+                case SvtPathOptions::Paths::Classification: aPath = GetClassificationPath(); break;
+                // coverity[dead_error_begin] - following conditions exist to avoid compiler warning
+                case SvtPathOptions::Paths::UserConfig:
+                case SvtPathOptions::Paths::LAST:
+                    break;
+            }
+
+            sal_Int32 nPathIndex = 0;
+            do
+            {
+                bool bIsURL = true;
+                OUString aPathToken( aPath.getToken( 0, SEARCHPATH_DELIMITER, nPathIndex ) );
+                INetURLObject aObj( aPathToken );
+                if ( aObj.HasError() )
+                {
+                    bIsURL = false;
+                    OUString aURL;
+                    if ( osl::FileBase::getFileURLFromSystemPath( aPathToken, aURL )
+                         == osl::FileBase::E_None )
+                        aObj.SetURL( aURL );
+                }
+                if ( aObj.GetProtocol() == INetProtocol::VndSunStarExpand )
+                {
+                    Reference< XMacroExpander > xMacroExpander = theMacroExpander::get( ::comphelper::getProcessComponentContext() );
+                    const OUString sExpandedPath = xMacroExpander->expandMacros( aObj.GetURLPath( INetURLObject::DecodeMechanism::WithCharset ) );
+                    aObj.SetURL( sExpandedPath );
+                }
+
+                sal_Int32 nIniIndex = 0;
+                do
+                {
+                    std::u16string_view aToken = o3tl::getToken(aIniFile, 0, '/', nIniIndex );
+                    aObj.insertName(aToken);
+                }
+                while ( nIniIndex >= 0 );
+
+                bRet = ::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+
+                if ( bRet )
+                {
+                    if ( !bIsURL )
+                    {
+                        OUString sTmp;
+                        osl::FileBase::getSystemPathFromFileURL(
+                                            aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), sTmp );
+                        rIniFile = sTmp;
+                    }
+                    else
+                        rIniFile = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+                    break;
+                }
+            }
+            while ( nPathIndex >= 0 );
+        }
+    }
+
+    return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */