chart2/source/tools/ErrorBar.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 <ErrorBar.hxx>
  21 #include <EventListenerHelper.hxx>
  22 #include <CloneHelper.hxx>
  23 #include <ModifyListenerHelper.hxx>
  24
  25 #include <comphelper/sequence.hxx>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <svl/itemprop.hxx>
  28 #include <vcl/svapp.hxx>
  29
  30 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  31
  32 #include <com/sun/star/drawing/LineStyle.hpp>
  33 #include <com/sun/star/util/Color.hpp>
  34 #include <com/sun/star/drawing/LineJoint.hpp>
  35
  36 #include <comphelper/diagnose_ex.hxx>
  37 #include <sal/log.hxx>
  38
  39 using namespace ::com::sun::star;
  40
  41 namespace
  42 {
  43
  44 constexpr OUString lcl_aServiceName = u"com.sun.star.comp.chart2.ErrorBar"_ustr;
  45
  46 bool lcl_isInternalData( const uno::Reference< chart2::data::XLabeledDataSequence > & xLSeq )
  47 {
  48     uno::Reference< lang::XServiceInfo > xServiceInfo( xLSeq, uno::UNO_QUERY );
  49     return ( xServiceInfo.is() && xServiceInfo->getImplementationName() == "com.sun.star.comp.chart2.LabeledDataSequence" );
  50 }
  51
  52 const SfxItemPropertySet* GetErrorBarPropertySet()
  53 {
  54     static const SfxItemPropertyMapEntry aErrorBarPropertyMap_Impl[] =
  55     {
  56         {u"ShowPositiveError"_ustr,0,cppu::UnoType<bool>::get(), 0, 0},
  57         {u"ShowNegativeError"_ustr,1,cppu::UnoType<bool>::get(), 0, 0},
  58         {u"PositiveError"_ustr,2,cppu::UnoType<double>::get(),0,0},
  59         {u"NegativeError"_ustr,3,cppu::UnoType<double>::get(), 0, 0},
  60         {u"PercentageError"_ustr,4,cppu::UnoType<double>::get(), 0, 0},
  61         {u"ErrorBarStyle"_ustr,5,cppu::UnoType<sal_Int32>::get(),0,0},
  62         {u"ErrorBarRangePositive"_ustr,6,cppu::UnoType<OUString>::get(),0,0}, // read-only for export
  63         {u"ErrorBarRangeNegative"_ustr,7,cppu::UnoType<OUString>::get(),0,0}, // read-only for export
  64         {u"Weight"_ustr,8,cppu::UnoType<double>::get(),0,0},
  65         {u"LineStyle"_ustr,9,cppu::UnoType<css::drawing::LineStyle>::get(),0,0},
  66         {u"LineDash"_ustr,10,cppu::UnoType<drawing::LineDash>::get(),0,0},
  67         {u"LineWidth"_ustr,11,cppu::UnoType<sal_Int32>::get(),0,0},
  68         {u"LineColor"_ustr,12,cppu::UnoType<css::util::Color>::get(),0,0},
  69         {u"LineTransparence"_ustr,13,cppu::UnoType<sal_Int16>::get(),0,0},
  70         {u"LineJoint"_ustr,14,cppu::UnoType<css::drawing::LineJoint>::get(),0,0},
  71     };
  72     static SfxItemPropertySet aPropSet( aErrorBarPropertyMap_Impl );
  73     return &aPropSet;
  74 }
  75
  76 } // anonymous namespace
  77
  78 namespace chart
  79 {
  80
  81 ErrorBar::ErrorBar() :
  82     mnLineWidth(0),
  83     meLineStyle(drawing::LineStyle_SOLID),
  84     maLineColor(0),
  85     mnLineTransparence(0),
  86     meLineJoint(drawing::LineJoint_ROUND),
  87     mbShowPositiveError(true),
  88     mbShowNegativeError(true),
  89     mfPositiveError(0),
  90     mfNegativeError(0),
  91     mfWeight(1),
  92     meStyle(css::chart::ErrorBarStyle::NONE),
  93     m_xModifyEventForwarder( new ModifyEventForwarder() )
  94 {}
  95
  96 ErrorBar::ErrorBar( const ErrorBar & rOther ) :
  97     impl::ErrorBar_Base(rOther),
  98     maDashName(rOther.maDashName),
  99     maLineDash(rOther.maLineDash),
 100     mnLineWidth(rOther.mnLineWidth),
 101     meLineStyle(rOther.meLineStyle),
 102     maLineColor(rOther.maLineColor),
 103     mnLineTransparence(rOther.mnLineTransparence),
 104     meLineJoint(rOther.meLineJoint),
 105     mbShowPositiveError(rOther.mbShowPositiveError),
 106     mbShowNegativeError(rOther.mbShowNegativeError),
 107     mfPositiveError(rOther.mfPositiveError),
 108     mfNegativeError(rOther.mfNegativeError),
 109     mfWeight(rOther.mfWeight),
 110     meStyle(rOther.meStyle),
 111     m_xModifyEventForwarder( new ModifyEventForwarder() )
 112 {
 113     if( ! rOther.m_aDataSequences.empty())
 114     {
 115         if( lcl_isInternalData( rOther.m_aDataSequences.front()))
 116             CloneHelper::CloneRefVector< css::chart2::data::XLabeledDataSequence >(
 117                 rOther.m_aDataSequences, m_aDataSequences );
 118         else
 119             m_aDataSequences = rOther.m_aDataSequences;
 120         ModifyListenerHelper::addListenerToAllElements( m_aDataSequences, m_xModifyEventForwarder );
 121     }
 122 }
 123
 124 ErrorBar::~ErrorBar()
 125 {}
 126
 127 uno::Reference< util::XCloneable > SAL_CALL ErrorBar::createClone()
 128 {
 129     return uno::Reference< util::XCloneable >( new ErrorBar( *this ));
 130 }
 131
 132 // ____ XPropertySet ____
 133 uno::Reference< beans::XPropertySetInfo > SAL_CALL ErrorBar::getPropertySetInfo()
 134 {
 135     static uno::Reference< beans::XPropertySetInfo > aRef (
 136             new SfxItemPropertySetInfo( GetErrorBarPropertySet()->getPropertyMap() ) );
 137     return aRef;
 138 }
 139
 140 void ErrorBar::setPropertyValue( const OUString& rPropName, const uno::Any& rAny )
 141 {
 142     SolarMutexGuard aGuard;
 143
 144     if(rPropName == "ErrorBarStyle")
 145         rAny >>= meStyle;
 146     else if(rPropName == "PositiveError")
 147         rAny >>= mfPositiveError;
 148     else if(rPropName == "PercentageError")
 149     {
 150         rAny >>= mfPositiveError;
 151         rAny >>= mfNegativeError;
 152     }
 153     else if(rPropName == "Weight")
 154     {
 155         rAny >>= mfWeight;
 156     }
 157     else if(rPropName == "NegativeError")
 158         rAny >>= mfNegativeError;
 159     else if(rPropName == "ShowPositiveError")
 160         rAny >>= mbShowPositiveError;
 161     else if(rPropName == "ShowNegativeError")
 162         rAny >>= mbShowNegativeError;
 163     else if(rPropName == "ErrorBarRangePositive" || rPropName == "ErrorBarRangeNegative")
 164         throw beans::UnknownPropertyException("read-only property", static_cast< uno::XWeak*>(this));
 165     else if(rPropName == "LineDashName")
 166         rAny >>= maDashName;
 167     else if(rPropName == "LineDash")
 168         rAny >>= maLineDash;
 169     else if(rPropName == "LineWidth")
 170         rAny >>= mnLineWidth;
 171     else if(rPropName == "LineStyle")
 172         rAny >>= meLineStyle;
 173     else if(rPropName == "LineColor")
 174         rAny >>= maLineColor;
 175     else if(rPropName == "LineTransparence")
 176         rAny >>= mnLineTransparence;
 177     else if(rPropName == "LineJoint")
 178         rAny >>= meLineJoint;
 179
 180     m_xModifyEventForwarder->modified( lang::EventObject( static_cast< uno::XWeak* >( this )));
 181 }
 182
 183 namespace {
 184
 185 OUString getSourceRangeStrFromLabeledSequences( const uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > >& aSequences, bool bPositive )
 186 {
 187     OUString aDirection;
 188     if(bPositive)
 189         aDirection = "positive";
 190     else
 191         aDirection = "negative";
 192
 193     for( uno::Reference< chart2::data::XLabeledDataSequence > const & labeledData : aSequences )
 194     {
 195         try
 196         {
 197             if( labeledData.is())
 198             {
 199                 uno::Reference< chart2::data::XDataSequence > xSequence( labeledData->getValues());
 200                 uno::Reference< beans::XPropertySet > xSeqProp( xSequence, uno::UNO_QUERY_THROW );
 201                 OUString aRole;
 202                 if( ( xSeqProp->getPropertyValue( "Role" ) >>= aRole ) &&
 203                         aRole.match( "error-bars" ) && aRole.indexOf(aDirection) >= 0 )
 204                 {
 205                     return xSequence->getSourceRangeRepresentation();
 206                 }
 207             }
 208         }
 209         catch (uno::Exception const &)
 210         {
 211             // we can't be sure that this is 100% safe and we don't want to kill the export
 212             // we should at least check why the exception is thrown
 213             TOOLS_WARN_EXCEPTION("chart2", "unexpected exception");
 214         }
 215         catch (...)
 216         {
 217             // we can't be sure that this is 100% safe and we don't want to kill the export
 218             // we should at least check why the exception is thrown
 219             SAL_WARN("chart2", "unexpected exception! ");
 220         }
 221     }
 222
 223     return OUString();
 224 }
 225
 226 }
 227
 228 uno::Any ErrorBar::getPropertyValue(const OUString& rPropName)
 229 {
 230     SolarMutexGuard aGuard;
 231
 232     uno::Any aRet;
 233     if(rPropName == "ErrorBarStyle")
 234         aRet <<= meStyle;
 235     else if(rPropName == "PositiveError")
 236         aRet <<= mfPositiveError;
 237     else if(rPropName == "NegativeError")
 238         aRet <<= mfNegativeError;
 239     else if(rPropName == "PercentageError")
 240         aRet <<= mfPositiveError;
 241     else if(rPropName == "ShowPositiveError")
 242         aRet <<= mbShowPositiveError;
 243     else if(rPropName == "ShowNegativeError")
 244         aRet <<= mbShowNegativeError;
 245     else if(rPropName == "Weight")
 246         aRet <<= mfWeight;
 247     else if(rPropName == "ErrorBarRangePositive")
 248     {
 249         OUString aRange;
 250         if(meStyle == css::chart::ErrorBarStyle::FROM_DATA)
 251         {
 252             uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aSequences =
 253                 getDataSequences();
 254
 255             aRange = getSourceRangeStrFromLabeledSequences( aSequences, true );
 256         }
 257
 258         aRet <<= aRange;
 259     }
 260     else if(rPropName == "ErrorBarRangeNegative")
 261     {
 262         OUString aRange;
 263         if(meStyle == css::chart::ErrorBarStyle::FROM_DATA)
 264         {
 265             uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > aSequences =
 266                 getDataSequences();
 267
 268             aRange = getSourceRangeStrFromLabeledSequences( aSequences, false );
 269         }
 270
 271         aRet <<= aRange;
 272     }
 273     else if(rPropName == "LineDashName")
 274         aRet <<= maDashName;
 275     else if(rPropName == "LineDash")
 276         aRet <<= maLineDash;
 277     else if(rPropName == "LineWidth")
 278         aRet <<= mnLineWidth;
 279     else if(rPropName == "LineStyle")
 280         aRet <<= meLineStyle;
 281     else if(rPropName == "LineColor")
 282         aRet <<= maLineColor;
 283     else if(rPropName == "LineTransparence")
 284         aRet <<= mnLineTransparence;
 285     else if(rPropName == "LineJoint")
 286         aRet <<= meLineJoint;
 287
 288     SAL_WARN_IF(!aRet.hasValue(), "chart2", "asked for property value: " << rPropName);
 289     return aRet;
 290 }
 291
 292 beans::PropertyState ErrorBar::getPropertyState( const OUString& rPropName )
 293 {
 294     if(rPropName == "ErrorBarStyle")
 295     {
 296         if(meStyle == css::chart::ErrorBarStyle::NONE)
 297             return beans::PropertyState_DEFAULT_VALUE;
 298         return beans::PropertyState_DIRECT_VALUE;
 299     }
 300     else if(rPropName == "PositiveError")
 301     {
 302         if(mbShowPositiveError)
 303         {
 304             switch(meStyle)
 305             {
 306                 case css::chart::ErrorBarStyle::ABSOLUTE:
 307                 case css::chart::ErrorBarStyle::ERROR_MARGIN:
 308                     return beans::PropertyState_DIRECT_VALUE;
 309                 default:
 310                     break;
 311             }
 312         }
 313         return beans::PropertyState_DEFAULT_VALUE;
 314     }
 315     else if(rPropName == "NegativeError")
 316     {
 317         if(mbShowNegativeError)
 318         {
 319             switch(meStyle)
 320             {
 321                 case css::chart::ErrorBarStyle::ABSOLUTE:
 322                 case css::chart::ErrorBarStyle::ERROR_MARGIN:
 323                     return beans::PropertyState_DIRECT_VALUE;
 324                 default:
 325                     break;
 326             }
 327         }
 328         return beans::PropertyState_DEFAULT_VALUE;
 329     }
 330     else if(rPropName == "PercentageError")
 331     {
 332         if(meStyle != css::chart::ErrorBarStyle::RELATIVE)
 333             return beans::PropertyState_DEFAULT_VALUE;
 334         return beans::PropertyState_DIRECT_VALUE;
 335     }
 336     else if(rPropName == "ShowPositiveError")
 337     {
 338         // this value should be never default
 339         return beans::PropertyState_DIRECT_VALUE;
 340     }
 341     else if(rPropName == "ShowNegativeError")
 342     {
 343         // this value should be never default
 344         return beans::PropertyState_DIRECT_VALUE;
 345     }
 346     else if(rPropName == "ErrorBarRangePositive")
 347     {
 348         if(meStyle == css::chart::ErrorBarStyle::FROM_DATA && mbShowPositiveError)
 349             return beans::PropertyState_DIRECT_VALUE;
 350         return beans::PropertyState_DEFAULT_VALUE;
 351     }
 352     else if(rPropName == "ErrorBarRangeNegative")
 353     {
 354         if(meStyle == css::chart::ErrorBarStyle::FROM_DATA && mbShowNegativeError)
 355             return beans::PropertyState_DIRECT_VALUE;
 356         return beans::PropertyState_DEFAULT_VALUE;
 357     }
 358     else
 359         return beans::PropertyState_DIRECT_VALUE;
 360 }
 361
 362 uno::Sequence< beans::PropertyState > ErrorBar::getPropertyStates( const uno::Sequence< OUString >& rPropNames )
 363 {
 364     uno::Sequence< beans::PropertyState > aRet( rPropNames.getLength() );
 365     auto aRetRange = asNonConstRange(aRet);
 366     for(sal_Int32 i = 0; i < rPropNames.getLength(); ++i)
 367     {
 368         aRetRange[i] = getPropertyState(rPropNames[i]);
 369     }
 370     return aRet;
 371 }
 372
 373 void ErrorBar::setPropertyToDefault( const OUString& )
 374 {
 375     //keep them unimplemented for now
 376 }
 377
 378 uno::Any ErrorBar::getPropertyDefault( const OUString& )
 379 {
 380     //keep them unimplemented for now
 381     return uno::Any();
 382 }
 383
 384 void ErrorBar::addPropertyChangeListener( const OUString&, const css::uno::Reference< css::beans::XPropertyChangeListener >& )
 385 {
 386 }
 387
 388 void ErrorBar::removePropertyChangeListener( const OUString&, const css::uno::Reference< css::beans::XPropertyChangeListener >& )
 389 {
 390 }
 391
 392 void ErrorBar::addVetoableChangeListener( const OUString&, const css::uno::Reference< css::beans::XVetoableChangeListener >& )
 393 {
 394 }
 395
 396 void ErrorBar::removeVetoableChangeListener( const OUString&, const css::uno::Reference< css::beans::XVetoableChangeListener >& )
 397 {
 398 }
 399
 400 // ____ XModifyBroadcaster ____
 401 void SAL_CALL ErrorBar::addModifyListener( const uno::Reference< util::XModifyListener >& aListener )
 402 {
 403     m_xModifyEventForwarder->addModifyListener( aListener );
 404 }
 405
 406 void SAL_CALL ErrorBar::removeModifyListener( const uno::Reference< util::XModifyListener >& aListener )
 407 {
 408     m_xModifyEventForwarder->removeModifyListener( aListener );
 409 }
 410
 411 // ____ XModifyListener ____
 412 void SAL_CALL ErrorBar::modified( const lang::EventObject& aEvent )
 413 {
 414     m_xModifyEventForwarder->modified( aEvent );
 415 }
 416
 417 // ____ XEventListener (base of XModifyListener) ____
 418 void SAL_CALL ErrorBar::disposing( const lang::EventObject& /* Source */ )
 419 {
 420     // nothing
 421 }
 422
 423 // ____ XDataSink ____
 424 void SAL_CALL ErrorBar::setData( const uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > >& aData )
 425 {
 426     ModifyListenerHelper::removeListenerFromAllElements( m_aDataSequences, m_xModifyEventForwarder );
 427     EventListenerHelper::removeListenerFromAllElements( m_aDataSequences, this );
 428     m_aDataSequences = comphelper::sequenceToContainer<tDataSequenceContainer>( aData );
 429     EventListenerHelper::addListenerToAllElements( m_aDataSequences, this );
 430     ModifyListenerHelper::addListenerToAllElements( m_aDataSequences, m_xModifyEventForwarder );
 431 }
 432
 433 // ____ XDataSource ____
 434 uno::Sequence< uno::Reference< chart2::data::XLabeledDataSequence > > SAL_CALL ErrorBar::getDataSequences()
 435 {
 436     return comphelper::containerToSequence( m_aDataSequences );
 437 }
 438
 439 OUString SAL_CALL ErrorBar::getImplementationName()
 440 {
 441     return lcl_aServiceName;
 442 }
 443
 444 sal_Bool SAL_CALL ErrorBar::supportsService( const OUString& rServiceName )
 445 {
 446     return cppu::supportsService(this, rServiceName);
 447 }
 448
 449 css::uno::Sequence< OUString > SAL_CALL ErrorBar::getSupportedServiceNames()
 450 {
 451     return {
 452         lcl_aServiceName,
 453         "com.sun.star.chart2.ErrorBar"
 454     };
 455 }
 456
 457 // needed by MSC compiler
 458 using impl::ErrorBar_Base;
 459
 460 } //  namespace chart
 461
 462 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 463 com_sun_star_comp_chart2_ErrorBar_get_implementation(css::uno::XComponentContext *,
 464         css::uno::Sequence<css::uno::Any> const &)
 465 {
 466     return cppu::acquire(new ::chart::ErrorBar);
 467 }
 468
 469 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */