fpicker/source/office/OfficeControlAccess.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <sal/macros.h>
  22 #include "OfficeControlAccess.hxx"
  23 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
  24 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
  25 #include <com/sun/star/ui/dialogs/ControlActions.hpp>
  26 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  27 #include <sal/log.hxx>
  28 #include <osl/diagnose.h>
  29 #include <com/sun/star/uno/Sequence.hxx>
  30 #include <tools/urlobj.hxx>
  31 #include <tools/debug.hxx>
  32
  33 #include <algorithm>
  34 #include <utility>
  35
  36
  37 namespace svt
  38 {
  39
  40
  41     // helper -------------------------------------------------------------
  42
  43     using namespace ::com::sun::star::uno;
  44     using namespace ::com::sun::star::lang;
  45     using namespace ::com::sun::star::ui::dialogs;
  46
  47     using namespace ExtendedFilePickerElementIds;
  48     using namespace CommonFilePickerElementIds;
  49     using namespace InternalFilePickerElementIds;
  50
  51
  52     namespace
  53     {
  54
  55         struct ControlDescription
  56         {
  57             const char*     pControlName;
  58             sal_Int16       nControlId;
  59             PropFlags       nPropertyFlags;
  60         };
  61
  62
  63         typedef const ControlDescription* ControlDescIterator;
  64
  65
  66         #define PROPERTY_FLAGS_COMMON       ( PropFlags::Enabled | PropFlags::Visible | PropFlags::HelpUrl )
  67         #define PROPERTY_FLAGS_LISTBOX      ( PropFlags::ListItems | PropFlags::SelectedItem | PropFlags::SelectedItemIndex )
  68         #define PROPERTY_FLAGS_CHECKBOX     ( PropFlags::Checked | PropFlags::Text )
  69
  70         // Note: this array MUST be sorted by name!
  71         const ControlDescription aDescriptions[] =  {
  72             { "AutoExtensionBox",       CHECKBOX_AUTOEXTENSION,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  73             { "CancelButton",           PUSHBUTTON_CANCEL,              PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  74             { "CurrentFolderText",      FIXEDTEXT_CURRENTFOLDER,        PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  75             { "FileURLEdit",            EDIT_FILEURL,                   PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  76             { "FileURLEditLabel",       EDIT_FILEURL_LABEL,             PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  77             { "FileView",               CONTROL_FILEVIEW,               PROPERTY_FLAGS_COMMON                               },
  78             { "FilterList",             LISTBOX_FILTER,                 PROPERTY_FLAGS_COMMON                               },
  79             { "FilterListLabel",        LISTBOX_FILTER_LABEL,           PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  80             { "FilterOptionsBox",       CHECKBOX_FILTEROPTIONS,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  81             { "GpgPassword",            CHECKBOX_GPGENCRYPTION,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  82             { "GpgSign",                CHECKBOX_GPGSIGN,               PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  83             { "HelpButton",             PUSHBUTTON_HELP,                PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  84             { "ImageAnchorList",        LISTBOX_IMAGE_ANCHOR,           PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
  85             { "ImageAnchorListLabel",   LISTBOX_IMAGE_ANCHOR_LABEL,     PROPERTY_FLAGS_COMMON | PropFlags::Text             },
  86             { "ImageTemplateList",      LISTBOX_IMAGE_TEMPLATE,         PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
  87             { "ImageTemplateListLabel", LISTBOX_IMAGE_TEMPLATE_LABEL,   PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  88             { "LevelUpButton",          TOOLBOXBUTTON_LEVEL_UP,         PROPERTY_FLAGS_COMMON                               },
  89             { "LinkBox",                CHECKBOX_LINK,                  PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  90             { "NewFolderButton",        TOOLBOXBUTTON_NEW_FOLDER,       PROPERTY_FLAGS_COMMON                               },
  91             { "OkButton",               PUSHBUTTON_OK ,                 PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  92             { "PasswordBox",            CHECKBOX_PASSWORD,              PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  93             { "PlayButton",             PUSHBUTTON_PLAY,                PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  94             { "PreviewBox",             CHECKBOX_PREVIEW,               PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  95             { "ReadOnlyBox",            CHECKBOX_READONLY,              PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  96             { "SelectionBox",           CHECKBOX_SELECTION,             PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_CHECKBOX     },
  97             { "TemplateList",           LISTBOX_TEMPLATE,               PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
  98             { "TemplateListLabel",      LISTBOX_TEMPLATE_LABEL,         PROPERTY_FLAGS_COMMON | PropFlags::Text          },
  99             { "VersionList",            LISTBOX_VERSION,                PROPERTY_FLAGS_COMMON | PROPERTY_FLAGS_LISTBOX      },
 100             { "VersionListLabel",       LISTBOX_VERSION_LABEL,          PROPERTY_FLAGS_COMMON | PropFlags::Text          }
 101         };
 102
 103         const sal_Int32 s_nControlCount = SAL_N_ELEMENTS( aDescriptions );
 104
 105         ControlDescIterator s_pControls = aDescriptions;
 106         ControlDescIterator s_pControlsEnd = aDescriptions + s_nControlCount;
 107
 108         struct ControlDescriptionLookup
 109         {
 110             bool operator()( const ControlDescription& rDesc1, const ControlDescription& rDesc2 )
 111             {
 112                 return strcmp(rDesc1.pControlName, rDesc2.pControlName) < 0;
 113             }
 114         };
 115
 116         struct ControlProperty
 117         {
 118             const char*     pPropertyName;
 119             PropFlags       nPropertyId;
 120         };
 121
 122         typedef const ControlProperty* ControlPropertyIterator;
 123
 124         const ControlProperty aProperties[] =  {
 125             { "Text",               PropFlags::Text              },
 126             { "Enabled",            PropFlags::Enabled          },
 127             { "Visible",            PropFlags::Visible           },
 128             { "HelpURL",            PropFlags::HelpUrl           },
 129             { "ListItems",          PropFlags::ListItems         },
 130             { "SelectedItem",       PropFlags::SelectedItem      },
 131             { "SelectedItemIndex",  PropFlags::SelectedItemIndex },
 132             { "Checked",            PropFlags::Checked           }
 133         };
 134
 135         const int s_nPropertyCount = SAL_N_ELEMENTS( aProperties );
 136
 137         ControlPropertyIterator s_pProperties = aProperties;
 138         ControlPropertyIterator s_pPropertiesEnd = aProperties + s_nPropertyCount;
 139
 140
 141         struct ControlPropertyLookup
 142         {
 143             OUString m_sLookup;
 144             explicit ControlPropertyLookup(OUString aLookup)
 145                 : m_sLookup(std::move(aLookup))
 146             {
 147             }
 148
 149             bool operator()(const ControlProperty& rProp)
 150             {
 151                 return m_sLookup.equalsAscii(rProp.pPropertyName);
 152             }
 153         };
 154     }
 155
 156     OControlAccess::OControlAccess(IFilePickerController* pController, SvtFileView* pFileView)
 157         : m_pFilePickerController(pController)
 158         , m_pFileView(pFileView)
 159     {
 160         DBG_ASSERT( m_pFilePickerController, "OControlAccess::OControlAccess: invalid control locator!" );
 161     }
 162
 163     bool OControlAccess::IsFileViewWidget(weld::Widget const * pControl) const
 164     {
 165         if (!pControl)
 166             return false;
 167         if (!m_pFileView)
 168             return false;
 169         return pControl == m_pFileView->identifier();
 170     }
 171
 172     void OControlAccess::setHelpURL(weld::Widget* pControl, const OUString& sHelpURL)
 173     {
 174         OUString sHelpID( sHelpURL );
 175         INetURLObject aHID( sHelpURL );
 176         if (aHID.GetProtocol() == INetProtocol::Hid)
 177             sHelpID = aHID.GetURLPath();
 178
 179         // URLs should always be escaped
 180         if (IsFileViewWidget(pControl))
 181         {
 182             // the file view "overrides" the SetHelpId
 183             m_pFileView->set_help_id(sHelpID);
 184         }
 185         else
 186             pControl->set_help_id(sHelpID);
 187     }
 188
 189     OUString OControlAccess::getHelpURL(weld::Widget const * pControl) const
 190     {
 191         OUString aHelpId = pControl->get_help_id();
 192         if (IsFileViewWidget(pControl))
 193         {
 194             // the file view "overrides" the SetHelpId
 195             aHelpId = m_pFileView->get_help_id();
 196         }
 197
 198         OUString sHelpURL;
 199         INetURLObject aHID(aHelpId);
 200         if ( aHID.GetProtocol() == INetProtocol::NotValid )
 201             sHelpURL = INET_HID_SCHEME;
 202         sHelpURL += aHelpId;
 203         return sHelpURL;
 204     }
 205
 206     Any OControlAccess::getControlProperty( std::u16string_view rControlName, const OUString& rControlProperty )
 207     {
 208         // look up the control
 209         sal_Int16 nControlId = -1;
 210         PropFlags nPropertyMask = PropFlags::NONE;
 211         weld::Widget* pControl = implGetControl( rControlName, &nControlId, &nPropertyMask );
 212             // will throw an IllegalArgumentException if the name is not valid
 213
 214         // look up the property
 215         ControlPropertyIterator aPropDesc = ::std::find_if( s_pProperties, s_pPropertiesEnd, ControlPropertyLookup( rControlProperty ) );
 216         if ( aPropDesc == s_pPropertiesEnd )
 217             // it's a completely unknown property
 218             throw IllegalArgumentException();
 219
 220         if ( !( nPropertyMask & aPropDesc->nPropertyId ) )
 221             // it's a property which is known, but not allowed for this control
 222             throw IllegalArgumentException();
 223
 224         return implGetControlProperty( pControl, aPropDesc->nPropertyId );
 225     }
 226
 227     weld::Widget* OControlAccess::implGetControl( std::u16string_view rControlName, sal_Int16* _pId, PropFlags* _pPropertyMask ) const
 228     {
 229         weld::Widget* pControl = nullptr;
 230         ControlDescription tmpDesc;
 231         OString aControlName = OUStringToOString( rControlName, RTL_TEXTENCODING_UTF8 );
 232         tmpDesc.pControlName = aControlName.getStr();
 233
 234         // translate the name into an id
 235         auto aFoundRange = ::std::equal_range( s_pControls, s_pControlsEnd, tmpDesc, ControlDescriptionLookup() );
 236         if ( aFoundRange.first != aFoundRange.second )
 237         {
 238             // get the VCL control determined by this id
 239             pControl = m_pFilePickerController->getControl( aFoundRange.first->nControlId );
 240         }
 241
 242         // if not found 'til here, the name is invalid, or we do not have the control in the current mode
 243         if ( !pControl )
 244             throw IllegalArgumentException();
 245
 246         // out parameters and outta here
 247         if ( _pId )
 248             *_pId = aFoundRange.first->nControlId;
 249         if ( _pPropertyMask )
 250             *_pPropertyMask = aFoundRange.first->nPropertyFlags;
 251
 252         return pControl;
 253     }
 254
 255     void OControlAccess::setControlProperty( std::u16string_view rControlName, const OUString& rControlProperty, const css::uno::Any& rValue )
 256     {
 257         // look up the control
 258         sal_Int16 nControlId = -1;
 259         weld::Widget* pControl = implGetControl( rControlName, &nControlId );
 260             // will throw an IllegalArgumentException if the name is not valid
 261
 262         // look up the property
 263         ControlPropertyIterator aPropDesc = ::std::find_if( s_pProperties, s_pPropertiesEnd, ControlPropertyLookup( rControlProperty ) );
 264         if ( aPropDesc == s_pPropertiesEnd )
 265             throw IllegalArgumentException();
 266
 267         // set the property
 268         implSetControlProperty( nControlId, pControl, aPropDesc->nPropertyId, rValue, false );
 269     }
 270
 271     Sequence< OUString > OControlAccess::getSupportedControls(  ) const
 272     {
 273         Sequence< OUString > aControls( s_nControlCount );
 274         OUString* pControls = aControls.getArray();
 275
 276         // collect the names of all _actually_existent_ controls
 277         for ( ControlDescIterator aControl = s_pControls; aControl != s_pControlsEnd; ++aControl )
 278         {
 279             if ( m_pFilePickerController->getControl( aControl->nControlId ) )
 280                 *pControls++ = OUString::createFromAscii( aControl->pControlName );
 281         }
 282
 283         aControls.realloc( pControls - aControls.getArray() );
 284         return aControls;
 285     }
 286
 287     Sequence< OUString > OControlAccess::getSupportedControlProperties( std::u16string_view rControlName )
 288     {
 289         sal_Int16 nControlId = -1;
 290         PropFlags nPropertyMask = PropFlags::NONE;
 291         implGetControl( rControlName, &nControlId, &nPropertyMask );
 292             // will throw an IllegalArgumentException if the name is not valid
 293
 294         // fill in the property names
 295         Sequence< OUString > aProps( s_nPropertyCount );
 296         OUString* pProperty = aProps.getArray();
 297
 298         for ( ControlPropertyIterator aProp = s_pProperties; aProp != s_pPropertiesEnd; ++aProp )
 299             if ( nPropertyMask & aProp->nPropertyId )
 300                 *pProperty++ = OUString::createFromAscii( aProp->pPropertyName );
 301
 302         aProps.realloc( pProperty - aProps.getArray() );
 303         return aProps;
 304     }
 305
 306     bool OControlAccess::isControlSupported( std::u16string_view rControlName )
 307     {
 308         ControlDescription tmpDesc;
 309         OString aControlName = OUStringToOString(rControlName, RTL_TEXTENCODING_UTF8);
 310         tmpDesc.pControlName = aControlName.getStr();
 311         return ::std::binary_search( s_pControls, s_pControlsEnd, tmpDesc, ControlDescriptionLookup() );
 312     }
 313
 314     bool OControlAccess::isControlPropertySupported( std::u16string_view rControlName, const OUString& rControlProperty )
 315     {
 316         // look up the control
 317         sal_Int16 nControlId = -1;
 318         PropFlags nPropertyMask = PropFlags::NONE;
 319         implGetControl( rControlName, &nControlId, &nPropertyMask );
 320             // will throw an IllegalArgumentException if the name is not valid
 321
 322         // look up the property
 323         ControlPropertyIterator aPropDesc = ::std::find_if( s_pProperties, s_pPropertiesEnd, ControlPropertyLookup( rControlProperty ) );
 324         if ( aPropDesc == s_pPropertiesEnd )
 325             // it's a property which is completely unknown
 326             return false;
 327
 328         return bool( aPropDesc->nPropertyId & nPropertyMask );
 329     }
 330
 331     void OControlAccess::setValue( sal_Int16 nControlId, sal_Int16 nControlAction, const Any& rValue )
 332     {
 333         weld::Widget* pControl = m_pFilePickerController->getControl( nControlId );
 334         DBG_ASSERT( pControl, "OControlAccess::SetValue: don't have this control in the current mode!" );
 335         if ( !pControl )
 336             return;
 337
 338         PropFlags nPropertyId = PropFlags::Unknown;
 339         if ( ControlActions::SET_HELP_URL == nControlAction )
 340         {
 341             nPropertyId = PropFlags::HelpUrl;
 342         }
 343         else
 344         {
 345             switch ( nControlId )
 346             {
 347                 case CHECKBOX_AUTOEXTENSION:
 348                 case CHECKBOX_PASSWORD:
 349                 case CHECKBOX_FILTEROPTIONS:
 350                 case CHECKBOX_READONLY:
 351                 case CHECKBOX_LINK:
 352                 case CHECKBOX_PREVIEW:
 353                 case CHECKBOX_SELECTION:
 354                     nPropertyId = PropFlags::Checked;
 355                     break;
 356
 357                 case LISTBOX_FILTER:
 358                     SAL_WARN( "fpicker.office", "Use the XFilterManager to access the filter listbox" );
 359                     break;
 360
 361                 case LISTBOX_VERSION:
 362                 case LISTBOX_TEMPLATE:
 363                 case LISTBOX_IMAGE_TEMPLATE:
 364                 case LISTBOX_IMAGE_ANCHOR:
 365                     if ( ControlActions::SET_SELECT_ITEM == nControlAction )
 366                     {
 367                         nPropertyId = PropFlags::SelectedItemIndex;
 368                     }
 369                     else
 370                     {
 371                         weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
 372                         assert(pComboBox && "OControlAccess::SetValue: implGetControl returned nonsense!");
 373                         implDoListboxAction(pComboBox, nControlAction, rValue);
 374                     }
 375                     break;
 376             }
 377         }
 378
 379         if ( PropFlags::Unknown != nPropertyId )
 380             implSetControlProperty( nControlId, pControl, nPropertyId, rValue );
 381     }
 382
 383     Any OControlAccess::getValue( sal_Int16 nControlId, sal_Int16 nControlAction ) const
 384     {
 385         Any aRet;
 386
 387         weld::Widget* pControl = m_pFilePickerController->getControl( nControlId );
 388         DBG_ASSERT( pControl, "OControlAccess::GetValue: don't have this control in the current mode!" );
 389         if ( pControl )
 390         {
 391             PropFlags nPropertyId = PropFlags::Unknown;
 392             if ( ControlActions::SET_HELP_URL == nControlAction )
 393             {
 394                 nPropertyId = PropFlags::HelpUrl;
 395             }
 396             else
 397             {
 398                 switch ( nControlId )
 399                 {
 400                     case CHECKBOX_AUTOEXTENSION:
 401                     case CHECKBOX_PASSWORD:
 402                     case CHECKBOX_GPGENCRYPTION:
 403                     case CHECKBOX_GPGSIGN:
 404                     case CHECKBOX_FILTEROPTIONS:
 405                     case CHECKBOX_READONLY:
 406                     case CHECKBOX_LINK:
 407                     case CHECKBOX_PREVIEW:
 408                     case CHECKBOX_SELECTION:
 409                         nPropertyId = PropFlags::Checked;
 410                         break;
 411
 412                     case LISTBOX_FILTER:
 413                         if ( ControlActions::GET_SELECTED_ITEM == nControlAction )
 414                         {
 415                             aRet <<= m_pFilePickerController->getCurFilter();
 416                         }
 417                         else
 418                         {
 419                             SAL_WARN( "fpicker.office", "Use the XFilterManager to access the filter listbox" );
 420                         }
 421                         break;
 422
 423                     case LISTBOX_VERSION:
 424                     case LISTBOX_TEMPLATE:
 425                     case LISTBOX_IMAGE_TEMPLATE:
 426                     case LISTBOX_IMAGE_ANCHOR:
 427                         switch ( nControlAction )
 428                         {
 429                             case ControlActions::GET_SELECTED_ITEM:
 430                                 nPropertyId = PropFlags::SelectedItem;
 431                                 break;
 432                             case ControlActions::GET_SELECTED_ITEM_INDEX:
 433                                 nPropertyId = PropFlags::SelectedItemIndex;
 434                                 break;
 435                             case ControlActions::GET_ITEMS:
 436                                 nPropertyId = PropFlags::ListItems;
 437                                 break;
 438                             default:
 439                                 SAL_WARN( "fpicker.office", "OControlAccess::GetValue: invalid control action for the listbox!" );
 440                                 break;
 441                         }
 442                         break;
 443                 }
 444             }
 445
 446             if ( PropFlags::Unknown != nPropertyId )
 447                 aRet = implGetControlProperty( pControl, nPropertyId );
 448         }
 449
 450         return aRet;
 451     }
 452
 453     void OControlAccess::setLabel( sal_Int16 nId, const OUString &rLabel )
 454     {
 455         weld::Widget* pControl = m_pFilePickerController->getControl(nId, true);
 456         if (weld::Label* pLabel = dynamic_cast<weld::Label*>(pControl))
 457         {
 458             pLabel->set_label(rLabel);
 459             return;
 460         }
 461         if (weld::Button* pButton = dynamic_cast<weld::Button*>(pControl))
 462         {
 463             pButton->set_label(rLabel);
 464             return;
 465         }
 466         assert(false && "OControlAccess::GetValue: don't have this control in the current mode!");
 467     }
 468
 469     OUString OControlAccess::getLabel( sal_Int16 nId ) const
 470     {
 471         weld::Widget* pControl = m_pFilePickerController->getControl(nId, true);
 472         if (weld::Label* pLabel = dynamic_cast<weld::Label*>(pControl))
 473             return pLabel->get_label();
 474         if (weld::Button* pButton = dynamic_cast<weld::Button*>(pControl))
 475             return pButton->get_label();
 476         assert(false && "OControlAccess::GetValue: don't have this control in the current mode!");
 477         return OUString();
 478     }
 479
 480     void OControlAccess::enableControl(sal_Int16 nId, bool bEnable)
 481     {
 482         m_pFilePickerController->enableControl(nId, bEnable);
 483     }
 484
 485     void OControlAccess::implDoListboxAction(weld::ComboBox* pListbox, sal_Int16 nControlAction, const Any& rValue)
 486     {
 487         switch ( nControlAction )
 488         {
 489             case ControlActions::ADD_ITEM:
 490             {
 491                 OUString aEntry;
 492                 rValue >>= aEntry;
 493                 if ( !aEntry.isEmpty() )
 494                     pListbox->append_text( aEntry );
 495             }
 496             break;
 497
 498             case ControlActions::ADD_ITEMS:
 499             {
 500                 Sequence < OUString > aTemplateList;
 501                 rValue >>= aTemplateList;
 502
 503                 if ( aTemplateList.hasElements() )
 504                 {
 505                     for (const OUString& s : aTemplateList)
 506                         pListbox->append_text( s );
 507                 }
 508             }
 509             break;
 510
 511             case ControlActions::DELETE_ITEM:
 512             {
 513                 sal_Int32 nPos = 0;
 514                 if ( rValue >>= nPos )
 515                     pListbox->remove( nPos );
 516             }
 517             break;
 518
 519             case ControlActions::DELETE_ITEMS:
 520                 pListbox->clear();
 521                 break;
 522
 523             default:
 524                 SAL_WARN( "fpicker.office", "Wrong ControlAction for implDoListboxAction()" );
 525         }
 526     }
 527
 528     void OControlAccess::implSetControlProperty( sal_Int16 nControlId, weld::Widget* pControl, PropFlags _nProperty, const Any& rValue, bool _bIgnoreIllegalArgument )
 529     {
 530         if ( !pControl )
 531             pControl = m_pFilePickerController->getControl( nControlId );
 532         DBG_ASSERT( pControl, "OControlAccess::implSetControlProperty: invalid argument, this will crash!" );
 533         if ( !pControl )
 534             return;
 535
 536         DBG_ASSERT( pControl == m_pFilePickerController->getControl( nControlId ),
 537             "OControlAccess::implSetControlProperty: inconsistent parameters!" );
 538
 539         switch ( _nProperty )
 540         {
 541             case PropFlags::Text:
 542             {
 543                 OUString sText;
 544                 if (rValue >>= sText)
 545                 {
 546                     weld::Label* pLabel = dynamic_cast<weld::Label*>(pControl);
 547                     assert(pLabel);
 548                     pLabel->set_label(sText);
 549                 }
 550                 else if ( !_bIgnoreIllegalArgument )
 551                 {
 552                     throw IllegalArgumentException();
 553                 }
 554             }
 555             break;
 556
 557             case PropFlags::Enabled:
 558             {
 559                 bool bEnabled = false;
 560                 if ( rValue >>= bEnabled )
 561                 {
 562                     m_pFilePickerController->enableControl( nControlId, bEnabled );
 563                 }
 564                 else if ( !_bIgnoreIllegalArgument )
 565                 {
 566                     throw IllegalArgumentException();
 567                 }
 568             }
 569             break;
 570
 571             case PropFlags::Visible:
 572             {
 573                 bool bVisible = false;
 574                 if ( rValue >>= bVisible )
 575                 {
 576                     pControl->set_visible( bVisible );
 577                 }
 578                 else if ( !_bIgnoreIllegalArgument )
 579                 {
 580                     throw IllegalArgumentException();
 581                 }
 582             }
 583             break;
 584
 585             case PropFlags::HelpUrl:
 586             {
 587                 OUString sHelpURL;
 588                 if ( rValue >>= sHelpURL )
 589                 {
 590                     setHelpURL(pControl, sHelpURL);
 591                 }
 592                 else if ( !_bIgnoreIllegalArgument )
 593                 {
 594                     throw IllegalArgumentException();
 595                 }
 596             }
 597             break;
 598
 599             case PropFlags::ListItems:
 600             {
 601                 weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
 602                 assert(pComboBox && "OControlAccess::implSetControlProperty: invalid control/property combination!");
 603
 604                 Sequence< OUString > aItems;
 605                 if ( rValue >>= aItems )
 606                 {
 607                     // remove all previous items
 608                     pComboBox->clear();
 609
 610                     // add the new ones
 611                     for (auto const& item : aItems)
 612                     {
 613                         pComboBox->append_text(item);
 614                     }
 615
 616                 }
 617                 else if ( !_bIgnoreIllegalArgument )
 618                 {
 619                     throw IllegalArgumentException();
 620                 }
 621             }
 622             break;
 623
 624             case PropFlags::SelectedItem:
 625             {
 626                 weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
 627                 assert(pComboBox && "OControlAccess::implSetControlProperty: invalid control/property combination!");
 628
 629                 OUString sSelected;
 630                 if ( rValue >>= sSelected )
 631                 {
 632                     pComboBox->set_active_text(sSelected);
 633                 }
 634                 else if ( !_bIgnoreIllegalArgument )
 635                 {
 636                     throw IllegalArgumentException();
 637                 }
 638             }
 639             break;
 640
 641             case PropFlags::SelectedItemIndex:
 642             {
 643                 weld::ComboBox* pComboBox = dynamic_cast<weld::ComboBox*>(pControl);
 644                 assert(pComboBox && "OControlAccess::implSetControlProperty: invalid control/property combination!");
 645
 646                 sal_Int32 nPos = 0;
 647                 if ( rValue >>= nPos )
 648                 {
 649                     pComboBox->set_active(nPos);
 650                 }
 651                 else if ( !_bIgnoreIllegalArgument )
 652                 {
 653                     throw IllegalArgumentException();
 654                 }
 655             }
 656             break;
 657
 658             case PropFlags::Checked:
 659             {
 660                 weld::Toggleable* pToggleButton = dynamic_cast<weld::Toggleable*>(pControl);
 661                 assert(pToggleButton && "OControlAccess::implSetControlProperty: invalid control/property combination!");
 662
 663                 bool bChecked = false;
 664                 if ( rValue >>= bChecked )
 665                 {
 666                     pToggleButton->set_active(bChecked);
 667                 }
 668                 else if ( !_bIgnoreIllegalArgument )
 669                 {
 670                     throw IllegalArgumentException();
 671                 }
 672             }
 673             break;
 674
 675             default:
 676                 OSL_FAIL( "OControlAccess::implSetControlProperty: invalid property id!" );
 677         }
 678     }
 679
 680     Any OControlAccess::implGetControlProperty( weld::Widget const * pControl, PropFlags _nProperty ) const
 681     {
 682         assert(pControl && "OControlAccess::implGetControlProperty: invalid argument, this will crash!");
 683
 684         Any aReturn;
 685         switch ( _nProperty )
 686         {
 687             case PropFlags::Text:
 688             {
 689                 const weld::Label* pLabel = dynamic_cast<const weld::Label*>(pControl);
 690                 assert(pLabel);
 691                 aReturn <<= pLabel->get_label();
 692                 break;
 693             }
 694             case PropFlags::Enabled:
 695                 aReturn <<= pControl->get_sensitive();
 696                 break;
 697
 698             case PropFlags::Visible:
 699                 aReturn <<= pControl->get_visible();
 700                 break;
 701
 702             case PropFlags::HelpUrl:
 703                 aReturn <<= getHelpURL(pControl);
 704                 break;
 705
 706             case PropFlags::ListItems:
 707             {
 708                 const weld::ComboBox* pComboBox = dynamic_cast<const weld::ComboBox*>(pControl);
 709                 assert(pComboBox && "OControlAccess::implGetControlProperty: invalid control/property combination!");
 710
 711                 Sequence< OUString > aItems(pComboBox->get_count());
 712                 OUString* pItems = aItems.getArray();
 713                 for (sal_Int32 i = 0; i < pComboBox->get_count(); ++i)
 714                     *pItems++ = pComboBox->get_text(i);
 715
 716                 aReturn <<= aItems;
 717                 break;
 718             }
 719
 720             case PropFlags::SelectedItem:
 721             {
 722                 const weld::ComboBox* pComboBox = dynamic_cast<const weld::ComboBox*>(pControl);
 723                 assert(pComboBox && "OControlAccess::implGetControlProperty: invalid control/property combination!");
 724
 725                 sal_Int32 nSelected = pComboBox->get_active();
 726                 OUString sSelected;
 727                 if (nSelected != -1)
 728                     sSelected = pComboBox->get_active_text();
 729                 aReturn <<= sSelected;
 730                 break;
 731             }
 732
 733             case PropFlags::SelectedItemIndex:
 734             {
 735                 const weld::ComboBox* pComboBox = dynamic_cast<const weld::ComboBox*>(pControl);
 736                 assert(pComboBox && "OControlAccess::implGetControlProperty: invalid control/property combination!");
 737
 738                 sal_Int32 nSelected = pComboBox->get_active();
 739                 if (nSelected != -1)
 740                     aReturn <<= nSelected;
 741                 else
 742                     aReturn <<= sal_Int32(-1);
 743                 break;
 744             }
 745
 746             case PropFlags::Checked:
 747             {
 748                 const weld::Toggleable* pToggleButton = dynamic_cast<const weld::Toggleable*>(pControl);
 749                 assert(pToggleButton && "OControlAccess::implGetControlProperty: invalid control/property combination!");
 750
 751                 aReturn <<= pToggleButton->get_active();
 752                 break;
 753             }
 754
 755             default:
 756                 OSL_FAIL( "OControlAccess::implGetControlProperty: invalid property id!" );
 757         }
 758         return aReturn;
 759     }
 760
 761 }   // namespace svt
 762
 763 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */