xref: /aoo41x/main/fpicker/source/office/OfficeControlAccess.cxx (revision b557fc96)

/**************************************************************
 *
 * 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 "OfficeControlAccess.hxx"
#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
#include <com/sun/star/ui/dialogs/ControlActions.hpp>
#include <vcl/lstbox.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <tools/urlobj.hxx>

#include <algorithm>
#include <functional>

//.........................................................................
namespace svt
{
//.........................................................................

	// helper -------------------------------------------------------------

	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::lang;
	using namespace ::com::sun::star::ui::dialogs;

	using namespace ExtendedFilePickerElementIds;
	using namespace CommonFilePickerElementIds;
	using namespace InternalFilePickerElementIds;

	// --------------------------------------------------------------------
	namespace
	{
		// ----------------------------------------------------------------
		#define PROPERTY_FLAG_TEXT					0x00000001
		#define PROPERTY_FLAG_ENDBALED				0x00000002
		#define PROPERTY_FLAG_VISIBLE				0x00000004
		#define PROPERTY_FLAG_HELPURL				0x00000008
		#define PROPERTY_FLAG_LISTITEMS				0x00000010
		#define PROPERTY_FLAG_SELECTEDITEM			0x00000020
		#define PROPERTY_FLAG_SELECTEDITEMINDEX		0x00000040
		#define PROPERTY_FLAG_CHECKED				0x00000080

		// ----------------------------------------------------------------
		// ................................................................
		struct ControlDescription
		{
			const sal_Char*	pControlName;
			sal_Int16		nControlId;
			sal_Int32		nPropertyFlags;
		};

		// ................................................................
		typedef const ControlDescription* ControlDescIterator;
		typedef ::std::pair< ControlDescIterator, ControlDescIterator >	ControlDescRange;

		// ......................................................................
		#define PROPERTY_FLAGS_COMMON		( PROPERTY_FLAG_ENDBALED | PROPERTY_FLAG_VISIBLE | PROPERTY_FLAG_HELPURL )
		#define PROPERTY_FLAGS_LISTBOX		( PROPERTY_FLAG_LISTITEMS | PROPERTY_FLAG_SELECTEDITEM | PROPERTY_FLAG_SELECTEDITEMINDEX )
		#define PROPERTY_FLAGS_CHECKBOX		( PROPERTY_FLAG_CHECKED | PROPERTY_FLAG_TEXT )

		// Note: this array MUST be sorted by name!
		static const ControlDescription aDescriptions[] =  {
			{ "AutoExtensionBox",		CHECKBOX_AUTOEXTENSION,			PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "CancelButton",			PUSHBUTTON_CANCEL,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "CurrentFolderText",		FIXEDTEXT_CURRENTFOLDER,		PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "DefaultLocationButton",	TOOLBOXBUTOON_DEFAULT_LOCATION,	PROPERTY_FLAGS_COMMON								},
			{ "FileURLEdit",			EDIT_FILEURL,					PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "FileURLEditLabel",		EDIT_FILEURL_LABEL,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "FileView",				CONTROL_FILEVIEW,				PROPERTY_FLAGS_COMMON								},
			{ "FilterList",				LISTBOX_FILTER,					PROPERTY_FLAGS_COMMON								},
			{ "FilterListLabel",		LISTBOX_FILTER_LABEL,			PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "FilterOptionsBox",		CHECKBOX_FILTEROPTIONS,			PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "HelpButton",				PUSHBUTTON_HELP,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "ImageTemplateList",		LISTBOX_IMAGE_TEMPLATE,			PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX		},
			{ "ImageTemplateListLabel",	LISTBOX_IMAGE_TEMPLATE_LABEL,	PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "LevelUpButton",			TOOLBOXBUTOON_LEVEL_UP,			PROPERTY_FLAGS_COMMON								},
			{ "LinkBox",				CHECKBOX_LINK,					PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "NewFolderButton",		TOOLBOXBUTOON_NEW_FOLDER,		PROPERTY_FLAGS_COMMON								},
			{ "OkButton",				PUSHBUTTON_OK ,					PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "PasswordBox",			CHECKBOX_PASSWORD,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "PlayButton",				PUSHBUTTON_PLAY,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "PreviewBox",				CHECKBOX_PREVIEW,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "ReadOnlyBox",			CHECKBOX_READONLY,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "SelectionBox",			CHECKBOX_SELECTION,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX		},
			{ "TemplateList",			LISTBOX_TEMPLATE,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX		},
			{ "TemplateListLabel",		LISTBOX_TEMPLATE_LABEL,			PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			},
			{ "VersionList",			LISTBOX_VERSION,				PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX		},
			{ "VersionListLabel",		LISTBOX_VERSION_LABEL,			PROPERTY_FLAGS_COMMON | PROPERTY_FLAG_TEXT			}
		};

		// ................................................................
		static const sal_Int32 s_nControlCount = sizeof( aDescriptions ) / sizeof( aDescriptions[0] );

		static ControlDescIterator s_pControls = aDescriptions;
		static ControlDescIterator s_pControlsEnd = aDescriptions + s_nControlCount;

		// ................................................................
		struct ControlDescriptionLookup
		{
			bool operator()( const ::rtl::OUString& _rLookup, const ControlDescription& _rDesc )
			{
				return _rLookup.compareToAscii( _rDesc.pControlName ) < 0;
			}
			bool operator()( const ControlDescription& _rDesc, const ::rtl::OUString& _rLookup )
			{
				return _rLookup.compareToAscii( _rDesc.pControlName ) > 0;
			}
		};

		// ................................................................
		struct ExtractControlName : public ::std::unary_function< ControlDescription, ::rtl::OUString >
		{
			::rtl::OUString operator()( const ControlDescription& _rDesc )
			{
				return ::rtl::OUString::createFromAscii( _rDesc.pControlName );
			}
		};

		// ----------------------------------------------------------------
		// ................................................................
		struct ControlProperty
		{
			const sal_Char* pPropertyName;
			sal_Int16		nPropertyId;
		};

		typedef const ControlProperty* ControlPropertyIterator;

		// ................................................................
		static const ControlProperty aProperties[] =  {
			{ "Text",				PROPERTY_FLAG_TEXT				},
			{ "Enabled",			PROPERTY_FLAG_ENDBALED			},
			{ "Visible",			PROPERTY_FLAG_VISIBLE			},
			{ "HelpURL",			PROPERTY_FLAG_HELPURL			},
			{ "ListItems",			PROPERTY_FLAG_LISTITEMS			},
			{ "SelectedItem",		PROPERTY_FLAG_SELECTEDITEM		},
			{ "SelectedItemIndex",	PROPERTY_FLAG_SELECTEDITEMINDEX	},
			{ "Checked",			PROPERTY_FLAG_CHECKED			}
		};

		// ................................................................
		static const int s_nPropertyCount = sizeof( aProperties ) / sizeof( aProperties[0] );

		static ControlPropertyIterator s_pProperties = aProperties;
		static ControlPropertyIterator s_pPropertiesEnd = aProperties + s_nPropertyCount;

		// ................................................................
		struct ControlPropertyLookup
		{
			::rtl::OUString	m_sLookup;
			ControlPropertyLookup( const ::rtl::OUString& _rLookup ) : m_sLookup( _rLookup ) { }

			sal_Bool operator()( const ControlProperty& _rProp )
			{
				return m_sLookup.equalsAscii( _rProp.pPropertyName );
			}
		};

		//-----------------------------------------------------------------
		void lcl_throwIllegalArgumentException( ) SAL_THROW( (IllegalArgumentException) )
		{
			throw IllegalArgumentException();
			// TODO: error message in the exception
		}
	}

	//---------------------------------------------------------------------
	OControlAccess::OControlAccess( IFilePickerController* _pController, SvtFileView* _pFileView )
		:m_pFilePickerController( _pController )
		,m_pFileView( _pFileView )
	{
		DBG_ASSERT( m_pFilePickerController, "OControlAccess::OControlAccess: invalid control locator!" );
	}

	//---------------------------------------------------------------------
	void OControlAccess::setHelpURL( Window* _pControl, const ::rtl::OUString& sHelpURL, sal_Bool _bFileView )
	{
        rtl::OUString sHelpID( sHelpURL );
        INetURLObject aHID( sHelpURL );
        if ( aHID.GetProtocol() == INET_PROT_HID )
      	    sHelpID = aHID.GetURLPath();

        // URLs should always be UTF8 encoded and escaped
	    rtl::OString sID( rtl::OUStringToOString( sHelpID, RTL_TEXTENCODING_UTF8 ) );
		if ( _bFileView )
			// the file view "overloaded" the SetHelpId
			static_cast< SvtFileView* >( _pControl )->SetHelpId( sID );
		else
			_pControl->SetHelpId( sID );
	}

	//---------------------------------------------------------------------
	::rtl::OUString	OControlAccess::getHelpURL( Window* _pControl, sal_Bool _bFileView )
	{
	    rtl::OString aHelpId = _pControl->GetHelpId();
		if ( _bFileView )
			// the file view "overloaded" the SetHelpId
			aHelpId = static_cast< SvtFileView* >( _pControl )->GetHelpId( );

        ::rtl::OUString sHelpURL;
        ::rtl::OUString aTmp( rtl::OStringToOUString( aHelpId, RTL_TEXTENCODING_UTF8 ) );
        INetURLObject aHID( aTmp );
        if ( aHID.GetProtocol() == INET_PROT_NOT_VALID )
            sHelpURL = rtl::OUString::createFromAscii( INET_HID_SCHEME );
		sHelpURL += aTmp;
		return sHelpURL;
	}

	// --------------------------------------------------------------------------
	Any	OControlAccess::getControlProperty( const ::rtl::OUString& _rControlName, const ::rtl::OUString& _rControlProperty )
	{
		// look up the control
		sal_Int16 nControlId = -1;
		sal_Int32 nPropertyMask = 0;
		Control* pControl = implGetControl( _rControlName, &nControlId, &nPropertyMask );
			// will throw an IllegalArgumentException if the name is not valid

		// look up the property
		ControlPropertyIterator aPropDesc = ::std::find_if( s_pProperties, s_pPropertiesEnd, ControlPropertyLookup( _rControlProperty ) );
		if ( aPropDesc == s_pPropertiesEnd )
			// it's a completely unknown property
			lcl_throwIllegalArgumentException();

		if ( 0 == ( nPropertyMask & aPropDesc->nPropertyId ) )
			// it's a property which is known, but not allowed for this control
			lcl_throwIllegalArgumentException();

		return implGetControlProperty( pControl, aPropDesc->nPropertyId );
	}

	//---------------------------------------------------------------------
	Control* OControlAccess::implGetControl( const ::rtl::OUString& _rControlName, sal_Int16* _pId, sal_Int32* _pPropertyMask ) const SAL_THROW( (IllegalArgumentException) )
	{
		Control* pControl = NULL;

		// translate the name into an id
		ControlDescRange aFoundRange = ::std::equal_range( s_pControls, s_pControlsEnd, _rControlName, ControlDescriptionLookup() );
		if ( aFoundRange.first != aFoundRange.second )
		{
			// get the VCL control determined by this id
			pControl = m_pFilePickerController->getControl( aFoundRange.first->nControlId );
		}

		// if not found 'til here, the name is invalid, or we do not have the control in the current mode
		if ( !pControl )
			lcl_throwIllegalArgumentException();

		// out parameters and outta here
		if ( _pId )
			*_pId = aFoundRange.first->nControlId;
		if ( _pPropertyMask )
			*_pPropertyMask = aFoundRange.first->nPropertyFlags;

		return pControl;
	}

	//---------------------------------------------------------------------
	void OControlAccess::setControlProperty( const ::rtl::OUString& _rControlName, const ::rtl::OUString& _rControlProperty, const ::com::sun::star::uno::Any& _rValue )
	{
		// look up the control
        sal_Int16 nControlId = -1;
		Control* pControl = implGetControl( _rControlName, &nControlId );
			// will throw an IllegalArgumentException if the name is not valid

		// look up the property
		ControlPropertyIterator aPropDesc = ::std::find_if( s_pProperties, s_pPropertiesEnd, ControlPropertyLookup( _rControlProperty ) );
		if ( aPropDesc == s_pPropertiesEnd )
			lcl_throwIllegalArgumentException();

		// set the property
		implSetControlProperty( nControlId, pControl, aPropDesc->nPropertyId, _rValue, sal_False );
	}

	// --------------------------------------------------------------------------
	Sequence< ::rtl::OUString > OControlAccess::getSupportedControls(  )
	{
		Sequence< ::rtl::OUString > aControls( s_nControlCount );
		::rtl::OUString* pControls = aControls.getArray();

		// collect the names of all _actually_existent_ controls
		for ( ControlDescIterator aControl = s_pControls; aControl != s_pControlsEnd; ++aControl )
		{
			if ( m_pFilePickerController->getControl( aControl->nControlId ) )
				*pControls++ = ::rtl::OUString::createFromAscii( aControl->pControlName );
		}

		aControls.realloc( pControls - aControls.getArray() );
		return aControls;
	}

	// --------------------------------------------------------------------------
	Sequence< ::rtl::OUString > OControlAccess::getSupportedControlProperties( const ::rtl::OUString& _rControlName )
	{
		sal_Int16 nControlId = -1;
		sal_Int32 nPropertyMask = 0;
		implGetControl( _rControlName, &nControlId, &nPropertyMask );
			// will throw an IllegalArgumentException if the name is not valid

		// fill in the property names
		Sequence< ::rtl::OUString > aProps( s_nPropertyCount );
		::rtl::OUString* pProperty = aProps.getArray();

		for ( ControlPropertyIterator aProp = s_pProperties; aProp != s_pPropertiesEnd; ++aProp )
			if ( 0 != ( nPropertyMask & aProp->nPropertyId ) )
				*pProperty++ = ::rtl::OUString::createFromAscii( aProp->pPropertyName );

		aProps.realloc( pProperty - aProps.getArray() );
		return aProps;
	}

	// --------------------------------------------------------------------------
	sal_Bool OControlAccess::isControlSupported( const ::rtl::OUString& _rControlName )
	{
		return ::std::binary_search( s_pControls, s_pControlsEnd, _rControlName, ControlDescriptionLookup() );
	}

	// --------------------------------------------------------------------------
	sal_Bool OControlAccess::isControlPropertySupported( const ::rtl::OUString& _rControlName, const ::rtl::OUString& _rControlProperty )
	{
		// look up the control
		sal_Int16 nControlId = -1;
		sal_Int32 nPropertyMask = 0;
		implGetControl( _rControlName, &nControlId, &nPropertyMask );
			// will throw an IllegalArgumentException if the name is not valid

		// look up the property
		ControlPropertyIterator aPropDesc = ::std::find_if( s_pProperties, s_pPropertiesEnd, ControlPropertyLookup( _rControlProperty ) );
		if ( aPropDesc == s_pPropertiesEnd )
			// it's a property which is completely unknown
			return sal_False;

		return 0 != ( aPropDesc->nPropertyId & nPropertyMask );
	}

	//-----------------------------------------------------------------------------
	void OControlAccess::setValue( sal_Int16 _nControlId, sal_Int16 _nControlAction, const Any& _rValue )
	{
		Control* pControl = m_pFilePickerController->getControl( _nControlId );
		DBG_ASSERT( pControl, "OControlAccess::SetValue: don't have this control in the current mode!" );
		if ( pControl )
		{
			sal_Int16 nPropertyId = -1;
			if ( ControlActions::SET_HELP_URL == _nControlAction )
			{
				nPropertyId = PROPERTY_FLAG_HELPURL;
			}
			else
			{
				switch ( _nControlId )
				{
					case CHECKBOX_AUTOEXTENSION:
					case CHECKBOX_PASSWORD:
					case CHECKBOX_FILTEROPTIONS:
					case CHECKBOX_READONLY:
					case CHECKBOX_LINK:
					case CHECKBOX_PREVIEW:
					case CHECKBOX_SELECTION:
						nPropertyId = PROPERTY_FLAG_CHECKED;
						break;

					case LISTBOX_FILTER:
						DBG_ERRORFILE( "Use the XFilterManager to access the filter listbox" );
						break;

					case LISTBOX_VERSION:
					case LISTBOX_TEMPLATE:
					case LISTBOX_IMAGE_TEMPLATE:
						if ( ControlActions::SET_SELECT_ITEM == _nControlAction )
						{
							nPropertyId = PROPERTY_FLAG_SELECTEDITEMINDEX;
						}
						else
						{
							DBG_ASSERT( WINDOW_LISTBOX == pControl->GetType(), "OControlAccess::SetValue: implGetControl returned nonsense!" );
							implDoListboxAction( static_cast< ListBox* >( pControl ), _nControlAction, _rValue );
						}
						break;
				}
			}

			if ( -1 != nPropertyId )
				implSetControlProperty( _nControlId, pControl, nPropertyId, _rValue );
		}
	}

	//-----------------------------------------------------------------------------
	Any OControlAccess::getValue( sal_Int16 _nControlId, sal_Int16 _nControlAction ) const
	{
		Any aRet;

		Control* pControl = m_pFilePickerController->getControl( _nControlId, sal_False );
		DBG_ASSERT( pControl, "OControlAccess::GetValue: don't have this control in the current mode!" );
		if ( pControl )
		{
			sal_Int16 nPropertyId = -1;
			if ( ControlActions::SET_HELP_URL == _nControlAction )
			{
				nPropertyId = PROPERTY_FLAG_HELPURL;
			}
			else
			{
				switch ( _nControlId )
				{
					case CHECKBOX_AUTOEXTENSION:
					case CHECKBOX_PASSWORD:
					case CHECKBOX_FILTEROPTIONS:
					case CHECKBOX_READONLY:
					case CHECKBOX_LINK:
					case CHECKBOX_PREVIEW:
					case CHECKBOX_SELECTION:
						nPropertyId = PROPERTY_FLAG_CHECKED;
						break;

					case LISTBOX_FILTER:
						if ( ControlActions::GET_SELECTED_ITEM == _nControlAction )
						{
							aRet <<= ::rtl::OUString( m_pFilePickerController->getCurFilter() );;
						}
						else
						{
							DBG_ERRORFILE( "Use the XFilterManager to access the filter listbox" );
                        }
						break;

					case LISTBOX_VERSION:
					case LISTBOX_TEMPLATE:
					case LISTBOX_IMAGE_TEMPLATE:
						switch ( _nControlAction )
						{
							case ControlActions::GET_SELECTED_ITEM:
								nPropertyId = PROPERTY_FLAG_SELECTEDITEM;
								break;
							case ControlActions::GET_SELECTED_ITEM_INDEX:
								nPropertyId = PROPERTY_FLAG_SELECTEDITEMINDEX;
								break;
							case ControlActions::GET_ITEMS:
								nPropertyId = PROPERTY_FLAG_LISTITEMS;
								break;
							default:
								DBG_ERRORFILE( "OControlAccess::GetValue: invalid control action for the listbox!" );
								break;
						}
						break;
				}
			}

			if ( -1 != nPropertyId )
				aRet = implGetControlProperty( pControl, nPropertyId );
		}

		return aRet;
	}

	//-----------------------------------------------------------------------------
	void OControlAccess::setLabel( sal_Int16 nId, const ::rtl::OUString &rLabel )
	{
		Control* pControl = m_pFilePickerController->getControl( nId, sal_True );
		DBG_ASSERT( pControl, "OControlAccess::GetValue: don't have this control in the current mode!" );
		if ( pControl )
			pControl->SetText( rLabel );
	}

	//-----------------------------------------------------------------------------
	::rtl::OUString OControlAccess::getLabel( sal_Int16 nId ) const
	{
		::rtl::OUString sLabel;

		Control* pControl = m_pFilePickerController->getControl( nId, sal_True );
		DBG_ASSERT( pControl, "OControlAccess::GetValue: don't have this control in the current mode!" );
		if ( pControl )
			sLabel = pControl->GetText();

		return sLabel;
	}

	//-----------------------------------------------------------------------------
	void OControlAccess::enableControl( sal_Int16 _nId, sal_Bool _bEnable )
	{
        m_pFilePickerController->enableControl( _nId, _bEnable );
	}

	// -----------------------------------------------------------------------
	void OControlAccess::implDoListboxAction( ListBox* _pListbox, sal_Int16 _nControlAction, const Any& _rValue )
	{
		switch ( _nControlAction )
		{
			case ControlActions::ADD_ITEM:
			{
				::rtl::OUString aEntry;
				_rValue >>= aEntry;
				if ( aEntry.getLength() )
					_pListbox->InsertEntry( aEntry );
			}
			break;

			case ControlActions::ADD_ITEMS:
			{
				Sequence < ::rtl::OUString > aTemplateList;
				_rValue >>= aTemplateList;

				if ( aTemplateList.getLength() )
				{
					for ( long i=0; i < aTemplateList.getLength(); i++ )
						_pListbox->InsertEntry( aTemplateList[i] );
				}
			}
			break;

			case ControlActions::DELETE_ITEM:
			{
				sal_Int32 nPos = 0;
				if ( _rValue >>= nPos )
					_pListbox->RemoveEntry( (sal_uInt16) nPos );
			}
			break;

			case ControlActions::DELETE_ITEMS:
				_pListbox->Clear();
				break;

			default:
				DBG_ERRORFILE( "Wrong ControlAction for implDoListboxAction()" );
		}
	}

	//-----------------------------------------------------------------------------
	void OControlAccess::implSetControlProperty( sal_Int16 _nControlId, Control* _pControl, sal_Int16 _nProperty, const Any& _rValue, sal_Bool _bIgnoreIllegalArgument )
	{
        if ( !_pControl )
            _pControl = m_pFilePickerController->getControl( _nControlId );
		DBG_ASSERT( _pControl, "OControlAccess::implSetControlProperty: invalid argument, this will crash!" );
        if ( !_pControl )
            return;

        DBG_ASSERT( _pControl == m_pFilePickerController->getControl( _nControlId ),
            "OControlAccess::implSetControlProperty: inconsistent parameters!" );

		switch ( _nProperty )
		{
			case PROPERTY_FLAG_TEXT:
			{
				::rtl::OUString sText;
				if ( _rValue >>= sText )
				{
					_pControl->SetText( sText );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_ENDBALED:
			{
				sal_Bool bEnabled = sal_False;
				if ( _rValue >>= bEnabled )
				{
                    m_pFilePickerController->enableControl( _nControlId, bEnabled );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_VISIBLE:
			{
				sal_Bool bVisible = sal_False;
				if ( _rValue >>= bVisible )
				{
					_pControl->Show( bVisible );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_HELPURL:
			{
				::rtl::OUString sHelpURL;
				if ( _rValue >>= sHelpURL )
				{
					setHelpURL( _pControl, sHelpURL, m_pFileView == _pControl );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_LISTITEMS:
			{
				DBG_ASSERT( WINDOW_LISTBOX == _pControl->GetType(),
					"OControlAccess::implSetControlProperty: invalid control/property combination!" );

				Sequence< ::rtl::OUString > aItems;
				if ( _rValue >>= aItems )
				{
					// remove all previous items
					static_cast< ListBox* >( _pControl )->Clear();

					// add the new ones
					const ::rtl::OUString* pItems		= aItems.getConstArray();
					const ::rtl::OUString* pItemsEnd	= aItems.getConstArray() + aItems.getLength();
					for	(	const ::rtl::OUString* pItem = pItems;
							pItem != pItemsEnd;
							++pItem
						)
					{
						static_cast< ListBox* >( _pControl )->InsertEntry( *pItem );
					}

				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_SELECTEDITEM:
			{
				DBG_ASSERT( WINDOW_LISTBOX == _pControl->GetType(),
					"OControlAccess::implSetControlProperty: invalid control/property combination!" );

				::rtl::OUString sSelected;
				if ( _rValue >>= sSelected )
				{
					static_cast< ListBox* >( _pControl )->SelectEntry( sSelected );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_SELECTEDITEMINDEX:
			{
				DBG_ASSERT( WINDOW_LISTBOX == _pControl->GetType(),
					"OControlAccess::implSetControlProperty: invalid control/property combination!" );

				sal_Int32 nPos = 0;
				if ( _rValue >>= nPos )
				{
					static_cast< ListBox* >( _pControl )->SelectEntryPos( (sal_uInt16) nPos );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			case PROPERTY_FLAG_CHECKED:
			{
				DBG_ASSERT( WINDOW_CHECKBOX == _pControl->GetType(),
					"OControlAccess::implSetControlProperty: invalid control/property combination!" );

				sal_Bool bChecked = sal_False;
				if ( _rValue >>= bChecked )
				{
					static_cast< CheckBox* >( _pControl )->Check( bChecked );
				}
				else if ( !_bIgnoreIllegalArgument )
				{
					lcl_throwIllegalArgumentException();
				}
			}
			break;

			default:
				DBG_ERROR( "OControlAccess::implSetControlProperty: invalid property id!" );
		}
	}

	//-----------------------------------------------------------------------------
	Any	OControlAccess::implGetControlProperty( Control* _pControl, sal_Int16 _nProperty ) const
	{
		DBG_ASSERT( _pControl, "OControlAccess::implGetControlProperty: invalid argument, this will crash!" );

		Any aReturn;
		switch ( _nProperty )
		{
			case PROPERTY_FLAG_TEXT:
				aReturn <<= ::rtl::OUString( _pControl->GetText() );
				break;

			case PROPERTY_FLAG_ENDBALED:
				aReturn <<= (sal_Bool)_pControl->IsEnabled();
				break;

			case PROPERTY_FLAG_VISIBLE:
				aReturn <<= (sal_Bool)_pControl->IsVisible();
				break;

			case PROPERTY_FLAG_HELPURL:
				aReturn <<= getHelpURL( _pControl, m_pFileView == _pControl );
				break;

			case PROPERTY_FLAG_LISTITEMS:
			{
				DBG_ASSERT( WINDOW_LISTBOX == _pControl->GetType(),
					"OControlAccess::implGetControlProperty: invalid control/property combination!" );

				Sequence< ::rtl::OUString > aItems( static_cast< ListBox* >( _pControl )->GetEntryCount() );
				::rtl::OUString* pItems = aItems.getArray();
				for ( sal_uInt16 i=0; i<static_cast< ListBox* >( _pControl )->GetEntryCount(); ++i )
					*pItems++ = static_cast< ListBox* >( _pControl )->GetEntry( i );

				aReturn <<= aItems;
			}
			break;

			case PROPERTY_FLAG_SELECTEDITEM:
			{
				DBG_ASSERT( WINDOW_LISTBOX == _pControl->GetType(),
					"OControlAccess::implGetControlProperty: invalid control/property combination!" );

				sal_uInt16 nSelected = static_cast< ListBox* >( _pControl )->GetSelectEntryPos();
				::rtl::OUString sSelected;
				if ( LISTBOX_ENTRY_NOTFOUND != nSelected )
					sSelected = static_cast< ListBox* >( _pControl )->GetSelectEntry();
				aReturn <<= sSelected;
			}
			break;

			case PROPERTY_FLAG_SELECTEDITEMINDEX:
			{
				DBG_ASSERT( WINDOW_LISTBOX == _pControl->GetType(),
					"OControlAccess::implGetControlProperty: invalid control/property combination!" );

				sal_uInt16 nSelected = static_cast< ListBox* >( _pControl )->GetSelectEntryPos();
				if ( LISTBOX_ENTRY_NOTFOUND != nSelected )
					aReturn <<= (sal_Int32)static_cast< ListBox* >( _pControl )->GetSelectEntryPos();
				else
					aReturn <<= (sal_Int32)-1;
			}
			break;

			case PROPERTY_FLAG_CHECKED:
				DBG_ASSERT( WINDOW_CHECKBOX == _pControl->GetType(),
					"OControlAccess::implGetControlProperty: invalid control/property combination!" );

				aReturn <<= (sal_Bool)static_cast< CheckBox* >( _pControl )->IsChecked( );
				break;

			default:
				DBG_ERROR( "OControlAccess::implGetControlProperty: invalid property id!" );
		}
		return aReturn;
	}

//.........................................................................
}	// namespace svt
//.........................................................................