chart2/source/controller/chartapiwrapper/MinMaxLineWrapper.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: MinMaxLineWrapper.cxx,v $
  10  * $Revision: 1.4.44.1 $
  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_chart2.hxx"
  33
  34 #include "MinMaxLineWrapper.hxx"
  35 #include "macros.hxx"
  36 #include "Chart2ModelContact.hxx"
  37 #include "DiagramHelper.hxx"
  38 #include "servicenames_charttypes.hxx"
  39 #include "ContainerHelper.hxx"
  40 #include <com/sun/star/chart2/XChartType.hpp>
  41 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  42 #include <com/sun/star/drawing/LineJoint.hpp>
  43
  44 #include "LineProperties.hxx"
  45 #include "UserDefinedProperties.hxx"
  46
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::chart2;
  49
  50 using ::com::sun::star::beans::Property;
  51 using ::osl::MutexGuard;
  52 using ::com::sun::star::uno::Reference;
  53 using ::com::sun::star::uno::Sequence;
  54 using ::com::sun::star::uno::Any;
  55 using ::rtl::OUString;
  56
  57 namespace
  58 {
  59 static const OUString lcl_aServiceName(
  60     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.chart.ChartLine" ));
  61
  62 const Sequence< Property > & lcl_GetPropertySequence()
  63 {
  64     static Sequence< Property > aPropSeq;
  65
  66     // /--
  67     MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
  68     if( 0 == aPropSeq.getLength() )
  69     {
  70         // get properties
  71         ::std::vector< ::com::sun::star::beans::Property > aProperties;
  72
  73         ::chart::LineProperties::AddPropertiesToVector( aProperties );
  74 //         ::chart::NamedLineProperties::AddPropertiesToVector( aProperties );
  75         ::chart::UserDefinedProperties::AddPropertiesToVector( aProperties );
  76
  77         // and sort them for access via bsearch
  78         ::std::sort( aProperties.begin(), aProperties.end(),
  79                      ::chart::PropertyNameLess() );
  80
  81         // transfer result to static Sequence
  82         aPropSeq = ::chart::ContainerHelper::ContainerToSequence( aProperties );
  83     }
  84
  85     return aPropSeq;
  86 }
  87
  88 } // anonymous namespace
  89
  90 // --------------------------------------------------------------------------------
  91
  92 namespace chart
  93 {
  94 namespace wrapper
  95 {
  96
  97 MinMaxLineWrapper::MinMaxLineWrapper( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
  98         : m_spChart2ModelContact( spChart2ModelContact )
  99         , m_aEventListenerContainer( m_aMutex )
 100         , m_pPropertyArrayHelper()
 101         , m_aWrappedLineJointProperty( C2U("LineJoint"), uno::makeAny( drawing::LineJoint_NONE ))
 102 {
 103 }
 104
 105 MinMaxLineWrapper::~MinMaxLineWrapper()
 106 {
 107 }
 108
 109 // ____ XComponent ____
 110 void SAL_CALL MinMaxLineWrapper::dispose()
 111     throw (uno::RuntimeException)
 112 {
 113     Reference< uno::XInterface > xSource( static_cast< ::cppu::OWeakObject* >( this ) );
 114     m_aEventListenerContainer.disposeAndClear( lang::EventObject( xSource ) );
 115
 116     // /--
 117     MutexGuard aGuard( GetMutex());
 118     m_xInfo.clear();
 119     // \--
 120 }
 121
 122 void SAL_CALL MinMaxLineWrapper::addEventListener(
 123     const Reference< lang::XEventListener >& xListener )
 124     throw (uno::RuntimeException)
 125 {
 126     m_aEventListenerContainer.addInterface( xListener );
 127 }
 128
 129 void SAL_CALL MinMaxLineWrapper::removeEventListener(
 130     const Reference< lang::XEventListener >& aListener )
 131     throw (uno::RuntimeException)
 132 {
 133     m_aEventListenerContainer.removeInterface( aListener );
 134 }
 135
 136 ::cppu::IPropertyArrayHelper& MinMaxLineWrapper::getInfoHelper()
 137 {
 138     if(!m_pPropertyArrayHelper.get())
 139     {
 140         // /--
 141         ::osl::MutexGuard aGuard( GetMutex() );
 142         if(!m_pPropertyArrayHelper.get())
 143         {
 144             sal_Bool bSorted = sal_True;
 145             m_pPropertyArrayHelper = ::boost::shared_ptr< ::cppu::OPropertyArrayHelper >( new ::cppu::OPropertyArrayHelper( lcl_GetPropertySequence(), bSorted ) );
 146         }
 147         // \--
 148     }
 149     return *m_pPropertyArrayHelper.get();
 150 }
 151
 152 //XPropertySet
 153 uno::Reference< beans::XPropertySetInfo > SAL_CALL MinMaxLineWrapper::getPropertySetInfo()
 154                     throw (uno::RuntimeException)
 155 {
 156     if( !m_xInfo.is() )
 157     {
 158         // /--
 159         ::osl::MutexGuard aGuard( GetMutex() );
 160         if( !m_xInfo.is() )
 161             m_xInfo = ::cppu::OPropertySetHelper::createPropertySetInfo( getInfoHelper() );
 162         // \--
 163     }
 164     return m_xInfo;
 165 }
 166 void SAL_CALL MinMaxLineWrapper::setPropertyValue( const ::rtl::OUString& rPropertyName, const uno::Any& rValue )
 167                     throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 168 {
 169     Reference< beans::XPropertySet > xPropSet(0);
 170
 171     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
 172     Sequence< Reference< chart2::XChartType > > aTypes(
 173             ::chart::DiagramHelper::getChartTypesFromDiagram( xDiagram ) );
 174     for( sal_Int32 nN = 0; nN < aTypes.getLength(); nN++ )
 175     {
 176         Reference< chart2::XChartType > xType( aTypes[nN] );
 177         if( xType->getChartType().equals(CHART2_SERVICE_NAME_CHARTTYPE_CANDLESTICK) )
 178         {
 179             Reference< chart2::XDataSeriesContainer > xSeriesContainer(xType,uno::UNO_QUERY);
 180             if( xSeriesContainer.is() )
 181             {
 182                 Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xSeriesContainer->getDataSeries() );
 183                 if(aSeriesSeq.getLength())
 184                 {
 185                     xPropSet = Reference< beans::XPropertySet >(aSeriesSeq[0],uno::UNO_QUERY);
 186                     if(xPropSet.is())
 187                     {
 188                         if( rPropertyName.equals( C2U("LineColor")) )
 189                             xPropSet->setPropertyValue( C2U("Color"), rValue );
 190                         else if( rPropertyName.equals( C2U("LineTransparence")) )
 191                             xPropSet->setPropertyValue( C2U("Transparency"), rValue );
 192                         else if( rPropertyName.equals( m_aWrappedLineJointProperty.getOuterName() ) )
 193                             m_aWrappedLineJointProperty.setPropertyValue( rValue, xPropSet );
 194                         else
 195                             xPropSet->setPropertyValue( rPropertyName, rValue );
 196                         return;
 197                     }
 198                 }
 199             }
 200         }
 201     }
 202 }
 203 uno::Any SAL_CALL MinMaxLineWrapper::getPropertyValue( const ::rtl::OUString& rPropertyName )
 204                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 205 {
 206     Any aRet;
 207
 208     Reference< beans::XPropertySet > xPropSet(0);
 209
 210     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
 211     Sequence< Reference< chart2::XChartType > > aTypes(
 212             ::chart::DiagramHelper::getChartTypesFromDiagram( xDiagram ) );
 213     for( sal_Int32 nN = 0; nN < aTypes.getLength(); nN++ )
 214     {
 215         Reference< chart2::XChartType > xType( aTypes[nN] );
 216         if( xType->getChartType().equals(CHART2_SERVICE_NAME_CHARTTYPE_CANDLESTICK) )
 217         {
 218             Reference< chart2::XDataSeriesContainer > xSeriesContainer(xType,uno::UNO_QUERY);
 219             if( xSeriesContainer.is() )
 220             {
 221                 Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xSeriesContainer->getDataSeries() );
 222                 if(aSeriesSeq.getLength())
 223                 {
 224                     xPropSet = Reference< beans::XPropertySet >(aSeriesSeq[0],uno::UNO_QUERY);
 225                     break;
 226                 }
 227             }
 228         }
 229     }
 230     if(xPropSet.is())
 231     {
 232         if( rPropertyName.equals( C2U("LineColor")) )
 233             aRet = xPropSet->getPropertyValue( C2U("Color") );
 234         else if( rPropertyName.equals( C2U("LineTransparence")) )
 235             aRet = xPropSet->getPropertyValue( C2U("Transparency") );
 236         else if( rPropertyName.equals( m_aWrappedLineJointProperty.getOuterName() ) )
 237             aRet = m_aWrappedLineJointProperty.getPropertyValue( xPropSet );
 238         else
 239             aRet = xPropSet->getPropertyValue( rPropertyName );
 240
 241     }
 242     return aRet;
 243 }
 244
 245 void SAL_CALL MinMaxLineWrapper::addPropertyChangeListener( const ::rtl::OUString& /*aPropertyName*/, const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
 246                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 247 {
 248     OSL_ENSURE(false,"not implemented");
 249 }
 250 void SAL_CALL MinMaxLineWrapper::removePropertyChangeListener( const ::rtl::OUString& /*aPropertyName*/, const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
 251                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 252 {
 253     OSL_ENSURE(false,"not implemented");
 254 }
 255 void SAL_CALL MinMaxLineWrapper::addVetoableChangeListener( const ::rtl::OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
 256                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 257 {
 258     OSL_ENSURE(false,"not implemented");
 259 }
 260 void SAL_CALL MinMaxLineWrapper::removeVetoableChangeListener( const ::rtl::OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
 261                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 262 {
 263     OSL_ENSURE(false,"not implemented");
 264 }
 265
 266 //XMultiPropertySet
 267 //getPropertySetInfo() already declared in XPropertySet
 268 void SAL_CALL MinMaxLineWrapper::setPropertyValues( const uno::Sequence< ::rtl::OUString >& rNameSeq, const uno::Sequence< uno::Any >& rValueSeq )
 269                     throw (beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 270 {
 271     bool bUnknownProperty = false;
 272     sal_Int32 nMinCount = std::min( rValueSeq.getLength(), rNameSeq.getLength() );
 273     for(sal_Int32 nN=0; nN<nMinCount; nN++)
 274     {
 275         ::rtl::OUString aPropertyName( rNameSeq[nN] );
 276         try
 277         {
 278             this->setPropertyValue( aPropertyName, rValueSeq[nN] );
 279         }
 280         catch( beans::UnknownPropertyException& ex )
 281         {
 282             ASSERT_EXCEPTION( ex );
 283             bUnknownProperty = true;
 284         }
 285     }
 286     //todo: store unknown properties elsewhere
 287 //    if( bUnknownProperty )
 288 //        throw beans::UnknownPropertyException();
 289 }
 290 uno::Sequence< uno::Any > SAL_CALL MinMaxLineWrapper::getPropertyValues( const uno::Sequence< ::rtl::OUString >& rNameSeq )
 291                     throw (uno::RuntimeException)
 292 {
 293     Sequence< Any > aRetSeq;
 294     if( rNameSeq.getLength() )
 295     {
 296         aRetSeq.realloc( rNameSeq.getLength() );
 297         for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 298         {
 299             ::rtl::OUString aPropertyName( rNameSeq[nN] );
 300             aRetSeq[nN] = this->getPropertyValue( aPropertyName );
 301         }
 302     }
 303     return aRetSeq;
 304 }
 305 void SAL_CALL MinMaxLineWrapper::addPropertiesChangeListener(
 306     const uno::Sequence< ::rtl::OUString >& /* aPropertyNames */,
 307     const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
 308                     throw (uno::RuntimeException)
 309 {
 310     OSL_ENSURE(false,"not implemented");
 311 }
 312 void SAL_CALL MinMaxLineWrapper::removePropertiesChangeListener(
 313     const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
 314                     throw (uno::RuntimeException)
 315 {
 316     OSL_ENSURE(false,"not implemented");
 317 }
 318 void SAL_CALL MinMaxLineWrapper::firePropertiesChangeEvent(
 319     const uno::Sequence< ::rtl::OUString >& /* aPropertyNames */,
 320     const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
 321                     throw (uno::RuntimeException)
 322 {
 323     OSL_ENSURE(false,"not implemented");
 324 }
 325
 326 //XPropertyState
 327 beans::PropertyState SAL_CALL MinMaxLineWrapper::getPropertyState( const ::rtl::OUString& rPropertyName )
 328                     throw (beans::UnknownPropertyException, uno::RuntimeException)
 329 {
 330     if( rPropertyName.equals( m_aWrappedLineJointProperty.getOuterName() ) )
 331         return beans::PropertyState_DEFAULT_VALUE;
 332
 333     uno::Any aDefault( this->getPropertyDefault( rPropertyName ) );
 334     uno::Any aValue( this->getPropertyValue( rPropertyName ) );
 335
 336     if( aDefault == aValue )
 337         return beans::PropertyState_DEFAULT_VALUE;
 338
 339     return beans::PropertyState_DIRECT_VALUE;
 340 }
 341 uno::Sequence< beans::PropertyState > SAL_CALL MinMaxLineWrapper::getPropertyStates( const uno::Sequence< ::rtl::OUString >& rNameSeq )
 342                     throw (beans::UnknownPropertyException, uno::RuntimeException)
 343 {
 344     Sequence< beans::PropertyState > aRetSeq;
 345     if( rNameSeq.getLength() )
 346     {
 347         aRetSeq.realloc( rNameSeq.getLength() );
 348         for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 349         {
 350             ::rtl::OUString aPropertyName( rNameSeq[nN] );
 351             aRetSeq[nN] = this->getPropertyState( aPropertyName );
 352         }
 353     }
 354     return aRetSeq;
 355 }
 356 void SAL_CALL MinMaxLineWrapper::setPropertyToDefault( const ::rtl::OUString& rPropertyName )
 357                     throw (beans::UnknownPropertyException, uno::RuntimeException)
 358 {
 359     this->setPropertyValue( rPropertyName, this->getPropertyDefault(rPropertyName) );
 360 }
 361 uno::Any SAL_CALL MinMaxLineWrapper::getPropertyDefault( const ::rtl::OUString& rPropertyName )
 362                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 363 {
 364     static tPropertyValueMap aStaticDefaults;
 365
 366     // /--
 367     ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 368     if( 0 == aStaticDefaults.size() )
 369     {
 370         LineProperties::AddDefaultsToMap( aStaticDefaults );
 371     }
 372
 373     sal_Int32 nHandle = getInfoHelper().getHandleByName( rPropertyName );
 374
 375     tPropertyValueMap::const_iterator aFound(
 376         aStaticDefaults.find( nHandle ));
 377
 378     if( aFound == aStaticDefaults.end())
 379         return uno::Any();
 380
 381     return (*aFound).second;
 382 }
 383
 384 //XMultiPropertyStates
 385 //getPropertyStates() already declared in XPropertyState
 386 void SAL_CALL MinMaxLineWrapper::setAllPropertiesToDefault(  )
 387                     throw (uno::RuntimeException)
 388 {
 389     const Sequence< beans::Property >&  rPropSeq = lcl_GetPropertySequence();
 390     for(sal_Int32 nN=0; nN<rPropSeq.getLength(); nN++)
 391     {
 392         ::rtl::OUString aPropertyName( rPropSeq[nN].Name );
 393         this->setPropertyToDefault( aPropertyName );
 394     }
 395 }
 396 void SAL_CALL MinMaxLineWrapper::setPropertiesToDefault( const uno::Sequence< ::rtl::OUString >& rNameSeq )
 397                     throw (beans::UnknownPropertyException, uno::RuntimeException)
 398 {
 399     for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 400     {
 401         ::rtl::OUString aPropertyName( rNameSeq[nN] );
 402         this->setPropertyToDefault( aPropertyName );
 403     }
 404 }
 405 uno::Sequence< uno::Any > SAL_CALL MinMaxLineWrapper::getPropertyDefaults( const uno::Sequence< ::rtl::OUString >& rNameSeq )
 406                     throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 407 {
 408     Sequence< Any > aRetSeq;
 409     if( rNameSeq.getLength() )
 410     {
 411         aRetSeq.realloc( rNameSeq.getLength() );
 412         for(sal_Int32 nN=0; nN<rNameSeq.getLength(); nN++)
 413         {
 414             ::rtl::OUString aPropertyName( rNameSeq[nN] );
 415             aRetSeq[nN] = this->getPropertyDefault( aPropertyName );
 416         }
 417     }
 418     return aRetSeq;
 419 }
 420
 421
 422 // ================================================================================
 423
 424 Sequence< OUString > MinMaxLineWrapper::getSupportedServiceNames_Static()
 425 {
 426     Sequence< OUString > aServices( 3 );
 427     aServices[ 0 ] = C2U( "com.sun.star.chart.ChartLine" );
 428     aServices[ 1 ] = C2U( "com.sun.star.xml.UserDefinedAttributeSupplier" );
 429     aServices[ 2 ] = C2U( "com.sun.star.drawing.LineProperties" );
 430
 431     return aServices;
 432 }
 433
 434 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 435 APPHELPER_XSERVICEINFO_IMPL( MinMaxLineWrapper, lcl_aServiceName );
 436
 437 } //  namespace wrapper
 438 } //  namespace chart