path: root/fpicker/source/office/OfficeControlAccess.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */


#include <sal/macros.h>
#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 <com/sun/star/lang/IllegalArgumentException.hpp>
#include <sal/log.hxx>
#include <osl/diagnose.h>
#include <com/sun/star/uno/Sequence.hxx>
#include <tools/urlobj.hxx>
#include <tools/debug.hxx>

#include <algorithm>
#include <utility>


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
    {

        struct ControlDescription
        {
            const char*     pControlName;
            sal_Int16       nControlId;
            PropFlags       nPropertyFlags;
        };


        typedef const ControlDescription* ControlDescIterator;


        #define PROPERTY_FLAGS_COMMON       ( PropFlags::Enabled | PropFlags::Visible | PropFlags::HelpUrl )
        #define PROPERTY_FLAGS_LISTBOX      ( PropFlags::ListItems | PropFlags::SelectedItem | PropFlags::SelectedItemIndex )
        #define PROPERTY_FLAGS_CHECKBOX     ( PropFlags::Checked | PropFlags::Text )

        // Note: this array MUST be sorted by name!
        const ControlDescription aDescriptions[] =  {
            { "AutoExtensionBox",       CHECKBOX_AUTOEXTENSION,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
            { "CancelButton",           PUSHBUTTON_CANCEL,              PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "CurrentFolderText",      FIXEDTEXT_CURRENTFOLDER,        PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "FileURLEdit",            EDIT_FILEURL,                   PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "FileURLEditLabel",       EDIT_FILEURL_LABEL,             PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "FileView",               CONTROL_FILEVIEW,               PROPERTY_FLAGS_COMMON                               },
            { "FilterList",             LISTBOX_FILTER,                 PROPERTY_FLAGS_COMMON                               },
            { "FilterListLabel",        LISTBOX_FILTER_LABEL,           PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "FilterOptionsBox",       CHECKBOX_FILTEROPTIONS,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
            { "GpgPassword",            CHECKBOX_GPGENCRYPTION,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
            { "HelpButton",             PUSHBUTTON_HELP,                PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "ImageAnchorList",        LISTBOX_IMAGE_ANCHOR,           PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
            { "ImageAnchorListLabel",   LISTBOX_IMAGE_ANCHOR_LABEL,     PROPERTY_FLAGS_COMMON | PropFlags::Text             },
            { "ImageTemplateList",      LISTBOX_IMAGE_TEMPLATE,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
            { "ImageTemplateListLabel", LISTBOX_IMAGE_TEMPLATE_LABEL,   PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "LevelUpButton",          TOOLBOXBUTTON_LEVEL_UP,         PROPERTY_FLAGS_COMMON                               },
            { "LinkBox",                CHECKBOX_LINK,                  PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
            { "NewFolderButton",        TOOLBOXBUTTON_NEW_FOLDER,       PROPERTY_FLAGS_COMMON                               },
            { "OkButton",               PUSHBUTTON_OK ,                 PROPERTY_FLAGS_COMMON | PropFlags::Text          },
            { "PasswordBox",            CHECKBOX_PASSWORD,              PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
            { "PlayButton",             PUSHBUTTON_PLAY,                PROPERTY_FLAGS_COMMON | PropFlags::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 | PropFlags::Text          },
            { "VersionList",            LISTBOX_VERSION,                PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
            { "VersionListLabel",       LISTBOX_VERSION_LABEL,          PROPERTY_FLAGS_COMMON | PropFlags::Text          }
        };

        const sal_Int32 s_nControlCount = SAL_N_ELEMENTS( aDescriptions );

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

        struct ControlDescriptionLookup
        {
            bool operator()( const ControlDescription& rDesc1, const ControlDescription& rDesc2 )
            {
                return strcmp(rDesc1.pControlName, rDesc2.pControlName) < 0;
            }
        };

        struct ControlProperty
        {
            const char*     pPropertyName;
            PropFlags       nPropertyId;
        };

        typedef const ControlProperty* ControlPropertyIterator;

        const ControlProperty aProperties[] =  {
            { "Text",               PropFlags::Text              },
            { "Enabled",            PropFlags::Enabled          },
            { "Visible",            PropFlags::Visible           },
            { "HelpURL",            PropFlags::HelpUrl           },
            { "ListItems",          PropFlags::ListItems         },
            { "SelectedItem",       PropFlags::SelectedItem      },
            { "SelectedItemIndex",  PropFlags::SelectedItemIndex },
            { "Checked",            PropFlags::Checked           }
        };

        const int s_nPropertyCount = SAL_N_ELEMENTS( aProperties );

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


        struct ControlPropertyLookup
        {
            OUString m_sLookup;
            explicit ControlPropertyLookup(OUString aLookup)
                : m_sLookup(std::move(aLookup))
            {
            }

            bool operator()(const ControlProperty& rProp)
            {
                return m_sLookup.equalsAscii(rProp.pPropertyName);
            }
        };
    }

    OControlAccess::OControlAccess(IFilePickerController* pController, SvtFileView* pFileView)
        : m_pFilePickerController(pController)
        , m_pFileView(pFileView)
    {
        DBG_ASSERT( m_pFilePickerController, "OControlAccess::OControlAccess: invalid control locator!" );
    }

    bool OControlAccess::IsFileViewWidget(weld::Widget const * pControl) const
    {
        if (!pControl)
            return false;
        if (!m_pFileView)
            return false;
        return pControl == m_pFileView->identifier();
    }

    void OControlAccess::setHelpURL(weld::Widget* pControl, const OUString& sHelpURL)
    {
        OUString sHelpID( sHelpURL );
        INetURLObject aHID( sHelpURL );
        if (aHID.GetProtocol() == INetProtocol::Hid)
            sHelpID = aHID.GetURLPath();

        // URLs should always be escaped
        if (IsFileViewWidget(pControl))
        {
            // the file view "overrides" the SetHelpId
            m_pFileView->set_help_id(sHelpID);
        }
        else
            pControl->set_help_id(sHelpID);
    }

    OUString OControlAccess::getHelpURL(weld::Widget const * pControl) const
    {
        OUString aHelpId = pControl->get_help_id();
        if (IsFileViewWidget(pControl))
        {
            // the file view "overrides" the SetHelpId
            aHelpId = m_pFileView->get_help_id();
        }

        OUString sHelpURL;
        INetURLObject aHID(aHelpId);
        if ( aHID.GetProtocol() == INetProtocol::NotValid )
            sHelpURL = INET_HID_SCHEME;
        sHelpURL += aHelpId;
        return sHelpURL;
    }

    Any OControlAccess::getControlProperty( std::u16string_view rControlName, const OUString& rControlProperty )
    {
        // look up the control
        sal_Int16 nControlId = -1;
        PropFlags nPropertyMask = PropFlags::NONE;
        weld::Widget* 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
            throw IllegalArgumentException();

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

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

    weld::Widget* OControlAccess::implGetControl( std::u16string_view rControlName, sal_Int16* _pId, PropFlags* _pPropertyMask ) const
    {
        weld::Widget* pControl = nullptr;
        ControlDescription tmpDesc;
        OString aControlName = OUStringToOString( rControlName, RTL_TEXTENCODING_UTF8 );
        tmpDesc.pControlName = aControlName.getStr();

        // translate the name into an id
        auto aFoundRange = ::std::equal_range( s_pControls, s_pControlsEnd, tmpDesc, 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 )
            throw IllegalArgumentException();

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

        return pControl;
    }

    void OControlAccess::setControlProperty( std::u16string_view rControlName, const OUString& rControlProperty, const css::uno::Any& rValue )
    {
        // look up the control
        sal_Int16 nControlId = -1;
        weld::Widget* 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 )
            throw IllegalArgumentException();

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

    Sequence< OUString > OControlAccess::getSupportedControls(  ) const
    {
        Sequence< OUString > aControls( s_nControlCount );
        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++ = OUString::createFromAscii( aControl->pControlName );
        }

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

    Sequence< OUString > OControlAccess::getSupportedControlProperties( std::u16string_view rControlName )
    {
        sal_Int16 nControlId = -1;
        PropFlags nPropertyMask = PropFlags::NONE;
        implGetControl( rControlName, &nControlId, &nPropertyMask );
            // will throw an IllegalArgumentException if the name is not valid

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

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

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

    bool OControlAccess::isControlSupported( std::u16string_view rControlName )
    {
        ControlDescription tmpDesc;
        OString aControlName = OUStringToOString(rControlName, RTL_TEXTENCODING_UTF8);
        tmpDesc.pControlName = aControlName.getStr();
        return ::std::binary_search( s_pControls, s_pControlsEnd, tmpDesc, ControlDescriptionLookup() );
    }

    bool OControlAccess::isControlPropertySupported( std::u16string_view rControlName, const OUString& rControlProperty )
    {
        // look up the control
        sal_Int16 nControlId = -1;
        PropFlags nPropertyMask = PropFlags::NONE;
        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 false;

        return bool( aPropDesc->nPropertyId & nPropertyMask );
    }

    void OControlAccess::setValue( sal_Int16 nControlId, sal_Int16 nControlAction, const Any& rValue )
    {
        weld::Widget* pControl = m_pFilePickerController->getControl( nControlId );
        DBG_ASSERT( pControl, "OControlAccess::SetValue: don't have this control in the current mode!" );
        if ( !pControl )
            return;

        PropFlags nPropertyId = PropFlags::Unknown;
        if ( ControlActions::SET_HELP_URL == nControlAction )
        {
            nPropertyId = PropFlags::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 = PropFlags::Checked;
                    break;

                case LISTBOX_FILTER:
                    SAL_WARN( "fpicker.office", "Use the XFilterManager to access the filter listbox" );
                    break;

                case LISTBOX_VERSION:
                case LISTBOX_TEMPLATE:
                case LISTBOX_IMAGE_TEMPLATE:
                case LISTBOX_IMAGE_ANCHOR:
                    if ( ControlActions::SET_SELECT_ITEM == nControlAction )
                    {
                        nPropertyId = PropFlags::SelectedItemIndex;
                    }
                    else
                    {
                        weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
                        assert(pComboBox && "OControlAccess::SetValue: implGetControl returned nonsense!");
                        implDoListboxAction(pComboBox, nControlAction, rValue);
                    }
                    break;
            }
        }

        if ( PropFlags::Unknown != nPropertyId )
            implSetControlProperty( nControlId, pControl, nPropertyId, rValue );
    }

    Any OControlAccess::getValue( sal_Int16 nControlId, sal_Int16 nControlAction ) const
    {
        Any aRet;

        weld::Widget* pControl = m_pFilePickerController->getControl( nControlId );
        DBG_ASSERT( pControl, "OControlAccess::GetValue: don't have this control in the current mode!" );
        if ( pControl )
        {
            PropFlags nPropertyId = PropFlags::Unknown;
            if ( ControlActions::SET_HELP_URL == nControlAction )
            {
                nPropertyId = PropFlags::HelpUrl;
            }
            else
            {
                switch ( nControlId )
                {
                    case CHECKBOX_AUTOEXTENSION:
                    case CHECKBOX_PASSWORD:
                    case CHECKBOX_GPGENCRYPTION:
                    case CHECKBOX_FILTEROPTIONS:
                    case CHECKBOX_READONLY:
                    case CHECKBOX_LINK:
                    case CHECKBOX_PREVIEW:
                    case CHECKBOX_SELECTION:
                        nPropertyId = PropFlags::Checked;
                        break;

                    case LISTBOX_FILTER:
                        if ( ControlActions::GET_SELECTED_ITEM == nControlAction )
                        {
                            aRet <<= m_pFilePickerController->getCurFilter();
                        }
                        else
                        {
                            SAL_WARN( "fpicker.office", "Use the XFilterManager to access the filter listbox" );
                        }
                        break;

                    case LISTBOX_VERSION:
                    case LISTBOX_TEMPLATE:
                    case LISTBOX_IMAGE_TEMPLATE:
                    case LISTBOX_IMAGE_ANCHOR:
                        switch ( nControlAction )
                        {
                            case ControlActions::GET_SELECTED_ITEM:
                                nPropertyId = PropFlags::SelectedItem;
                                break;
                            case ControlActions::GET_SELECTED_ITEM_INDEX:
                                nPropertyId = PropFlags::SelectedItemIndex;
                                break;
                            case ControlActions::GET_ITEMS:
                                nPropertyId = PropFlags::ListItems;
                                break;
                            default:
                                SAL_WARN( "fpicker.office", "OControlAccess::GetValue: invalid control action for the listbox!" );
                                break;
                        }
                        break;
                }
            }

            if ( PropFlags::Unknown != nPropertyId )
                aRet = implGetControlProperty( pControl, nPropertyId );
        }

        return aRet;
    }

    void OControlAccess::setLabel( sal_Int16 nId, const OUString &rLabel )
    {
        weld::Widget* pControl = m_pFilePickerController->getControl(nId, true);
        if (weld::Label* pLabel = dynamic_cast<weld::Label*>(pControl))
        {
            pLabel->set_label(rLabel);
            return;
        }
        if (weld::Button* pButton = dynamic_cast<weld::Button*>(pControl))
        {
            pButton->set_label(rLabel);
            return;
        }
        assert(false && "OControlAccess::GetValue: don't have this control in the current mode!");
    }

    OUString OControlAccess::getLabel( sal_Int16 nId ) const
    {
        weld::Widget* pControl = m_pFilePickerController->getControl(nId, true);
        if (weld::Label* pLabel = dynamic_cast<weld::Label*>(pControl))
            return pLabel->get_label();
        if (weld::Button* pButton = dynamic_cast<weld::Button*>(pControl))
            return pButton->get_label();
        assert(false && "OControlAccess::GetValue: don't have this control in the current mode!");
        return OUString();
    }

    void OControlAccess::enableControl(sal_Int16 nId, bool bEnable)
    {
        m_pFilePickerController->enableControl(nId, bEnable);
    }

    void OControlAccess::implDoListboxAction(weld::ComboBox* pListbox, sal_Int16 nControlAction, const Any& rValue)
    {
        switch ( nControlAction )
        {
            case ControlActions::ADD_ITEM:
            {
                OUString aEntry;
                rValue >>= aEntry;
                if ( !aEntry.isEmpty() )
                    pListbox->append_text( aEntry );
            }
            break;

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

                if ( aTemplateList.hasElements() )
                {
                    for ( const OUString& s : std::as_const(aTemplateList) )
                        pListbox->append_text( s );
                }
            }
            break;

            case ControlActions::DELETE_ITEM:
            {
                sal_Int32 nPos = 0;
                if ( rValue >>= nPos )
                    pListbox->remove( nPos );
            }
            break;

            case ControlActions::DELETE_ITEMS:
                pListbox->clear();
                break;

            default:
                SAL_WARN( "fpicker.office", "Wrong ControlAction for implDoListboxAction()" );
        }
    }

    void OControlAccess::implSetControlProperty( sal_Int16 nControlId, weld::Widget* pControl, PropFlags _nProperty, const Any& rValue, 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 PropFlags::Text:
            {
                OUString sText;
                if (rValue >>= sText)
                {
                    weld::Label* pLabel = dynamic_cast<weld::Label*>(pControl);
                    assert(pLabel);
                    pLabel->set_label(sText);
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::Enabled:
            {
                bool bEnabled = false;
                if ( rValue >>= bEnabled )
                {
                    m_pFilePickerController->enableControl( nControlId, bEnabled );
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::Visible:
            {
                bool bVisible = false;
                if ( rValue >>= bVisible )
                {
                    pControl->set_visible( bVisible );
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::HelpUrl:
            {
                OUString sHelpURL;
                if ( rValue >>= sHelpURL )
                {
                    setHelpURL(pControl, sHelpURL);
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::ListItems:
            {
                weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
                assert(pComboBox && "OControlAccess::implSetControlProperty: invalid control/property combination!");

                Sequence< OUString > aItems;
                if ( rValue >>= aItems )
                {
                    // remove all previous items
                    pComboBox->clear();

                    // add the new ones
                    for (auto const & item : std::as_const(aItems))
                    {
                        pComboBox->append_text(item);
                    }

                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::SelectedItem:
            {
                weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
                assert(pComboBox && "OControlAccess::implSetControlProperty: invalid control/property combination!");

                OUString sSelected;
                if ( rValue >>= sSelected )
                {
                    pComboBox->set_active_text(sSelected);
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::SelectedItemIndex:
            {
                weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
                assert(pComboBox && "OControlAccess::implSetControlProperty: invalid control/property combination!");

                sal_Int32 nPos = 0;
                if ( rValue >>= nPos )
                {
                    pComboBox->set_active(nPos);
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

            case PropFlags::Checked:
            {
                weld::Toggleable* pToggleButton = dynamic_cast<weld::Toggleable*>(pControl);
                assert(pToggleButton && "OControlAccess::implSetControlProperty: invalid control/property combination!");

                bool bChecked = false;
                if ( rValue >>= bChecked )
                {
                    pToggleButton->set_active(bChecked);
                }
                else if ( !_bIgnoreIllegalArgument )
                {
                    throw IllegalArgumentException();
                }
            }
            break;

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

    Any OControlAccess::implGetControlProperty( weld::Widget const * pControl, PropFlags _nProperty ) const
    {
        assert(pControl && "OControlAccess::implGetControlProperty: invalid argument, this will crash!");

        Any aReturn;
        switch ( _nProperty )
        {
            case PropFlags::Text:
            {
                const weld::Label* pLabel = dynamic_cast<const weld::Label*>(pControl);
                assert(pLabel);
                aReturn <<= pLabel->get_label();
                break;
            }
            case PropFlags::Enabled:
                aReturn <<= pControl->get_sensitive();
                break;

            case PropFlags::Visible:
                aReturn <<= pControl->get_visible();
                break;

            case PropFlags::HelpUrl:
                aReturn <<= getHelpURL(pControl);
                break;

            case PropFlags::ListItems:
            {
                const weld::ComboBox* pComboBox = dynamic_cast<const weld::ComboBox*>(pControl);
                assert(pComboBox && "OControlAccess::implGetControlProperty: invalid control/property combination!");

                Sequence< OUString > aItems(pComboBox->get_count());
                OUString* pItems = aItems.getArray();
                for (sal_Int32 i = 0; i < pComboBox->get_count(); ++i)
                    *pItems++ = pComboBox->get_text(i);

                aReturn <<= aItems;
                break;
            }

            case PropFlags::SelectedItem:
            {
                const weld::ComboBox* pComboBox = dynamic_cast<const weld::ComboBox*>(pControl);
                assert(pComboBox && "OControlAccess::implGetControlProperty: invalid control/property combination!");

                sal_Int32 nSelected = pComboBox->get_active();
                OUString sSelected;
                if (nSelected != -1)
                    sSelected = pComboBox->get_active_text();
                aReturn <<= sSelected;
                break;
            }

            case PropFlags::SelectedItemIndex:
            {
                const weld::ComboBox* pComboBox = dynamic_cast<const weld::ComboBox*>(pControl);
                assert(pComboBox && "OControlAccess::implGetControlProperty: invalid control/property combination!");

                sal_Int32 nSelected = pComboBox->get_active();
                if (nSelected != -1)
                    aReturn <<= nSelected;
                else
                    aReturn <<= sal_Int32(-1);
                break;
            }

            case PropFlags::Checked:
            {
                const weld::Toggleable* pToggleButton = dynamic_cast<const weld::Toggleable*>(pControl);
                assert(pToggleButton && "OControlAccess::implGetControlProperty: invalid control/property combination!");

                aReturn <<= pToggleButton->get_active();
                break;
            }

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

}   // namespace svt

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */