/**************************************************************
 *
 * 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_fpicker.hxx"

#include "OfficeFilePicker.hxx"
#include "iodlg.hxx"

#ifndef _LIST_
#include <list>
#endif
#ifndef _FUNCTIONAL_
#include <functional>
#endif
#ifndef _ALGORITHM_
#include <algorithm>
#endif
#include <tools/urlobj.hxx>
#include <tools/debug.hxx>
#define _SVSTDARR_STRINGSDTOR
#include "svl/svstdarr.hxx"
#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/ui/dialogs/FilePickerEvent.hpp>
#include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp>
#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/awt/XWindow.hpp>
#include <com/sun/star/beans/StringPair.hpp>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/beans/NamedValue.hpp>
#include <unotools/ucbhelper.hxx>
#include <unotools/pathoptions.hxx>
#include <comphelper/sequence.hxx>
#include <cppuhelper/typeprovider.hxx>
#include "vos/mutex.hxx"
#ifndef _SV_APP_HXX
#include "vcl/svapp.hxx"
#endif

// define ----------------------------------------------------------------

#define MAKE_ANY	::com::sun::star::uno::makeAny

// using ----------------------------------------------------------------

using namespace		::com::sun::star::container;
using namespace		::com::sun::star::lang;
using namespace		::com::sun::star::ui::dialogs;
using namespace		::com::sun::star::uno;
using namespace		::com::sun::star::beans;
using namespace		::com::sun::star::awt;
using namespace		::utl;

//=====================================================================

//=====================================================================

struct FilterEntry
{
protected:
	::rtl::OUString		m_sTitle;
	::rtl::OUString		m_sFilter;

	UnoFilterList		m_aSubFilters;

public:
	FilterEntry( const ::rtl::OUString& _rTitle, const ::rtl::OUString& _rFilter )
		:m_sTitle( _rTitle )
		,m_sFilter( _rFilter )
	{
	}

	FilterEntry( const ::rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters );

	::rtl::OUString		getTitle() const { return m_sTitle; }
	::rtl::OUString		getFilter() const { return m_sFilter; }

	/// determines if the filter has sub filter (i.e., the filter is a filter group in real)
	sal_Bool			hasSubFilters( ) const;

	/** retrieves the filters belonging to the entry
	@return
		the number of sub filters
	*/
	sal_Int32			getSubFilters( UnoFilterList& _rSubFilterList );

	// helpers for iterating the sub filters
	const UnoFilterEntry*	beginSubFilters() const { return m_aSubFilters.getConstArray(); }
	const UnoFilterEntry*	endSubFilters() const { return m_aSubFilters.getConstArray() + m_aSubFilters.getLength(); }
};

//=====================================================================

//---------------------------------------------------------------------
FilterEntry::FilterEntry( const ::rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters )
	:m_sTitle( _rTitle )
	,m_aSubFilters( _rSubFilters )
{
}

//---------------------------------------------------------------------
sal_Bool FilterEntry::hasSubFilters( ) const
{
	return ( 0 < m_aSubFilters.getLength() );
}

//---------------------------------------------------------------------
sal_Int32 FilterEntry::getSubFilters( UnoFilterList& _rSubFilterList )
{
	_rSubFilterList = m_aSubFilters;
	return m_aSubFilters.getLength();
}

// struct ElementEntry_Impl ----------------------------------------------

struct ElementEntry_Impl
{
	sal_Int16		m_nElementID;
	sal_Int16		m_nControlAction;
	Any				m_aValue;
	rtl::OUString	m_aLabel;
	sal_Bool		m_bEnabled		: 1;

	sal_Bool		m_bHasValue		: 1;
	sal_Bool		m_bHasLabel		: 1;
	sal_Bool		m_bHasEnabled	: 1;

					ElementEntry_Impl( sal_Int16 nId );

	void			setValue( const Any& rVal ) { m_aValue = rVal; m_bHasValue = sal_True; }
	void			setAction( sal_Int16 nAction ) { m_nControlAction = nAction; }
	void			setLabel( const rtl::OUString& rVal ) { m_aLabel = rVal; m_bHasLabel = sal_True; }
	void			setEnabled( sal_Bool bEnabled ) { m_bEnabled = bEnabled; m_bHasEnabled = sal_True; }
};

ElementEntry_Impl::ElementEntry_Impl( sal_Int16 nId )
	: m_nElementID( nId )
	, m_nControlAction( 0 )
	, m_bEnabled( sal_False )
	, m_bHasValue( sal_False )
	, m_bHasLabel( sal_False )
	, m_bHasEnabled( sal_False )
{}

//------------------------------------------------------------------------------------
void SvtFilePicker::prepareExecute()
{
	// set the default directory
	// --**-- doesn't match the spec yet
	if ( m_aDisplayDirectory.getLength() > 0 || m_aDefaultName.getLength() > 0 )
	{
		sal_Bool isFileSet = sal_False;
		if ( m_aDisplayDirectory.getLength() > 0 )
		{

			INetURLObject aPath;
			INetURLObject givenPath( m_aDisplayDirectory );
			if (!givenPath.HasError())
				aPath = givenPath;
			else
			{
				INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() );
				aPath = aStdDirObj;
			}
			if ( m_aDefaultName.getLength() > 0 )
			{
				aPath.insertName( m_aDefaultName );
				getDialog()->SetHasFilename( true );
			}
			String sPath = aPath.GetMainURL( INetURLObject::NO_DECODE );
			getDialog()->SetPath( sPath );
			isFileSet = sal_True;
		}
		if ( !isFileSet && m_aDefaultName.getLength() > 0 )
		{
			getDialog()->SetPath( m_aDefaultName );
			getDialog()->SetHasFilename( true );
		}
	}
	else
	{
		// set default-standard-dir
		INetURLObject aStdDirObj( SvtPathOptions().GetWorkPath() );
		getDialog()->SetPath( aStdDirObj.GetMainURL( INetURLObject::NO_DECODE ) );
	}

	// set the control values and set the control labels, too
	if ( m_pElemList && !m_pElemList->empty() )
	{
		::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );

		ElementList::iterator aListIter;
		for ( aListIter = m_pElemList->begin();
			  aListIter != m_pElemList->end(); ++aListIter )
		{
			ElementEntry_Impl& rEntry = *aListIter;
			if ( rEntry.m_bHasValue )
				aAccess.setValue( rEntry.m_nElementID, rEntry.m_nControlAction, rEntry.m_aValue );
			if ( rEntry.m_bHasLabel )
				aAccess.setLabel( rEntry.m_nElementID, rEntry.m_aLabel );
			if ( rEntry.m_bHasEnabled )
				aAccess.enableControl( rEntry.m_nElementID, rEntry.m_bEnabled );
		}

		getDialog()->updateListboxLabelSizes();
	}

	if ( m_pFilterList && !m_pFilterList->empty() )
	{
		for (   FilterList::iterator aListIter = m_pFilterList->begin();
				aListIter != m_pFilterList->end();
				++aListIter
			)
		{
			if ( aListIter->hasSubFilters() )
			{   // it's a filter group
				UnoFilterList aSubFilters;
				aListIter->getSubFilters( aSubFilters );

				getDialog()->AddFilterGroup( aListIter->getTitle(), aSubFilters );
			}
			else
				// it's a single filter
				getDialog()->AddFilter( aListIter->getTitle(), aListIter->getFilter() );
		}
	}

	// set the default filter
	if ( m_aCurrentFilter.getLength() > 0 )
		getDialog()->SetCurFilter( m_aCurrentFilter );

}

//-----------------------------------------------------------------------------
IMPL_LINK( SvtFilePicker, DialogClosedHdl, Dialog*, pDlg )
{
	if ( m_xDlgClosedListener.is() )
	{
		sal_Int16 nRet = static_cast< sal_Int16 >( pDlg->GetResult() );
		::com::sun::star::ui::dialogs::DialogClosedEvent aEvent( *this, nRet );
		m_xDlgClosedListener->dialogClosed( aEvent );
		m_xDlgClosedListener.clear();
	}
	return 0;
}

//------------------------------------------------------------------------------------
// SvtFilePicker
//------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------
WinBits SvtFilePicker::getWinBits( WinBits& rExtraBits )
{
	// set the winbits for creating the filedialog
	WinBits nBits = 0L;
	rExtraBits = 0L;

	// set the standard bits according to the service name
	if ( m_nServiceType == TemplateDescription::FILEOPEN_SIMPLE )
	{
		nBits = WB_OPEN;
	}
	else if ( m_nServiceType == TemplateDescription::FILESAVE_SIMPLE )
	{
		nBits = WB_SAVEAS;
	}
	else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION )
	{
		nBits = WB_SAVEAS;
		rExtraBits = SFX_EXTRA_AUTOEXTENSION;
	}
	else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD )
	{
		nBits = WB_SAVEAS | SFXWB_PASSWORD;
		rExtraBits = SFX_EXTRA_AUTOEXTENSION;
	}
	else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS )
	{
		nBits = WB_SAVEAS | SFXWB_PASSWORD;
		rExtraBits = SFX_EXTRA_AUTOEXTENSION | SFX_EXTRA_FILTEROPTIONS;
	}
	else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_TEMPLATE )
	{
		nBits = WB_SAVEAS;
		rExtraBits = SFX_EXTRA_AUTOEXTENSION | SFX_EXTRA_TEMPLATES;
	}
	else if ( m_nServiceType == TemplateDescription::FILESAVE_AUTOEXTENSION_SELECTION )
	{
		nBits = WB_SAVEAS;
		rExtraBits = SFX_EXTRA_AUTOEXTENSION | SFX_EXTRA_SELECTION;
	}

	else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE )
	{
		nBits = WB_OPEN;
		rExtraBits = SFX_EXTRA_INSERTASLINK | SFX_EXTRA_SHOWPREVIEW | SFX_EXTRA_IMAGE_TEMPLATE;
	}
	else if ( m_nServiceType == TemplateDescription::FILEOPEN_PLAY )
	{
		nBits = WB_OPEN;
		rExtraBits = SFX_EXTRA_PLAYBUTTON;
	}
	else if ( m_nServiceType == TemplateDescription::FILEOPEN_READONLY_VERSION )
	{
		nBits = WB_OPEN | SFXWB_READONLY;
		rExtraBits = SFX_EXTRA_SHOWVERSIONS;
	}
	else if ( m_nServiceType == TemplateDescription::FILEOPEN_LINK_PREVIEW )
	{
		nBits = WB_OPEN;
		rExtraBits = SFX_EXTRA_INSERTASLINK | SFX_EXTRA_SHOWPREVIEW;
	}
	if ( m_bMultiSelection && ( ( nBits & WB_OPEN ) == WB_OPEN ) )
		nBits |= SFXWB_MULTISELECTION;

	return nBits;
}

//------------------------------------------------------------------------------------
void SvtFilePicker::notify( sal_Int16 _nEventId, sal_Int16 _nControlId )
{
	if ( !m_xListener.is() )
		return;

	FilePickerEvent aEvent( *this, _nControlId );

	switch ( _nEventId )
	{
		case FILE_SELECTION_CHANGED:
			m_xListener->fileSelectionChanged( aEvent );
			break;
		case DIRECTORY_CHANGED:
			m_xListener->directoryChanged( aEvent );
			break;
		case HELP_REQUESTED:
			m_xListener->helpRequested( aEvent );
			break;
		case CTRL_STATE_CHANGED:
			m_xListener->controlStateChanged( aEvent );
			break;
		case DIALOG_SIZE_CHANGED:
			m_xListener->dialogSizeChanged();
			break;
		default:
			DBG_ERRORFILE( "SvtFilePicker::notify(): Unknown event id!" );
			break;
	}
}

//------------------------------------------------------------------------------------
namespace {
	//................................................................................
	struct FilterTitleMatch : public ::std::unary_function< FilterEntry, bool >
	{
	protected:
		const ::rtl::OUString& rTitle;

	public:
		FilterTitleMatch( const ::rtl::OUString& _rTitle ) : rTitle( _rTitle ) { }

		//............................................................................
		bool operator () ( const FilterEntry& _rEntry )
		{
			sal_Bool bMatch;
			if ( !_rEntry.hasSubFilters() )
				// a real filter
				bMatch = ( _rEntry.getTitle() == rTitle );
			else
				// a filter group -> search the sub filters
				bMatch =
					_rEntry.endSubFilters() != ::std::find_if(
						_rEntry.beginSubFilters(),
						_rEntry.endSubFilters(),
						*this
					);

			return bMatch ? true : false;
		}
		bool operator () ( const UnoFilterEntry& _rEntry )
		{
			return _rEntry.First == rTitle ? true : false;
		}
	};
}

//------------------------------------------------------------------------------------
sal_Bool SvtFilePicker::FilterNameExists( const ::rtl::OUString& rTitle )
{
	sal_Bool bRet = sal_False;

	if ( m_pFilterList )
		bRet =
			m_pFilterList->end() != ::std::find_if(
				m_pFilterList->begin(),
				m_pFilterList->end(),
				FilterTitleMatch( rTitle )
			);

	return bRet;
}

//------------------------------------------------------------------------------------
sal_Bool SvtFilePicker::FilterNameExists( const UnoFilterList& _rGroupedFilters )
{
	sal_Bool bRet = sal_False;

	if ( m_pFilterList )
	{
		const UnoFilterEntry* pStart = _rGroupedFilters.getConstArray();
		const UnoFilterEntry* pEnd = pStart + _rGroupedFilters.getLength();
		for ( ; pStart != pEnd; ++pStart )
			if ( m_pFilterList->end() != ::std::find_if( m_pFilterList->begin(), m_pFilterList->end(), FilterTitleMatch( pStart->First ) ) )
				break;

		bRet = pStart != pEnd;
	}

	return bRet;
}

//------------------------------------------------------------------------------------
void SvtFilePicker::ensureFilterList( const ::rtl::OUString& _rInitialCurrentFilter )
{
	if ( !m_pFilterList )
	{
		m_pFilterList = new FilterList;

		// set the first filter to the current filter
		if ( ! m_aCurrentFilter.getLength() )
			m_aCurrentFilter = _rInitialCurrentFilter;
	}
}

//------------------------------------------------------------------------------------
// class SvtFilePicker
//------------------------------------------------------------------------------------
SvtFilePicker::SvtFilePicker( const Reference < XMultiServiceFactory >& xFactory )
	:OCommonPicker( xFactory )
	,m_pFilterList		( NULL )
	,m_pElemList		( NULL )
	,m_bMultiSelection	( sal_False )
	,m_nServiceType		( TemplateDescription::FILEOPEN_SIMPLE )
{
}

SvtFilePicker::~SvtFilePicker()
{
	if ( m_pFilterList && !m_pFilterList->empty() )
		m_pFilterList->erase( m_pFilterList->begin(), m_pFilterList->end() );
	delete m_pFilterList;

	if ( m_pElemList && !m_pElemList->empty() )
		m_pElemList->erase( m_pElemList->begin(), m_pElemList->end() );
	delete m_pElemList;
}

//------------------------------------------------------------------------------------
sal_Int16 SvtFilePicker::implExecutePicker( )
{
	getDialog()->SetFileCallback( this );

	prepareExecute();

	getDialog()->EnableAutocompletion( sal_True );
	// now we are ready to execute the dialog
	sal_Int16 nRet = getDialog()->Execute();

	// the execution of the dialog yields, so it is possible the at this point the window or the dialog is closed
	if ( getDialog() )
		getDialog()->SetFileCallback( NULL );

	return nRet;
}

//------------------------------------------------------------------------------------
SvtFileDialog* SvtFilePicker::implCreateDialog( Window* _pParent )
{
	WinBits	nExtraBits;
	WinBits	nBits = getWinBits( nExtraBits );

	SvtFileDialog* dialog = new SvtFileDialog( _pParent, nBits, nExtraBits );

	// Set StandardDir if present
	if ( m_aStandardDir.getLength() > 0)
	{
		String sStandardDir = String( m_aStandardDir );
		dialog->SetStandardDir( sStandardDir );
		dialog->SetBlackList( m_aBlackList );
	}

	return dialog;
}

//------------------------------------------------------------------------------------
// disambiguate XInterface
//------------------------------------------------------------------------------------
IMPLEMENT_FORWARD_XINTERFACE2( SvtFilePicker, OCommonPicker, SvtFilePicker_Base )

//------------------------------------------------------------------------------------
// disambiguate XTypeProvider
//------------------------------------------------------------------------------------
IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvtFilePicker, OCommonPicker, SvtFilePicker_Base )

//------------------------------------------------------------------------------------
// XExecutableDialog functions
//------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::setTitle( const ::rtl::OUString& _rTitle ) throw (RuntimeException)
{
	OCommonPicker::setTitle( _rTitle );
}

//------------------------------------------------------------------------------------
sal_Int16 SAL_CALL SvtFilePicker::execute(  ) throw (RuntimeException)
{
	return OCommonPicker::execute();
}

//------------------------------------------------------------------------------------
// XAsynchronousExecutableDialog functions
//------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::setDialogTitle( const ::rtl::OUString& _rTitle ) throw (RuntimeException)
{
	setTitle( _rTitle );
}

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::startExecuteModal( const Reference< ::com::sun::star::ui::dialogs::XDialogClosedListener >& xListener ) throw (RuntimeException)
{
	m_xDlgClosedListener = xListener;
	prepareDialog();
	prepareExecute();
	getDialog()->EnableAutocompletion( sal_True );
	getDialog()->StartExecuteModal( LINK( this, SvtFilePicker, DialogClosedHdl ) );
}

//------------------------------------------------------------------------------------
// XFilePicker functions
//------------------------------------------------------------------------------------

void SAL_CALL SvtFilePicker::setMultiSelectionMode( sal_Bool bMode ) throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	m_bMultiSelection = bMode;
}

void SAL_CALL SvtFilePicker::setDefaultName( const rtl::OUString& aName ) throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	m_aDefaultName = aName;
}

void SAL_CALL SvtFilePicker::setDisplayDirectory( const rtl::OUString& aDirectory )
	throw( IllegalArgumentException, RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	m_aDisplayDirectory = aDirectory;
}

rtl::OUString SAL_CALL SvtFilePicker::getDisplayDirectory() throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( getDialog() )
	{
		rtl::OUString aPath = getDialog()->GetPath();

		// #97148# ----
		if( m_aOldHideDirectory == aPath )
			return m_aOldDisplayDirectory;
		m_aOldHideDirectory = aPath;

		// #102204# -----
		if( !getDialog()->ContentIsFolder( aPath ) )
		{
			INetURLObject aFolder( aPath );
			aFolder.CutLastName();
			aPath = aFolder.GetMainURL( INetURLObject::NO_DECODE );
		}
		m_aOldDisplayDirectory = aPath;
		return aPath;
	}
	else
		return m_aDisplayDirectory;
}

Sequence< rtl::OUString > SAL_CALL SvtFilePicker::getFiles() throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( ! getDialog() )
	{
		Sequence< rtl::OUString > aEmpty;
		return aEmpty;
	}

	// if there is more than one path we have to return the path to the
	// files first and then the list of the selected entries

	SvStringsDtor* pPathList = getDialog()->GetPathList();
	sal_uInt16 i, nCount = pPathList->Count();
	sal_uInt16 nTotal = nCount > 1 ? nCount+1: nCount;

	Sequence< rtl::OUString > aPath( nTotal );

	if ( nCount == 1 )
		aPath[0] = rtl::OUString( *pPathList->GetObject( 0 ) );
	else if ( nCount > 1 )
	{
		INetURLObject aObj( *pPathList->GetObject( 0 ) );
		aObj.removeSegment();
		aPath[0] = aObj.GetMainURL( INetURLObject::NO_DECODE );

		for ( i = 0; i < nCount; /* i++ is done below */ )
		{
			aObj.SetURL( *pPathList->GetObject(i++) );
			aPath[i] = aObj.getName();
		}
	}

	delete pPathList;
	return aPath;
}

//------------------------------------------------------------------------------------
// XFilePickerControlAccess functions
//------------------------------------------------------------------------------------

void SAL_CALL SvtFilePicker::setValue( sal_Int16 nElementID,
									   sal_Int16 nControlAction,
									   const Any& rValue )
	throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( getDialog() )
	{
		::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
		aAccess.setValue( nElementID, nControlAction, rValue );
	}
	else
	{
		if ( !m_pElemList )
			m_pElemList = new ElementList;

		sal_Bool bFound = sal_False;
		ElementList::iterator aListIter;

		for ( aListIter = m_pElemList->begin();
			  aListIter != m_pElemList->end(); ++aListIter )
		{
			ElementEntry_Impl& rEntry = *aListIter;
			if ( ( rEntry.m_nElementID == nElementID ) &&
				( !rEntry.m_bHasValue || ( rEntry.m_nControlAction == nControlAction ) ) )
			{
				rEntry.setAction( nControlAction );
				rEntry.setValue( rValue );
				bFound = sal_True;
			}
		}

		if ( !bFound )
		{
			ElementEntry_Impl aNew( nElementID );
			aNew.setAction( nControlAction );
			aNew.setValue( rValue );
			m_pElemList->insert( m_pElemList->end(), aNew );
		}
	}
}

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

Any SAL_CALL SvtFilePicker::getValue( sal_Int16 nElementID, sal_Int16 nControlAction )
	throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	Any aAny;

	// execute() called?
	if ( getDialog() )
	{
		::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
		aAny = aAccess.getValue( nElementID, nControlAction );
	}
	else if ( m_pElemList && !m_pElemList->empty() )
	{
		ElementList::iterator aListIter;
		for ( aListIter = m_pElemList->begin();
			  aListIter != m_pElemList->end(); ++aListIter )
		{
			ElementEntry_Impl& rEntry = *aListIter;
			if ( ( rEntry.m_nElementID == nElementID ) &&
				 ( rEntry.m_bHasValue ) &&
				 ( rEntry.m_nControlAction == nControlAction ) )
			{
				aAny = rEntry.m_aValue;
				break;
			}
		}
	}

	return aAny;
}


//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::setLabel( sal_Int16 nLabelID, const rtl::OUString& rValue )
	throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( getDialog() )
	{
		::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
		aAccess.setLabel( nLabelID, rValue );
	}
	else
	{
		if ( !m_pElemList )
			m_pElemList = new ElementList;

		sal_Bool bFound = sal_False;
		ElementList::iterator aListIter;

		for ( aListIter = m_pElemList->begin();
			  aListIter != m_pElemList->end(); ++aListIter )
		{
			ElementEntry_Impl& rEntry = *aListIter;
			if ( rEntry.m_nElementID == nLabelID )
			{
				rEntry.setLabel( rValue );
				bFound = sal_True;
			}
		}

		if ( !bFound )
		{
			ElementEntry_Impl aNew( nLabelID );
			aNew.setLabel( rValue );
			m_pElemList->insert( m_pElemList->end(), aNew );
		}
	}
}

//------------------------------------------------------------------------------------
rtl::OUString SAL_CALL SvtFilePicker::getLabel( sal_Int16 nLabelID )
	throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	rtl::OUString aLabel;

	if ( getDialog() )
	{
		::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
		aLabel = aAccess.getLabel( nLabelID );
	}
	else if ( m_pElemList && !m_pElemList->empty() )
	{
		ElementList::iterator aListIter;
		for ( aListIter = m_pElemList->begin();
			  aListIter != m_pElemList->end(); ++aListIter )
		{
			ElementEntry_Impl& rEntry = *aListIter;
			if ( rEntry.m_nElementID == nLabelID )
			{
				if ( rEntry.m_bHasLabel )
					aLabel = rEntry.m_aLabel;
				break;
			}
		}
	}

	return aLabel;
}

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::enableControl( sal_Int16 nElementID, sal_Bool bEnable )
	throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( getDialog() )
	{
		::svt::OControlAccess aAccess( getDialog(), getDialog()->GetView() );
		aAccess.enableControl( nElementID, bEnable );
	}
	else
	{
		if ( !m_pElemList )
			m_pElemList = new ElementList;

		sal_Bool bFound = sal_False;
		ElementList::iterator aListIter;

		for ( aListIter = m_pElemList->begin();
			  aListIter != m_pElemList->end(); ++aListIter )
		{
			ElementEntry_Impl& rEntry = *aListIter;
			if ( rEntry.m_nElementID == nElementID )
			{
				rEntry.setEnabled( bEnable );
				bFound = sal_True;
			}
		}

		if ( !bFound )
		{
			ElementEntry_Impl aNew( nElementID );
			aNew.setEnabled( bEnable );
			m_pElemList->insert( m_pElemList->end(), aNew );
		}
	}
}

//------------------------------------------------------------------------------------
// XFilePickerNotifier functions
//------------------------------------------------------------------------------------

void SAL_CALL SvtFilePicker::addFilePickerListener( const Reference< XFilePickerListener >& xListener ) throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	m_xListener = xListener;
}

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::removeFilePickerListener( const Reference< XFilePickerListener >& ) throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	m_xListener.clear();
}

//------------------------------------------------------------------------------------
// XFilePreview functions
//------------------------------------------------------------------------------------

Sequence< sal_Int16 > SAL_CALL SvtFilePicker::getSupportedImageFormats()
	throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	Sequence< sal_Int16 > aFormats( 1 );

	aFormats[0] = FilePreviewImageFormats::BITMAP;

	return aFormats;
}

//------------------------------------------------------------------------------------
sal_Int32 SAL_CALL SvtFilePicker::getTargetColorDepth() throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	sal_Int32 nDepth = 0;

	if ( getDialog() )
		nDepth = getDialog()->getTargetColorDepth();

	return nDepth;
}

//------------------------------------------------------------------------------------
sal_Int32 SAL_CALL SvtFilePicker::getAvailableWidth() throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	sal_Int32 nWidth = 0;

	if ( getDialog() )
		nWidth = getDialog()->getAvailableWidth();

	return nWidth;
}

//------------------------------------------------------------------------------------
sal_Int32 SAL_CALL SvtFilePicker::getAvailableHeight() throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	sal_Int32 nHeigth = 0;

	if ( getDialog() )
		nHeigth = getDialog()->getAvailableHeight();

	return nHeigth;
}

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::setImage( sal_Int16 aImageFormat, const Any& rImage )
	throw ( IllegalArgumentException, RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( getDialog() )
		getDialog()->setImage( aImageFormat, rImage );
}

//------------------------------------------------------------------------------------
sal_Bool SAL_CALL SvtFilePicker::setShowState( sal_Bool bShowState )
	throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	sal_Bool bRet = sal_False;

	if ( getDialog() )
		bRet = getDialog()->setShowState( bShowState );

	return bRet;
}

//------------------------------------------------------------------------------------
sal_Bool SAL_CALL SvtFilePicker::getShowState() throw ( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	sal_Bool bRet = sal_False;

	if ( getDialog() )
		bRet = getDialog()->getShowState();

	return bRet;
}

//------------------------------------------------------------------------------------
// XFilterGroupManager functions
//------------------------------------------------------------------------------------

void SAL_CALL SvtFilePicker::appendFilterGroup(	const ::rtl::OUString& sGroupTitle,
												const Sequence< StringPair >& aFilters )
	throw ( IllegalArgumentException, RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );

	// check the names
	if ( FilterNameExists( aFilters ) )
		throw IllegalArgumentException(
			rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("filter name exists")),
			static_cast< OWeakObject * >(this), 1);

	// ensure that we have a filter list
	::rtl::OUString sInitialCurrentFilter;
	if ( aFilters.getLength() )
		sInitialCurrentFilter = aFilters[0].First;
	ensureFilterList( sInitialCurrentFilter );

	// append the filter
	m_pFilterList->insert( m_pFilterList->end(), FilterEntry( sGroupTitle, aFilters ) );
}

//------------------------------------------------------------------------------------
// XFilterManager functions
//------------------------------------------------------------------------------------

void SAL_CALL SvtFilePicker::appendFilter( const rtl::OUString& aTitle,
										   const rtl::OUString& aFilter )
	throw( IllegalArgumentException, RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	// check the name
	if ( FilterNameExists( aTitle ) )
		// TODO: a more precise exception message
		throw IllegalArgumentException();

	// ensure that we have a filter list
	ensureFilterList( aTitle );

	// append the filter
	m_pFilterList->insert( m_pFilterList->end(), FilterEntry( aTitle, aFilter ) );
}

//------------------------------------------------------------------------------------
void SAL_CALL SvtFilePicker::setCurrentFilter( const rtl::OUString& aTitle )
	throw( IllegalArgumentException, RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	if ( ! FilterNameExists( aTitle ) )
		throw IllegalArgumentException();

	m_aCurrentFilter = aTitle;

	if ( getDialog() )
		getDialog()->SetCurFilter( aTitle );
}

//------------------------------------------------------------------------------------
rtl::OUString SAL_CALL SvtFilePicker::getCurrentFilter()
	throw( RuntimeException )
{
	checkAlive();

	::vos::OGuard aGuard( Application::GetSolarMutex() );
	rtl::OUString aFilter = getDialog() ? rtl::OUString( getDialog()->GetCurFilter() ) :
										  rtl::OUString( m_aCurrentFilter );
	return aFilter;
}


//------------------------------------------------------------------------------------
// XInitialization functions
//------------------------------------------------------------------------------------

void SAL_CALL SvtFilePicker::initialize( const Sequence< Any >& _rArguments )
	throw ( Exception, RuntimeException )
{
	checkAlive();

	Sequence< Any > aArguments( _rArguments.getLength());

	m_nServiceType = TemplateDescription::FILEOPEN_SIMPLE;

	if ( _rArguments.getLength() >= 1 )
	{
		// compatibility: one argument, type sal_Int16 , specifies the service type
		int index = 0;

		if (_rArguments[0] >>= m_nServiceType)
		{
			// skip the first entry if it was the ServiceType, because it's not needed in OCommonPicker::initialize and it's not a NamedValue
			NamedValue emptyNamedValue;
			aArguments[0] <<= emptyNamedValue;
			index = 1;

		}
		for ( int i = index; i < _rArguments.getLength(); i++)
		{
			NamedValue namedValue;
			aArguments[i] <<= _rArguments[i];

			if (aArguments[i] >>= namedValue )
			{

				if ( namedValue.Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StandardDir" ) ) ) )
				{
					::rtl::OUString sStandardDir;

					namedValue.Value >>= sStandardDir;

					// Set the directory for the "back to the default dir" button
						if ( sStandardDir.getLength() > 0 )
					{
						m_aStandardDir = sStandardDir;
					}
				}
				else if ( namedValue.Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BlackList" ) ) ) )
				{
					namedValue.Value >>= m_aBlackList;
				}
			}
		}
	}

	// let the base class analyze the sequence (will call into implHandleInitializationArgument)
	OCommonPicker::initialize( aArguments );
}

//-------------------------------------------------------------------------
sal_Bool SvtFilePicker::implHandleInitializationArgument( const ::rtl::OUString& _rName, const Any& _rValue ) SAL_THROW( ( Exception, RuntimeException ) )
{
	if ( _rName.equalsAscii( "TemplateDescription" ) )
	{
		m_nServiceType = TemplateDescription::FILEOPEN_SIMPLE;
		OSL_VERIFY( _rValue >>= m_nServiceType );
		return sal_True;
	}
	if ( _rName.equalsAscii( "StandardDir" ) )
	{
		OSL_VERIFY( _rValue >>= m_aStandardDir );
		return sal_True;
	}

	if ( _rName.equalsAscii( "BlackList" ) )
	{
		OSL_VERIFY( _rValue >>= m_aBlackList );
		return sal_True;
	}



	return OCommonPicker::implHandleInitializationArgument( _rName, _rValue );
}

//------------------------------------------------------------------------------------
// XServiceInfo
//------------------------------------------------------------------------------------

/* XServiceInfo */
rtl::OUString SAL_CALL SvtFilePicker::getImplementationName() throw( RuntimeException )
{
	return impl_getStaticImplementationName();
}

/* XServiceInfo */
sal_Bool SAL_CALL SvtFilePicker::supportsService( const rtl::OUString& sServiceName ) throw( RuntimeException )
{
	Sequence< rtl::OUString > seqServiceNames = getSupportedServiceNames();
	const rtl::OUString* pArray = seqServiceNames.getConstArray();
	for ( sal_Int32 i = 0; i < seqServiceNames.getLength(); i++ )
	{
		if ( sServiceName == pArray[i] )
		{
			return sal_True ;
		}
	}
	return sal_False ;
}

/* XServiceInfo */
Sequence< rtl::OUString > SAL_CALL SvtFilePicker::getSupportedServiceNames() throw( RuntimeException )
{
	return impl_getStaticSupportedServiceNames();
}

/* Helper for XServiceInfo */
Sequence< rtl::OUString > SvtFilePicker::impl_getStaticSupportedServiceNames()
{
	Sequence< rtl::OUString > seqServiceNames( 1 );
	rtl::OUString* pArray = seqServiceNames.getArray();
	pArray[0] = rtl::OUString::createFromAscii( "com.sun.star.ui.dialogs.OfficeFilePicker" );
	return seqServiceNames ;
}

/* Helper for XServiceInfo */
rtl::OUString SvtFilePicker::impl_getStaticImplementationName()
{
	return rtl::OUString::createFromAscii( "com.sun.star.svtools.OfficeFilePicker" );
}

/* Helper for registry */
Reference< XInterface > SAL_CALL SvtFilePicker::impl_createInstance(
	const Reference< XComponentContext >& rxContext) throw( Exception )
{
	Reference< XMultiServiceFactory > xServiceManager (rxContext->getServiceManager(), UNO_QUERY_THROW);
	return Reference< XInterface >( *new SvtFilePicker( xServiceManager ) );
}