chart2/source/tools/WrappedPropertySet.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 #include <WrappedPropertySet.hxx>
  21 #include <cppuhelper/propshlp.hxx>
  22
  23 #include <tools/diagnose_ex.h>
  24 #include <sal/log.hxx>
  25
  26 namespace chart
  27 {
  28
  29 using namespace ::com::sun::star;
  30 using ::com::sun::star::uno::Reference;
  31 using ::com::sun::star::uno::Sequence;
  32 using ::com::sun::star::uno::Any;
  33
  34 WrappedPropertySet::WrappedPropertySet()
  35 {
  36 }
  37 WrappedPropertySet::~WrappedPropertySet()
  38 {
  39     clearWrappedPropertySet();
  40 }
  41
  42 Reference< beans::XPropertyState > WrappedPropertySet::getInnerPropertyState()
  43 {
  44     return Reference< beans::XPropertyState >( getInnerPropertySet(), uno::UNO_QUERY );
  45 }
  46
  47 void WrappedPropertySet::clearWrappedPropertySet()
  48 {
  49     ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );//do not use different mutex than is already used for static property sequence
  50
  51     m_pPropertyArrayHelper.reset();
  52     m_pWrappedPropertyMap.reset();
  53
  54     m_xInfo = nullptr;
  55 }
  56
  57 //XPropertySet
  58 Reference< beans::XPropertySetInfo > SAL_CALL WrappedPropertySet::getPropertySetInfo(  )
  59 {
  60     Reference< beans::XPropertySetInfo > xInfo = m_xInfo;
  61     if( !xInfo.is() )
  62     {
  63         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );//do not use different mutex than is already used for static property sequence
  64         xInfo = m_xInfo;
  65         if( !xInfo.is() )
  66         {
  67             xInfo = ::cppu::OPropertySetHelper::createPropertySetInfo( getInfoHelper() );
  68             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
  69             m_xInfo = xInfo;
  70         }
  71     }
  72     else
  73     {
  74         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
  75     }
  76     return m_xInfo;
  77 }
  78
  79 void SAL_CALL WrappedPropertySet::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
  80 {
  81     try
  82     {
  83         sal_Int32 nHandle = getInfoHelper().getHandleByName( rPropertyName );
  84         const WrappedProperty* pWrappedProperty = getWrappedProperty( nHandle );
  85         Reference< beans::XPropertySet > xInnerPropertySet( getInnerPropertySet() );
  86         if( pWrappedProperty )
  87             pWrappedProperty->setPropertyValue( rValue, xInnerPropertySet );
  88         else if( xInnerPropertySet.is() )
  89             xInnerPropertySet->setPropertyValue( rPropertyName, rValue );
  90         else
  91         {
  92             SAL_WARN("chart2.tools", "found no inner property set to map to");
  93         }
  94     }
  95     catch( const beans::UnknownPropertyException& )
  96     {
  97         throw;
  98     }
  99     catch( const beans::PropertyVetoException& )
 100     {
 101         throw;
 102     }
 103     catch( const lang::IllegalArgumentException& )
 104     {
 105         throw;
 106     }
 107     catch( const lang::WrappedTargetException& )
 108     {
 109         throw;
 110     }
 111     catch( const uno::RuntimeException& )
 112     {
 113         throw;
 114     }
 115     catch( const uno::Exception& ex )
 116     {
 117         css::uno::Any anyEx = cppu::getCaughtException();
 118         OSL_FAIL("invalid exception caught in WrappedPropertySet::setPropertyValue");
 119         throw lang::WrappedTargetException( ex.Message, nullptr, anyEx );
 120     }
 121 }
 122 Any SAL_CALL WrappedPropertySet::getPropertyValue( const OUString& rPropertyName )
 123 {
 124     Any aRet;
 125
 126     try
 127     {
 128         sal_Int32 nHandle = getInfoHelper().getHandleByName( rPropertyName );
 129         const WrappedProperty* pWrappedProperty = getWrappedProperty( nHandle );
 130         Reference< beans::XPropertySet > xInnerPropertySet( getInnerPropertySet() );
 131         if( pWrappedProperty )
 132             aRet = pWrappedProperty->getPropertyValue( xInnerPropertySet );
 133         else if( xInnerPropertySet.is() )
 134             aRet = xInnerPropertySet->getPropertyValue( rPropertyName );
 135         else
 136         {
 137             SAL_WARN("chart2.tools", "found no inner property set to map to");
 138         }
 139     }
 140     catch( const beans::UnknownPropertyException& )
 141     {
 142         throw;
 143     }
 144     catch( const lang::WrappedTargetException& )
 145     {
 146         throw;
 147     }
 148     catch( const uno::RuntimeException& )
 149     {
 150         throw;
 151     }
 152     catch( const uno::Exception& ex )
 153     {
 154         css::uno::Any anyEx = cppu::getCaughtException();
 155         OSL_FAIL("invalid exception caught in WrappedPropertySet::setPropertyValue");
 156         throw lang::WrappedTargetException( ex.Message, nullptr, anyEx );
 157     }
 158
 159     return aRet;
 160 }
 161
 162 void SAL_CALL WrappedPropertySet::addPropertyChangeListener( const OUString& rPropertyName, const Reference< beans::XPropertyChangeListener >& xListener )
 163 {
 164     Reference< beans::XPropertySet > xInnerPropertySet( getInnerPropertySet() );
 165     if( xInnerPropertySet.is() )
 166     {
 167         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 168         if( pWrappedProperty )
 169             xInnerPropertySet->addPropertyChangeListener( pWrappedProperty->getInnerName(), xListener );
 170         else
 171             xInnerPropertySet->addPropertyChangeListener( rPropertyName, xListener );
 172     }
 173 }
 174 void SAL_CALL WrappedPropertySet::removePropertyChangeListener( const OUString& rPropertyName, const Reference< beans::XPropertyChangeListener >& aListener )
 175 {
 176     Reference< beans::XPropertySet > xInnerPropertySet( getInnerPropertySet() );
 177     if( xInnerPropertySet.is() )
 178     {
 179         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 180         if( pWrappedProperty )
 181             xInnerPropertySet->removePropertyChangeListener( pWrappedProperty->getInnerName(), aListener );
 182         else
 183             xInnerPropertySet->removePropertyChangeListener( rPropertyName, aListener );
 184     }
 185 }
 186 void SAL_CALL WrappedPropertySet::addVetoableChangeListener( const OUString& rPropertyName, const Reference< beans::XVetoableChangeListener >& aListener )
 187 {
 188     Reference< beans::XPropertySet > xInnerPropertySet( getInnerPropertySet() );
 189     if( xInnerPropertySet.is() )
 190     {
 191         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 192         if( pWrappedProperty )
 193             xInnerPropertySet->addVetoableChangeListener( pWrappedProperty->getInnerName(), aListener );
 194         else
 195             xInnerPropertySet->addVetoableChangeListener( rPropertyName, aListener );
 196     }
 197 }
 198 void SAL_CALL WrappedPropertySet::removeVetoableChangeListener( const OUString& rPropertyName, const Reference< beans::XVetoableChangeListener >& aListener )
 199 {
 200     Reference< beans::XPropertySet > xInnerPropertySet( getInnerPropertySet() );
 201     if( xInnerPropertySet.is() )
 202     {
 203         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 204         if( pWrappedProperty )
 205             xInnerPropertySet->removeVetoableChangeListener( pWrappedProperty->getInnerName(), aListener );
 206         else
 207             xInnerPropertySet->removeVetoableChangeListener( rPropertyName, aListener );
 208     }
 209 }
 210
 211 //XMultiPropertySet
 212 void SAL_CALL WrappedPropertySet::setPropertyValues( const Sequence< OUString >& rNameSeq, const Sequence< Any >& rValueSeq )
 213 {
 214     bool bUnknownProperty = false;
 215     sal_Int32 nMinCount = std::min( rValueSeq.getLength(), rNameSeq.getLength() );
 216     for(sal_Int32 nN=0; nN<nMinCount; nN++)
 217     {
 218         OUString aPropertyName( rNameSeq[nN] );
 219         try
 220         {
 221             setPropertyValue( aPropertyName, rValueSeq[nN] );
 222         }
 223         catch( const beans::UnknownPropertyException& )
 224         {
 225             DBG_UNHANDLED_EXCEPTION("chart2");
 226             bUnknownProperty = true;
 227         }
 228     }
 229     //todo: store unknown properties elsewhere
 230     OSL_ENSURE(!bUnknownProperty,"unknown property");
 231 //    if( bUnknownProperty )
 232 //        throw beans::UnknownPropertyException();
 233 }
 234 Sequence< Any > SAL_CALL WrappedPropertySet::getPropertyValues( const Sequence< OUString >& rNameSeq )
 235 {
 236     Sequence< Any > aRetSeq;
 237     if( rNameSeq.hasElements() )
 238     {
 239         aRetSeq.realloc( rNameSeq.getLength() );
 240         for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 241         {
 242             try
 243             {
 244                 OUString aPropertyName( rNameSeq[nN] );
 245                 aRetSeq[nN] = getPropertyValue( aPropertyName );
 246             }
 247             catch( const beans::UnknownPropertyException& )
 248             {
 249                 DBG_UNHANDLED_EXCEPTION("chart2");
 250             }
 251             catch( const lang::WrappedTargetException& )
 252             {
 253                 DBG_UNHANDLED_EXCEPTION("chart2");
 254             }
 255         }
 256     }
 257     return aRetSeq;
 258 }
 259 void SAL_CALL WrappedPropertySet::addPropertiesChangeListener( const Sequence< OUString >& /* rNameSeq */, const Reference< beans::XPropertiesChangeListener >& /* xListener */ )
 260 {
 261     OSL_FAIL("not implemented yet");
 262     //todo
 263 }
 264 void SAL_CALL WrappedPropertySet::removePropertiesChangeListener( const Reference< beans::XPropertiesChangeListener >& /* xListener */ )
 265 {
 266     OSL_FAIL("not implemented yet");
 267     //todo
 268 }
 269 void SAL_CALL WrappedPropertySet::firePropertiesChangeEvent( const Sequence< OUString >& /* rNameSeq */, const Reference< beans::XPropertiesChangeListener >& /* xListener */ )
 270 {
 271     OSL_FAIL("not implemented yet");
 272     //todo
 273 }
 274
 275 //XPropertyState
 276 beans::PropertyState SAL_CALL WrappedPropertySet::getPropertyState( const OUString& rPropertyName )
 277 {
 278     beans::PropertyState aState( beans::PropertyState_DIRECT_VALUE );
 279
 280     Reference< beans::XPropertyState > xInnerPropertyState( getInnerPropertyState() );
 281     if( xInnerPropertyState.is() )
 282     {
 283         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 284         if( pWrappedProperty )
 285             aState = pWrappedProperty->getPropertyState( xInnerPropertyState );
 286         else
 287             aState = xInnerPropertyState->getPropertyState( rPropertyName );
 288     }
 289     return aState;
 290 }
 291
 292 const WrappedProperty* WrappedPropertySet::getWrappedProperty( const OUString& rOuterName )
 293 {
 294     sal_Int32 nHandle = getInfoHelper().getHandleByName( rOuterName );
 295     return getWrappedProperty( nHandle );
 296 }
 297
 298 const WrappedProperty* WrappedPropertySet::getWrappedProperty( sal_Int32 nHandle )
 299 {
 300     tWrappedPropertyMap::const_iterator aFound( getWrappedPropertyMap().find( nHandle ) );
 301     if( aFound != getWrappedPropertyMap().end() )
 302         return (*aFound).second.get();
 303     return nullptr;
 304 }
 305
 306 Sequence< beans::PropertyState > SAL_CALL WrappedPropertySet::getPropertyStates( const Sequence< OUString >& rNameSeq )
 307 {
 308     Sequence< beans::PropertyState > aRetSeq;
 309     if( rNameSeq.hasElements() )
 310     {
 311         aRetSeq.realloc( rNameSeq.getLength() );
 312         for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 313         {
 314             OUString aPropertyName( rNameSeq[nN] );
 315             aRetSeq[nN] = getPropertyState( aPropertyName );
 316         }
 317     }
 318     return aRetSeq;
 319 }
 320
 321 void SAL_CALL WrappedPropertySet::setPropertyToDefault( const OUString& rPropertyName )
 322 {
 323     Reference< beans::XPropertyState > xInnerPropertyState( getInnerPropertyState() );
 324     if( xInnerPropertyState.is() )
 325     {
 326         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 327         if( pWrappedProperty )
 328             pWrappedProperty->setPropertyToDefault( xInnerPropertyState );
 329         else
 330             xInnerPropertyState->setPropertyToDefault( rPropertyName );
 331     }
 332 }
 333 Any SAL_CALL WrappedPropertySet::getPropertyDefault( const OUString& rPropertyName )
 334 {
 335     Any aRet;
 336     Reference< beans::XPropertyState > xInnerPropertyState( getInnerPropertyState() );
 337     if( xInnerPropertyState.is() )
 338     {
 339         const WrappedProperty* pWrappedProperty = getWrappedProperty( rPropertyName );
 340         if( pWrappedProperty )
 341             aRet = pWrappedProperty->getPropertyDefault(xInnerPropertyState);
 342         else
 343             aRet = xInnerPropertyState->getPropertyDefault( rPropertyName );
 344     }
 345     return aRet;
 346 }
 347
 348 //XMultiPropertyStates
 349 void SAL_CALL WrappedPropertySet::setAllPropertiesToDefault(  )
 350 {
 351     const Sequence< beans::Property >&  rPropSeq = getPropertySequence();
 352     for(sal_Int32 nN=0; nN<rPropSeq.getLength(); nN++)
 353     {
 354         OUString aPropertyName( rPropSeq[nN].Name );
 355         setPropertyToDefault( aPropertyName );
 356     }
 357 }
 358 void SAL_CALL WrappedPropertySet::setPropertiesToDefault( const Sequence< OUString >& rNameSeq )
 359 {
 360     for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 361     {
 362         OUString aPropertyName( rNameSeq[nN] );
 363         setPropertyToDefault( aPropertyName );
 364     }
 365 }
 366 Sequence< Any > SAL_CALL WrappedPropertySet::getPropertyDefaults( const Sequence< OUString >& rNameSeq )
 367 {
 368     Sequence< Any > aRetSeq;
 369     if( rNameSeq.hasElements() )
 370     {
 371         aRetSeq.realloc( rNameSeq.getLength() );
 372         for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 373         {
 374             OUString aPropertyName( rNameSeq[nN] );
 375             aRetSeq[nN] = getPropertyDefault( aPropertyName );
 376         }
 377     }
 378     return aRetSeq;
 379 }
 380
 381 ::cppu::IPropertyArrayHelper& WrappedPropertySet::getInfoHelper()
 382 {
 383     ::cppu::OPropertyArrayHelper* p = m_pPropertyArrayHelper.get();
 384     if(!p)
 385     {
 386         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );//do not use different mutex than is already used for static property sequence
 387         p = m_pPropertyArrayHelper.get();
 388         if(!p)
 389         {
 390             p = new ::cppu::OPropertyArrayHelper( getPropertySequence(), true );
 391             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 392             m_pPropertyArrayHelper.reset(p);
 393         }
 394     }
 395     else
 396     {
 397         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 398     }
 399     return *m_pPropertyArrayHelper;
 400 }
 401
 402 tWrappedPropertyMap& WrappedPropertySet::getWrappedPropertyMap()
 403 {
 404     tWrappedPropertyMap* p = m_pWrappedPropertyMap.get();
 405     if(!p)
 406     {
 407         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );//do not use different mutex than is already used for static property sequence
 408         p = m_pWrappedPropertyMap.get();
 409         if(!p)
 410         {
 411             std::vector< std::unique_ptr<WrappedProperty> > aPropList( createWrappedProperties() );
 412             p = new tWrappedPropertyMap;
 413
 414             for (auto & elem : aPropList)
 415             {
 416                 sal_Int32 nHandle = getInfoHelper().getHandleByName( elem->getOuterName() );
 417
 418                 if( nHandle == -1 )
 419                 {
 420                     OSL_FAIL( "missing property in property list" );
 421                 }
 422                 else if( p->find( nHandle ) != p->end() )
 423                 {
 424                     //duplicate Wrapped property
 425                     OSL_FAIL( "duplicate Wrapped property" );
 426                 }
 427                 else
 428                     (*p)[ nHandle ] = std::move(elem);
 429             }
 430
 431             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 432             m_pWrappedPropertyMap.reset(p);
 433         }
 434     }
 435     else
 436     {
 437         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 438     }
 439     return *m_pWrappedPropertyMap;
 440 }
 441
 442 } //namespace chart
 443
 444 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */