chart2/source/tools/OPropertySet.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 <OPropertySet.hxx>
  21 #include <CloneHelper.hxx>
  22 #include <cppuhelper/queryinterface.hxx>
  23 #include <com/sun/star/uno/Sequence.hxx>
  24 #include <com/sun/star/style/XStyle.hpp>
  25
  26 #include <algorithm>
  27 #include <memory>
  28
  29 using namespace ::com::sun::star;
  30
  31 using ::com::sun::star::uno::Reference;
  32 using ::com::sun::star::uno::Sequence;
  33 using ::com::sun::star::uno::Any;
  34 using ::osl::MutexGuard;
  35
  36 // needed for MS compiler
  37 using ::cppu::OBroadcastHelper;
  38 using ::cppu::OPropertySetHelper;
  39
  40 namespace property
  41 {
  42
  43 OPropertySet::OPropertySet( ) :
  44         OBroadcastHelper( m_aMutex ),
  45         // the following causes a warning; there seems to be no way to avoid it
  46         OPropertySetHelper( static_cast< OBroadcastHelper & >( *this )),
  47         m_bSetNewValuesExplicitlyEvenIfTheyEqualDefault(false)
  48 {
  49 }
  50
  51 OPropertySet::OPropertySet( const OPropertySet & rOther ) :
  52         OBroadcastHelper( m_aMutex ),
  53         // the following causes a warning; there seems to be no way to avoid it
  54         OPropertySetHelper( static_cast< OBroadcastHelper & >( *this )),
  55         css::lang::XTypeProvider(),
  56         css::beans::XPropertyState(),
  57         css::beans::XMultiPropertyStates(),
  58         css::style::XStyleSupplier(),
  59         m_bSetNewValuesExplicitlyEvenIfTheyEqualDefault(false)
  60 {
  61     MutexGuard aGuard( m_aMutex );
  62
  63     m_aProperties = rOther.m_aProperties;
  64
  65     // clone interface properties
  66     for(auto& rProp : m_aProperties)
  67     {
  68         if( rProp.second.hasValue() &&
  69             rProp.second.getValueTypeClass() == uno::TypeClass_INTERFACE )
  70         {
  71             Reference< util::XCloneable > xCloneable;
  72             if( rProp.second >>= xCloneable )
  73                 rProp.second <<= xCloneable->createClone();
  74         }
  75     }
  76
  77     m_xStyle.set( ::chart::CloneHelper::CreateRefClone< style::XStyle >()( rOther.m_xStyle ));
  78 }
  79
  80 void OPropertySet::SetNewValuesExplicitlyEvenIfTheyEqualDefault()
  81 {
  82     m_bSetNewValuesExplicitlyEvenIfTheyEqualDefault = true;
  83 }
  84
  85 OPropertySet::~OPropertySet()
  86 {}
  87
  88 Any SAL_CALL OPropertySet::queryInterface( const uno::Type& aType )
  89 {
  90     return ::cppu::queryInterface(
  91         aType,
  92         static_cast< lang::XTypeProvider * >( this ),
  93         static_cast< beans::XPropertySet * >( this ),
  94         static_cast< beans::XMultiPropertySet * >( this ),
  95         static_cast< beans::XFastPropertySet * >( this ),
  96         static_cast< beans::XPropertyState * >( this ),
  97         static_cast< beans::XMultiPropertyStates * >( this ),
  98         static_cast< style::XStyleSupplier * >( this ) );
  99 }
 100
 101 //  ____ XTypeProvider ____
 102 Sequence< uno::Type > SAL_CALL
 103     OPropertySet::getTypes()
 104 {
 105     static const Sequence< uno::Type > aTypeList{
 106         cppu::UnoType<lang::XTypeProvider>::get(),
 107         cppu::UnoType<beans::XPropertySet>::get(),
 108         cppu::UnoType<beans::XMultiPropertySet>::get(),
 109         cppu::UnoType<beans::XFastPropertySet>::get(),
 110         cppu::UnoType<beans::XPropertyState>::get(),
 111         cppu::UnoType<beans::XMultiPropertyStates>::get(),
 112         cppu::UnoType<style::XStyleSupplier>::get() };
 113
 114     return aTypeList;
 115 }
 116
 117 Sequence< sal_Int8 > SAL_CALL
 118     OPropertySet::getImplementationId()
 119 {
 120     return css::uno::Sequence<sal_Int8>();
 121 }
 122
 123 // ____ XPropertyState ____
 124 beans::PropertyState SAL_CALL
 125     OPropertySet::getPropertyState( const OUString& PropertyName )
 126 {
 127     cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 128
 129     return GetPropertyStateByHandle(
 130         rPH.getHandleByName( PropertyName ));
 131 }
 132
 133 Sequence< beans::PropertyState > SAL_CALL
 134     OPropertySet::getPropertyStates( const Sequence< OUString >& aPropertyName )
 135 {
 136     cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 137
 138     std::unique_ptr<sal_Int32[]> pHandles(new sal_Int32[ aPropertyName.getLength() ]);
 139     rPH.fillHandles( pHandles.get(), aPropertyName );
 140
 141     std::vector< sal_Int32 > aHandles( pHandles.get(), pHandles.get() + aPropertyName.getLength());
 142     pHandles.reset();
 143
 144     return GetPropertyStatesByHandle( aHandles );
 145 }
 146
 147 void SAL_CALL
 148     OPropertySet::setPropertyToDefault( const OUString& PropertyName )
 149 {
 150     cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 151
 152     SetPropertyToDefault( rPH.getHandleByName( PropertyName ));
 153     firePropertyChangeEvent();
 154 }
 155
 156 Any SAL_CALL
 157     OPropertySet::getPropertyDefault( const OUString& aPropertyName )
 158 {
 159     cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 160
 161     Any any;
 162     GetDefaultValue( rPH.getHandleByName( aPropertyName ), any );
 163     return any;
 164 }
 165
 166 // ____ XMultiPropertyStates ____
 167
 168 // Note: getPropertyStates() is already implemented in XPropertyState with the
 169 // same signature
 170
 171 void SAL_CALL
 172     OPropertySet::setAllPropertiesToDefault()
 173 {
 174     SetAllPropertiesToDefault();
 175     firePropertyChangeEvent();
 176 }
 177
 178 void SAL_CALL
 179     OPropertySet::setPropertiesToDefault( const Sequence< OUString >& aPropertyNames )
 180 {
 181     cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 182
 183     std::unique_ptr<sal_Int32[]> pHandles(new sal_Int32[ aPropertyNames.getLength() ]);
 184     rPH.fillHandles( pHandles.get(), aPropertyNames );
 185
 186     std::vector< sal_Int32 > aHandles( pHandles.get(), pHandles.get() + aPropertyNames.getLength());
 187     pHandles.reset();
 188
 189     SetPropertiesToDefault( aHandles );
 190 }
 191
 192 Sequence< Any > SAL_CALL
 193     OPropertySet::getPropertyDefaults( const Sequence< OUString >& aPropertyNames )
 194 {
 195     ::cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 196     const sal_Int32 nElements = aPropertyNames.getLength();
 197
 198     Sequence< Any > aResult( nElements );
 199     Any * pResultArray = aResult.getArray();
 200     sal_Int32 nI = 0;
 201
 202     for( ; nI < nElements; ++nI )
 203     {
 204         GetDefaultValue(
 205             rPH.getHandleByName( aPropertyNames[ nI ] ),
 206             pResultArray[ nI ]);
 207     }
 208
 209     return aResult;
 210 }
 211
 212 sal_Bool SAL_CALL OPropertySet::convertFastPropertyValue
 213     ( Any & rConvertedValue,
 214       Any & rOldValue,
 215       sal_Int32 nHandle,
 216       const Any& rValue )
 217 {
 218     getFastPropertyValue( rOldValue, nHandle );
 219     //accept longs also for short values
 220     {
 221         sal_Int16 nValue;
 222         if( (rOldValue>>=nValue) && !(rValue>>=nValue) )
 223         {
 224             sal_Int32 n32Value = 0;
 225             if( rValue>>=n32Value )
 226             {
 227                 rConvertedValue <<= static_cast<sal_Int16>(n32Value);
 228                 return true;
 229             }
 230
 231             sal_Int64 n64Value = 0;
 232             if( rValue>>=n64Value )
 233             {
 234                 rConvertedValue <<= static_cast<sal_Int16>(n64Value);
 235                 return true;
 236             }
 237         }
 238     }
 239     rConvertedValue = rValue;
 240     if( !m_bSetNewValuesExplicitlyEvenIfTheyEqualDefault && rOldValue == rConvertedValue )
 241         return false;//no change necessary
 242     return true;
 243 }
 244
 245 void SAL_CALL OPropertySet::setFastPropertyValue_NoBroadcast
 246     ( sal_Int32 nHandle,
 247       const Any& rValue )
 248 {
 249 #if OSL_DEBUG_LEVEL > 0
 250     if( rValue.hasValue())
 251     {
 252         cppu::IPropertyArrayHelper & rPH = getInfoHelper();
 253         OUString aName;
 254         rPH.fillPropertyMembersByHandle( &aName, nullptr, nHandle );
 255         OSL_ENSURE( rValue.isExtractableTo( rPH.getPropertyByName( aName ).Type ),
 256                     "Property type is wrong" );
 257     }
 258 #endif
 259
 260     Any aDefault;
 261     try
 262     {
 263         GetDefaultValue( nHandle, aDefault );
 264     }
 265     catch( const beans::UnknownPropertyException& )
 266     {
 267         aDefault.clear();
 268     }
 269     if( !m_bSetNewValuesExplicitlyEvenIfTheyEqualDefault && aDefault.hasValue() && aDefault == rValue ) //#i98893# don't export defaults to file
 270         SetPropertyToDefault( nHandle );
 271     else
 272         SetPropertyValueByHandle( nHandle, rValue );
 273 }
 274
 275 void SAL_CALL OPropertySet::getFastPropertyValue
 276     ( Any& rValue,
 277       sal_Int32 nHandle ) const
 278 {
 279     if(  GetPropertyValueByHandle( rValue, nHandle ))
 280         return;
 281
 282     // property was not set -> try style
 283     uno::Reference< beans::XFastPropertySet > xStylePropSet( m_xStyle, uno::UNO_QUERY );
 284     if( xStylePropSet.is() )
 285     {
 286 #ifdef DBG_UTIL
 287         {
 288             // check if the handle of the style points to the same property
 289             // name as the handle in this property set
 290             uno::Reference< beans::XPropertySet > xPropSet( xStylePropSet, uno::UNO_QUERY );
 291             if( xPropSet.is())
 292             {
 293                 uno::Reference< beans::XPropertySetInfo > xInfo = xPropSet->getPropertySetInfo();
 294                 if( xInfo.is() )
 295                 {
 296                     // for some reason the virtual method getInfoHelper() is
 297                     // not const
 298                     ::cppu::IPropertyArrayHelper & rPH =
 299                           const_cast< OPropertySet * >( this )->getInfoHelper();
 300
 301                     // find the Property with Handle nHandle in Style
 302                     Sequence< beans::Property > aProps( xInfo->getProperties() );
 303                     sal_Int32 nI = aProps.getLength() - 1;
 304                     while( ( nI >= 0 ) && nHandle != aProps[ nI ].Handle )
 305                         --nI;
 306
 307                     if( nI >= 0 ) // => nHandle == aProps[nI].Handle
 308                     {
 309                         // check whether the handle in this property set is
 310                         // the same as the one in the style
 311                         beans::Property aProp( rPH.getPropertyByName( aProps[ nI ].Name ) );
 312                         OSL_ENSURE( nHandle == aProp.Handle,
 313                                     "HandleCheck: Handles for same property differ!" );
 314
 315                         if( nHandle == aProp.Handle )
 316                         {
 317                             OSL_ENSURE( aProp.Type == aProps[nI].Type,
 318                                         "HandleCheck: Types differ!" );
 319                             OSL_ENSURE( aProp.Attributes == aProps[nI].Attributes,
 320                                         "HandleCheck: Attributes differ!" );
 321                         }
 322                     }
 323                     else
 324                     {
 325                         OSL_FAIL(  "HandleCheck: Handle not found in Style" );
 326                     }
 327                 }
 328                 else
 329                     OSL_FAIL( "HandleCheck: Invalid XPropertySetInfo returned" );
 330             }
 331             else
 332                 OSL_FAIL( "HandleCheck: XPropertySet not supported" );
 333         }
 334 #endif
 335         rValue = xStylePropSet->getFastPropertyValue( nHandle );
 336     }
 337     else
 338     {
 339         // there is no style (or the style does not support XFastPropertySet)
 340         // => take the default value
 341         try
 342         {
 343             GetDefaultValue( nHandle, rValue );
 344         }
 345         catch( const beans::UnknownPropertyException& )
 346         {
 347             rValue.clear();
 348         }
 349     }
 350 }
 351
 352 void OPropertySet::firePropertyChangeEvent()
 353 {
 354     // nothing in base class
 355 }
 356
 357 // ____ XStyleSupplier ____
 358 Reference< style::XStyle > SAL_CALL OPropertySet::getStyle()
 359 {
 360     return m_xStyle;
 361 }
 362
 363 void SAL_CALL OPropertySet::setStyle( const Reference< style::XStyle >& xStyle )
 364 {
 365     if( ! SetStyle( xStyle ))
 366         throw lang::IllegalArgumentException(
 367             u"Empty Style"_ustr,
 368             static_cast< beans::XPropertySet * >( this ),
 369             0 );
 370 }
 371
 372 // ____ XMultiPropertySet ____
 373 void SAL_CALL OPropertySet::setPropertyValues(
 374     const Sequence< OUString >& PropertyNames, const Sequence< Any >& Values )
 375 {
 376     ::cppu::OPropertySetHelper::setPropertyValues( PropertyNames, Values );
 377
 378     firePropertyChangeEvent();
 379 }
 380
 381 // ____ XFastPropertySet ____
 382 void SAL_CALL OPropertySet::setFastPropertyValue( sal_Int32 nHandle, const Any& rValue )
 383 {
 384     ::cppu::OPropertySetHelper::setFastPropertyValue( nHandle, rValue );
 385
 386     firePropertyChangeEvent();
 387 }
 388
 389 beans::PropertyState OPropertySet::GetPropertyStateByHandle( sal_Int32 nHandle ) const
 390 {
 391     if( m_aProperties.end() == m_aProperties.find( nHandle ))
 392         return beans::PropertyState_DEFAULT_VALUE;
 393     return beans::PropertyState_DIRECT_VALUE;
 394 }
 395
 396 Sequence< beans::PropertyState > OPropertySet::GetPropertyStatesByHandle(
 397     const std::vector< sal_Int32 > & aHandles ) const
 398 {
 399     Sequence< beans::PropertyState > aResult( aHandles.size());
 400
 401     std::transform( aHandles.begin(), aHandles.end(),
 402                       aResult.getArray(),
 403                       [this](sal_Int32 nHandle) { return GetPropertyStateByHandle(nHandle); });
 404
 405     return aResult;
 406 }
 407
 408 void OPropertySet::SetPropertyToDefault( sal_Int32 nHandle )
 409 {
 410     auto aFoundIter( m_aProperties.find( nHandle ) );
 411
 412     if( m_aProperties.end() != aFoundIter )
 413     {
 414         m_aProperties.erase( aFoundIter );
 415     }
 416 }
 417
 418 void OPropertySet::SetPropertiesToDefault(
 419     const std::vector< sal_Int32 > & aHandles )
 420 {
 421     for(auto nHandle : aHandles)
 422         m_aProperties.erase(nHandle);
 423 }
 424
 425 void OPropertySet::SetAllPropertiesToDefault()
 426 {
 427     m_aProperties.clear();
 428 }
 429
 430 bool OPropertySet::GetPropertyValueByHandle(
 431     Any & rValue,
 432     sal_Int32 nHandle ) const
 433 {
 434     bool bResult = false;
 435
 436     auto aFoundIter( m_aProperties.find( nHandle ) );
 437
 438     if( m_aProperties.end() != aFoundIter )
 439     {
 440         rValue = (*aFoundIter).second;
 441         bResult = true;
 442     }
 443
 444     return bResult;
 445 }
 446
 447 void OPropertySet::SetPropertyValueByHandle(
 448     sal_Int32 nHandle, const Any & rValue )
 449 {
 450     m_aProperties[ nHandle ] = rValue;
 451 }
 452
 453 bool OPropertySet::SetStyle( const Reference< style::XStyle > & xStyle )
 454 {
 455     if( ! xStyle.is())
 456         return false;
 457
 458     m_xStyle = xStyle;
 459     return true;
 460 }
 461
 462
 463 } //  namespace property
 464
 465 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */