framework/source/classes/actiontriggerpropertyset.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_framework.hxx"
  30
  31 #include <classes/actiontriggerpropertyset.hxx>
  32 #include <com/sun/star/beans/PropertyAttribute.hpp>
  33 #include <cppuhelper/proptypehlp.hxx>
  34 #include <cppuhelper/typeprovider.hxx>
  35 #include <vcl/svapp.hxx>
  36
  37
  38 using namespace cppu;
  39 using namespace com::sun::star::uno;
  40 using namespace com::sun::star::beans;
  41 using namespace com::sun::star::lang;
  42 using namespace com::sun::star::awt;
  43
  44 // Handles for properties
  45 // (PLEASE SORT THIS FIELD, IF YOU ADD NEW PROPERTIES!)
  46 // We use an enum to define these handles, to use all numbers from 0 to nn and
  47 // if you add someone, you don't must control this!
  48 // But don't forget to change values of follow defines, if you do something with this enum!
  49 enum EPROPERTIES
  50 {
  51     HANDLE_COMMANDURL,
  52     HANDLE_HELPURL,
  53     HANDLE_IMAGE,
  54     HANDLE_SUBCONTAINER,
  55     HANDLE_TEXT,
  56     PROPERTYCOUNT
  57 };
  58
  59 namespace framework
  60 {
  61
  62 ActionTriggerPropertySet::ActionTriggerPropertySet( const Reference< XMultiServiceFactory >& /*xServiceManager*/ )
  63     : ThreadHelpBase           ( &Application::GetSolarMutex()               )
  64     , OBroadcastHelper         ( m_aLock.getShareableOslMutex()              )
  65     ,   OPropertySetHelper       ( *SAL_STATIC_CAST( OBroadcastHelper *, this ))
  66     , OWeakObject              ()
  67     , m_xBitmap                ( 0 )
  68     , m_xActionTriggerContainer( 0 )
  69 {
  70 }
  71
  72 ActionTriggerPropertySet::~ActionTriggerPropertySet()
  73 {
  74 }
  75
  76 // XInterface
  77 Any SAL_CALL ActionTriggerPropertySet::queryInterface( const Type& aType )
  78 throw ( RuntimeException )
  79 {
  80     Any a = ::cppu::queryInterface(
  81                 aType ,
  82                 SAL_STATIC_CAST( XServiceInfo*, this ));
  83
  84     if( a.hasValue() )
  85         return a;
  86     else
  87     {
  88         a = OPropertySetHelper::queryInterface( aType );
  89
  90         if( a.hasValue() )
  91             return a;
  92     }
  93
  94     return OWeakObject::queryInterface( aType );
  95 }
  96
  97 void SAL_CALL ActionTriggerPropertySet::acquire() throw ()
  98 {
  99     OWeakObject::acquire();
 100 }
 101
 102 void SAL_CALL ActionTriggerPropertySet::release() throw ()
 103 {
 104     OWeakObject::release();
 105 }
 106
 107
 108 // XServiceInfo
 109 ::rtl::OUString SAL_CALL ActionTriggerPropertySet::getImplementationName()
 110 throw ( RuntimeException )
 111 {
 112     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATIONNAME_ACTIONTRIGGER ));
 113 }
 114
 115 sal_Bool SAL_CALL ActionTriggerPropertySet::supportsService( const ::rtl::OUString& ServiceName )
 116 throw ( RuntimeException )
 117 {
 118     if ( ServiceName.equalsAscii( SERVICENAME_ACTIONTRIGGER ))
 119         return sal_True;
 120
 121     return sal_False;
 122 }
 123
 124 Sequence< ::rtl::OUString > SAL_CALL ActionTriggerPropertySet::getSupportedServiceNames()
 125 throw ( RuntimeException )
 126 {
 127     Sequence< ::rtl::OUString > seqServiceNames( 1 );
 128     seqServiceNames[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_ACTIONTRIGGER ));
 129     return seqServiceNames;
 130 }
 131
 132 // XTypeProvider
 133 Sequence< Type > SAL_CALL ActionTriggerPropertySet::getTypes() throw ( RuntimeException )
 134 {
 135     // Optimize this method !
 136     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 137     // For the first call; pTypeCollection is NULL - for the second call pTypeCollection is different from NULL!
 138     static ::cppu::OTypeCollection* pTypeCollection = NULL ;
 139
 140     if ( pTypeCollection == NULL )
 141     {
 142         // Ready for multithreading; get global mutex for first call of this method only! see before
 143         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
 144
 145         // Control these pointer again ... it can be, that another instance will be faster then these!
 146         if ( pTypeCollection == NULL )
 147         {
 148             // Create a static typecollection ...
 149             static ::cppu::OTypeCollection aTypeCollection(
 150                         ::getCppuType(( const Reference< XPropertySet           >*)NULL ) ,
 151                         ::getCppuType(( const Reference< XFastPropertySet       >*)NULL ) ,
 152                         ::getCppuType(( const Reference< XMultiPropertySet      >*)NULL ) ,
 153                         ::getCppuType(( const Reference< XServiceInfo           >*)NULL ) ,
 154                         ::getCppuType(( const Reference< XTypeProvider          >*)NULL ) ) ;
 155
 156             // ... and set his address to static pointer!
 157             pTypeCollection = &aTypeCollection ;
 158         }
 159     }
 160
 161     return pTypeCollection->getTypes() ;
 162 }
 163
 164 Sequence< sal_Int8 > SAL_CALL ActionTriggerPropertySet::getImplementationId() throw ( RuntimeException )
 165 {
 166     // Create one Id for all instances of this class.
 167     // Use ethernet address to do this! (sal_True)
 168
 169     // Optimize this method
 170     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 171     // For the first call; pID is NULL - for the second call pID is different from NULL!
 172     static ::cppu::OImplementationId* pID = NULL ;
 173
 174     if ( pID == NULL )
 175     {
 176         // Ready for multithreading; get global mutex for first call of this method only! see before
 177         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
 178
 179         // Control these pointer again ... it can be, that another instance will be faster then these!
 180         if ( pID == NULL )
 181         {
 182             // Create a new static ID ...
 183             static ::cppu::OImplementationId aID( sal_False ) ;
 184             // ... and set his address to static pointer!
 185             pID = &aID ;
 186         }
 187     }
 188
 189     return pID->getImplementationId() ;
 190 }
 191
 192 //---------------------------------------------------------------------------------------------------------
 193 //  OPropertySetHelper implementation
 194 //---------------------------------------------------------------------------------------------------------
 195
 196 sal_Bool SAL_CALL ActionTriggerPropertySet::convertFastPropertyValue(
 197     Any&        aConvertedValue,
 198     Any&        aOldValue,
 199     sal_Int32   nHandle,
 200     const Any&  aValue  )
 201 throw( IllegalArgumentException )
 202 {
 203     //  Check, if value of property will changed in method "setFastPropertyValue_NoBroadcast()".
 204     //  Return TRUE, if changed - else return FALSE.
 205     //  Attention: Method "impl_tryToChangeProperty()" can throw the IllegalArgumentException !!!
 206     //  Initialize return value with FALSE !!!
 207     //  (Handle can be invalid)
 208     sal_Bool bReturn = sal_False;
 209
 210     switch( nHandle )
 211     {
 212         case HANDLE_COMMANDURL:
 213             bReturn = impl_tryToChangeProperty( m_aCommandURL, aValue, aOldValue, aConvertedValue );
 214             break;
 215
 216         case HANDLE_HELPURL:
 217             bReturn = impl_tryToChangeProperty( m_aHelpURL, aValue, aOldValue, aConvertedValue ) ;
 218             break;
 219
 220         case HANDLE_IMAGE:
 221             bReturn = impl_tryToChangeProperty( m_xBitmap, aValue, aOldValue, aConvertedValue ) ;
 222             break;
 223
 224         case HANDLE_SUBCONTAINER:
 225             bReturn = impl_tryToChangeProperty( m_xActionTriggerContainer, aValue, aOldValue, aConvertedValue );
 226             break;
 227
 228         case HANDLE_TEXT:
 229             bReturn = impl_tryToChangeProperty( m_aText, aValue, aOldValue, aConvertedValue ) ;
 230             break;
 231     }
 232
 233     // Return state of operation.
 234     return bReturn;
 235 }
 236
 237
 238 void SAL_CALL ActionTriggerPropertySet::setFastPropertyValue_NoBroadcast(
 239     sal_Int32 nHandle, const Any& aValue )
 240 throw( Exception )
 241 {
 242     ::osl::MutexGuard aGuard( LockHelper::getGlobalLock().getShareableOslMutex() );
 243
 244     // Search for right handle ... and try to set property value.
 245     switch( nHandle )
 246     {
 247         case HANDLE_COMMANDURL:
 248             aValue >>= m_aCommandURL;
 249             break;
 250
 251         case HANDLE_HELPURL:
 252             aValue >>= m_aHelpURL;
 253             break;
 254
 255         case HANDLE_IMAGE:
 256             aValue >>= m_xBitmap;
 257             break;
 258
 259         case HANDLE_SUBCONTAINER:
 260             aValue >>= m_xActionTriggerContainer;
 261             break;
 262
 263         case HANDLE_TEXT:
 264             aValue >>= m_aText;
 265             break;
 266     }
 267 }
 268
 269 void SAL_CALL ActionTriggerPropertySet::getFastPropertyValue(
 270     Any& aValue, sal_Int32 nHandle ) const
 271 {
 272     ::osl::MutexGuard aGuard( LockHelper::getGlobalLock().getShareableOslMutex() );
 273
 274     // Search for right handle ... and try to get property value.
 275     switch( nHandle )
 276     {
 277         case HANDLE_COMMANDURL:
 278             aValue <<= m_aCommandURL;
 279             break;
 280
 281         case HANDLE_HELPURL:
 282             aValue <<= m_aHelpURL;
 283             break;
 284
 285         case HANDLE_IMAGE:
 286             aValue <<= m_xBitmap;
 287             break;
 288
 289         case HANDLE_SUBCONTAINER:
 290             aValue <<= m_xActionTriggerContainer;
 291             break;
 292
 293         case HANDLE_TEXT:
 294             aValue <<= m_aText;
 295             break;
 296     }
 297 }
 298
 299 ::cppu::IPropertyArrayHelper& SAL_CALL ActionTriggerPropertySet::getInfoHelper()
 300 {
 301     // Optimize this method !
 302     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 303     // For the first call; pInfoHelper is NULL - for the second call pInfoHelper is different from NULL!
 304     static OPropertyArrayHelper* pInfoHelper = NULL;
 305
 306     if( pInfoHelper == NULL )
 307     {
 308         // Ready for multithreading
 309         ::osl::MutexGuard aGuard( LockHelper::getGlobalLock().getShareableOslMutex() );
 310         // Control this pointer again, another instance can be faster then these!
 311         if( pInfoHelper == NULL )
 312         {
 313             // Define static member to give structure of properties to baseclass "OPropertySetHelper".
 314             // "impl_getStaticPropertyDescriptor" is a non exported and static funtion, who will define a static propertytable.
 315             // "sal_True" say: Table is sorted by name.
 316             static OPropertyArrayHelper aInfoHelper( impl_getStaticPropertyDescriptor(), sal_True );
 317             pInfoHelper = &aInfoHelper;
 318         }
 319     }
 320
 321     return (*pInfoHelper);
 322 }
 323
 324 Reference< XPropertySetInfo > SAL_CALL ActionTriggerPropertySet::getPropertySetInfo()
 325 throw ( RuntimeException )
 326 {
 327     // Optimize this method !
 328     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 329     // For the first call; pInfo is NULL - for the second call pInfo is different from NULL!
 330     static Reference< XPropertySetInfo >* pInfo = NULL ;
 331
 332     if( pInfo == NULL )
 333     {
 334         // Ready for multithreading
 335         ::osl::MutexGuard aGuard( LockHelper::getGlobalLock().getShareableOslMutex() );
 336         // Control this pointer again, another instance can be faster then these!
 337         if( pInfo == NULL )
 338         {
 339             // Create structure of propertysetinfo for baseclass "OPropertySetHelper".
 340             // (Use method "getInfoHelper()".)
 341             static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 342             pInfo = &xInfo;
 343         }
 344     }
 345
 346     return (*pInfo);
 347 }
 348
 349 const Sequence< Property > ActionTriggerPropertySet::impl_getStaticPropertyDescriptor()
 350 {
 351     static const Property pActionTriggerPropertys[] =
 352     {
 353         Property( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CommandURL"    )), HANDLE_COMMANDURL   , ::getCppuType((::rtl::OUString*)0)                , PropertyAttribute::TRANSIENT  ),
 354         Property( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "HelpURL"       )), HANDLE_HELPURL      , ::getCppuType((::rtl::OUString*)0)                , PropertyAttribute::TRANSIENT  ),
 355         Property( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Image"        )), HANDLE_IMAGE     , ::getCppuType((Reference<XBitmap>*)0)     , PropertyAttribute::TRANSIENT  ),
 356         Property( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SubContainer"  )), HANDLE_SUBCONTAINER , ::getCppuType((::rtl::OUString*)0)                , PropertyAttribute::TRANSIENT  ),
 357         Property( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Text"          )), HANDLE_TEXT         , ::getCppuType((Reference<XInterface>*)0)  , PropertyAttribute::TRANSIENT  )
 358     };
 359
 360     // Use it to initialize sequence!
 361     static const Sequence< Property > seqActionTriggerPropertyDescriptor( pActionTriggerPropertys, PROPERTYCOUNT );
 362
 363     // Return static "PropertyDescriptor"
 364     return seqActionTriggerPropertyDescriptor ;
 365 }
 366
 367
 368 //******************************************************************************************************************************
 369 //  private method
 370 //******************************************************************************************************************************
 371 sal_Bool ActionTriggerPropertySet::impl_tryToChangeProperty(
 372     const   ::rtl::OUString&    sCurrentValue   ,
 373     const   Any&        aNewValue       ,
 374     Any&        aOldValue       ,
 375     Any&        aConvertedValue )
 376 throw( IllegalArgumentException )
 377 {
 378     // Set default return value if method failed.
 379     sal_Bool bReturn = sal_False;
 380     // Get new value from any.
 381     // IllegalArgumentException() can be thrown!
 382     ::rtl::OUString sValue ;
 383     convertPropertyValue( sValue, aNewValue );
 384
 385     // If value change ...
 386     if( sValue != sCurrentValue )
 387     {
 388         // ... set information of change.
 389         aOldValue       <<= sCurrentValue   ;
 390         aConvertedValue <<= sValue          ;
 391         // Return OK - "value will be change ..."
 392         bReturn = sal_True;
 393     }
 394     else
 395     {
 396         // ... clear information of return parameter!
 397         aOldValue.clear         () ;
 398         aConvertedValue.clear   () ;
 399         // Return NOTHING - "value will not be change ..."
 400         bReturn = sal_False;
 401     }
 402
 403     return bReturn;
 404 }
 405
 406
 407 sal_Bool ActionTriggerPropertySet::impl_tryToChangeProperty(
 408     const Reference< XBitmap >  aCurrentValue   ,
 409     const Any&                  aNewValue       ,
 410     Any&                        aOldValue       ,
 411     Any&                        aConvertedValue )
 412 throw( IllegalArgumentException )
 413 {
 414     // Set default return value if method failed.
 415     sal_Bool bReturn = sal_False;
 416     // Get new value from any.
 417     // IllegalArgumentException() can be thrown!
 418     Reference< XBitmap > aValue ;
 419     convertPropertyValue( aValue, aNewValue );
 420
 421     // If value change ...
 422     if( aValue != aCurrentValue )
 423     {
 424         // ... set information of change.
 425         aOldValue       <<= aCurrentValue   ;
 426         aConvertedValue <<= aValue          ;
 427         // Return OK - "value will be change ..."
 428         bReturn = sal_True;
 429     }
 430     else
 431     {
 432         // ... clear information of return parameter!
 433         aOldValue.clear         () ;
 434         aConvertedValue.clear   () ;
 435         // Return NOTHING - "value will not be change ..."
 436         bReturn = sal_False;
 437     }
 438
 439     return bReturn;
 440 }
 441
 442 sal_Bool ActionTriggerPropertySet::impl_tryToChangeProperty(
 443     const Reference< XInterface >   aCurrentValue   ,
 444     const Any&                      aNewValue       ,
 445     Any&                            aOldValue       ,
 446     Any&                            aConvertedValue )
 447 throw( IllegalArgumentException )
 448 {
 449     // Set default return value if method failed.
 450     sal_Bool bReturn = sal_False;
 451     // Get new value from any.
 452     // IllegalArgumentException() can be thrown!
 453     Reference< XInterface > aValue ;
 454     convertPropertyValue( aValue, aNewValue );
 455
 456     // If value change ...
 457     if( aValue != aCurrentValue )
 458     {
 459         // ... set information of change.
 460         aOldValue       <<= aCurrentValue   ;
 461         aConvertedValue <<= aValue          ;
 462         // Return OK - "value will be change ..."
 463         bReturn = sal_True;
 464     }
 465     else
 466     {
 467         // ... clear information of return parameter!
 468         aOldValue.clear         () ;
 469         aConvertedValue.clear   () ;
 470         // Return NOTHING - "value will not be change ..."
 471         bReturn = sal_False;
 472     }
 473
 474     return bReturn;
 475 }
 476
 477 }
 478