extensions/source/propctrlr/genericpropertyhandler.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: genericpropertyhandler.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33 #include "genericpropertyhandler.hxx"
  34 #include "formmetadata.hxx"
  35 #include "handlerhelper.hxx"
  36
  37 /** === begin UNO includes === **/
  38 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  39 #include <com/sun/star/reflection/XEnumTypeDescription.hpp>
  40 #include <com/sun/star/beans/XIntrospection.hpp>
  41 #include <com/sun/star/inspection/PropertyControlType.hpp>
  42 #include <com/sun/star/inspection/XHyperlinkControl.hpp>
  43 #include <com/sun/star/awt/XActionListener.hpp>
  44 #include <com/sun/star/util/XURLTransformer.hpp>
  45 #include <com/sun/star/frame/XDispatchProvider.hpp>
  46 /** === end UNO includes === **/
  47 #include <tools/debug.hxx>
  48 #include <cppuhelper/extract.hxx>
  49
  50 #include <algorithm>
  51
  52 //------------------------------------------------------------------------
  53 extern "C" void SAL_CALL createRegistryInfo_GenericPropertyHandler()
  54 {
  55     ::pcr::OAutoRegistration< ::pcr::GenericPropertyHandler > aAutoRegistration;
  56 }
  57
  58 //........................................................................
  59 namespace pcr
  60 {
  61 //........................................................................
  62
  63     using namespace ::com::sun::star::uno;
  64     using namespace ::com::sun::star::beans;
  65     using namespace ::com::sun::star::script;
  66     using namespace ::com::sun::star::frame;
  67     using namespace ::com::sun::star::lang;
  68     using namespace ::com::sun::star::util;
  69     using namespace ::com::sun::star::container;
  70     using namespace ::com::sun::star::reflection;
  71     using namespace ::com::sun::star::inspection;
  72     using ::com::sun::star::awt::XActionListener;
  73     using ::com::sun::star::awt::ActionEvent;
  74
  75     //====================================================================
  76     //= EnumRepresentation
  77     //====================================================================
  78     class EnumRepresentation : public IPropertyEnumRepresentation
  79     {
  80     private:
  81         oslInterlockedCount                 m_refCount;
  82         Reference< XEnumTypeDescription >   m_xTypeDescription;
  83         Type                                m_aEnumType;
  84
  85     public:
  86         EnumRepresentation( const Reference< XComponentContext >& _rxContext, const Type& _rEnumType );
  87
  88         // IPropertyEnumRepresentation implementqation
  89         virtual ::std::vector< ::rtl::OUString >
  90                                     SAL_CALL getDescriptions() const;
  91         virtual void                SAL_CALL getValueFromDescription( const ::rtl::OUString& _rDescription, ::com::sun::star::uno::Any& _out_rValue ) const;
  92         virtual ::rtl::OUString     SAL_CALL getDescriptionForValue( const ::com::sun::star::uno::Any& _rEnumValue ) const;
  93
  94         // IReference implementqation
  95         virtual oslInterlockedCount SAL_CALL acquire();
  96         virtual oslInterlockedCount SAL_CALL release();
  97
  98     private:
  99         void            impl_getValues( Sequence< sal_Int32 >& _out_rValues ) const;
 100
 101     private:
 102         EnumRepresentation();                                       // never implemented
 103         EnumRepresentation( const EnumRepresentation& );            // never implemented
 104         EnumRepresentation& operator=( const EnumRepresentation& ); // never implemented
 105     };
 106
 107     //--------------------------------------------------------------------
 108     EnumRepresentation::EnumRepresentation( const Reference< XComponentContext >& _rxContext, const Type& _rEnumType )
 109         :m_refCount( 0 )
 110         ,m_aEnumType( _rEnumType )
 111     {
 112         try
 113         {
 114             if ( _rxContext.is() )
 115             {
 116                 Reference< XHierarchicalNameAccess > xTypeDescProv(
 117                     _rxContext->getValueByName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/singletons/com.sun.star.reflection.theTypeDescriptionManager" ) ) ),
 118                     UNO_QUERY_THROW );
 119
 120                 m_xTypeDescription = Reference< XEnumTypeDescription >( xTypeDescProv->getByHierarchicalName( m_aEnumType.getTypeName() ), UNO_QUERY_THROW );
 121             }
 122         }
 123         catch( const Exception& )
 124         {
 125             OSL_ENSURE( sal_False, "EnumRepresentation::EnumRepresentation: caught an exception!" );
 126         }
 127     }
 128
 129     //--------------------------------------------------------------------
 130     ::std::vector< ::rtl::OUString > EnumRepresentation::getDescriptions() const
 131     {
 132         Sequence< ::rtl::OUString > aNames;
 133         try
 134         {
 135             if ( m_xTypeDescription.is() )
 136                 aNames = m_xTypeDescription->getEnumNames();
 137         }
 138         catch( const Exception& )
 139         {
 140             OSL_ENSURE( sal_False, "EnumRepresentation::getDescriptions: caught an exception!" );
 141         }
 142
 143         return ::std::vector< ::rtl::OUString >( aNames.getConstArray(), aNames.getConstArray() + aNames.getLength() );
 144     }
 145
 146     //--------------------------------------------------------------------
 147     void EnumRepresentation::impl_getValues( Sequence< sal_Int32 >& _out_rValues ) const
 148     {
 149         _out_rValues.realloc( 0 );
 150         try
 151         {
 152             if  ( m_xTypeDescription.is() )
 153                 _out_rValues = m_xTypeDescription->getEnumValues();
 154         }
 155         catch( const Exception& )
 156         {
 157             OSL_ENSURE( sal_False, "EnumRepresentation::impl_getValues: caught an exception!" );
 158         }
 159     }
 160
 161     //--------------------------------------------------------------------
 162     void EnumRepresentation::getValueFromDescription( const ::rtl::OUString& _rDescription, Any& _out_rValue ) const
 163     {
 164         ::std::vector< ::rtl::OUString > aDescriptions( getDescriptions() );
 165
 166         sal_Int32 index = ::std::find( aDescriptions.begin(), aDescriptions.end(),
 167             _rDescription ) - aDescriptions.begin();
 168
 169         Sequence< sal_Int32 > aValues;
 170         impl_getValues( aValues );
 171
 172         if ( ( index >= 0 ) && ( index < aValues.getLength() ) )
 173             _out_rValue = ::cppu::int2enum( aValues[ index ], m_aEnumType );
 174         else
 175         {
 176             DBG_ERROR( "EnumRepresentation::getValueFromDescription: cannot convert!" );
 177             _out_rValue.clear();
 178         }
 179     }
 180
 181     //--------------------------------------------------------------------
 182     ::rtl::OUString EnumRepresentation::getDescriptionForValue( const Any& _rEnumValue ) const
 183     {
 184         ::rtl::OUString sDescription;
 185
 186         sal_Int32 nAsInt = 0;
 187         OSL_VERIFY( ::cppu::enum2int( nAsInt, _rEnumValue ) );
 188
 189         Sequence< sal_Int32 > aValues;
 190         impl_getValues( aValues );
 191
 192         sal_Int32 index = ::std::find( aValues.getConstArray(), aValues.getConstArray() + aValues.getLength(),
 193             nAsInt ) - aValues.getConstArray();
 194
 195         ::std::vector< ::rtl::OUString > aDescriptions( getDescriptions() );
 196         if ( ( index >= 0 ) && ( index < (sal_Int32)aDescriptions.size() ) )
 197             sDescription = aDescriptions[ index ];
 198         else
 199         {
 200              DBG_ERROR( "EnumRepresentation::getDescriptionForValue: cannot convert!" );
 201         }
 202         return sDescription;
 203     }
 204
 205     //--------------------------------------------------------------------
 206     oslInterlockedCount SAL_CALL EnumRepresentation::acquire()
 207     {
 208         return osl_incrementInterlockedCount( &m_refCount );
 209     }
 210
 211     //--------------------------------------------------------------------
 212     oslInterlockedCount SAL_CALL EnumRepresentation::release()
 213     {
 214         if ( 0 == osl_decrementInterlockedCount( &m_refCount ) )
 215         {
 216            delete this;
 217            return 0;
 218         }
 219         return m_refCount;
 220     }
 221
 222     //====================================================================
 223     //= UrlClickHandler
 224     //====================================================================
 225     typedef ::cppu::WeakImplHelper1 <   XActionListener
 226                                     >   UrlClickHandler_Base;
 227     class UrlClickHandler : public UrlClickHandler_Base
 228     {
 229         ComponentContext    m_aContext;
 230     public:
 231         UrlClickHandler( const ComponentContext& _rContext, const Reference< XHyperlinkControl >& _rxControl );
 232
 233     protected:
 234         ~UrlClickHandler();
 235
 236         // XActionListener
 237         virtual void SAL_CALL actionPerformed( const ActionEvent& rEvent ) throw (RuntimeException);
 238
 239         // XEventListener
 240         virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException);
 241
 242     protected:
 243         void impl_dispatch_throw( const ::rtl::OUString& _rURL );
 244     };
 245
 246     //--------------------------------------------------------------------
 247     DBG_NAME( UrlClickHandler )
 248     //--------------------------------------------------------------------
 249     UrlClickHandler::UrlClickHandler( const ComponentContext& _rContext, const Reference< XHyperlinkControl >& _rxControl )
 250         :m_aContext( _rContext )
 251     {
 252         if ( !_rxControl.is() )
 253             throw NullPointerException();
 254
 255         osl_incrementInterlockedCount( &m_refCount );
 256         {
 257             _rxControl->addActionListener( this );
 258         }
 259         osl_decrementInterlockedCount( &m_refCount );
 260         OSL_ENSURE( m_refCount > 0, "UrlClickHandler::UrlClickHandler: leaking!" );
 261
 262         DBG_CTOR( UrlClickHandler, NULL );
 263     }
 264
 265     //--------------------------------------------------------------------
 266     UrlClickHandler::~UrlClickHandler()
 267     {
 268         DBG_DTOR( UrlClickHandler, NULL );
 269     }
 270
 271     //--------------------------------------------------------------------
 272     void SAL_CALL UrlClickHandler::actionPerformed( const ActionEvent& rEvent ) throw (RuntimeException)
 273     {
 274         Reference< XPropertyControl > xControl( rEvent.Source, UNO_QUERY_THROW );
 275         Any aControlValue( xControl->getValue() );
 276
 277         ::rtl::OUString sURL;
 278         if ( aControlValue.hasValue() && !( aControlValue >>= sURL ) )
 279             throw RuntimeException( ::rtl::OUString(), *this );
 280
 281         if ( !sURL.getLength() )
 282             return;
 283
 284         impl_dispatch_throw( sURL );
 285     }
 286
 287     //--------------------------------------------------------------------
 288     void SAL_CALL UrlClickHandler::disposing( const EventObject& /*Source*/ ) throw (RuntimeException)
 289     {
 290         // not interested in
 291     }
 292
 293     //--------------------------------------------------------------------
 294     void UrlClickHandler::impl_dispatch_throw( const ::rtl::OUString& _rURL )
 295     {
 296         Reference< XURLTransformer > xTransformer( m_aContext.createComponent( "com.sun.star.util.URLTransformer" ), UNO_QUERY_THROW );
 297         URL aURL; aURL.Complete = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:OpenHyperlink" ) );
 298         xTransformer->parseStrict( aURL );
 299
 300         Reference< XDispatchProvider > xDispProv( m_aContext.createComponent( "com.sun.star.frame.Desktop" ), UNO_QUERY_THROW );
 301         Reference< XDispatch > xDispatch( xDispProv->queryDispatch( aURL, ::rtl::OUString(), 0 ), UNO_QUERY_THROW );
 302
 303         Sequence< PropertyValue > aDispatchArgs(1);
 304         aDispatchArgs[0].Name   = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("URL"));
 305         aDispatchArgs[0].Value  <<= _rURL;
 306
 307         xDispatch->dispatch( aURL, aDispatchArgs );
 308     }
 309
 310     //====================================================================
 311     //= GenericPropertyHandler
 312     //====================================================================
 313     DBG_NAME( GenericPropertyHandler )
 314     //--------------------------------------------------------------------
 315     GenericPropertyHandler::GenericPropertyHandler( const Reference< XComponentContext >& _rxContext )
 316         :GenericPropertyHandler_Base( m_aMutex )
 317         ,m_aContext( _rxContext )
 318         ,m_aPropertyListeners( m_aMutex )
 319         ,m_bPropertyMapInitialized( false )
 320     {
 321         DBG_CTOR( GenericPropertyHandler, NULL );
 322
 323         m_xTypeConverter = Reference< XTypeConverter >(
 324             m_aContext.createComponent( "com.sun.star.script.Converter" ),
 325             UNO_QUERY_THROW
 326         );
 327     }
 328
 329     //--------------------------------------------------------------------
 330     GenericPropertyHandler::~GenericPropertyHandler()
 331     {
 332         DBG_DTOR( GenericPropertyHandler, NULL );
 333     }
 334
 335     //--------------------------------------------------------------------
 336     ::rtl::OUString SAL_CALL GenericPropertyHandler::getImplementationName(  ) throw (RuntimeException)
 337     {
 338         return getImplementationName_static();
 339     }
 340
 341     //--------------------------------------------------------------------
 342     ::sal_Bool SAL_CALL GenericPropertyHandler::supportsService( const ::rtl::OUString& ServiceName ) throw (RuntimeException)
 343     {
 344         StlSyntaxSequence< ::rtl::OUString > aAllServices( getSupportedServiceNames() );
 345         return ::std::find( aAllServices.begin(), aAllServices.end(), ServiceName ) != aAllServices.end();
 346     }
 347
 348     //--------------------------------------------------------------------
 349     Sequence< ::rtl::OUString > SAL_CALL GenericPropertyHandler::getSupportedServiceNames(  ) throw (RuntimeException)
 350     {
 351         return getSupportedServiceNames_static();
 352     }
 353
 354     //--------------------------------------------------------------------
 355     ::rtl::OUString SAL_CALL GenericPropertyHandler::getImplementationName_static(  ) throw (RuntimeException)
 356     {
 357         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.extensions.GenericPropertyHandler" ) );
 358     }
 359
 360     //--------------------------------------------------------------------
 361     Sequence< ::rtl::OUString > SAL_CALL GenericPropertyHandler::getSupportedServiceNames_static(  ) throw (RuntimeException)
 362     {
 363         Sequence< ::rtl::OUString > aSupported( 1 );
 364         aSupported[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.inspection.GenericPropertyHandler" ) );
 365         return aSupported;
 366     }
 367
 368     //--------------------------------------------------------------------
 369     Reference< XInterface > SAL_CALL GenericPropertyHandler::Create( const Reference< XComponentContext >& _rxContext )
 370     {
 371         return *( new GenericPropertyHandler( _rxContext ) );
 372     }
 373
 374     //--------------------------------------------------------------------
 375     void SAL_CALL GenericPropertyHandler::inspect( const Reference< XInterface >& _rxIntrospectee ) throw (RuntimeException, NullPointerException)
 376     {
 377         ::osl::MutexGuard aGuard( m_aMutex );
 378
 379         if ( !_rxIntrospectee.is() )
 380             throw NullPointerException();
 381
 382         // revoke old property change listeners
 383         ::cppu::OInterfaceIteratorHelper iterRemove( m_aPropertyListeners );
 384         ::cppu::OInterfaceIteratorHelper iterReAdd( m_aPropertyListeners ); // this holds a copy of the container ...
 385         while ( iterRemove.hasMoreElements() )
 386             m_xComponent->removePropertyChangeListener( ::rtl::OUString(), static_cast< XPropertyChangeListener* >( iterRemove.next() ) );
 387
 388         m_xComponentIntrospectionAccess.clear();
 389         m_xComponent.clear();
 390         m_xPropertyState.clear();
 391
 392         // create an introspection adapter for the component
 393         Reference< XIntrospection > xIntrospection;
 394         if ( !m_aContext.createComponent( "com.sun.star.beans.Introspection", xIntrospection ) )
 395             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Could not create an instance of the service com.sun.star.beans.Introspection." ) ), *this );
 396
 397         Reference< XIntrospectionAccess > xIntrospectionAccess( xIntrospection->inspect( makeAny( _rxIntrospectee ) ) );
 398         if ( !xIntrospectionAccess.is() )
 399             throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "The introspection service could not handle the given component." ) ), *this );
 400
 401         m_xComponent = Reference< XPropertySet >( xIntrospectionAccess->queryAdapter( XPropertySet::static_type() ), UNO_QUERY_THROW );
 402         // now that we survived so far, remember m_xComponentIntrospectionAccess
 403         m_xComponentIntrospectionAccess = xIntrospectionAccess;
 404         m_xPropertyState = m_xPropertyState.query( m_xComponent );
 405
 406         m_bPropertyMapInitialized = false;
 407         m_aProperties.clear();
 408
 409         // re-add the property change listeners
 410         while ( iterReAdd.hasMoreElements() )
 411             m_xComponent->addPropertyChangeListener( ::rtl::OUString(), static_cast< XPropertyChangeListener* >( iterReAdd.next() ) );
 412     }
 413
 414     //--------------------------------------------------------------------
 415     Any SAL_CALL GenericPropertyHandler::getPropertyValue( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException)
 416     {
 417         ::osl::MutexGuard aGuard( m_aMutex );
 418         if ( !m_xComponent.is() )
 419             throw UnknownPropertyException();
 420
 421         return m_xComponent->getPropertyValue( _rPropertyName );
 422     }
 423
 424     //--------------------------------------------------------------------
 425     void SAL_CALL GenericPropertyHandler::setPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rValue ) throw (UnknownPropertyException, RuntimeException)
 426     {
 427         ::osl::MutexGuard aGuard( m_aMutex );
 428         if ( !m_xComponent.is() )
 429             throw UnknownPropertyException();
 430
 431         m_xComponent->setPropertyValue( _rPropertyName, _rValue );
 432     }
 433
 434     //--------------------------------------------------------------------
 435     ::rtl::Reference< IPropertyEnumRepresentation > GenericPropertyHandler::impl_getEnumConverter( const Type& _rEnumType )
 436     {
 437         ::rtl::Reference< IPropertyEnumRepresentation >& rConverter = m_aEnumConverters[ _rEnumType ];
 438         if ( !rConverter.is() )
 439             rConverter = new EnumRepresentation( m_aContext.getUNOContext(), _rEnumType );
 440         return rConverter;
 441     }
 442
 443     //--------------------------------------------------------------------
 444     Any SAL_CALL GenericPropertyHandler::convertToPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rControlValue ) throw (UnknownPropertyException, RuntimeException)
 445     {
 446         ::osl::MutexGuard aGuard( m_aMutex );
 447         const_cast< GenericPropertyHandler* >( this )->impl_ensurePropertyMap();
 448
 449         PropertyMap::const_iterator pos = m_aProperties.find( _rPropertyName );
 450         if ( pos == m_aProperties.end() )
 451             throw UnknownPropertyException();
 452
 453         Any aPropertyValue;
 454         if ( !_rControlValue.hasValue() )
 455             // NULL is converted to NULL
 456             return aPropertyValue;
 457
 458         if ( pos->second.Type.getTypeClass() == TypeClass_ENUM )
 459         {
 460             ::rtl::OUString sControlValue;
 461             OSL_VERIFY( _rControlValue >>= sControlValue );
 462             impl_getEnumConverter( pos->second.Type )->getValueFromDescription( sControlValue, aPropertyValue );
 463         }
 464         else
 465             aPropertyValue = PropertyHandlerHelper::convertToPropertyValue( m_aContext.getContext(),m_xTypeConverter, pos->second, _rControlValue );
 466
 467         return aPropertyValue;
 468     }
 469
 470     //--------------------------------------------------------------------
 471     Any SAL_CALL GenericPropertyHandler::convertToControlValue( const ::rtl::OUString& _rPropertyName, const Any& _rPropertyValue, const Type& _rControlValueType ) throw (UnknownPropertyException, RuntimeException)
 472     {
 473         ::osl::MutexGuard aGuard( m_aMutex );
 474         const_cast< GenericPropertyHandler* >( this )->impl_ensurePropertyMap();
 475
 476         PropertyMap::const_iterator pos = m_aProperties.find( _rPropertyName );
 477         if ( pos == m_aProperties.end() )
 478             throw UnknownPropertyException();
 479
 480         Any aControlValue;
 481         if ( !_rPropertyValue.hasValue() )
 482             // NULL is converted to NULL
 483             return aControlValue;
 484
 485         if ( pos->second.Type.getTypeClass() == TypeClass_ENUM )
 486         {
 487             aControlValue <<= impl_getEnumConverter( pos->second.Type )->getDescriptionForValue( _rPropertyValue );
 488         }
 489         else
 490             aControlValue = PropertyHandlerHelper::convertToControlValue( m_aContext.getContext(),m_xTypeConverter, _rPropertyValue, _rControlValueType );
 491         return aControlValue;
 492     }
 493
 494     //--------------------------------------------------------------------
 495     PropertyState SAL_CALL GenericPropertyHandler::getPropertyState( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException)
 496     {
 497         ::osl::MutexGuard aGuard( m_aMutex );
 498         PropertyState eState = PropertyState_DIRECT_VALUE;
 499         if ( m_xPropertyState.is() )
 500             eState = m_xPropertyState->getPropertyState( _rPropertyName );
 501         return eState;
 502     }
 503
 504     //--------------------------------------------------------------------
 505     void SAL_CALL GenericPropertyHandler::addPropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException)
 506     {
 507         if ( !_rxListener.is() )
 508             throw NullPointerException();
 509
 510         ::osl::MutexGuard aGuard( m_aMutex );
 511         m_aPropertyListeners.addInterface( _rxListener );
 512         if ( m_xComponent.is() )
 513         {
 514             try
 515             {
 516                 m_xComponent->addPropertyChangeListener( ::rtl::OUString(), _rxListener );
 517             }
 518             catch( const UnknownPropertyException& )
 519             {
 520                 OSL_ENSURE( false, "GenericPropertyHandler::addPropertyChangeListener:\nThe inspected component does not allow registering for all properties at once! This violates the interface contract!" );
 521             }
 522         }
 523     }
 524
 525     //--------------------------------------------------------------------
 526     void SAL_CALL GenericPropertyHandler::removePropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException)
 527     {
 528         ::osl::MutexGuard aGuard( m_aMutex );
 529         if ( m_xComponent.is() )
 530         {
 531             try
 532             {
 533                 m_xComponent->removePropertyChangeListener( ::rtl::OUString(), _rxListener );
 534             }
 535             catch( const UnknownPropertyException& )
 536             {
 537                 OSL_ENSURE( false, "GenericPropertyHandler::removePropertyChangeListener:\nThe inspected component does not allow de-registering for all properties at once! This violates the interface contract!" );
 538             }
 539         }
 540         m_aPropertyListeners.removeInterface( _rxListener );
 541     }
 542
 543     //--------------------------------------------------------------------
 544     void GenericPropertyHandler::impl_ensurePropertyMap()
 545     {
 546         if ( !m_bPropertyMapInitialized )
 547         {
 548             m_bPropertyMapInitialized = true;
 549             try
 550             {
 551                 Reference< XPropertySetInfo > xPSI;
 552                 if ( m_xComponent.is() )
 553                     xPSI = m_xComponent->getPropertySetInfo();
 554                 Sequence< Property > aProperties;
 555                 if ( xPSI.is() )
 556                     aProperties = xPSI->getProperties();
 557                 DBG_ASSERT( aProperties.getLength(), "GenericPropertyHandler::getSupportedProperties: no properties!" );
 558
 559                 for ( const Property* pProperties = aProperties.getConstArray();
 560                       pProperties != aProperties.getConstArray() + aProperties.getLength();
 561                       ++pProperties
 562                     )
 563                 {
 564                     switch ( pProperties->Type.getTypeClass() )
 565                     {
 566                     case TypeClass_BOOLEAN:
 567                     case TypeClass_BYTE:
 568                     case TypeClass_SHORT:
 569                     case TypeClass_UNSIGNED_SHORT:
 570                     case TypeClass_LONG:
 571                     case TypeClass_UNSIGNED_LONG:
 572                     case TypeClass_HYPER:
 573                     case TypeClass_UNSIGNED_HYPER:
 574                     case TypeClass_FLOAT:
 575                     case TypeClass_DOUBLE:
 576                     case TypeClass_ENUM:
 577                     case TypeClass_STRING:
 578                         // allowed, we can handle this type
 579                         break;
 580
 581                     case TypeClass_SEQUENCE:
 582                     {
 583                         TypeClass eElementTypeClass = ::comphelper::getSequenceElementType( pProperties->Type ).getTypeClass();
 584                         if  (   ( eElementTypeClass != TypeClass_STRING )
 585                             &&  ( eElementTypeClass != TypeClass_BYTE )
 586                             &&  ( eElementTypeClass != TypeClass_SHORT )
 587                             &&  ( eElementTypeClass != TypeClass_UNSIGNED_SHORT )
 588                             &&  ( eElementTypeClass != TypeClass_LONG )
 589                             &&  ( eElementTypeClass != TypeClass_UNSIGNED_LONG )
 590                             )
 591                             // can only handle the above
 592                             continue;
 593                     }
 594                     break;
 595
 596                     default:
 597                         // next property, we don't support this type
 598                         continue;
 599                     }
 600
 601                     m_aProperties.insert( PropertyMap::value_type( pProperties->Name, *pProperties ) );
 602                 }
 603             }
 604             catch( const Exception& )
 605             {
 606                 OSL_ENSURE( sal_False, "GenericPropertyHandler::impl_ensurePropertyMap: caught an exception!" );
 607             }
 608         }
 609     }
 610
 611     //--------------------------------------------------------------------
 612     Sequence< Property > SAL_CALL GenericPropertyHandler::getSupportedProperties() throw (RuntimeException)
 613     {
 614         ::osl::MutexGuard aGuard( m_aMutex );
 615         const_cast< GenericPropertyHandler* >( this )->impl_ensurePropertyMap();
 616
 617         Sequence< Property > aReturn( m_aProperties.size() );
 618         ::std::transform( m_aProperties.begin(), m_aProperties.end(),
 619             aReturn.getArray(), ::std::select2nd< PropertyMap::value_type >() );
 620         return aReturn;
 621     }
 622
 623     //--------------------------------------------------------------------
 624     Sequence< ::rtl::OUString > SAL_CALL GenericPropertyHandler::getSupersededProperties( ) throw (RuntimeException)
 625     {
 626         // no superseded properties at all. This handler offers the very basic PropertyHandler
 627         // functionality, so it's much more likely that other handlers want to supersede
 628         // *our* properties ....
 629         return Sequence< ::rtl::OUString >( );
 630     }
 631
 632     //--------------------------------------------------------------------
 633     Sequence< ::rtl::OUString > SAL_CALL GenericPropertyHandler::getActuatingProperties( ) throw (RuntimeException)
 634     {
 635         // This basic PropertyHandler implementation is too dumb^Wgeneric to know
 636         // anything about property dependencies
 637         return Sequence< ::rtl::OUString >( );
 638     }
 639
 640     //--------------------------------------------------------------------
 641     LineDescriptor SAL_CALL GenericPropertyHandler::describePropertyLine( const ::rtl::OUString& _rPropertyName,
 642         const Reference< XPropertyControlFactory >& _rxControlFactory )
 643         throw (UnknownPropertyException, NullPointerException, RuntimeException)
 644     {
 645         if ( !_rxControlFactory.is() )
 646             throw NullPointerException();
 647
 648         ::osl::MutexGuard aGuard( m_aMutex );
 649         const_cast< GenericPropertyHandler* >( this )->impl_ensurePropertyMap();
 650
 651         PropertyMap::const_iterator pos = m_aProperties.find( _rPropertyName );
 652         if ( pos == m_aProperties.end() )
 653             throw UnknownPropertyException();
 654
 655         LineDescriptor aDescriptor;
 656         aDescriptor.DisplayName = _rPropertyName;
 657         switch ( pos->second.Type.getTypeClass() )
 658         {
 659         case TypeClass_ENUM:
 660             aDescriptor.Control = PropertyHandlerHelper::createListBoxControl( _rxControlFactory,
 661                 impl_getEnumConverter( pos->second.Type )->getDescriptions(),
 662                 PropertyHandlerHelper::requiresReadOnlyControl( pos->second.Attributes ),
 663                 sal_False );
 664             break;
 665         case TypeClass_STRING:
 666         {
 667             // some special handling for URL properties
 668             bool bIsURLProperty = ( _rPropertyName.getLength() >= 3 ) && _rPropertyName.matchAsciiL( "URL", 3, _rPropertyName.getLength() - 3 );
 669             if ( bIsURLProperty )
 670             {
 671                 aDescriptor.Control = _rxControlFactory->createPropertyControl(
 672                     PropertyControlType::HyperlinkField, PropertyHandlerHelper::requiresReadOnlyControl( pos->second.Attributes ) );
 673
 674                 Reference< XHyperlinkControl > xControl( aDescriptor.Control, UNO_QUERY_THROW );
 675                 Reference< XActionListener > xEnsureDelete( new UrlClickHandler( m_aContext, xControl ) );
 676             }
 677         }
 678         break;
 679         default:
 680             break;
 681         }
 682         // fallback
 683         if ( !aDescriptor.Control.is() )
 684             PropertyHandlerHelper::describePropertyLine( pos->second, aDescriptor, _rxControlFactory );
 685
 686         aDescriptor.Category = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "General" ) );
 687         return aDescriptor;
 688     }
 689
 690     //--------------------------------------------------------------------
 691     ::sal_Bool SAL_CALL GenericPropertyHandler::isComposable( const ::rtl::OUString& /*_rPropertyName*/ ) throw (UnknownPropertyException, RuntimeException)
 692     {
 693         return sal_False;
 694     }
 695
 696     //--------------------------------------------------------------------
 697     InteractiveSelectionResult SAL_CALL GenericPropertyHandler::onInteractivePropertySelection( const ::rtl::OUString& /*_rPropertyName*/, sal_Bool /*_bPrimary*/, Any& /*_rData*/, const Reference< XObjectInspectorUI >& /*_rxInspectorUI*/ ) throw (UnknownPropertyException, NullPointerException, RuntimeException)
 698     {
 699         DBG_ERROR( "GenericPropertyHandler::onInteractivePropertySelection: I'm too dumb to know anything about property browse buttons!" );
 700         return InteractiveSelectionResult_Cancelled;
 701     }
 702
 703     //--------------------------------------------------------------------
 704     void SAL_CALL GenericPropertyHandler::actuatingPropertyChanged( const ::rtl::OUString& /*_rActuatingPropertyName*/, const Any& /*_rNewValue*/, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& /*_rxInspectorUI*/, sal_Bool /*_bFirstTimeInit*/ ) throw (NullPointerException, RuntimeException)
 705     {
 706         DBG_ERROR( "GenericPropertyHandler::actuatingPropertyChanged: no no no, I did not register for any actuating properties!" );
 707     }
 708
 709     //--------------------------------------------------------------------
 710     sal_Bool SAL_CALL GenericPropertyHandler::suspend( sal_Bool /*_bSuspend*/ ) throw (RuntimeException)
 711     {
 712         return sal_True;
 713     }
 714
 715     //--------------------------------------------------------------------
 716     void SAL_CALL GenericPropertyHandler::disposing()
 717     {
 718         m_aPropertyListeners.clear();
 719             // not disposeAndClear: the listeners are (virtually) listeners at our introspectee, not
 720             // at this handler instance
 721     }
 722
 723     //--------------------------------------------------------------------
 724     IMPLEMENT_FORWARD_XCOMPONENT( GenericPropertyHandler, GenericPropertyHandler_Base );
 725
 726 //........................................................................
 727 }   // namespace pcr
 728 //........................................................................
 729