path: root/unotools/source/config/pathoptions.cxx

/* -*- 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: */