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