chart2/source/controller/chartapiwrapper/WrappedSymbolProperties.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 "WrappedSymbolProperties.hxx"
  21 #include "WrappedSeriesOrDiagramProperty.hxx"
  22 #include <FastPropertyIdRanges.hxx>
  23 #include <ChartType.hxx>
  24 #include <ChartTypeHelper.hxx>
  25 #include <com/sun/star/chart2/Symbol.hpp>
  26 #include <com/sun/star/chart2/SymbolStyle.hpp>
  27 #include <com/sun/star/awt/Size.hpp>
  28 #include <com/sun/star/beans/PropertyAttribute.hpp>
  29 #include <com/sun/star/beans/XPropertyState.hpp>
  30 #include <com/sun/star/chart/ChartSymbolType.hpp>
  31 #include <com/sun/star/drawing/LineStyle.hpp>
  32 #include <vcl/GraphicLoader.hxx>
  33
  34 #include <vcl/graph.hxx>
  35 #include <comphelper/diagnose_ex.hxx>
  36
  37 using namespace ::com::sun::star;
  38 using ::com::sun::star::uno::Any;
  39 using ::com::sun::star::uno::Reference;
  40 using ::com::sun::star::beans::Property;
  41
  42 namespace chart::wrapper
  43 {
  44
  45 namespace
  46 {
  47
  48 class WrappedSymbolTypeProperty : public WrappedSeriesOrDiagramProperty< sal_Int32 >
  49 {
  50 public:
  51     virtual sal_Int32 getValueFromSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet ) const override;
  52     virtual void setValueToSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet, const sal_Int32& aNewValue ) const override;
  53
  54     virtual Any getPropertyValue( const Reference< beans::XPropertySet >& xInnerPropertySet ) const override;
  55     virtual beans::PropertyState getPropertyState( const Reference< beans::XPropertyState >& xInnerPropertyState ) const override;
  56
  57     explicit WrappedSymbolTypeProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
  58                                        tSeriesOrDiagramPropertyType ePropertyType);
  59 };
  60
  61 class WrappedSymbolBitmapURLProperty : public WrappedSeriesOrDiagramProperty<OUString>
  62 {
  63 public:
  64     virtual OUString getValueFromSeries(const Reference<beans::XPropertySet>& xSeriesPropertySet) const override;
  65     virtual void setValueToSeries(const Reference<beans::XPropertySet> & xSeriesPropertySet, OUString const & xNewGraphicURL) const override;
  66
  67     explicit WrappedSymbolBitmapURLProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
  68                                             tSeriesOrDiagramPropertyType ePropertyType);
  69 };
  70
  71 class WrappedSymbolBitmapProperty : public WrappedSeriesOrDiagramProperty<uno::Reference<graphic::XGraphic>>
  72 {
  73 public:
  74     virtual uno::Reference<graphic::XGraphic> getValueFromSeries(const Reference<beans::XPropertySet>& xSeriesPropertySet) const override;
  75     virtual void setValueToSeries(const Reference<beans::XPropertySet> & xSeriesPropertySet, uno::Reference<graphic::XGraphic> const & xNewGraphic) const override;
  76
  77     explicit WrappedSymbolBitmapProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
  78                                             tSeriesOrDiagramPropertyType ePropertyType);
  79 };
  80
  81 class WrappedSymbolSizeProperty : public WrappedSeriesOrDiagramProperty< awt::Size >
  82 {
  83 public:
  84     virtual awt::Size getValueFromSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet ) const override;
  85     virtual void setValueToSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet, const awt::Size& aNewSize ) const override;
  86     virtual beans::PropertyState getPropertyState( const Reference< beans::XPropertyState >& xInnerPropertyState ) const override;
  87
  88     explicit WrappedSymbolSizeProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
  89                                        tSeriesOrDiagramPropertyType ePropertyType);
  90 };
  91
  92 class WrappedSymbolAndLinesProperty : public WrappedSeriesOrDiagramProperty< bool >
  93 {
  94 public:
  95     virtual bool getValueFromSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet ) const override;
  96     virtual void setValueToSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet, const bool& bDrawLines ) const override;
  97     virtual beans::PropertyState getPropertyState( const Reference< beans::XPropertyState >& xInnerPropertyState ) const override;
  98
  99     explicit WrappedSymbolAndLinesProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 100                                            tSeriesOrDiagramPropertyType ePropertyType);
 101 };
 102
 103 enum
 104 {
 105     //symbol properties
 106     PROP_CHART_SYMBOL_TYPE = FAST_PROPERTY_ID_START_CHART_SYMBOL_PROP,
 107     PROP_CHART_SYMBOL_BITMAP_URL,
 108     PROP_CHART_SYMBOL_BITMAP,
 109     PROP_CHART_SYMBOL_SIZE,
 110     PROP_CHART_SYMBOL_AND_LINES
 111 };
 112
 113 sal_Int32 lcl_getSymbolType( const css::chart2::Symbol& rSymbol )
 114 {
 115     sal_Int32 nSymbol = css::chart::ChartSymbolType::NONE;
 116     switch( rSymbol.Style )
 117     {
 118         case chart2::SymbolStyle_NONE:
 119             break;
 120         case chart2::SymbolStyle_AUTO:
 121         case chart2::SymbolStyle_POLYGON://new feature
 122             nSymbol = css::chart::ChartSymbolType::AUTO;
 123             break;
 124         case chart2::SymbolStyle_STANDARD:
 125             nSymbol = rSymbol.StandardSymbol%15;
 126             break;
 127         case chart2::SymbolStyle_GRAPHIC:
 128             nSymbol = css::chart::ChartSymbolType::BITMAPURL;
 129             break;
 130         default:
 131             nSymbol = css::chart::ChartSymbolType::AUTO;
 132             break;
 133     }
 134     return nSymbol;
 135 }
 136 void lcl_setSymbolTypeToSymbol( sal_Int32 nSymbolType, chart2::Symbol& rSymbol )
 137 {
 138     switch( nSymbolType )
 139     {
 140         case css::chart::ChartSymbolType::NONE:
 141             rSymbol.Style = chart2::SymbolStyle_NONE;
 142             break;
 143         case css::chart::ChartSymbolType::AUTO:
 144             rSymbol.Style = chart2::SymbolStyle_AUTO;
 145             break;
 146         case css::chart::ChartSymbolType::BITMAPURL:
 147             rSymbol.Style = chart2::SymbolStyle_GRAPHIC;
 148             break;
 149         default:
 150             rSymbol.Style = chart2::SymbolStyle_STANDARD;
 151             rSymbol.StandardSymbol = nSymbolType;
 152             break;
 153     }
 154 }
 155
 156 void lcl_addWrappedProperties( std::vector< std::unique_ptr<WrappedProperty> >& rList
 157                                     , const std::shared_ptr< Chart2ModelContact >& spChart2ModelContact
 158                                     , tSeriesOrDiagramPropertyType ePropertyType )
 159 {
 160     rList.emplace_back( new WrappedSymbolTypeProperty( spChart2ModelContact, ePropertyType ) );
 161     rList.emplace_back( new WrappedSymbolBitmapURLProperty( spChart2ModelContact, ePropertyType ) );
 162     rList.emplace_back( new WrappedSymbolBitmapProperty( spChart2ModelContact, ePropertyType ) );
 163     rList.emplace_back( new WrappedSymbolSizeProperty( spChart2ModelContact, ePropertyType  ) );
 164     rList.emplace_back( new WrappedSymbolAndLinesProperty( spChart2ModelContact, ePropertyType  ) );
 165 }
 166
 167 }//anonymous namespace
 168
 169 void WrappedSymbolProperties::addProperties( std::vector< Property > & rOutProperties )
 170 {
 171     rOutProperties.emplace_back( "SymbolType",
 172                   PROP_CHART_SYMBOL_TYPE,
 173                   cppu::UnoType<sal_Int32>::get(),
 174                   beans::PropertyAttribute::BOUND
 175                   | beans::PropertyAttribute::MAYBEDEFAULT );
 176
 177     rOutProperties.emplace_back( "SymbolBitmapURL",
 178                   PROP_CHART_SYMBOL_BITMAP_URL,
 179                   cppu::UnoType<OUString>::get(),
 180                   beans::PropertyAttribute::BOUND
 181                   | beans::PropertyAttribute::MAYBEDEFAULT );
 182
 183     rOutProperties.emplace_back( "SymbolBitmap",
 184                   PROP_CHART_SYMBOL_BITMAP,
 185                   cppu::UnoType<graphic::XGraphic>::get(),
 186                   beans::PropertyAttribute::BOUND
 187                   | beans::PropertyAttribute::MAYBEDEFAULT );
 188
 189     rOutProperties.emplace_back( "SymbolSize",
 190                   PROP_CHART_SYMBOL_SIZE,
 191                   cppu::UnoType<awt::Size>::get(),
 192                   beans::PropertyAttribute::BOUND
 193                   | beans::PropertyAttribute::MAYBEDEFAULT );
 194
 195     rOutProperties.emplace_back( "Lines",
 196                   PROP_CHART_SYMBOL_AND_LINES,
 197                   cppu::UnoType<bool>::get(),
 198                   beans::PropertyAttribute::BOUND
 199                   | beans::PropertyAttribute::MAYBEDEFAULT );
 200 }
 201
 202 void WrappedSymbolProperties::addWrappedPropertiesForSeries( std::vector< std::unique_ptr<WrappedProperty> >& rList
 203                                     , const std::shared_ptr< Chart2ModelContact >& spChart2ModelContact )
 204 {
 205     lcl_addWrappedProperties( rList, spChart2ModelContact, DATA_SERIES );
 206 }
 207
 208 void WrappedSymbolProperties::addWrappedPropertiesForDiagram( std::vector< std::unique_ptr<WrappedProperty> >& rList
 209                                     , const std::shared_ptr< Chart2ModelContact >& spChart2ModelContact )
 210 {
 211     lcl_addWrappedProperties( rList, spChart2ModelContact, DIAGRAM );
 212 }
 213
 214 WrappedSymbolTypeProperty::WrappedSymbolTypeProperty(
 215     const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 216     tSeriesOrDiagramPropertyType ePropertyType )
 217         : WrappedSeriesOrDiagramProperty< sal_Int32 >( u"SymbolType"_ustr
 218             , uno::Any( css::chart::ChartSymbolType::NONE )
 219             , spChart2ModelContact
 220             , ePropertyType )
 221 {
 222 }
 223
 224 sal_Int32 WrappedSymbolTypeProperty::getValueFromSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet ) const
 225 {
 226     sal_Int32 aRet = 0;
 227     m_aDefaultValue >>= aRet;
 228     chart2::Symbol aSymbol;
 229     if( xSeriesPropertySet.is() && ( xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol ) )
 230         aRet = lcl_getSymbolType( aSymbol );
 231     return aRet;
 232 }
 233
 234 void WrappedSymbolTypeProperty::setValueToSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet, const sal_Int32& nSymbolType ) const
 235 {
 236     if(!xSeriesPropertySet.is())
 237         return;
 238
 239     chart2::Symbol aSymbol;
 240     xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol;
 241
 242     lcl_setSymbolTypeToSymbol( nSymbolType, aSymbol );
 243     xSeriesPropertySet->setPropertyValue( u"Symbol"_ustr, uno::Any( aSymbol ) );
 244 }
 245
 246 Any WrappedSymbolTypeProperty::getPropertyValue( const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 247 {
 248     //the old chart (< OOo 2.3) needs symbol-type="automatic" at the plot-area if any of the series should be able to have symbols
 249     if( m_ePropertyType == DIAGRAM )
 250     {
 251         bool bHasAmbiguousValue = false;
 252         sal_Int32 aValue = 0;
 253         if( detectInnerValue( aValue, bHasAmbiguousValue ) )
 254         {
 255             if(bHasAmbiguousValue)
 256             {
 257                 m_aOuterValue <<= css::chart::ChartSymbolType::AUTO;
 258             }
 259             else
 260             {
 261                 if( aValue == css::chart::ChartSymbolType::NONE )
 262                     m_aOuterValue <<= css::chart::ChartSymbolType::NONE;
 263                 else
 264                     m_aOuterValue <<= css::chart::ChartSymbolType::AUTO;
 265             }
 266         }
 267         return m_aOuterValue;
 268     }
 269     else
 270     {
 271         css::uno::Any aRet( m_aDefaultValue );
 272         aRet <<= getValueFromSeries( xInnerPropertySet );
 273         return aRet;
 274     }
 275 }
 276
 277 beans::PropertyState WrappedSymbolTypeProperty::getPropertyState( const Reference< beans::XPropertyState >& xInnerPropertyState ) const
 278 {
 279     //the special situation for this property here is that the diagram default can be
 280     //different from the normal default and different from all singles series values
 281     //so we need to return PropertyState_DIRECT_VALUE for more cases
 282
 283     if( m_ePropertyType == DATA_SERIES && //single series or point
 284         m_spChart2ModelContact)
 285     {
 286         rtl::Reference< ::chart::Diagram > xDiagram( m_spChart2ModelContact->getDiagram() );
 287         rtl::Reference< ::chart::DataSeries > xSeries( dynamic_cast<DataSeries*>(xInnerPropertyState.get()) );
 288         rtl::Reference< ChartType > xChartType( xDiagram->getChartTypeOfSeries( xSeries ) );
 289         if( ChartTypeHelper::isSupportingSymbolProperties( xChartType, 2 ) )
 290             return beans::PropertyState_DIRECT_VALUE;
 291     }
 292     return WrappedProperty::getPropertyState( xInnerPropertyState );
 293 }
 294
 295 WrappedSymbolBitmapURLProperty::WrappedSymbolBitmapURLProperty(
 296     const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 297     tSeriesOrDiagramPropertyType ePropertyType )
 298         : WrappedSeriesOrDiagramProperty<OUString>(u"SymbolBitmapURL"_ustr,
 299             uno::Any(OUString()), spChart2ModelContact, ePropertyType)
 300 {
 301 }
 302
 303 OUString WrappedSymbolBitmapURLProperty::getValueFromSeries(const Reference< beans::XPropertySet >& /*xSeriesPropertySet*/) const
 304 {
 305     return OUString();
 306 }
 307
 308 void WrappedSymbolBitmapURLProperty::setValueToSeries(
 309     const Reference< beans::XPropertySet >& xSeriesPropertySet,
 310     OUString const & xNewGraphicURL) const
 311 {
 312     if (!xSeriesPropertySet.is())
 313         return;
 314
 315     chart2::Symbol aSymbol;
 316     if (xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol)
 317     {
 318         if (!xNewGraphicURL.isEmpty())
 319         {
 320             Graphic aGraphic = vcl::graphic::loadFromURL(xNewGraphicURL);
 321             aSymbol.Graphic.set(aGraphic.GetXGraphic());
 322             xSeriesPropertySet->setPropertyValue(u"Symbol"_ustr, uno::Any(aSymbol));
 323         }
 324     }
 325 }
 326
 327 WrappedSymbolBitmapProperty::WrappedSymbolBitmapProperty(
 328     const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 329     tSeriesOrDiagramPropertyType ePropertyType )
 330         : WrappedSeriesOrDiagramProperty<uno::Reference<graphic::XGraphic>>(u"SymbolBitmap"_ustr,
 331             uno::Any(uno::Reference<graphic::XGraphic>()), spChart2ModelContact, ePropertyType)
 332 {
 333 }
 334
 335 uno::Reference<graphic::XGraphic> WrappedSymbolBitmapProperty::getValueFromSeries(const Reference< beans::XPropertySet >& xSeriesPropertySet) const
 336 {
 337     uno::Reference<graphic::XGraphic> xGraphic;
 338     m_aDefaultValue >>= xGraphic;
 339
 340     chart2::Symbol aSymbol;
 341     if (xSeriesPropertySet.is() && (xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol)
 342         && aSymbol.Graphic.is())
 343     {
 344         xGraphic = aSymbol.Graphic;
 345     }
 346     return xGraphic;
 347 }
 348
 349 void WrappedSymbolBitmapProperty::setValueToSeries(
 350     const Reference< beans::XPropertySet >& xSeriesPropertySet,
 351     uno::Reference<graphic::XGraphic> const & xNewGraphic) const
 352 {
 353     if (!xSeriesPropertySet.is())
 354         return;
 355
 356     chart2::Symbol aSymbol;
 357     if (xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol)
 358     {
 359         if (xNewGraphic.is())
 360         {
 361             aSymbol.Graphic.set(xNewGraphic);
 362             xSeriesPropertySet->setPropertyValue(u"Symbol"_ustr, uno::Any(aSymbol));
 363         }
 364     }
 365 }
 366
 367 namespace
 368 {
 369
 370 void lcl_correctSymbolSizeForBitmaps( chart2::Symbol& rSymbol )
 371 {
 372     if( rSymbol.Style != chart2::SymbolStyle_GRAPHIC )
 373         return;
 374     if( rSymbol.Size.Width != -1 )
 375         return;
 376     if( rSymbol.Size.Height != -1 )
 377         return;
 378
 379     //find a good automatic size
 380     try
 381     {
 382         const awt::Size aDefaultSize(250,250);
 383         awt::Size aSize = aDefaultSize;
 384         uno::Reference< beans::XPropertySet > xProp( rSymbol.Graphic, uno::UNO_QUERY );
 385         if( xProp.is() )
 386         {
 387             bool bFoundSize = false;
 388             try
 389             {
 390                 if( xProp->getPropertyValue( u"Size100thMM"_ustr ) >>= aSize )
 391                 {
 392                     if( aSize.Width == 0 && aSize.Height == 0 )
 393                         aSize = aDefaultSize;
 394                     else
 395                         bFoundSize = true;
 396                 }
 397             }
 398             catch( const uno::Exception& )
 399             {
 400                 TOOLS_WARN_EXCEPTION("chart2", "" );
 401             }
 402
 403             if(!bFoundSize)
 404             {
 405                 awt::Size aAWTPixelSize(10,10);
 406                 if( xProp->getPropertyValue( u"SizePixel"_ustr ) >>= aAWTPixelSize )
 407                 {
 408                     Size aPixelSize(aAWTPixelSize.Width,aAWTPixelSize.Height);
 409                     Size aNewSize = o3tl::convert(aPixelSize, o3tl::Length::pt, o3tl::Length::mm100);
 410
 411                     aSize = awt::Size( aNewSize.Width(), aNewSize.Height() );
 412
 413                     if( aSize.Width == 0 && aSize.Height == 0 )
 414                         aSize = aDefaultSize;
 415                 }
 416             }
 417         }
 418         rSymbol.Size = aSize;
 419     }
 420     catch( const uno::Exception& )
 421     {
 422         TOOLS_WARN_EXCEPTION("chart2", "" );
 423     }
 424 }
 425
 426 }//end anonymous namespace
 427
 428 WrappedSymbolSizeProperty::WrappedSymbolSizeProperty(
 429     const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 430     tSeriesOrDiagramPropertyType ePropertyType )
 431         : WrappedSeriesOrDiagramProperty< awt::Size >( u"SymbolSize"_ustr
 432             , uno::Any( awt::Size(250,250) ), spChart2ModelContact, ePropertyType  )
 433 {
 434 }
 435
 436 awt::Size WrappedSymbolSizeProperty::getValueFromSeries( const Reference< beans::XPropertySet >& xSeriesPropertySet ) const
 437 {
 438     awt::Size aRet;
 439     m_aDefaultValue >>= aRet;
 440     chart2::Symbol aSymbol;
 441     if( xSeriesPropertySet.is() && ( xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol ))
 442         aRet = aSymbol.Size;
 443     return aRet;
 444 }
 445
 446 void WrappedSymbolSizeProperty::setValueToSeries(
 447     const Reference< beans::XPropertySet >& xSeriesPropertySet,
 448     const awt::Size& aNewSize ) const
 449 {
 450     if(!xSeriesPropertySet.is())
 451         return;
 452
 453     chart2::Symbol aSymbol;
 454     if( xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol )
 455     {
 456         aSymbol.Size = aNewSize;
 457         lcl_correctSymbolSizeForBitmaps(aSymbol);
 458         xSeriesPropertySet->setPropertyValue( u"Symbol"_ustr, uno::Any( aSymbol ) );
 459     }
 460 }
 461
 462 beans::PropertyState WrappedSymbolSizeProperty::getPropertyState( const Reference< beans::XPropertyState >& xInnerPropertyState ) const
 463 {
 464     //only export symbol size if necessary
 465     if( m_ePropertyType == DIAGRAM )
 466         return beans::PropertyState_DEFAULT_VALUE;
 467
 468     try
 469     {
 470         chart2::Symbol aSymbol;
 471         Reference< beans::XPropertySet > xSeriesPropertySet( xInnerPropertyState, uno::UNO_QUERY );
 472         if( xSeriesPropertySet.is() && ( xSeriesPropertySet->getPropertyValue(u"Symbol"_ustr) >>= aSymbol ))
 473         {
 474             if(  aSymbol.Style != chart2::SymbolStyle_NONE )
 475                 return beans::PropertyState_DIRECT_VALUE;
 476         }
 477     }
 478     catch( const uno::Exception & )
 479     {
 480         DBG_UNHANDLED_EXCEPTION("chart2");
 481     }
 482     return beans::PropertyState_DEFAULT_VALUE;
 483 }
 484
 485 WrappedSymbolAndLinesProperty::WrappedSymbolAndLinesProperty(
 486     const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact,
 487     tSeriesOrDiagramPropertyType ePropertyType )
 488         : WrappedSeriesOrDiagramProperty< bool >( u"Lines"_ustr
 489             , uno::Any( true ), spChart2ModelContact, ePropertyType  )
 490 {
 491 }
 492
 493 bool WrappedSymbolAndLinesProperty::getValueFromSeries( const Reference< beans::XPropertySet >& /*xSeriesPropertySet*/ ) const
 494 {
 495     //do not export this property anymore, instead use a linestyle none for no lines
 496     return true;
 497 }
 498
 499 void WrappedSymbolAndLinesProperty::setValueToSeries(
 500     const Reference< beans::XPropertySet >& xSeriesPropertySet,
 501     const bool& bDrawLines ) const
 502 {
 503     if(!xSeriesPropertySet.is())
 504         return;
 505
 506     drawing::LineStyle eOldLineStyle( drawing::LineStyle_SOLID );
 507     xSeriesPropertySet->getPropertyValue( u"LineStyle"_ustr ) >>= eOldLineStyle;
 508     if( bDrawLines )
 509     {
 510         //#i114298# don't overwrite dashed lines with solid lines here
 511         if( eOldLineStyle == drawing::LineStyle_NONE )
 512             xSeriesPropertySet->setPropertyValue( u"LineStyle"_ustr, uno::Any( drawing::LineStyle_SOLID ) );
 513     }
 514     else
 515     {
 516         if( eOldLineStyle != drawing::LineStyle_NONE )
 517             xSeriesPropertySet->setPropertyValue( u"LineStyle"_ustr, uno::Any( drawing::LineStyle_NONE ) );
 518     }
 519 }
 520
 521 beans::PropertyState WrappedSymbolAndLinesProperty::getPropertyState( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 522 {
 523     //do not export this property anymore, instead use a linestyle none for no lines
 524     return beans::PropertyState_DEFAULT_VALUE;
 525 }
 526
 527 } //namespace chart
 528
 529 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */