xref: /aoo42x/main/unotools/source/config/pathoptions.cxx (revision 86e1cf34)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_unotools.hxx"
#ifndef GCC
#endif

#include <unotools/pathoptions.hxx>
#include <unotools/configitem.hxx>
#include <unotools/configmgr.hxx>
#include <tools/debug.hxx>
#include <tools/resmgr.hxx>
#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/localfilehelper.hxx>
#include <unotools/bootstrap.hxx>

#include <unotools/ucbhelper.hxx>
#include <vos/process.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/componentcontext.hxx>
#include <com/sun/star/beans/XFastPropertySet.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/beans/XPropertySetInfo.hpp>
#include <com/sun/star/util/XStringSubstitution.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/util/XMacroExpander.hpp>
#include <rtl/instance.hxx>

#include <itemholder1.hxx>

#include <vector>
#include <hash_map>

using namespace osl;
using namespace utl;
using namespace rtl;
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 ----------------------------------------------------------------

#define SEARCHPATH_DELIMITER			';'

#define ASCII_STR(s)					OUString( RTL_CONSTASCII_USTRINGPARAM(s) )

#define	SIGN_STARTVARIABLE				ASCII_STR("$(")
#define	SIGN_ENDVARIABLE				ASCII_STR(")")

// Supported variables by the old SvtPathOptions implementation
#define	SUBSTITUTE_INST					"$(inst)"
#define	SUBSTITUTE_PROG					"$(prog)"
#define	SUBSTITUTE_USER					"$(user)"
#define SUBSTITUTE_INSTPATH             "$(instpath)"
#define SUBSTITUTE_PROGPATH             "$(progpath)"
#define SUBSTITUTE_USERPATH             "$(userpath)"
#define	SUBSTITUTE_INSTURL				"$(insturl)"
#define	SUBSTITUTE_PROGURL				"$(progurl)"
#define	SUBSTITUTE_USERURL				"$(userurl)"
#define	SUBSTITUTE_PATH					"$(path)"
//#define	SUBSTITUTE_LANG					"$(lang)"
#define	SUBSTITUTE_LANGID				"$(langid)"
#define	SUBSTITUTE_VLANG				"$(vlang)"
#define	SUBSTITUTE_WORKDIRURL			"$(workdirurl)"

#define STRPOS_NOTFOUND					-1

struct OUStringHashCode
{
    size_t operator()( const ::rtl::OUString& sString ) const
	{
		return sString.hashCode();
	}
};

enum VarNameProperty
{
	VAR_NEEDS_SYSTEM_PATH,
	VAR_NEEDS_FILEURL
};

class NameToHandleMap : public ::std::hash_map<	::rtl::OUString, sal_Int32, OUStringHashCode, ::std::equal_to< ::rtl::OUString > >
{
	public:
		inline void free() { NameToHandleMap().swap( *this ); }
};

class EnumToHandleMap : public ::std::hash_map< sal_Int32, sal_Int32, std::hash< sal_Int32 >, std::equal_to< sal_Int32 > >
{
	public:
		inline void free() { EnumToHandleMap().swap( *this ); }
};

class VarNameToEnumMap : public ::std::hash_map< OUString, VarNameProperty, OUStringHashCode, ::std::equal_to< OUString > >
{
	public:
		inline void free() { VarNameToEnumMap().swap( *this ); }
};


// class SvtPathOptions_Impl ---------------------------------------------
class SvtPathOptions_Impl
{
	private:
		// Local variables to return const references
		std::vector< String >				m_aPathArray;
		Reference< XFastPropertySet >		m_xPathSettings;
		Reference< XStringSubstitution >	m_xSubstVariables;
        Reference< XMacroExpander >         m_xMacroExpander;
        mutable EnumToHandleMap             m_aMapEnumToPropHandle;
		VarNameToEnumMap					m_aMapVarNamesToEnum;

	    ::com::sun::star::lang::Locale 						m_aLocale;
		String								m_aEmptyString;
        mutable ::osl::Mutex                m_aMutex;

	public:
						SvtPathOptions_Impl();

		// get the pathes, not const because of using a mutex
        const String&   GetPath( SvtPathOptions::Pathes );
        const String&   GetAddinPath() { return GetPath( SvtPathOptions::PATH_ADDIN ); }
		const String&	GetAutoCorrectPath() { return GetPath( SvtPathOptions::PATH_AUTOCORRECT ); }
		const String&	GetAutoTextPath() { return GetPath( SvtPathOptions::PATH_AUTOTEXT ); }
		const String&	GetBackupPath() { return GetPath( SvtPathOptions::PATH_BACKUP ); }
		const String&	GetBasicPath() { return GetPath( SvtPathOptions::PATH_BASIC ); }
		const String&	GetBitmapPath() { return GetPath( SvtPathOptions::PATH_BITMAP ); }
		const String&	GetConfigPath() { return GetPath( SvtPathOptions::PATH_CONFIG ); }
		const String&	GetDictionaryPath() { return GetPath( SvtPathOptions::PATH_DICTIONARY ); }
		const String&	GetFavoritesPath() { return GetPath( SvtPathOptions::PATH_FAVORITES ); }
		const String&	GetFilterPath() { return GetPath( SvtPathOptions::PATH_FILTER ); }
		const String&	GetGalleryPath() { return GetPath( SvtPathOptions::PATH_GALLERY ); }
		const String&	GetGraphicPath() { return GetPath( SvtPathOptions::PATH_GRAPHIC ); }
		const String&	GetHelpPath() { return GetPath( SvtPathOptions::PATH_HELP ); }
		const String&	GetLinguisticPath() { return GetPath( SvtPathOptions::PATH_LINGUISTIC ); }
		const String&	GetModulePath() { return GetPath( SvtPathOptions::PATH_MODULE ); }
		const String&	GetPalettePath() { return GetPath( SvtPathOptions::PATH_PALETTE ); }
		const String&	GetPluginPath() { return GetPath( SvtPathOptions::PATH_PLUGIN ); }
		const String&	GetStoragePath() { return GetPath( SvtPathOptions::PATH_STORAGE ); }
		const String&	GetTempPath() { return GetPath( SvtPathOptions::PATH_TEMP ); }
		const String&	GetTemplatePath() { return GetPath( SvtPathOptions::PATH_TEMPLATE ); }
		const String&	GetUserConfigPath() { return GetPath( SvtPathOptions::PATH_USERCONFIG ); }
		const String&	GetWorkPath() { return GetPath( SvtPathOptions::PATH_WORK ); }
	    const String&   GetUIConfigPath() { return GetPath( SvtPathOptions::PATH_UICONFIG ); }
        const String&   GetFingerprintPath() { return GetPath( SvtPathOptions::PATH_FINGERPRINT ); }

		// set the pathes
        void            SetPath( SvtPathOptions::Pathes, const String& rNewPath );
        void            SetAddinPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_ADDIN, rPath ); }
		void			SetAutoCorrectPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_AUTOCORRECT, rPath ); }
		void			SetAutoTextPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_AUTOTEXT, rPath ); }
		void			SetBackupPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_BACKUP, rPath ); }
		void			SetBasicPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_BASIC, rPath ); }
		void			SetBitmapPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_BITMAP, rPath ); }
		void			SetConfigPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_CONFIG, rPath ); }
		void			SetDictionaryPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_DICTIONARY, rPath ); }
		void			SetFavoritesPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_FAVORITES, rPath ); }
		void			SetFilterPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_FILTER, rPath ); }
		void			SetGalleryPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_GALLERY, rPath ); }
		void			SetGraphicPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_GRAPHIC, rPath ); }
		void			SetHelpPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_HELP, rPath ); }
		void			SetLinguisticPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_LINGUISTIC, rPath ); }
		void			SetModulePath( const String& rPath ) { SetPath( SvtPathOptions::PATH_MODULE, rPath ); }
		void			SetPalettePath( const String& rPath ) { SetPath( SvtPathOptions::PATH_PALETTE, rPath ); }
		void			SetPluginPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_PLUGIN, rPath ); }
		void			SetStoragePath( const String& rPath ) { SetPath( SvtPathOptions::PATH_STORAGE, rPath ); }
		void			SetTempPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_TEMP, rPath ); }
		void			SetTemplatePath( const String& rPath ) { SetPath( SvtPathOptions::PATH_TEMPLATE, rPath ); }
		void			SetUserConfigPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_USERCONFIG, rPath ); }
		void			SetWorkPath( const String& rPath ) { SetPath( SvtPathOptions::PATH_WORK, rPath ); }

		rtl::OUString	SubstVar( const rtl::OUString& rVar ) const;
		rtl::OUString	ExpandMacros( const rtl::OUString& rPath ) const;
		rtl::OUString	UsePathVariables( const rtl::OUString& rPath ) const;

		::com::sun::star::lang::Locale	GetLocale() const { return m_aLocale; }

        sal_Bool            IsPathReadonly(SvtPathOptions::Pathes ePath)const;
};

// global ----------------------------------------------------------------

static SvtPathOptions_Impl* pOptions = NULL;
static sal_Int32 nRefCount = 0;

// functions -------------------------------------------------------------
struct PropertyStruct
{
	const char*				pPropName;	// The ascii name of the Office path
	SvtPathOptions::Pathes	ePath;		// The enum value used by SvtPathOptions
};

struct VarNameAttribute
{
	const char*				pVarName;		// The name of the path variable
	VarNameProperty			eVarProperty;	// Which return value is needed by this path variable
};

static PropertyStruct aPropNames[] =
{
	{ "Addin",			SvtPathOptions::PATH_ADDIN			},
	{ "AutoCorrect",	SvtPathOptions::PATH_AUTOCORRECT	},
	{ "AutoText",		SvtPathOptions::PATH_AUTOTEXT		},
	{ "Backup",			SvtPathOptions::PATH_BACKUP			},
	{ "Basic",			SvtPathOptions::PATH_BASIC			},
	{ "Bitmap",			SvtPathOptions::PATH_BITMAP			},
	{ "Config",			SvtPathOptions::PATH_CONFIG			},
	{ "Dictionary",		SvtPathOptions::PATH_DICTIONARY		},
	{ "Favorite",		SvtPathOptions::PATH_FAVORITES		},
	{ "Filter",			SvtPathOptions::PATH_FILTER			},
	{ "Gallery",		SvtPathOptions::PATH_GALLERY		},
	{ "Graphic",		SvtPathOptions::PATH_GRAPHIC		},
	{ "Help",			SvtPathOptions::PATH_HELP			},
	{ "Linguistic",		SvtPathOptions::PATH_LINGUISTIC		},
	{ "Module",			SvtPathOptions::PATH_MODULE			},
	{ "Palette",		SvtPathOptions::PATH_PALETTE		},
	{ "Plugin",			SvtPathOptions::PATH_PLUGIN			},
	{ "Storage",		SvtPathOptions::PATH_STORAGE		},
	{ "Temp",			SvtPathOptions::PATH_TEMP			},
	{ "Template",		SvtPathOptions::PATH_TEMPLATE		},
	{ "UserConfig",		SvtPathOptions::PATH_USERCONFIG		},
    { "Work",           SvtPathOptions::PATH_WORK			},
    { "UIConfig",       SvtPathOptions::PATH_UICONFIG		},
    { "Fingerprint",    SvtPathOptions::PATH_FINGERPRINT	}
};

static VarNameAttribute aVarNameAttribute[] =
{
	{ SUBSTITUTE_INSTPATH,	VAR_NEEDS_SYSTEM_PATH },	// $(instpath)
	{ SUBSTITUTE_PROGPATH,	VAR_NEEDS_SYSTEM_PATH },	// $(progpath)
	{ SUBSTITUTE_USERPATH,	VAR_NEEDS_SYSTEM_PATH },	// $(userpath)
	{ SUBSTITUTE_PATH,		VAR_NEEDS_SYSTEM_PATH },	// $(path)
};

#if 0
// currently unused
static Sequence< OUString > GetPathPropertyNames()
{
	const int nCount = sizeof( aPropNames ) / sizeof( PropertyStruct );
	Sequence< OUString > aNames( nCount );
	OUString* pNames = aNames.getArray();
	for ( int i = 0; i < nCount; i++ )
		pNames[i] = OUString::createFromAscii( aPropNames[i].pPropName );

	return aNames;
}
#endif

// class SvtPathOptions_Impl ---------------------------------------------

const String& SvtPathOptions_Impl::GetPath( SvtPathOptions::Pathes ePath )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( ePath >= SvtPathOptions::PATH_COUNT )
        return m_aEmptyString;

    OUString 	aPathValue;
	String		aResult;
	sal_Int32	nHandle = m_aMapEnumToPropHandle[ (sal_Int32)ePath ];

	// Substitution is done by the service itself using the substition service
	Any 		a = m_xPathSettings->getFastPropertyValue( nHandle );
	a >>= aPathValue;
	if( ePath == SvtPathOptions::PATH_ADDIN     ||
        ePath == SvtPathOptions::PATH_FILTER    ||
        ePath == SvtPathOptions::PATH_HELP      ||
        ePath == SvtPathOptions::PATH_MODULE    ||
        ePath == SvtPathOptions::PATH_PLUGIN    ||
        ePath == SvtPathOptions::PATH_STORAGE
      )
	{
        // These office paths have to be converted to system pathes
        utl::LocalFileHelper::ConvertURLToPhysicalName( aPathValue, aResult );
        aPathValue = aResult;
	}

	m_aPathArray[ ePath ] = aPathValue;
    return m_aPathArray[ ePath ];
}
// -----------------------------------------------------------------------
sal_Bool SvtPathOptions_Impl::IsPathReadonly(SvtPathOptions::Pathes ePath)const
{
    ::osl::MutexGuard aGuard( m_aMutex );
    sal_Bool bReadonly = sal_False;
    if ( ePath < SvtPathOptions::PATH_COUNT )
    {
        Reference<XPropertySet> xPrSet(m_xPathSettings, UNO_QUERY);
        if(xPrSet.is())
        {
            Reference<XPropertySetInfo> xInfo = xPrSet->getPropertySetInfo();
			const char* pA = aPropNames[ePath].pPropName;
			::rtl::OUString sU = OUString::createFromAscii(pA);
            Property aProperty = xInfo->getPropertyByName(sU);
            bReadonly = 0 != (aProperty.Attributes & PropertyAttribute::READONLY);
        }
    }
    return bReadonly;
}
// -----------------------------------------------------------------------

void SvtPathOptions_Impl::SetPath( SvtPathOptions::Pathes ePath, const String& rNewPath )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( ePath < SvtPathOptions::PATH_COUNT )
	{
		String 		aResult;
		OUString	aNewValue;
		Any			a;

		switch ( ePath )
		{
			case SvtPathOptions::PATH_ADDIN:
			case SvtPathOptions::PATH_FILTER:
			case SvtPathOptions::PATH_HELP:
			case SvtPathOptions::PATH_MODULE:
			case SvtPathOptions::PATH_PLUGIN:
			case SvtPathOptions::PATH_STORAGE:
			{
				// These office paths have to be convert back to UCB-URL's
				utl::LocalFileHelper::ConvertPhysicalNameToURL( rNewPath, aResult );
				aNewValue = aResult;
			}
			break;

			default:
				aNewValue = rNewPath;
		}

		// Resubstitution is done by the service itself using the substition service
		a <<= aNewValue;
		try
		{
			m_xPathSettings->setFastPropertyValue( m_aMapEnumToPropHandle[ (sal_Int32)ePath], a );
		}
		catch (const Exception&)
		{
		}
	}
}

//-------------------------------------------------------------------------

OUString SvtPathOptions_Impl::ExpandMacros( const rtl::OUString& rPath ) const
{
    ::rtl::OUString sExpanded( rPath );

    const INetURLObject aParser( rPath );
    if ( aParser.GetProtocol() == INET_PROT_VND_SUN_STAR_EXPAND )
        sExpanded = m_xMacroExpander->expandMacros( aParser.GetURLPath( INetURLObject::DECODE_WITH_CHARSET ) );

    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!
	sal_Bool bConvertLocal = sal_False;

	// Search for first occur 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 aReplacement;
		OUString aSubString = aWorkText.copy( nPosition, nLength );
        aSubString = aSubString.toAsciiLowerCase();

		// Look for special variable that needs a system path.
		VarNameToEnumMap::const_iterator pIter = m_aMapVarNamesToEnum.find( aSubString );
		if ( pIter != m_aMapVarNamesToEnum.end() )
			bConvertLocal = sal_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, sal_False );

	if ( bConvertLocal )
	{
		// Convert the URL to a system path for special path variables
        String aReturn;
		utl::LocalFileHelper::ConvertURLToPhysicalName( aWorkText, aReturn );
		return aReturn;
	}

    return aWorkText;
}

// -----------------------------------------------------------------------

SvtPathOptions_Impl::SvtPathOptions_Impl() :
	m_aPathArray( (sal_Int32)SvtPathOptions::PATH_COUNT )
{
	Reference< XMultiServiceFactory > xSMgr = comphelper::getProcessServiceFactory();

	// Create necessary services
	m_xPathSettings = Reference< XFastPropertySet >( xSMgr->createInstance(
													::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
														"com.sun.star.util.PathSettings" ))),
												UNO_QUERY );
    if ( !m_xPathSettings.is() )
	{
        // #112719#: check for existence
		DBG_ERROR( "SvtPathOptions_Impl::SvtPathOptions_Impl(): #112719# happened again!" );
        throw RuntimeException(
            ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Service com.sun.star.util.PathSettings cannot be created" )),
            Reference< XInterface >() );
	}

    ::comphelper::ComponentContext aContext( xSMgr );
    m_xSubstVariables.set( aContext.createComponent( "com.sun.star.util.PathSubstitution" ), UNO_QUERY_THROW );
    m_xMacroExpander.set( aContext.getSingleton( "com.sun.star.util.theMacroExpander" ), UNO_QUERY_THROW );

    // Create temporary hash map to have a mapping between property names and property handles
	Reference< XPropertySet > xPropertySet = Reference< XPropertySet >( m_xPathSettings, UNO_QUERY );
	Reference< XPropertySetInfo > xPropSetInfo = xPropertySet->getPropertySetInfo();
	Sequence< Property > aPathPropSeq = xPropSetInfo->getProperties();

	NameToHandleMap aTempHashMap;
	for ( sal_Int32 n = 0; n < aPathPropSeq.getLength(); n++ )
	{
		const com::sun::star::beans::Property& aProperty = aPathPropSeq[n];
		aTempHashMap.insert( NameToHandleMap::value_type( aProperty.Name, aProperty.Handle ));
	}

	// Create mapping between internal enum (SvtPathOptions::Pathes) and property handle
	sal_Int32 nCount = sizeof( aPropNames ) / sizeof( PropertyStruct );
	sal_Int32 i;
	for ( i = 0; i < nCount; i++ )
	{
		NameToHandleMap::const_iterator pIter =
			aTempHashMap.find( rtl::OUString::createFromAscii( aPropNames[i].pPropName ));

		if ( pIter != aTempHashMap.end() )
		{
			sal_Int32 nHandle	= pIter->second;
			sal_Int32 nEnum		= aPropNames[i].ePath;
			m_aMapEnumToPropHandle.insert( EnumToHandleMap::value_type( nEnum, nHandle ));
		}
	}

	// Create hash map for path variables that need a system path as a return value!
	nCount = sizeof( aVarNameAttribute ) / sizeof( VarNameAttribute );
	for ( i = 0; i < nCount; i++ )
	{
		m_aMapVarNamesToEnum.insert( VarNameToEnumMap::value_type(
				OUString::createFromAscii( aVarNameAttribute[i].pVarName ),
				aVarNameAttribute[i].eVarProperty ));
	}

	// Set language type!
	Any aLocale = ConfigManager::GetConfigManager()->GetDirectConfigProperty( ConfigManager::LOCALE );
	OUString aLocaleStr;
	if ( aLocale >>= aLocaleStr )
    {
        sal_Int32 nIndex = 0;
        m_aLocale.Language = aLocaleStr.getToken(0, '-', nIndex );
        m_aLocale.Country = aLocaleStr.getToken(0, '-', nIndex );
        m_aLocale.Variant = aLocaleStr.getToken(0, '-', nIndex );
    }
	else
	{
		DBG_ERRORFILE( "wrong any type" );
        m_aLocale.Language = OStringToOUString(OString("en"), RTL_TEXTENCODING_UTF8);
        m_aLocale.Country =  OStringToOUString(OString("US"), RTL_TEXTENCODING_UTF8);
        m_aLocale.Variant =  OStringToOUString(OString(""), RTL_TEXTENCODING_UTF8);
	}
}

// -----------------------------------------------------------------------

// class SvtPathOptions --------------------------------------------------

namespace { struct lclMutex : public rtl::Static< ::osl::Mutex, lclMutex > {}; }

SvtPathOptions::SvtPathOptions()
{
    // Global access, must be guarded (multithreading)
    ::osl::MutexGuard aGuard( lclMutex::get() );
    if ( !pOptions )
	{
        pOptions = new SvtPathOptions_Impl;
        ItemHolder1::holdConfigItem(E_PATHOPTIONS);
	}
    ++nRefCount;
    pImp = pOptions;
}

// -----------------------------------------------------------------------

SvtPathOptions::~SvtPathOptions()
{
    // Global access, must be guarded (multithreading)
    ::osl::MutexGuard aGuard( lclMutex::get() );
    if ( !--nRefCount )
	{
        DELETEZ( pOptions );
	}
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetAddinPath() const
{
	return pImp->GetAddinPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetAutoCorrectPath() const
{
	return pImp->GetAutoCorrectPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetAutoTextPath() const
{
	return pImp->GetAutoTextPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetBackupPath() const
{
	return pImp->GetBackupPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetBasicPath() const
{
	return pImp->GetBasicPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetBitmapPath() const
{
	return pImp->GetBitmapPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetConfigPath() const
{
	return pImp->GetConfigPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetDictionaryPath() const
{
	return pImp->GetDictionaryPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetFavoritesPath() const
{
	return pImp->GetFavoritesPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetFilterPath() const
{
	return pImp->GetFilterPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetGalleryPath() const
{
	return pImp->GetGalleryPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetGraphicPath() const
{
	return pImp->GetGraphicPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetHelpPath() const
{
	return pImp->GetHelpPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetLinguisticPath() const
{
	return pImp->GetLinguisticPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetFingerprintPath() const
{
    return pImp->GetFingerprintPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetModulePath() const
{
	return pImp->GetModulePath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetPalettePath() const
{
	return pImp->GetPalettePath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetPluginPath() const
{
	return pImp->GetPluginPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetStoragePath() const
{
	return pImp->GetStoragePath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetTempPath() const
{
	return pImp->GetTempPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetTemplatePath() const
{
	return pImp->GetTemplatePath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetUserConfigPath() const
{
	return pImp->GetUserConfigPath();
}

const String& SvtPathOptions::GetUIConfigPath() const
{
    return pImp->GetUIConfigPath();
}

// -----------------------------------------------------------------------

const String& SvtPathOptions::GetWorkPath() const
{
	return pImp->GetWorkPath();
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetAddinPath( const String& rPath )
{
	pImp->SetAddinPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetAutoCorrectPath( const String& rPath )
{
	pImp->SetAutoCorrectPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetAutoTextPath( const String& rPath )
{
	pImp->SetAutoTextPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetBackupPath( const String& rPath )
{
	pImp->SetBackupPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetBasicPath( const String& rPath )
{
	pImp->SetBasicPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetBitmapPath( const String& rPath )
{
	pImp->SetBitmapPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetConfigPath( const String& rPath )
{
	pImp->SetConfigPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetDictionaryPath( const String& rPath )
{
	pImp->SetDictionaryPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetFavoritesPath( const String& rPath )
{
	pImp->SetFavoritesPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetFilterPath( const String& rPath )
{
	pImp->SetFilterPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetGalleryPath( const String& rPath )
{
	pImp->SetGalleryPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetGraphicPath( const String& rPath )
{
	pImp->SetGraphicPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetHelpPath( const String& rPath )
{
	pImp->SetHelpPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetLinguisticPath( const String& rPath )
{
	pImp->SetLinguisticPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetModulePath( const String& rPath )
{
	pImp->SetModulePath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetPalettePath( const String& rPath )
{
	pImp->SetPalettePath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetPluginPath( const String& rPath )
{
	pImp->SetPluginPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetStoragePath( const String& rPath )
{
	pImp->SetStoragePath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetTempPath( const String& rPath )
{
	pImp->SetTempPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetTemplatePath( const String& rPath )
{
	pImp->SetTemplatePath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetUserConfigPath( const String& rPath )
{
	pImp->SetUserConfigPath( rPath );
}

// -----------------------------------------------------------------------

void SvtPathOptions::SetWorkPath( const String& rPath )
{
	pImp->SetWorkPath( rPath );
}

// -----------------------------------------------------------------------

String SvtPathOptions::SubstituteVariable( const String& rVar ) const
{
    String aRet = pImp->SubstVar( rVar );
	return aRet;
}

// -----------------------------------------------------------------------

String SvtPathOptions::ExpandMacros( const String& rPath ) const
{
    return pImp->ExpandMacros( rPath );
}

// -----------------------------------------------------------------------

String SvtPathOptions::UseVariable( const String& rPath ) const
{
    String aRet = pImp->UsePathVariables( rPath );
	return aRet;
}

// -----------------------------------------------------------------------

sal_Bool SvtPathOptions::SearchFile( String& rIniFile, Pathes ePath )
{
	// check parameter: empty inifile name?
	if ( !rIniFile.Len() )
	{
		DBG_ERRORFILE( "SvtPathOptions::SearchFile(): invalid parameter" );
		return sal_False;
	}

    String aIniFile = pImp->SubstVar( rIniFile );
	sal_Bool bRet = sal_False;

	switch ( ePath )
	{
		case PATH_USERCONFIG:
		{
            // path is a URL
			bRet = sal_True;
            INetURLObject aObj( GetUserConfigPath() );
			xub_StrLen i, nCount = aIniFile.GetTokenCount( '/' );
			for ( i = 0; i < nCount; ++i )
				aObj.insertName( aIniFile.GetToken( i, '/' ) );

            if ( !::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::NO_DECODE ) ) )
			{
                aObj.SetSmartURL( GetConfigPath() );
				aObj.insertName( aIniFile );
                bRet = ::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::NO_DECODE ) );
			}

			if ( bRet )
				rIniFile = aObj.GetMainURL( INetURLObject::NO_DECODE );

			break;
		}

		default:
		{
			String aPath;
			switch ( ePath )
			{
				case PATH_ADDIN:		aPath = GetAddinPath();			break;
				case PATH_AUTOCORRECT:	aPath = GetAutoCorrectPath();	break;
				case PATH_AUTOTEXT:		aPath = GetAutoTextPath();		break;
				case PATH_BACKUP:		aPath = GetBackupPath();		break;
				case PATH_BASIC:		aPath = GetBasicPath();			break;
				case PATH_BITMAP:		aPath = GetBitmapPath();		break;
				case PATH_CONFIG:		aPath = GetConfigPath();		break;
				case PATH_DICTIONARY:	aPath = GetDictionaryPath();	break;
				case PATH_FAVORITES:	aPath = GetFavoritesPath();		break;
				case PATH_FILTER:		aPath = GetFilterPath();		break;
				case PATH_GALLERY:		aPath = GetGalleryPath();		break;
				case PATH_GRAPHIC:		aPath = GetGraphicPath();		break;
				case PATH_HELP:			aPath = GetHelpPath();			break;
				case PATH_LINGUISTIC:	aPath = GetLinguisticPath();	break;
				case PATH_MODULE:		aPath = GetModulePath();		break;
				case PATH_PALETTE:		aPath = GetPalettePath();		break;
				case PATH_PLUGIN:		aPath = GetPluginPath();		break;
				case PATH_STORAGE:		aPath = GetStoragePath();		break;
				case PATH_TEMP:			aPath = GetTempPath();			break;
				case PATH_TEMPLATE:		aPath = GetTemplatePath();      break;
				case PATH_WORK:			aPath = GetWorkPath();			break;
                case PATH_UICONFIG:     aPath = GetUIConfigPath();      break;
                case PATH_FINGERPRINT:  aPath = GetFingerprintPath();   break;
				case PATH_USERCONFIG:/*-Wall???*/			break;
                case PATH_COUNT: /*-Wall???*/ break;
			}

			sal_uInt16 j, nIdx = 0, nTokenCount = aPath.GetTokenCount( SEARCHPATH_DELIMITER );
			for ( j = 0; j < nTokenCount; ++j )
			{
                sal_Bool bIsURL = sal_True;
				String aPathToken = aPath.GetToken( 0, SEARCHPATH_DELIMITER, nIdx );
				INetURLObject aObj( aPathToken );
				if ( aObj.HasError() )
				{
                    bIsURL = sal_False;
					String aURL;
					if ( LocalFileHelper::ConvertPhysicalNameToURL( aPathToken, aURL ) )
						aObj.SetURL( aURL );
				}
                if ( aObj.GetProtocol() == INET_PROT_VND_SUN_STAR_EXPAND )
                {
                    ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() );
                    Reference< XMacroExpander > xMacroExpander( aContext.getSingleton( "com.sun.star.util.theMacroExpander" ), UNO_QUERY );
                    OSL_ENSURE( xMacroExpander.is(), "SvtPathOptions::SearchFile: unable to access the MacroExpander singleton!" );
                    if ( xMacroExpander.is() )
                    {
                        const ::rtl::OUString sExpandedPath = xMacroExpander->expandMacros( aObj.GetURLPath( INetURLObject::DECODE_WITH_CHARSET ) );
                        aObj.SetURL( sExpandedPath );
                    }
                }

				xub_StrLen i, nCount = aIniFile.GetTokenCount( '/' );
				for ( i = 0; i < nCount; ++i )
					aObj.insertName( aIniFile.GetToken( i, '/' ) );
                bRet = ::utl::UCBContentHelper::Exists( aObj.GetMainURL( INetURLObject::NO_DECODE ) );

				if ( bRet )
				{
                    if ( !bIsURL )
                        ::utl::LocalFileHelper::ConvertURLToPhysicalName(
											aObj.GetMainURL( INetURLObject::NO_DECODE ), rIniFile );
					else
						rIniFile = aObj.GetMainURL( INetURLObject::NO_DECODE );
					break;
				}
			}
		}
	}

	return bRet;
}

// -----------------------------------------------------------------------

::com::sun::star::lang::Locale SvtPathOptions::GetLocale() const
{
	return pImp->GetLocale();
}
// -----------------------------------------------------------------------
sal_Bool SvtPathOptions::IsPathReadonly(Pathes ePath)const
{
    return pImp->IsPathReadonly(ePath);
}
// -----------------------------------------------------------------------
const String& SvtPathOptions::GetPath(Pathes ePath)const
{
    return pImp->GetPath(ePath);
}
// -----------------------------------------------------------------------
void SvtPathOptions::SetPath( SvtPathOptions::Pathes ePath, const String& rNewPath )
{
    pImp->SetPath(ePath, rNewPath);
}

// class PathService -----------------------------------------------------
#include <com/sun/star/frame/XConfigManager.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <cppuhelper/implbase2.hxx>

class PathService : public ::cppu::WeakImplHelper2< ::com::sun::star::frame::XConfigManager, ::com::sun::star::lang::XServiceInfo >
{
    virtual ::rtl::OUString	SAL_CALL	getImplementationName(  ) throw(::com::sun::star::uno::RuntimeException);
    virtual sal_Bool SAL_CALL			supportsService( const ::rtl::OUString& ServiceName ) throw(::com::sun::star::uno::RuntimeException);
    virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL
										getSupportedServiceNames(  ) throw(::com::sun::star::uno::RuntimeException);
    virtual ::rtl::OUString SAL_CALL	substituteVariables( const ::rtl::OUString& sText ) throw(::com::sun::star::uno::RuntimeException);
    virtual void SAL_CALL				addPropertyChangeListener( const ::rtl::OUString& sKeyName, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener >& xListener ) throw(::com::sun::star::uno::RuntimeException);
    virtual void SAL_CALL				removePropertyChangeListener( const ::rtl::OUString& sKeyName, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener >& xListener ) throw(::com::sun::star::uno::RuntimeException);
    virtual void SAL_CALL				flush(  ) throw(::com::sun::star::uno::RuntimeException);
};

// class PathService -----------------------------------------------------

void SAL_CALL PathService::addPropertyChangeListener( const ::rtl::OUString&, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener >& ) throw(::com::sun::star::uno::RuntimeException) {}
void SAL_CALL PathService::removePropertyChangeListener( const ::rtl::OUString&, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener >& ) throw(::com::sun::star::uno::RuntimeException) {}
void SAL_CALL PathService::flush(  ) throw(::com::sun::star::uno::RuntimeException) {}

::rtl::OUString SAL_CALL PathService::substituteVariables( const ::rtl::OUString& sText ) throw(::com::sun::star::uno::RuntimeException)
{
    return SvtPathOptions().SubstituteVariable( sText );
}

::rtl::OUString SAL_CALL PathService::getImplementationName(  ) throw(::com::sun::star::uno::RuntimeException)
{
    return OUString::createFromAscii("com.sun.star.comp.unotools.PathService");
}

sal_Bool SAL_CALL PathService::supportsService( const ::rtl::OUString& ServiceName ) throw(::com::sun::star::uno::RuntimeException)
{
    if ( ServiceName.compareToAscii("com.sun.star.config.SpecialConfigManager") == COMPARE_EQUAL )
        return sal_True;
    else
        return sal_False;
}

::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL PathService::getSupportedServiceNames(  ) throw(::com::sun::star::uno::RuntimeException)
{
    Sequence< OUString > aRet(1);
    *aRet.getArray() = OUString::createFromAscii("com.sun.star.config.SpecialConfigManager");
    return aRet;
}