chart2/source/controller/chartapiwrapper/DiagramWrapper.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 "DiagramWrapper.hxx"
  21 #include <servicenames_charttypes.hxx>
  22 #include "DataSeriesPointWrapper.hxx"
  23 #include "AxisWrapper.hxx"
  24 #include "Chart2ModelContact.hxx"
  25 #include "WallFloorWrapper.hxx"
  26 #include "MinMaxLineWrapper.hxx"
  27 #include "UpDownBarWrapper.hxx"
  28 #include <DiagramHelper.hxx>
  29 #include <DataSourceHelper.hxx>
  30 #include <ChartModelHelper.hxx>
  31 #include <WrappedIgnoreProperty.hxx>
  32 #include "WrappedAxisAndGridExistenceProperties.hxx"
  33 #include "WrappedStatisticProperties.hxx"
  34 #include "WrappedSymbolProperties.hxx"
  35 #include "WrappedDataCaptionProperties.hxx"
  36 #include "WrappedSplineProperties.hxx"
  37 #include "WrappedStockProperties.hxx"
  38 #include "WrappedSceneProperty.hxx"
  39 #include <ControllerLockGuard.hxx>
  40 #include <DisposeHelper.hxx>
  41 #include "WrappedAutomaticPositionProperties.hxx"
  42 #include <CommonConverters.hxx>
  43 #include <unonames.hxx>
  44 #include <comphelper/sequence.hxx>
  45 #include <cppuhelper/supportsservice.hxx>
  46
  47 #include <com/sun/star/beans/PropertyAttribute.hpp>
  48 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  49 #include <com/sun/star/chart2/RelativeSize.hpp>
  50 #include <com/sun/star/chart2/RelativePosition.hpp>
  51 #include <com/sun/star/chart2/XChartDocument.hpp>
  52 #include <com/sun/star/chart/ChartSolidType.hpp>
  53 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  54 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  55
  56 #include <LinePropertiesHelper.hxx>
  57 #include <FillProperties.hxx>
  58 #include <UserDefinedProperties.hxx>
  59 #include <SceneProperties.hxx>
  60
  61 #include <algorithm>
  62 #include <map>
  63 #include <com/sun/star/lang/XServiceName.hpp>
  64 #include <com/sun/star/util/XRefreshable.hpp>
  65 #include <tools/diagnose_ex.h>
  66
  67 using namespace ::com::sun::star;
  68 using namespace ::chart::wrapper;
  69
  70 using ::com::sun::star::uno::Reference;
  71 using ::com::sun::star::uno::Any;
  72 using ::com::sun::star::uno::Sequence;
  73 using ::com::sun::star::beans::Property;
  74 using ::com::sun::star::chart::XAxis;
  75 using ::osl::MutexGuard;
  76
  77 namespace
  78 {
  79
  80 enum
  81 {
  82     PROP_DIAGRAM_ATTRIBUTED_DATA_POINTS,
  83     PROP_DIAGRAM_PERCENT_STACKED,
  84     PROP_DIAGRAM_STACKED,
  85     PROP_DIAGRAM_THREE_D,
  86     PROP_DIAGRAM_SOLIDTYPE,
  87     PROP_DIAGRAM_DEEP,
  88     PROP_DIAGRAM_VERTICAL,
  89     PROP_DIAGRAM_NUMBER_OF_LINES,
  90     PROP_DIAGRAM_STACKED_BARS_CONNECTED,
  91     PROP_DIAGRAM_DATAROW_SOURCE,
  92
  93     PROP_DIAGRAM_GROUP_BARS_PER_AXIS,
  94     PROP_DIAGRAM_INCLUDE_HIDDEN_CELLS,
  95
  96     PROP_DIAGRAM_SORT_BY_X_VALUES,
  97
  98     PROP_DIAGRAM_STARTING_ANGLE,
  99
 100     PROP_DIAGRAM_RIGHT_ANGLED_AXES,
 101     PROP_DIAGRAM_PERSPECTIVE,
 102     PROP_DIAGRAM_ROTATION_HORIZONTAL,
 103     PROP_DIAGRAM_ROTATION_VERTICAL,
 104
 105     PROP_DIAGRAM_MISSING_VALUE_TREATMENT,
 106
 107     PROP_DIAGRAM_HAS_X_AXIS,
 108     PROP_DIAGRAM_HAS_X_AXIS_DESCR,
 109     PROP_DIAGRAM_HAS_X_AXIS_TITLE,
 110     PROP_DIAGRAM_HAS_X_AXIS_GRID,
 111     PROP_DIAGRAM_HAS_X_AXIS_HELP_GRID,
 112
 113     PROP_DIAGRAM_HAS_Y_AXIS,
 114     PROP_DIAGRAM_HAS_Y_AXIS_DESCR,
 115     PROP_DIAGRAM_HAS_Y_AXIS_TITLE,
 116     PROP_DIAGRAM_HAS_Y_AXIS_GRID,
 117     PROP_DIAGRAM_HAS_Y_AXIS_HELP_GRID,
 118
 119     PROP_DIAGRAM_HAS_Z_AXIS,
 120     PROP_DIAGRAM_HAS_Z_AXIS_DESCR,
 121     PROP_DIAGRAM_HAS_Z_AXIS_TITLE,
 122     PROP_DIAGRAM_HAS_Z_AXIS_GRID,
 123     PROP_DIAGRAM_HAS_Z_AXIS_HELP_GRID,
 124
 125     PROP_DIAGRAM_HAS_SECOND_X_AXIS,
 126     PROP_DIAGRAM_HAS_SECOND_X_AXIS_DESCR,
 127
 128     PROP_DIAGRAM_HAS_SECOND_Y_AXIS,
 129     PROP_DIAGRAM_HAS_SECOND_Y_AXIS_DESCR,
 130
 131     PROP_DIAGRAM_HAS_SECOND_X_AXIS_TITLE,
 132     PROP_DIAGRAM_HAS_SECOND_Y_AXIS_TITLE,
 133
 134     PROP_DIAGRAM_AUTOMATIC_SIZE,
 135     PROP_DIAGRAM_DATATABLEHBORDER,
 136     PROP_DIAGRAM_DATATABLEVBORDER,
 137     PROP_DIAGRAM_DATATABLEOUTLINE,
 138     PROP_DIAGRAM_EXTERNALDATA
 139 };
 140
 141 void lcl_AddPropertiesToVector(
 142     std::vector< Property > & rOutProperties )
 143 {
 144     rOutProperties.emplace_back( "AttributedDataPoints",
 145                   PROP_DIAGRAM_ATTRIBUTED_DATA_POINTS,
 146                   cppu::UnoType<uno::Sequence< uno::Sequence< sal_Int32 > >>::get(),
 147                   beans::PropertyAttribute::BOUND
 148                   | beans::PropertyAttribute::MAYBEVOID );
 149
 150     // see com.sun.star.chart.StackableDiagram
 151     rOutProperties.emplace_back( "Percent",
 152                   PROP_DIAGRAM_PERCENT_STACKED,
 153                   cppu::UnoType<bool>::get(),
 154                   beans::PropertyAttribute::BOUND
 155                   | beans::PropertyAttribute::MAYBEDEFAULT );
 156     rOutProperties.emplace_back( "Stacked",
 157                   PROP_DIAGRAM_STACKED,
 158                   cppu::UnoType<bool>::get(),
 159                   beans::PropertyAttribute::BOUND
 160                   | beans::PropertyAttribute::MAYBEDEFAULT );
 161
 162     rOutProperties.emplace_back( "Dim3D",
 163                   PROP_DIAGRAM_THREE_D,
 164                   cppu::UnoType<bool>::get(),
 165                   beans::PropertyAttribute::BOUND
 166                   | beans::PropertyAttribute::MAYBEDEFAULT );
 167
 168     // see com.sun.star.chart.Chart3DBarProperties
 169     rOutProperties.emplace_back( "SolidType",
 170                   PROP_DIAGRAM_SOLIDTYPE,
 171                   cppu::UnoType<sal_Int32>::get(),
 172                   beans::PropertyAttribute::BOUND
 173                   | beans::PropertyAttribute::MAYBEDEFAULT );
 174
 175     // see com.sun.star.chart.BarDiagram
 176     rOutProperties.emplace_back( "Deep",
 177                   PROP_DIAGRAM_DEEP,
 178                   cppu::UnoType<bool>::get(),
 179                   beans::PropertyAttribute::BOUND
 180                   | beans::PropertyAttribute::MAYBEDEFAULT );
 181     rOutProperties.emplace_back( "Vertical",
 182                   PROP_DIAGRAM_VERTICAL,
 183                   cppu::UnoType<bool>::get(),
 184                   beans::PropertyAttribute::BOUND
 185                   | beans::PropertyAttribute::MAYBEDEFAULT );
 186     rOutProperties.emplace_back( "NumberOfLines",
 187                   PROP_DIAGRAM_NUMBER_OF_LINES,
 188                   cppu::UnoType<sal_Int32>::get(),
 189                   beans::PropertyAttribute::BOUND
 190                   | beans::PropertyAttribute::MAYBEDEFAULT );
 191     rOutProperties.emplace_back( "StackedBarsConnected",
 192                   PROP_DIAGRAM_STACKED_BARS_CONNECTED,
 193                   cppu::UnoType<bool>::get(),
 194                   beans::PropertyAttribute::BOUND
 195                   | beans::PropertyAttribute::MAYBEDEFAULT );
 196
 197     rOutProperties.emplace_back( "DataRowSource",
 198                   PROP_DIAGRAM_DATAROW_SOURCE,
 199                   cppu::UnoType<css::chart::ChartDataRowSource>::get(),
 200                   beans::PropertyAttribute::BOUND
 201                   | beans::PropertyAttribute::MAYBEDEFAULT );
 202
 203     rOutProperties.emplace_back( "GroupBarsPerAxis",
 204                   PROP_DIAGRAM_GROUP_BARS_PER_AXIS,
 205                   cppu::UnoType<bool>::get(),
 206                   beans::PropertyAttribute::BOUND
 207                   | beans::PropertyAttribute::MAYBEDEFAULT );
 208
 209     rOutProperties.emplace_back( "IncludeHiddenCells",
 210                   PROP_DIAGRAM_INCLUDE_HIDDEN_CELLS,
 211                   cppu::UnoType<bool>::get(),
 212                   beans::PropertyAttribute::BOUND
 213                   | beans::PropertyAttribute::MAYBEDEFAULT );
 214
 215     //new for XY charts
 216     rOutProperties.emplace_back( CHART_UNONAME_SORT_BY_XVALUES,
 217                   PROP_DIAGRAM_SORT_BY_X_VALUES,
 218                   cppu::UnoType<bool>::get(),
 219                   beans::PropertyAttribute::BOUND
 220                   | beans::PropertyAttribute::MAYBEDEFAULT );
 221
 222     //for pie and donut charts
 223     rOutProperties.emplace_back( "StartingAngle",
 224                   PROP_DIAGRAM_STARTING_ANGLE,
 225                   cppu::UnoType<sal_Int32>::get(),
 226                   beans::PropertyAttribute::BOUND
 227                   | beans::PropertyAttribute::MAYBEDEFAULT );
 228
 229     //new for 3D charts
 230     rOutProperties.emplace_back( "RightAngledAxes",
 231                   PROP_DIAGRAM_RIGHT_ANGLED_AXES,
 232                   cppu::UnoType<bool>::get(),
 233                   beans::PropertyAttribute::BOUND
 234                   | beans::PropertyAttribute::MAYBEDEFAULT );
 235
 236     rOutProperties.emplace_back( "Perspective",
 237                   PROP_DIAGRAM_PERSPECTIVE,
 238                   cppu::UnoType<sal_Int32>::get(),
 239                   beans::PropertyAttribute::MAYBEVOID );
 240
 241     rOutProperties.emplace_back( "RotationHorizontal",
 242                   PROP_DIAGRAM_ROTATION_HORIZONTAL,
 243                   cppu::UnoType<sal_Int32>::get(),
 244                   beans::PropertyAttribute::MAYBEVOID );
 245
 246     rOutProperties.emplace_back( "RotationVertical",
 247                   PROP_DIAGRAM_ROTATION_VERTICAL,
 248                   cppu::UnoType<sal_Int32>::get(),
 249                   beans::PropertyAttribute::MAYBEVOID );
 250
 251     // XAxisXSupplier
 252     rOutProperties.emplace_back( "HasXAxis",
 253                   PROP_DIAGRAM_HAS_X_AXIS,
 254                   cppu::UnoType<bool>::get(),
 255                   beans::PropertyAttribute::BOUND
 256                   | beans::PropertyAttribute::MAYBEDEFAULT );
 257     rOutProperties.emplace_back( "HasXAxisDescription",
 258                   PROP_DIAGRAM_HAS_X_AXIS_DESCR,
 259                   cppu::UnoType<bool>::get(),
 260                   beans::PropertyAttribute::BOUND
 261                   | beans::PropertyAttribute::MAYBEDEFAULT );
 262     rOutProperties.emplace_back( "HasXAxisTitle",
 263                   PROP_DIAGRAM_HAS_X_AXIS_TITLE,
 264                   cppu::UnoType<bool>::get(),
 265                   beans::PropertyAttribute::BOUND
 266                   | beans::PropertyAttribute::MAYBEDEFAULT );
 267     rOutProperties.emplace_back( "HasXAxisGrid",
 268                   PROP_DIAGRAM_HAS_X_AXIS_GRID,
 269                   cppu::UnoType<bool>::get(),
 270                   beans::PropertyAttribute::BOUND
 271                   | beans::PropertyAttribute::MAYBEDEFAULT );
 272     rOutProperties.emplace_back( "HasXAxisHelpGrid",
 273                   PROP_DIAGRAM_HAS_X_AXIS_HELP_GRID,
 274                   cppu::UnoType<bool>::get(),
 275                   beans::PropertyAttribute::BOUND
 276                   | beans::PropertyAttribute::MAYBEDEFAULT );
 277
 278     // XAxisYSupplier
 279     rOutProperties.emplace_back( "HasYAxis",
 280                   PROP_DIAGRAM_HAS_Y_AXIS,
 281                   cppu::UnoType<bool>::get(),
 282                   beans::PropertyAttribute::BOUND
 283                   | beans::PropertyAttribute::MAYBEDEFAULT );
 284     rOutProperties.emplace_back( "HasYAxisDescription",
 285                   PROP_DIAGRAM_HAS_Y_AXIS_DESCR,
 286                   cppu::UnoType<bool>::get(),
 287                   beans::PropertyAttribute::BOUND
 288                   | beans::PropertyAttribute::MAYBEDEFAULT );
 289     rOutProperties.emplace_back( "HasYAxisTitle",
 290                   PROP_DIAGRAM_HAS_Y_AXIS_TITLE,
 291                   cppu::UnoType<bool>::get(),
 292                   beans::PropertyAttribute::BOUND
 293                   | beans::PropertyAttribute::MAYBEDEFAULT );
 294     rOutProperties.emplace_back( "HasYAxisGrid",
 295                   PROP_DIAGRAM_HAS_Y_AXIS_GRID,
 296                   cppu::UnoType<bool>::get(),
 297                   beans::PropertyAttribute::BOUND
 298                   | beans::PropertyAttribute::MAYBEDEFAULT );
 299     rOutProperties.emplace_back( "HasYAxisHelpGrid",
 300                   PROP_DIAGRAM_HAS_Y_AXIS_HELP_GRID,
 301                   cppu::UnoType<bool>::get(),
 302                   beans::PropertyAttribute::BOUND
 303                   | beans::PropertyAttribute::MAYBEDEFAULT );
 304
 305     // XAxisZSupplier
 306     rOutProperties.emplace_back( "HasZAxis",
 307                   PROP_DIAGRAM_HAS_Z_AXIS,
 308                   cppu::UnoType<bool>::get(),
 309                   beans::PropertyAttribute::BOUND
 310                   | beans::PropertyAttribute::MAYBEDEFAULT );
 311     rOutProperties.emplace_back( "HasZAxisDescription",
 312                   PROP_DIAGRAM_HAS_Z_AXIS_DESCR,
 313                   cppu::UnoType<bool>::get(),
 314                   beans::PropertyAttribute::BOUND
 315                   | beans::PropertyAttribute::MAYBEDEFAULT );
 316     rOutProperties.emplace_back( "HasZAxisTitle",
 317                   PROP_DIAGRAM_HAS_Z_AXIS_TITLE,
 318                   cppu::UnoType<bool>::get(),
 319                   beans::PropertyAttribute::BOUND
 320                   | beans::PropertyAttribute::MAYBEDEFAULT );
 321     rOutProperties.emplace_back( "HasZAxisGrid",
 322                   PROP_DIAGRAM_HAS_Z_AXIS_GRID,
 323                   cppu::UnoType<bool>::get(),
 324                   beans::PropertyAttribute::BOUND
 325                   | beans::PropertyAttribute::MAYBEDEFAULT );
 326     rOutProperties.emplace_back( "HasZAxisHelpGrid",
 327                   PROP_DIAGRAM_HAS_Z_AXIS_HELP_GRID,
 328                   cppu::UnoType<bool>::get(),
 329                   beans::PropertyAttribute::BOUND
 330                   | beans::PropertyAttribute::MAYBEDEFAULT );
 331
 332     // XTwoAxisXSupplier
 333     rOutProperties.emplace_back( "HasSecondaryXAxis",
 334                   PROP_DIAGRAM_HAS_SECOND_X_AXIS,
 335                   cppu::UnoType<bool>::get(),
 336                   beans::PropertyAttribute::BOUND
 337                   | beans::PropertyAttribute::MAYBEDEFAULT );
 338     rOutProperties.emplace_back( "HasSecondaryXAxisDescription",
 339                   PROP_DIAGRAM_HAS_SECOND_X_AXIS_DESCR,
 340                   cppu::UnoType<bool>::get(),
 341                   beans::PropertyAttribute::BOUND
 342                   | beans::PropertyAttribute::MAYBEDEFAULT );
 343
 344     // XTwoAxisYSupplier
 345     rOutProperties.emplace_back( "HasSecondaryYAxis",
 346                   PROP_DIAGRAM_HAS_SECOND_Y_AXIS,
 347                   cppu::UnoType<bool>::get(),
 348                   beans::PropertyAttribute::BOUND
 349                   | beans::PropertyAttribute::MAYBEDEFAULT );
 350     rOutProperties.emplace_back( "HasSecondaryYAxisDescription",
 351                   PROP_DIAGRAM_HAS_SECOND_Y_AXIS_DESCR,
 352                   cppu::UnoType<bool>::get(),
 353                   beans::PropertyAttribute::BOUND
 354                   | beans::PropertyAttribute::MAYBEDEFAULT );
 355
 356     // XSecondAxisTitleSupplier
 357     rOutProperties.emplace_back( "HasSecondaryXAxisTitle",
 358                   PROP_DIAGRAM_HAS_SECOND_X_AXIS_TITLE,
 359                   cppu::UnoType<bool>::get(),
 360                   beans::PropertyAttribute::BOUND
 361                   | beans::PropertyAttribute::MAYBEDEFAULT );
 362     rOutProperties.emplace_back( "HasSecondaryYAxisTitle",
 363                   PROP_DIAGRAM_HAS_SECOND_Y_AXIS_TITLE,
 364                   cppu::UnoType<bool>::get(),
 365                   beans::PropertyAttribute::BOUND
 366                   | beans::PropertyAttribute::MAYBEDEFAULT );
 367
 368     rOutProperties.emplace_back( "MissingValueTreatment",
 369                   PROP_DIAGRAM_MISSING_VALUE_TREATMENT,
 370                   cppu::UnoType<sal_Int32>::get(),
 371                   beans::PropertyAttribute::BOUND
 372                   | beans::PropertyAttribute::MAYBEVOID );
 373
 374     rOutProperties.emplace_back( "AutomaticSize",
 375                   PROP_DIAGRAM_AUTOMATIC_SIZE,
 376                   cppu::UnoType<bool>::get(),
 377                   beans::PropertyAttribute::BOUND
 378                   | beans::PropertyAttribute::MAYBEDEFAULT );
 379     rOutProperties.emplace_back( "DataTableHBorder",
 380                 PROP_DIAGRAM_DATATABLEHBORDER,
 381                   cppu::UnoType<bool>::get(),
 382                   beans::PropertyAttribute::BOUND
 383                   | beans::PropertyAttribute::MAYBEDEFAULT );
 384     rOutProperties.emplace_back( "DataTableVBorder",
 385                 PROP_DIAGRAM_DATATABLEVBORDER,
 386                   cppu::UnoType<bool>::get(),
 387                   beans::PropertyAttribute::BOUND
 388                   | beans::PropertyAttribute::MAYBEDEFAULT );
 389     rOutProperties.emplace_back( "DataTableOutline",
 390                 PROP_DIAGRAM_DATATABLEOUTLINE,
 391                   cppu::UnoType<bool>::get(),
 392                   beans::PropertyAttribute::BOUND
 393                   | beans::PropertyAttribute::MAYBEDEFAULT );
 394     rOutProperties.emplace_back( "ExternalData",
 395                   PROP_DIAGRAM_EXTERNALDATA,
 396                   cppu::UnoType<OUString>::get(),
 397                   beans::PropertyAttribute::BOUND
 398                   | beans::PropertyAttribute::MAYBEVOID );
 399 }
 400
 401 struct StaticDiagramWrapperPropertyArray_Initializer
 402 {
 403     Sequence< Property >* operator()()
 404     {
 405         static Sequence< Property > aPropSeq( lcl_GetPropertySequence() );
 406         return &aPropSeq;
 407     }
 408
 409 private:
 410     static uno::Sequence< Property > lcl_GetPropertySequence()
 411     {
 412         std::vector< css::beans::Property > aProperties;
 413         lcl_AddPropertiesToVector( aProperties );
 414         ::chart::LinePropertiesHelper::AddPropertiesToVector( aProperties );
 415         ::chart::FillProperties::AddPropertiesToVector( aProperties );
 416         ::chart::UserDefinedProperties::AddPropertiesToVector( aProperties );
 417         ::chart::SceneProperties::AddPropertiesToVector( aProperties );
 418         WrappedStatisticProperties::addProperties( aProperties );
 419         WrappedSymbolProperties::addProperties( aProperties );
 420         WrappedDataCaptionProperties::addProperties( aProperties );
 421         WrappedSplineProperties::addProperties( aProperties );
 422         WrappedStockProperties::addProperties( aProperties );
 423         WrappedAutomaticPositionProperties::addProperties( aProperties );
 424
 425         std::sort( aProperties.begin(), aProperties.end(),
 426                      ::chart::PropertyNameLess() );
 427
 428         return comphelper::containerToSequence( aProperties );
 429     }
 430 };
 431
 432 struct StaticDiagramWrapperPropertyArray : public rtl::StaticAggregate< Sequence< Property >, StaticDiagramWrapperPropertyArray_Initializer >
 433 {
 434 };
 435
 436 bool lcl_isXYChart( const Reference< chart2::XDiagram >& rDiagram )
 437 {
 438     bool bRet = false;
 439     Reference< chart2::XChartType > xChartType( ::chart::DiagramHelper::getChartTypeByIndex( rDiagram, 0 ) );
 440     if( xChartType.is() )
 441     {
 442         OUString aChartType( xChartType->getChartType() );
 443         if( aChartType.equalsIgnoreAsciiCase(CHART2_SERVICE_NAME_CHARTTYPE_SCATTER) )
 444             bRet = true;
 445     }
 446     return bRet;
 447 }
 448
 449 sal_Int32 lcl_getNewAPIIndexForOldAPIIndex(
 450                 sal_Int32 nOldAPIIndex
 451                 , const Reference< chart2::XDiagram >& xDiagram )
 452 {
 453     sal_Int32 nNewAPIIndex = nOldAPIIndex;
 454
 455     if( lcl_isXYChart( xDiagram ) )
 456     {
 457         if( nNewAPIIndex >= 1 )
 458             nNewAPIIndex -= 1;
 459     }
 460
 461     std::vector< uno::Reference< chart2::XDataSeries > > aSeriesList(
 462         ::chart::DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
 463     if( nNewAPIIndex >= static_cast<sal_Int32>(aSeriesList.size()) )
 464         nNewAPIIndex = -1;
 465
 466     return nNewAPIIndex;
 467 }
 468
 469 OUString lcl_getDiagramType( const OUString & rTemplateServiceName )
 470 {
 471     const OUString aPrefix("com.sun.star.chart2.template.");
 472
 473     if( rTemplateServiceName.match( aPrefix ))
 474     {
 475         const OUString aName( rTemplateServiceName.copy( aPrefix.getLength()));
 476
 477         // "Area" "StackedArea" "PercentStackedArea" "ThreeDArea"
 478         // "StackedThreeDArea" "PercentStackedThreeDArea"
 479         if( aName.indexOf( "Area" ) != -1 )
 480             return "com.sun.star.chart.AreaDiagram";
 481
 482         // "Pie" "PieAllExploded" "ThreeDPie" "ThreeDPieAllExploded"
 483         if( aName.indexOf( "Pie" ) != -1 )
 484             return "com.sun.star.chart.PieDiagram";
 485
 486         // "Column" "StackedColumn" "PercentStackedColumn" "ThreeDColumnDeep"
 487         // "ThreeDColumnFlat" "StackedThreeDColumnFlat"
 488         // "PercentStackedThreeDColumnFlat" "Bar" "StackedBar"
 489         // "PercentStackedBar" "ThreeDBarDeep" "ThreeDBarFlat"
 490         // "StackedThreeDBarFlat" "PercentStackedThreeDBarFlat" "ColumnWithLine"
 491         // "StackedColumnWithLine"
 492         if( aName.indexOf( "Column" ) != -1 || aName.indexOf( "Bar" ) != -1 )
 493             return "com.sun.star.chart.BarDiagram";
 494
 495         // "Donut" "DonutAllExploded" "ThreeDDonut" "ThreeDDonutAllExploded"
 496         if( aName.indexOf( "Donut" ) != -1 )
 497             return "com.sun.star.chart.DonutDiagram";
 498
 499         // "ScatterLineSymbol" "ScatterLine" "ScatterSymbol" "ThreeDScatter"
 500         if( aName.indexOf( "Scatter" ) != -1 )
 501             return "com.sun.star.chart.XYDiagram";
 502
 503         // "FilledNet" "StackedFilledNet" "PercentStackedFilledNet"
 504         if( aName.indexOf( "FilledNet" ) != -1 )
 505             return "com.sun.star.chart.FilledNetDiagram";
 506
 507         // "Net" "NetSymbol" "NetLine" "StackedNet" "StackedNetSymbol"
 508         // "StackedNetLine" "PercentStackedNet" "PercentStackedNetSymbol"
 509         // "PercentStackedNetLine"
 510         if( aName.indexOf( "Net" ) != -1 )
 511             return "com.sun.star.chart.NetDiagram";
 512
 513         // "StockLowHighClose" "StockOpenLowHighClose" "StockVolumeLowHighClose"
 514         // "StockVolumeOpenLowHighClose"
 515         if( aName.indexOf( "Stock" ) != -1 )
 516             return "com.sun.star.chart.StockDiagram";
 517
 518         if( aName.indexOf( "Bubble" ) != -1 )
 519             return "com.sun.star.chart.BubbleDiagram";
 520
 521         // Note: this must be checked after Bar, Net and Scatter
 522
 523         // "Symbol" "StackedSymbol" "PercentStackedSymbol" "Line" "StackedLine"
 524         // "PercentStackedLine" "LineSymbol" "StackedLineSymbol"
 525         // "PercentStackedLineSymbol" "ThreeDLine" "StackedThreeDLine"
 526         // "PercentStackedThreeDLine" "ThreeDLineDeep"
 527         if( aName.indexOf( "Line" ) != -1 || aName.indexOf( "Symbol" ) != -1 )
 528             return "com.sun.star.chart.LineDiagram";
 529
 530         OSL_FAIL( "unknown template" );
 531     }
 532
 533     return OUString();
 534 }
 535
 536 typedef std::map< OUString, OUString > tMakeStringStringMap;
 537
 538 const tMakeStringStringMap& lcl_getChartTypeNameMap()
 539 {
 540     static tMakeStringStringMap g_aChartTypeNameMap{
 541         {"com.sun.star.chart2.LineChartType", "com.sun.star.chart.LineDiagram"},
 542         {"com.sun.star.chart2.AreaChartType", "com.sun.star.chart.AreaDiagram"},
 543         {"com.sun.star.chart2.ColumnChartType", "com.sun.star.chart.BarDiagram"},
 544         {"com.sun.star.chart2.PieChartType", "com.sun.star.chart.PieDiagram"},
 545         {"com.sun.star.chart2.DonutChartType", "com.sun.star.chart.DonutDiagram"},
 546         {"com.sun.star.chart2.ScatterChartType", "com.sun.star.chart.XYDiagram"},
 547         {"com.sun.star.chart2.FilledNetChartType", "com.sun.star.chart.FilledNetDiagram"},
 548         {"com.sun.star.chart2.NetChartType", "com.sun.star.chart.NetDiagram"},
 549         {"com.sun.star.chart2.CandleStickChartType", "com.sun.star.chart.StockDiagram"},
 550         {"com.sun.star.chart2.BubbleChartType", "com.sun.star.chart.BubbleDiagram"}
 551     };
 552     return g_aChartTypeNameMap;
 553 }
 554
 555 OUString lcl_getOldChartTypeName( const OUString & rNewChartTypeName )
 556 {
 557     OUString aOld(rNewChartTypeName);
 558
 559     const tMakeStringStringMap& rMap = lcl_getChartTypeNameMap();
 560     tMakeStringStringMap::const_iterator aIt( rMap.find( rNewChartTypeName ));
 561     if( aIt != rMap.end())
 562     {
 563         aOld = aIt->second;
 564     }
 565     return aOld;
 566 }
 567
 568 } // anonymous namespace
 569
 570 namespace chart
 571 {
 572 namespace wrapper
 573 {
 574
 575 DiagramWrapper::DiagramWrapper(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 576     : m_spChart2ModelContact(spChart2ModelContact)
 577     , m_aEventListenerContainer(m_aMutex)
 578 {
 579 }
 580
 581 DiagramWrapper::~DiagramWrapper()
 582 {}
 583
 584 // ____ XDiagram ____
 585 OUString SAL_CALL DiagramWrapper::getDiagramType()
 586 {
 587     OUString aRet;
 588
 589     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 590     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
 591     if( xChartDoc.is() && xDiagram.is() )
 592     {
 593         Reference< beans::XPropertySet > xChartDocProp( xChartDoc, uno::UNO_QUERY );
 594         if( xChartDocProp.is() )
 595         {
 596             uno::Reference< util::XRefreshable > xAddIn;
 597             if( xChartDocProp->getPropertyValue( "AddIn" ) >>= xAddIn )
 598             {
 599                 uno::Reference< lang::XServiceName > xServiceName( xAddIn, uno::UNO_QUERY );
 600                 if( xServiceName.is())
 601                     return xServiceName->getServiceName();
 602             }
 603         }
 604
 605         Reference< lang::XMultiServiceFactory > xChartTypeManager( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
 606         DiagramHelper::tTemplateWithServiceName aTemplateAndService =
 607             DiagramHelper::getTemplateForDiagram( xDiagram, xChartTypeManager );
 608
 609         aRet = lcl_getDiagramType( aTemplateAndService.second );
 610     }
 611
 612     if( aRet.isEmpty())
 613     {
 614         // none of the standard templates matched
 615         // use first chart type
 616         Reference< chart2::XChartType > xChartType( DiagramHelper::getChartTypeByIndex( xDiagram, 0 ) );
 617         if( xChartType.is() )
 618         {
 619             aRet = xChartType->getChartType();
 620             if( !aRet.isEmpty() )
 621                 aRet = lcl_getOldChartTypeName( aRet );
 622         }
 623         if( aRet.isEmpty())
 624             aRet = "com.sun.star.chart.BarDiagram";
 625     }
 626
 627     return aRet;
 628 }
 629
 630 Reference<
 631     beans::XPropertySet > SAL_CALL DiagramWrapper::getDataRowProperties( sal_Int32 nRow )
 632 {
 633     if( nRow < 0 )
 634         throw lang::IndexOutOfBoundsException("DataSeries index invalid",
 635                                               static_cast< ::cppu::OWeakObject * >( this ));
 636
 637     sal_Int32 nNewAPIIndex = lcl_getNewAPIIndexForOldAPIIndex( nRow, m_spChart2ModelContact->getChart2Diagram() );
 638     if( nNewAPIIndex < 0 )
 639         throw lang::IndexOutOfBoundsException("DataSeries index invalid",
 640                                               static_cast< ::cppu::OWeakObject * >( this ));
 641
 642     Reference< beans::XPropertySet > xRet( new DataSeriesPointWrapper(
 643           DataSeriesPointWrapper::DATA_SERIES, nNewAPIIndex, 0, m_spChart2ModelContact ) );
 644     return xRet;
 645 }
 646
 647 Reference<
 648     beans::XPropertySet > SAL_CALL DiagramWrapper::getDataPointProperties( sal_Int32 nCol, sal_Int32 nRow )
 649 {
 650     if( nCol < 0 || nRow < 0 )
 651         throw lang::IndexOutOfBoundsException("DataSeries index invalid",
 652                                               static_cast< ::cppu::OWeakObject * >( this ));
 653
 654     sal_Int32 nNewAPIIndex = lcl_getNewAPIIndexForOldAPIIndex( nRow, m_spChart2ModelContact->getChart2Diagram() );
 655     if( nNewAPIIndex < 0 )
 656         throw lang::IndexOutOfBoundsException("DataSeries index invalid",
 657                                               static_cast< ::cppu::OWeakObject * >( this ));
 658
 659     //todo: check borders of point index
 660
 661     Reference< beans::XPropertySet > xRet( new DataSeriesPointWrapper(
 662           DataSeriesPointWrapper::DATA_POINT, nNewAPIIndex, nCol, m_spChart2ModelContact ) );
 663
 664     return xRet;
 665 }
 666
 667 // ____ XShape (base of XDiagram) ____
 668 awt::Point SAL_CALL DiagramWrapper::getPosition()
 669 {
 670     awt::Point aPosition = ToPoint( m_spChart2ModelContact->GetDiagramRectangleIncludingAxes() );
 671     return aPosition;
 672 }
 673
 674 void SAL_CALL DiagramWrapper::setPosition( const awt::Point& aPosition )
 675 {
 676     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 677     Reference< beans::XPropertySet > xProp( getInnerPropertySet() );
 678     if( xProp.is() )
 679     {
 680         awt::Size aPageSize( m_spChart2ModelContact->GetPageSize() );
 681
 682         chart2::RelativePosition aRelativePosition;
 683         aRelativePosition.Anchor = drawing::Alignment_TOP_LEFT;
 684         aRelativePosition.Primary = double(aPosition.X)/double(aPageSize.Width);
 685         aRelativePosition.Secondary = double(aPosition.Y)/double(aPageSize.Height);
 686         if( aRelativePosition.Primary < 0 || aRelativePosition.Secondary < 0 || aRelativePosition.Primary > 1 || aRelativePosition.Secondary > 1 )
 687         {
 688             OSL_FAIL("DiagramWrapper::setPosition called with a position out of range -> automatic values are taken instead" );
 689             uno::Any aEmpty;
 690             xProp->setPropertyValue( "RelativePosition", aEmpty );
 691             return;
 692         }
 693         xProp->setPropertyValue( "RelativePosition", uno::Any(aRelativePosition) );
 694         xProp->setPropertyValue( "PosSizeExcludeAxes", uno::Any(false) );
 695     }
 696 }
 697
 698 awt::Size SAL_CALL DiagramWrapper::getSize()
 699 {
 700     awt::Size aSize = ToSize( m_spChart2ModelContact->GetDiagramRectangleIncludingAxes() );
 701     return aSize;
 702 }
 703
 704 void SAL_CALL DiagramWrapper::setSize( const awt::Size& aSize )
 705 {
 706     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 707     Reference< beans::XPropertySet > xProp( getInnerPropertySet() );
 708     if( xProp.is() )
 709     {
 710         awt::Size aPageSize( m_spChart2ModelContact->GetPageSize() );
 711
 712         chart2::RelativeSize aRelativeSize;
 713         aRelativeSize.Primary = double(aSize.Width)/double(aPageSize.Width);
 714         aRelativeSize.Secondary = double(aSize.Height)/double(aPageSize.Height);
 715
 716         if( aRelativeSize.Primary > 1 || aRelativeSize.Secondary > 1 )
 717         {
 718             OSL_FAIL("DiagramWrapper::setSize called with sizes bigger than page -> automatic values are taken instead" );
 719             uno::Any aEmpty;
 720             xProp->setPropertyValue( "RelativeSize", aEmpty );
 721             return;
 722         }
 723
 724         xProp->setPropertyValue( "RelativeSize", uno::Any(aRelativeSize) );
 725         xProp->setPropertyValue( "PosSizeExcludeAxes", uno::Any(false) );
 726     }
 727 }
 728
 729 // ____ XShapeDescriptor (base of XShape) ____
 730 OUString SAL_CALL DiagramWrapper::getShapeType()
 731 {
 732     return "com.sun.star.chart.Diagram";
 733 }
 734
 735 // ____ XDiagramPositioning ____
 736
 737 void SAL_CALL DiagramWrapper::setAutomaticDiagramPositioning()
 738 {
 739     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 740     uno::Reference< beans::XPropertySet > xDiaProps( getDiagram(), uno::UNO_QUERY );
 741     if( xDiaProps.is() )
 742     {
 743         xDiaProps->setPropertyValue( "RelativeSize", Any() );
 744         xDiaProps->setPropertyValue( "RelativePosition", Any() );
 745     }
 746 }
 747 sal_Bool SAL_CALL DiagramWrapper::isAutomaticDiagramPositioning(  )
 748 {
 749     uno::Reference< beans::XPropertySet > xDiaProps( getDiagram(), uno::UNO_QUERY );
 750     if( xDiaProps.is() )
 751     {
 752         Any aRelativeSize( xDiaProps->getPropertyValue( "RelativeSize" ) );
 753         Any aRelativePosition( xDiaProps->getPropertyValue( "RelativePosition" ) );
 754         if( aRelativeSize.hasValue() && aRelativePosition.hasValue() )
 755             return false;
 756     }
 757     return true;
 758 }
 759 void SAL_CALL DiagramWrapper::setDiagramPositionExcludingAxes( const awt::Rectangle& rPositionRect )
 760 {
 761     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 762     DiagramHelper::setDiagramPositioning( m_spChart2ModelContact->getChartModel(), rPositionRect );
 763     uno::Reference< beans::XPropertySet > xDiaProps( getDiagram(), uno::UNO_QUERY );
 764     if( xDiaProps.is() )
 765         xDiaProps->setPropertyValue("PosSizeExcludeAxes", uno::Any(true) );
 766 }
 767 sal_Bool SAL_CALL DiagramWrapper::isExcludingDiagramPositioning()
 768 {
 769     uno::Reference< beans::XPropertySet > xDiaProps( getDiagram(), uno::UNO_QUERY );
 770     if( xDiaProps.is() )
 771     {
 772         Any aRelativeSize( xDiaProps->getPropertyValue( "RelativeSize" ) );
 773         Any aRelativePosition( xDiaProps->getPropertyValue( "RelativePosition" ) );
 774         if( aRelativeSize.hasValue() && aRelativePosition.hasValue() )
 775         {
 776             bool bPosSizeExcludeAxes = false;
 777             xDiaProps->getPropertyValue( "PosSizeExcludeAxes" ) >>= bPosSizeExcludeAxes;
 778             return bPosSizeExcludeAxes;
 779         }
 780     }
 781     return false;
 782 }
 783 awt::Rectangle SAL_CALL DiagramWrapper::calculateDiagramPositionExcludingAxes(  )
 784 {
 785     return m_spChart2ModelContact->GetDiagramRectangleExcludingAxes();
 786 }
 787 void SAL_CALL DiagramWrapper::setDiagramPositionIncludingAxes( const awt::Rectangle& rPositionRect )
 788 {
 789     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 790     DiagramHelper::setDiagramPositioning( m_spChart2ModelContact->getChartModel(), rPositionRect );
 791     uno::Reference< beans::XPropertySet > xDiaProps( getDiagram(), uno::UNO_QUERY );
 792     if( xDiaProps.is() )
 793         xDiaProps->setPropertyValue("PosSizeExcludeAxes", uno::Any(false) );
 794 }
 795 awt::Rectangle SAL_CALL DiagramWrapper::calculateDiagramPositionIncludingAxes(  )
 796 {
 797     return m_spChart2ModelContact->GetDiagramRectangleIncludingAxes();
 798 }
 799 void SAL_CALL DiagramWrapper::setDiagramPositionIncludingAxesAndAxisTitles( const awt::Rectangle& rPositionRect )
 800 {
 801     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 802     awt::Rectangle aRect( m_spChart2ModelContact->SubstractAxisTitleSizes(rPositionRect) );
 803     DiagramWrapper::setDiagramPositionIncludingAxes( aRect );
 804 }
 805 css::awt::Rectangle SAL_CALL DiagramWrapper::calculateDiagramPositionIncludingAxesAndAxisTitles(  )
 806 {
 807     return m_spChart2ModelContact->GetDiagramRectangleIncludingTitle();
 808 }
 809
 810 // ____ XAxisSupplier ____
 811 Reference< XAxis > SAL_CALL DiagramWrapper::getAxis( sal_Int32 nDimensionIndex )
 812 {
 813     Reference< XAxis > xAxis;
 814     if(!nDimensionIndex)
 815     {
 816         if( !m_xXAxis.is() )
 817             m_xXAxis = new AxisWrapper( AxisWrapper::X_AXIS, m_spChart2ModelContact );
 818         xAxis = m_xXAxis;
 819     }
 820     else if(nDimensionIndex==1)
 821     {
 822         if( !m_xYAxis.is() )
 823             m_xYAxis = new AxisWrapper( AxisWrapper::Y_AXIS, m_spChart2ModelContact );
 824         xAxis = m_xYAxis;
 825     }
 826     else if(nDimensionIndex==2)
 827     {
 828         if( !m_xZAxis.is() )
 829             m_xZAxis = new AxisWrapper( AxisWrapper::Z_AXIS, m_spChart2ModelContact );
 830         xAxis = m_xZAxis;
 831     }
 832     return xAxis;
 833 }
 834
 835 Reference< XAxis > SAL_CALL DiagramWrapper::getSecondaryAxis( sal_Int32 nDimensionIndex )
 836 {
 837     Reference< XAxis > xAxis;
 838     if(!nDimensionIndex)
 839     {
 840         if( !m_xSecondXAxis.is() )
 841             m_xSecondXAxis = new AxisWrapper( AxisWrapper::SECOND_X_AXIS, m_spChart2ModelContact );
 842         xAxis = m_xSecondXAxis;
 843     }
 844     else if(nDimensionIndex==1)
 845     {
 846         if( !m_xSecondYAxis.is() )
 847             m_xSecondYAxis = new AxisWrapper( AxisWrapper::SECOND_Y_AXIS, m_spChart2ModelContact );
 848         xAxis = m_xSecondYAxis;
 849     }
 850     return xAxis;
 851 }
 852
 853 // ____ XAxisZSupplier ____
 854 Reference< drawing::XShape > SAL_CALL DiagramWrapper::getZAxisTitle()
 855 {
 856     Reference< drawing::XShape > xRet;
 857     Reference< XAxis > xAxis( getAxis(2) );
 858     if( xAxis.is() )
 859         xRet.set( xAxis->getAxisTitle(), uno::UNO_QUERY );
 860     return xRet;
 861 }
 862
 863 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getZMainGrid()
 864 {
 865     Reference< beans::XPropertySet > xRet;
 866     Reference< XAxis > xAxis( getAxis(2) );
 867     if( xAxis.is() )
 868         xRet = xAxis->getMajorGrid();
 869     return xRet;
 870 }
 871
 872 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getZHelpGrid()
 873 {
 874     Reference< beans::XPropertySet > xRet;
 875     Reference< XAxis > xAxis( getAxis(2) );
 876     if( xAxis.is() )
 877         xRet = xAxis->getMinorGrid();
 878     return xRet;
 879 }
 880
 881 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getZAxis()
 882 {
 883     if( ! m_xZAxis.is())
 884         m_xZAxis = new AxisWrapper( AxisWrapper::Z_AXIS, m_spChart2ModelContact );
 885     return Reference< beans::XPropertySet >( m_xZAxis, uno::UNO_QUERY );
 886 }
 887
 888 // ____ XTwoAxisXSupplier ____
 889 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getSecondaryXAxis()
 890 {
 891     if( ! m_xSecondXAxis.is())
 892         m_xSecondXAxis = new AxisWrapper( AxisWrapper::SECOND_X_AXIS, m_spChart2ModelContact );
 893     return Reference< beans::XPropertySet >( m_xSecondXAxis, uno::UNO_QUERY );
 894 }
 895
 896 // ____ XAxisXSupplier (base of XTwoAxisXSupplier) ____
 897 Reference< drawing::XShape > SAL_CALL DiagramWrapper::getXAxisTitle()
 898 {
 899     Reference< drawing::XShape > xRet;
 900     Reference< XAxis > xAxis( getAxis(0) );
 901     if( xAxis.is() )
 902         xRet.set( xAxis->getAxisTitle(), uno::UNO_QUERY );
 903     return xRet;
 904 }
 905
 906 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getXAxis()
 907 {
 908     if( ! m_xXAxis.is())
 909         m_xXAxis = new AxisWrapper( AxisWrapper::X_AXIS, m_spChart2ModelContact );
 910     return Reference< beans::XPropertySet >( m_xXAxis, uno::UNO_QUERY );
 911 }
 912
 913 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getXMainGrid()
 914 {
 915     Reference< beans::XPropertySet > xRet;
 916     Reference< XAxis > xAxis( getAxis(0) );
 917     if( xAxis.is() )
 918         xRet = xAxis->getMajorGrid();
 919     return xRet;
 920 }
 921
 922 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getXHelpGrid()
 923 {
 924     Reference< beans::XPropertySet > xRet;
 925     Reference< XAxis > xAxis( getAxis(0) );
 926     if( xAxis.is() )
 927         xRet = xAxis->getMinorGrid();
 928     return xRet;
 929 }
 930
 931 // ____ XTwoAxisYSupplier ____
 932 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getSecondaryYAxis()
 933 {
 934     if( ! m_xSecondYAxis.is())
 935         m_xSecondYAxis = new AxisWrapper( AxisWrapper::SECOND_Y_AXIS, m_spChart2ModelContact );
 936     return Reference< beans::XPropertySet >( m_xSecondYAxis, uno::UNO_QUERY );
 937 }
 938
 939 // ____ XAxisYSupplier (base of XTwoAxisYSupplier) ____
 940 Reference< drawing::XShape > SAL_CALL DiagramWrapper::getYAxisTitle()
 941 {
 942     Reference< drawing::XShape > xRet;
 943     Reference< XAxis > xAxis( getAxis(1) );
 944     if( xAxis.is() )
 945         xRet.set( xAxis->getAxisTitle(), uno::UNO_QUERY );
 946     return xRet;
 947 }
 948
 949 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getYAxis()
 950 {
 951     if( ! m_xYAxis.is())
 952         m_xYAxis = new AxisWrapper( AxisWrapper::Y_AXIS, m_spChart2ModelContact );
 953     return Reference< beans::XPropertySet >( m_xYAxis, uno::UNO_QUERY );
 954 }
 955
 956 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getYMainGrid()
 957 {
 958     Reference< beans::XPropertySet > xRet;
 959     Reference< XAxis > xAxis( getAxis(1) );
 960     if( xAxis.is() )
 961         xRet = xAxis->getMajorGrid();
 962     return xRet;
 963 }
 964
 965 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getYHelpGrid()
 966 {
 967     Reference< beans::XPropertySet > xRet;
 968     Reference< XAxis > xAxis( getAxis(1) );
 969     if( xAxis.is() )
 970         xRet = xAxis->getMinorGrid();
 971     return xRet;
 972 }
 973
 974 // ____ XSecondAxisTitleSupplier ____
 975 Reference< drawing::XShape > SAL_CALL DiagramWrapper::getSecondXAxisTitle()
 976 {
 977     Reference< drawing::XShape > xRet;
 978     Reference< XAxis > xAxis( getSecondaryAxis(0) );
 979     if( xAxis.is() )
 980         xRet.set( xAxis->getAxisTitle(), uno::UNO_QUERY );
 981     return xRet;
 982 }
 983
 984 Reference< drawing::XShape > SAL_CALL DiagramWrapper::getSecondYAxisTitle()
 985 {
 986     Reference< drawing::XShape > xRet;
 987     Reference< XAxis > xAxis( getSecondaryAxis(1) );
 988     if( xAxis.is() )
 989         xRet.set( xAxis->getAxisTitle(), uno::UNO_QUERY );
 990     return xRet;
 991 }
 992
 993 // ____ XStatisticDisplay ____
 994 Reference<
 995     beans::XPropertySet > SAL_CALL DiagramWrapper::getUpBar()
 996 {
 997     if( !m_xUpBarWrapper.is() )
 998     {
 999         m_xUpBarWrapper = new UpDownBarWrapper( true, m_spChart2ModelContact );
1000     }
1001     return m_xUpBarWrapper;
1002 }
1003
1004 Reference<
1005     beans::XPropertySet > SAL_CALL DiagramWrapper::getDownBar()
1006 {
1007     if( !m_xDownBarWrapper.is() )
1008     {
1009         m_xDownBarWrapper = new UpDownBarWrapper( false, m_spChart2ModelContact );
1010     }
1011     return m_xDownBarWrapper;
1012 }
1013
1014 Reference<
1015     beans::XPropertySet > SAL_CALL DiagramWrapper::getMinMaxLine()
1016 {
1017     if( !m_xMinMaxLineWrapper.is() )
1018     {
1019         m_xMinMaxLineWrapper = new MinMaxLineWrapper( m_spChart2ModelContact );
1020     }
1021     return m_xMinMaxLineWrapper;
1022 }
1023
1024 // ____ X3DDisplay ____
1025 Reference< beans::XPropertySet > SAL_CALL DiagramWrapper::getWall()
1026 {
1027     if( !m_xWall.is() )
1028     {
1029         m_xWall = new WallFloorWrapper( true, m_spChart2ModelContact );
1030     }
1031     return m_xWall;
1032 }
1033
1034 Reference<
1035     beans::XPropertySet > SAL_CALL DiagramWrapper::getFloor()
1036 {
1037     if( !m_xFloor.is() )
1038     {
1039         m_xFloor = new WallFloorWrapper( false, m_spChart2ModelContact );
1040     }
1041     return m_xFloor;
1042 }
1043
1044 // ____ X3DDefaultSetter ____
1045 void SAL_CALL DiagramWrapper::set3DSettingsToDefault()
1046 {
1047     Reference< X3DDefaultSetter > x3DDefaultSetter( m_spChart2ModelContact->getChart2Diagram(), uno::UNO_QUERY );
1048     if( x3DDefaultSetter.is() )
1049         x3DDefaultSetter->set3DSettingsToDefault();
1050 }
1051
1052 void SAL_CALL DiagramWrapper::setDefaultRotation()
1053 {
1054     Reference< X3DDefaultSetter > x3DDefaultSetter( m_spChart2ModelContact->getChart2Diagram(), uno::UNO_QUERY );
1055     if( x3DDefaultSetter.is() )
1056         x3DDefaultSetter->setDefaultRotation();
1057 }
1058
1059 void SAL_CALL DiagramWrapper::setDefaultIllumination()
1060 {
1061     Reference< X3DDefaultSetter > x3DDefaultSetter( m_spChart2ModelContact->getChart2Diagram(), uno::UNO_QUERY );
1062     if( x3DDefaultSetter.is() )
1063         x3DDefaultSetter->setDefaultIllumination();
1064 }
1065
1066 // ____ XComponent ____
1067 void SAL_CALL DiagramWrapper::dispose()
1068 {
1069     m_aEventListenerContainer.disposeAndClear( lang::EventObject( static_cast< ::cppu::OWeakObject* >( this )));
1070
1071     MutexGuard aGuard( m_aMutex);
1072
1073     DisposeHelper::DisposeAndClear( m_xXAxis );
1074     DisposeHelper::DisposeAndClear( m_xYAxis );
1075     DisposeHelper::DisposeAndClear( m_xZAxis );
1076     DisposeHelper::DisposeAndClear( m_xSecondXAxis );
1077     DisposeHelper::DisposeAndClear( m_xSecondYAxis );
1078     DisposeHelper::DisposeAndClear( m_xWall );
1079     DisposeHelper::DisposeAndClear( m_xFloor );
1080     DisposeHelper::DisposeAndClear( m_xMinMaxLineWrapper );
1081     DisposeHelper::DisposeAndClear( m_xUpBarWrapper );
1082     DisposeHelper::DisposeAndClear( m_xDownBarWrapper );
1083
1084     clearWrappedPropertySet();
1085 }
1086
1087 void SAL_CALL DiagramWrapper::addEventListener(
1088     const Reference< lang::XEventListener >& xListener )
1089 {
1090     m_aEventListenerContainer.addInterface( xListener );
1091 }
1092
1093 void SAL_CALL DiagramWrapper::removeEventListener(
1094     const Reference< lang::XEventListener >& aListener )
1095 {
1096     m_aEventListenerContainer.removeInterface( aListener );
1097 }
1098
1099 //PROP_DIAGRAM_DATAROW_SOURCE
1100 class WrappedDataRowSourceProperty : public WrappedProperty
1101 {
1102 public:
1103     explicit WrappedDataRowSourceProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1104
1105     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1106
1107     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1108
1109     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1110
1111 private: //member
1112     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1113     mutable Any                                 m_aOuterValue;
1114 };
1115
1116 WrappedDataRowSourceProperty::WrappedDataRowSourceProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1117             : WrappedProperty("DataRowSource",OUString())
1118             , m_spChart2ModelContact( spChart2ModelContact )
1119             , m_aOuterValue()
1120 {
1121     m_aOuterValue = WrappedDataRowSourceProperty::getPropertyDefault( nullptr );
1122 }
1123
1124 void WrappedDataRowSourceProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1125 {
1126     css::chart::ChartDataRowSource eChartDataRowSource = css::chart::ChartDataRowSource_ROWS;
1127     if( ! (rOuterValue >>= eChartDataRowSource) )
1128     {
1129         sal_Int32 nNew = sal_Int32(css::chart::ChartDataRowSource_ROWS);
1130         if( !(rOuterValue >>= nNew) )
1131             throw lang::IllegalArgumentException( "Property DataRowSource requires css::chart::ChartDataRowSource value", nullptr, 0 );
1132         eChartDataRowSource = css::chart::ChartDataRowSource(nNew);
1133     }
1134
1135     m_aOuterValue = rOuterValue;
1136
1137     bool bNewUseColumns = eChartDataRowSource == css::chart::ChartDataRowSource_COLUMNS;
1138
1139     OUString aRangeString;
1140     bool bUseColumns = true;
1141     bool bFirstCellAsLabel = true;
1142     bool bHasCategories = true;
1143     uno::Sequence< sal_Int32 > aSequenceMapping;
1144
1145     if( DataSourceHelper::detectRangeSegmentation(
1146             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
1147             , bFirstCellAsLabel, bHasCategories ) )
1148     {
1149         if( bUseColumns != bNewUseColumns )
1150         {
1151             aSequenceMapping.realloc(0);
1152             DataSourceHelper::setRangeSegmentation(
1153                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bNewUseColumns , bFirstCellAsLabel , bHasCategories);
1154         }
1155     }
1156 }
1157
1158 Any WrappedDataRowSourceProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1159 {
1160     OUString aRangeString;
1161     bool bUseColumns = true;
1162     bool bFirstCellAsLabel = true;
1163     bool bHasCategories = true;
1164     uno::Sequence< sal_Int32 > aSequenceMapping;
1165
1166     if( DataSourceHelper::detectRangeSegmentation(
1167             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
1168             , bFirstCellAsLabel, bHasCategories ) )
1169     {
1170         css::chart::ChartDataRowSource eChartDataRowSource = css::chart::ChartDataRowSource_ROWS;
1171         if(bUseColumns)
1172             eChartDataRowSource = css::chart::ChartDataRowSource_COLUMNS;
1173
1174         m_aOuterValue <<= eChartDataRowSource;
1175     }
1176
1177     return m_aOuterValue;
1178 }
1179
1180 Any WrappedDataRowSourceProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1181 {
1182     Any aRet;
1183     aRet <<= css::chart::ChartDataRowSource_COLUMNS;
1184     return aRet;
1185 }
1186
1187 //PROP_DIAGRAM_STACKED
1188 //PROP_DIAGRAM_DEEP
1189 //PROP_DIAGRAM_PERCENT_STACKED
1190 class WrappedStackingProperty : public WrappedProperty
1191 {
1192 public:
1193     WrappedStackingProperty(StackMode eStackMode, const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1194
1195     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1196
1197     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1198
1199     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1200
1201 protected: //methods
1202     bool    detectInnerValue( StackMode& eInnerStackMode ) const;
1203
1204 private: //member
1205 std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1206     const StackMode                         m_eStackMode;
1207     mutable Any                             m_aOuterValue;
1208 };
1209
1210 WrappedStackingProperty::WrappedStackingProperty(StackMode eStackMode, const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1211             : WrappedProperty(OUString(),OUString())
1212             , m_spChart2ModelContact( spChart2ModelContact )
1213             , m_eStackMode( eStackMode )
1214             , m_aOuterValue()
1215 {
1216     switch( m_eStackMode )
1217     {
1218     case StackMode::YStacked:
1219         m_aOuterName = "Stacked";
1220         break;
1221     case StackMode::YStackedPercent:
1222         m_aOuterName = "Percent";
1223         break;
1224     case StackMode::ZStacked:
1225         m_aOuterName = "Deep";
1226         break;
1227     default:
1228         OSL_FAIL( "unexpected stack mode" );
1229         break;
1230     }
1231 }
1232
1233 bool WrappedStackingProperty::detectInnerValue( StackMode& eStackMode ) const
1234 {
1235     bool bHasDetectableInnerValue = false;
1236     bool bIsAmbiguous = false;
1237     eStackMode = DiagramHelper::getStackMode( m_spChart2ModelContact->getChart2Diagram()
1238         , bHasDetectableInnerValue, bIsAmbiguous );
1239     return bHasDetectableInnerValue;
1240 }
1241
1242 void WrappedStackingProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1243 {
1244     bool bNewValue = false;
1245     if( ! (rOuterValue >>= bNewValue) )
1246         throw lang::IllegalArgumentException( "Stacking Properties require boolean values", nullptr, 0 );
1247
1248     StackMode eInnerStackMode;
1249     bool bHasDetectableInnerValue = detectInnerValue( eInnerStackMode );
1250
1251     if( !bHasDetectableInnerValue )
1252     {
1253         m_aOuterValue = rOuterValue;
1254         return;
1255     }
1256
1257     if( bNewValue && eInnerStackMode == m_eStackMode )
1258         return;
1259     if( !bNewValue && eInnerStackMode != m_eStackMode )
1260         return;
1261
1262     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1263     if( xDiagram.is() )
1264     {
1265         StackMode eNewStackMode = bNewValue ? m_eStackMode : StackMode::NONE;
1266         DiagramHelper::setStackMode( xDiagram, eNewStackMode );
1267     }
1268 }
1269
1270 Any WrappedStackingProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1271 {
1272     StackMode eInnerStackMode;
1273     if( detectInnerValue( eInnerStackMode ) )
1274     {
1275         bool bValue = (eInnerStackMode == m_eStackMode);
1276         return Any(bValue);
1277     }
1278     return m_aOuterValue;
1279 }
1280
1281 Any WrappedStackingProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1282 {
1283     Any aRet;
1284     aRet <<= false;
1285     return aRet;
1286 }
1287
1288 //PROP_DIAGRAM_THREE_D
1289 class WrappedDim3DProperty : public WrappedProperty
1290 {
1291 public:
1292     explicit WrappedDim3DProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1293
1294     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1295
1296     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1297
1298     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1299
1300 private: //member
1301     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1302     mutable Any                                 m_aOuterValue;
1303 };
1304
1305 WrappedDim3DProperty::WrappedDim3DProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1306             : WrappedProperty("Dim3D",OUString())
1307             , m_spChart2ModelContact( spChart2ModelContact )
1308             , m_aOuterValue()
1309 {
1310     m_aOuterValue = WrappedDim3DProperty::getPropertyDefault( nullptr );
1311 }
1312
1313 void WrappedDim3DProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1314 {
1315     bool bNew3D = false;
1316     if( ! (rOuterValue >>= bNew3D) )
1317         throw lang::IllegalArgumentException( "Property Dim3D requires boolean value", nullptr, 0 );
1318
1319     m_aOuterValue = rOuterValue;
1320
1321     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1322     if( !xDiagram.is() )
1323         return;
1324
1325     bool bOld3D = DiagramHelper::getDimension( xDiagram ) == 3;
1326     if( bOld3D != bNew3D )
1327         DiagramHelper::setDimension( xDiagram, bNew3D ? 3 : 2 );
1328 }
1329
1330 Any WrappedDim3DProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1331 {
1332     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1333     if( xDiagram.is() )
1334     {
1335         bool b3D = DiagramHelper::getDimension( xDiagram ) == 3;
1336         m_aOuterValue <<= b3D;
1337     }
1338     return m_aOuterValue;
1339 }
1340
1341 Any WrappedDim3DProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1342 {
1343     Any aRet;
1344     aRet <<= false;
1345     return aRet;
1346 }
1347
1348 //PROP_DIAGRAM_VERTICAL
1349 class WrappedVerticalProperty : public WrappedProperty
1350 {
1351 public:
1352     explicit WrappedVerticalProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1353
1354     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1355
1356     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1357
1358     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1359
1360 private: //member
1361     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1362     mutable Any                                 m_aOuterValue;
1363 };
1364
1365 WrappedVerticalProperty::WrappedVerticalProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1366             : WrappedProperty("Vertical",OUString())
1367             , m_spChart2ModelContact( spChart2ModelContact )
1368             , m_aOuterValue()
1369 {
1370     m_aOuterValue = WrappedVerticalProperty::getPropertyDefault( nullptr );
1371 }
1372
1373 void WrappedVerticalProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1374 {
1375     bool bNewVertical = false;
1376     if( ! (rOuterValue >>= bNewVertical) )
1377         throw lang::IllegalArgumentException( "Property Vertical requires boolean value", nullptr, 0 );
1378
1379     m_aOuterValue = rOuterValue;
1380
1381     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1382     if( !xDiagram.is() )
1383         return;
1384
1385     bool bFound = false;
1386     bool bAmbiguous = false;
1387     bool bOldVertical = DiagramHelper::getVertical( xDiagram, bFound, bAmbiguous );
1388     if( bFound && ( bOldVertical != bNewVertical || bAmbiguous ) )
1389         DiagramHelper::setVertical( xDiagram, bNewVertical );
1390 }
1391
1392 Any WrappedVerticalProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1393 {
1394     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1395     if( xDiagram.is() )
1396     {
1397         bool bFound = false;
1398         bool bAmbiguous = false;
1399         bool bVertical = DiagramHelper::getVertical( xDiagram, bFound, bAmbiguous );
1400         if( bFound )
1401             m_aOuterValue <<= bVertical;
1402     }
1403     return m_aOuterValue;
1404 }
1405
1406 Any WrappedVerticalProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1407 {
1408     Any aRet;
1409     aRet <<= false;
1410     return aRet;
1411 }
1412
1413 //PROP_DIAGRAM_NUMBER_OF_LINES
1414 class WrappedNumberOfLinesProperty : public WrappedProperty
1415 {
1416 public:
1417     explicit WrappedNumberOfLinesProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1418
1419     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1420
1421     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1422
1423     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1424
1425 protected: //methods
1426     bool    detectInnerValue( uno::Any& rInnerValue ) const;
1427
1428 private: //member
1429     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1430     mutable Any                                 m_aOuterValue;
1431 };
1432
1433 WrappedNumberOfLinesProperty::WrappedNumberOfLinesProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1434             : WrappedProperty("NumberOfLines",OUString())
1435             , m_spChart2ModelContact( spChart2ModelContact )
1436             , m_aOuterValue( getPropertyDefault(nullptr) )
1437 {
1438 }
1439
1440 bool WrappedNumberOfLinesProperty::detectInnerValue( uno::Any& rInnerValue ) const
1441 {
1442     sal_Int32 nNumberOfLines = 0;
1443     bool bHasDetectableInnerValue = false;
1444     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1445     uno::Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
1446     if( xDiagram.is() && xChartDoc.is() )
1447     {
1448         std::vector< uno::Reference< chart2::XDataSeries > > aSeriesVector(
1449             DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
1450         if( !aSeriesVector.empty() )
1451         {
1452             Reference< lang::XMultiServiceFactory > xFact( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
1453             DiagramHelper::tTemplateWithServiceName aTemplateAndService =
1454                     DiagramHelper::getTemplateForDiagram( xDiagram, xFact );
1455             if( aTemplateAndService.second == "com.sun.star.chart2.template.ColumnWithLine" )
1456             {
1457                 try
1458                 {
1459                     uno::Reference< beans::XPropertySet > xProp( aTemplateAndService.first, uno::UNO_QUERY );
1460                     xProp->getPropertyValue( m_aOuterName ) >>= nNumberOfLines;
1461                     bHasDetectableInnerValue = true;
1462                 }
1463                 catch( const uno::Exception & )
1464                 {
1465                     DBG_UNHANDLED_EXCEPTION("chart2");
1466                 }
1467             }
1468         }
1469     }
1470     if(bHasDetectableInnerValue)
1471         rInnerValue <<= nNumberOfLines;
1472     return bHasDetectableInnerValue;
1473 }
1474
1475 void WrappedNumberOfLinesProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1476 {
1477     sal_Int32 nNewValue;
1478     if( ! (rOuterValue >>= nNewValue) )
1479         throw lang::IllegalArgumentException( "property NumberOfLines requires sal_Int32 value", nullptr, 0 );
1480
1481     m_aOuterValue = rOuterValue;
1482
1483     uno::Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
1484     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1485     sal_Int32 nDimension = ::chart::DiagramHelper::getDimension( xDiagram );
1486     if( xChartDoc.is() && xDiagram.is() && nDimension == 2 )
1487     {
1488         Reference< lang::XMultiServiceFactory > xFact( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
1489         DiagramHelper::tTemplateWithServiceName aTemplateAndService =
1490                 DiagramHelper::getTemplateForDiagram( xDiagram, xFact );
1491
1492         uno::Reference< chart2::XChartTypeTemplate > xTemplate;
1493         if( aTemplateAndService.second == "com.sun.star.chart2.template.ColumnWithLine" )
1494         {
1495             if( nNewValue != 0 )
1496             {
1497                 xTemplate.set( aTemplateAndService.first );
1498                 try
1499                 {
1500                     sal_Int32 nOldValue = 0;
1501                     uno::Reference< beans::XPropertySet > xProp( xTemplate, uno::UNO_QUERY );
1502                     xProp->getPropertyValue( m_aOuterName ) >>= nOldValue;
1503                     if( nOldValue == nNewValue )
1504                         return;
1505                 }
1506                 catch( const uno::Exception & )
1507                 {
1508                     DBG_UNHANDLED_EXCEPTION("chart2");
1509                 }
1510             }
1511             else
1512             {
1513                 xTemplate.set( xFact->createInstance("com.sun.star.chart2.template.Column"), uno::UNO_QUERY );
1514             }
1515         }
1516         else if( aTemplateAndService.second == "com.sun.star.chart2.template.Column" )
1517         {
1518             if( nNewValue == 0 )
1519                 return;
1520             xTemplate.set( xFact->createInstance( "com.sun.star.chart2.template.ColumnWithLine" ), uno::UNO_QUERY );
1521         }
1522
1523         if(xTemplate.is())
1524         {
1525             try
1526             {
1527                 // locked controllers
1528                 ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
1529                 uno::Reference< beans::XPropertySet > xProp( xTemplate, uno::UNO_QUERY );
1530                 xProp->setPropertyValue( "NumberOfLines", uno::Any(nNewValue) );
1531                 xTemplate->changeDiagram( xDiagram );
1532             }
1533             catch( const uno::Exception & )
1534             {
1535                 DBG_UNHANDLED_EXCEPTION("chart2");
1536             }
1537         }
1538     }
1539 }
1540
1541 Any WrappedNumberOfLinesProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1542 {
1543     Any aRet;
1544     if( !detectInnerValue( aRet ) )
1545         aRet = m_aOuterValue;
1546     return aRet;
1547 }
1548
1549 Any WrappedNumberOfLinesProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1550 {
1551     Any aRet;
1552     aRet <<= sal_Int32( 0 );
1553     return aRet;
1554 }
1555
1556 //PROP_DIAGRAM_ATTRIBUTED_DATA_POINTS
1557 class WrappedAttributedDataPointsProperty : public WrappedProperty
1558 {
1559 public:
1560     explicit WrappedAttributedDataPointsProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1561
1562     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1563
1564     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1565
1566     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1567
1568 private: //member
1569     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1570     mutable Any                                 m_aOuterValue;
1571 };
1572
1573 WrappedAttributedDataPointsProperty::WrappedAttributedDataPointsProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1574             : WrappedProperty("AttributedDataPoints",OUString())
1575             , m_spChart2ModelContact( spChart2ModelContact )
1576             , m_aOuterValue()
1577 {
1578     m_aOuterValue = WrappedAttributedDataPointsProperty::getPropertyDefault( nullptr );
1579 }
1580
1581 void WrappedAttributedDataPointsProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1582 {
1583     uno::Sequence< uno::Sequence< sal_Int32 > > aNewValue;
1584     if( ! (rOuterValue >>= aNewValue) )
1585         throw lang::IllegalArgumentException( "Property AttributedDataPoints requires value of type uno::Sequence< uno::Sequence< sal_Int32 > >", nullptr, 0 );
1586
1587     m_aOuterValue = rOuterValue;
1588
1589     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1590     Reference< beans::XPropertySet > xDiaProp( xDiagram, uno::UNO_QUERY );
1591
1592     if( xDiagram.is() && xDiaProp.is())
1593     {
1594         std::vector< Reference< chart2::XDataSeries > > aSeriesVector(
1595             ::chart::DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
1596         sal_Int32 i = 0;
1597         for (auto const& series : aSeriesVector)
1598         {
1599             Reference< beans::XPropertySet > xProp(series, uno::UNO_QUERY);
1600             if( xProp.is())
1601             {
1602                 uno::Any aVal;
1603                 if( i < aNewValue.getLength() )
1604                     aVal <<= aNewValue[i];
1605                 else
1606                 {
1607                     //set empty sequence
1608                     uno::Sequence< sal_Int32 > aSeq;
1609                     aVal <<= aSeq;
1610                 }
1611                 xProp->setPropertyValue( "AttributedDataPoints", aVal );
1612             }
1613             ++i;
1614         }
1615     }
1616 }
1617
1618 Any WrappedAttributedDataPointsProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1619 {
1620     Reference< chart2::XDiagram >    xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1621     Reference< beans::XPropertySet > xDiaProp( xDiagram, uno::UNO_QUERY );
1622
1623     if( xDiagram.is() && xDiaProp.is())
1624     {
1625         std::vector< Reference< chart2::XDataSeries > > aSeriesVector(
1626             ::chart::DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
1627
1628         uno::Sequence< uno::Sequence< sal_Int32 > > aResult( aSeriesVector.size() );
1629
1630         sal_Int32 i = 0;
1631         for (auto const& series : aSeriesVector)
1632         {
1633             Reference< beans::XPropertySet > xProp(series, uno::UNO_QUERY);
1634             if( xProp.is())
1635             {
1636                 uno::Any aVal(
1637                     xProp->getPropertyValue("AttributedDataPoints"));
1638                 uno::Sequence< sal_Int32 > aSeq;
1639                 if( aVal >>= aSeq )
1640                     aResult[ i ] = aSeq;
1641             }
1642             ++i;
1643         }
1644         m_aOuterValue <<= aResult;
1645     }
1646     return m_aOuterValue;
1647 }
1648
1649 Any WrappedAttributedDataPointsProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1650 {
1651     Any aRet;
1652     uno::Sequence< uno::Sequence< sal_Int32 > > aSeq;
1653     aRet <<= aSeq;
1654     return aRet;
1655 }
1656
1657 //PROP_DIAGRAM_SOLIDTYPE
1658 class WrappedSolidTypeProperty : public WrappedProperty
1659 {
1660 public:
1661     explicit WrappedSolidTypeProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1662
1663     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1664
1665     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1666
1667     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1668
1669 private: //member
1670     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1671     mutable Any                                 m_aOuterValue;
1672 };
1673
1674 WrappedSolidTypeProperty::WrappedSolidTypeProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1675             : WrappedProperty( "SolidType", OUString() )
1676             , m_spChart2ModelContact( spChart2ModelContact )
1677             , m_aOuterValue()
1678 {
1679     m_aOuterValue = WrappedSolidTypeProperty::getPropertyDefault( nullptr );
1680 }
1681
1682 void WrappedSolidTypeProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1683 {
1684     sal_Int32 nNewSolidType = css::chart::ChartSolidType::RECTANGULAR_SOLID;
1685     if( ! (rOuterValue >>= nNewSolidType) )
1686         throw lang::IllegalArgumentException( "Property SolidType requires integer value", nullptr, 0 );
1687
1688     m_aOuterValue = rOuterValue;
1689
1690     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1691     if( !xDiagram.is() )
1692         return;
1693
1694     bool bFound = false;
1695     bool bAmbiguous = false;
1696     sal_Int32 nOldSolidType = DiagramHelper::getGeometry3D( xDiagram, bFound, bAmbiguous );
1697     if( bFound && ( nOldSolidType != nNewSolidType || bAmbiguous ) )
1698         DiagramHelper::setGeometry3D( xDiagram, nNewSolidType );
1699 }
1700
1701 Any WrappedSolidTypeProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1702 {
1703     Reference< chart2::XDiagram > xDiagram( m_spChart2ModelContact->getChart2Diagram() );
1704     if( xDiagram.is() )
1705     {
1706         bool bFound = false;
1707         bool bAmbiguous = false;
1708         sal_Int32 nGeometry = DiagramHelper::getGeometry3D( xDiagram, bFound, bAmbiguous );
1709         if( bFound )
1710             m_aOuterValue <<= nGeometry;
1711     }
1712     return m_aOuterValue;
1713 }
1714
1715 Any WrappedSolidTypeProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1716 {
1717     return uno::Any( css::chart::ChartSolidType::RECTANGULAR_SOLID );
1718 }
1719
1720 class WrappedAutomaticSizeProperty : public WrappedProperty
1721 {
1722 public:
1723     WrappedAutomaticSizeProperty();
1724
1725     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1726
1727     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1728
1729     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
1730 };
1731
1732 WrappedAutomaticSizeProperty::WrappedAutomaticSizeProperty()
1733             : WrappedProperty( "AutomaticSize", OUString() )
1734 {
1735 }
1736
1737 void WrappedAutomaticSizeProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
1738 {
1739     if( xInnerPropertySet.is() )
1740     {
1741         bool bNewValue = true;
1742         if( ! (rOuterValue >>= bNewValue) )
1743             throw lang::IllegalArgumentException( "Property AutomaticSize requires value of type boolean", nullptr, 0 );
1744
1745         try
1746         {
1747             if( bNewValue )
1748             {
1749                 Any aRelativeSize( xInnerPropertySet->getPropertyValue( "RelativeSize" ) );
1750                 if( aRelativeSize.hasValue() )
1751                     xInnerPropertySet->setPropertyValue( "RelativeSize", Any() );
1752             }
1753         }
1754         catch( const uno::Exception & )
1755         {
1756             DBG_UNHANDLED_EXCEPTION("chart2");
1757         }
1758     }
1759 }
1760
1761 Any WrappedAutomaticSizeProperty::getPropertyValue( const Reference< beans::XPropertySet >& xInnerPropertySet ) const
1762 {
1763     Any aRet( getPropertyDefault( Reference< beans::XPropertyState >( xInnerPropertySet, uno::UNO_QUERY ) ) );
1764     if( xInnerPropertySet.is() )
1765     {
1766         Any aRelativeSize( xInnerPropertySet->getPropertyValue( "RelativeSize" ) );
1767         if( !aRelativeSize.hasValue() )
1768             aRet <<= true;
1769     }
1770     return aRet;
1771 }
1772
1773 Any WrappedAutomaticSizeProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
1774 {
1775     Any aRet;
1776     aRet <<= false;
1777     return aRet;
1778 }
1779
1780 //PROP_DIAGRAM_INCLUDE_HIDDEN_CELLS
1781 class WrappedIncludeHiddenCellsProperty : public WrappedProperty
1782 {
1783 public:
1784     explicit WrappedIncludeHiddenCellsProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
1785
1786     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
1787     virtual Any getPropertyValue(const Reference<beans::XPropertySet>& xInnerPropertySet) const override;
1788
1789 private: //member
1790     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
1791 };
1792
1793 WrappedIncludeHiddenCellsProperty::WrappedIncludeHiddenCellsProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
1794             : WrappedProperty("IncludeHiddenCells","IncludeHiddenCells")
1795             , m_spChart2ModelContact( spChart2ModelContact )
1796 {
1797 }
1798
1799 void WrappedIncludeHiddenCellsProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1800 {
1801     bool bNewValue = false;
1802     if( ! (rOuterValue >>= bNewValue) )
1803         throw lang::IllegalArgumentException( "Property IncludeHiddenCells requires boolean value", nullptr, 0 );
1804
1805     ChartModelHelper::setIncludeHiddenCells( bNewValue, *m_spChart2ModelContact->getModel() );
1806 }
1807
1808 Any WrappedIncludeHiddenCellsProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
1809 {
1810     bool bValue = ChartModelHelper::isIncludeHiddenCells( m_spChart2ModelContact->getChartModel() );
1811     return uno::Any(bValue);
1812 }
1813
1814 // ____ XDiagramProvider ____
1815 Reference< chart2::XDiagram > SAL_CALL DiagramWrapper::getDiagram()
1816 {
1817     return m_spChart2ModelContact->getChart2Diagram();
1818 }
1819
1820 void SAL_CALL DiagramWrapper::setDiagram(
1821     const Reference< chart2::XDiagram >& /*xDiagram*/ )
1822 {
1823     //@todo: remove this method from interface
1824     OSL_FAIL("DiagramWrapper::setDiagram is not implemented, should be removed and not be called" );
1825 }
1826
1827 Reference< beans::XPropertySet > DiagramWrapper::getInnerPropertySet()
1828 {
1829     return Reference< beans::XPropertySet >( m_spChart2ModelContact->getChart2Diagram(), uno::UNO_QUERY );
1830 }
1831
1832 const Sequence< beans::Property >& DiagramWrapper::getPropertySequence()
1833 {
1834     return *StaticDiagramWrapperPropertyArray::get();
1835 }
1836
1837 std::vector< std::unique_ptr<WrappedProperty> > DiagramWrapper::createWrappedProperties()
1838 {
1839     std::vector< std::unique_ptr<WrappedProperty> > aWrappedProperties;
1840
1841     WrappedAxisAndGridExistenceProperties::addWrappedProperties( aWrappedProperties, m_spChart2ModelContact );
1842     WrappedAxisTitleExistenceProperties::addWrappedProperties( aWrappedProperties, m_spChart2ModelContact );
1843     WrappedAxisLabelExistenceProperties::addWrappedProperties( aWrappedProperties, m_spChart2ModelContact );
1844     WrappedSceneProperty::addWrappedProperties( aWrappedProperties, m_spChart2ModelContact );
1845     WrappedIgnoreProperties::addIgnoreFillProperties( aWrappedProperties );
1846     WrappedIgnoreProperties::addIgnoreLineProperties( aWrappedProperties );
1847     WrappedStatisticProperties::addWrappedPropertiesForDiagram( aWrappedProperties, m_spChart2ModelContact );
1848     WrappedSymbolProperties::addWrappedPropertiesForDiagram( aWrappedProperties, m_spChart2ModelContact );
1849     WrappedDataCaptionProperties::addWrappedPropertiesForDiagram( aWrappedProperties, m_spChart2ModelContact );
1850     WrappedSplineProperties::addWrappedProperties( aWrappedProperties, m_spChart2ModelContact );
1851     WrappedStockProperties::addWrappedProperties( aWrappedProperties, m_spChart2ModelContact );
1852     WrappedAutomaticPositionProperties::addWrappedProperties( aWrappedProperties );
1853
1854     aWrappedProperties.emplace_back( new WrappedDataRowSourceProperty( m_spChart2ModelContact ) );
1855     aWrappedProperties.emplace_back( new WrappedStackingProperty( StackMode::YStacked,m_spChart2ModelContact ) );
1856     aWrappedProperties.emplace_back( new WrappedStackingProperty( StackMode::YStackedPercent, m_spChart2ModelContact ) );
1857     aWrappedProperties.emplace_back( new WrappedStackingProperty( StackMode::ZStacked, m_spChart2ModelContact ) );
1858     aWrappedProperties.emplace_back( new WrappedDim3DProperty( m_spChart2ModelContact ) );
1859     aWrappedProperties.emplace_back( new WrappedVerticalProperty( m_spChart2ModelContact ) );
1860     aWrappedProperties.emplace_back( new WrappedNumberOfLinesProperty( m_spChart2ModelContact ) );
1861     aWrappedProperties.emplace_back( new WrappedAttributedDataPointsProperty( m_spChart2ModelContact ) );
1862     aWrappedProperties.emplace_back( new WrappedProperty( "StackedBarsConnected", "ConnectBars" ) );
1863     aWrappedProperties.emplace_back( new WrappedSolidTypeProperty( m_spChart2ModelContact ) );
1864     aWrappedProperties.emplace_back( new WrappedAutomaticSizeProperty() );
1865     aWrappedProperties.emplace_back( new WrappedIncludeHiddenCellsProperty( m_spChart2ModelContact ) );
1866
1867     return aWrappedProperties;
1868 }
1869
1870 OUString SAL_CALL DiagramWrapper::getImplementationName()
1871 {
1872     return "com.sun.star.comp.chart.Diagram";
1873 }
1874
1875 sal_Bool SAL_CALL DiagramWrapper::supportsService( const OUString& rServiceName )
1876 {
1877     return cppu::supportsService(this, rServiceName);
1878 }
1879
1880 css::uno::Sequence< OUString > SAL_CALL DiagramWrapper::getSupportedServiceNames()
1881 {
1882     return {
1883         "com.sun.star.chart.Diagram",
1884         "com.sun.star.xml.UserDefinedAttributesSupplier",
1885         "com.sun.star.chart.StackableDiagram",
1886         "com.sun.star.chart.ChartAxisXSupplier",
1887         "com.sun.star.chart.ChartAxisYSupplier",
1888         "com.sun.star.chart.ChartAxisZSupplier",
1889         "com.sun.star.chart.ChartTwoAxisXSupplier",
1890         "com.sun.star.chart.ChartTwoAxisYSupplier"
1891     };
1892 }
1893
1894 } //  namespace wrapper
1895 } //  namespace chart
1896
1897 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */