chart2/source/controller/chartapiwrapper/ChartDocumentWrapper.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 <ChartDocumentWrapper.hxx>
  21 #include <servicenames.hxx>
  22 #include <PropertyHelper.hxx>
  23 #include <TitleHelper.hxx>
  24 #include <LegendHelper.hxx>
  25 #include <ControllerLockGuard.hxx>
  26 #include <DisposeHelper.hxx>
  27 #include "DataSeriesPointWrapper.hxx"
  28 #include <chartview/ExplicitValueProvider.hxx>
  29 #include <chartview/DrawModelWrapper.hxx>
  30 #include "Chart2ModelContact.hxx"
  31
  32 #include <ChartModel.hxx>
  33
  34 #include <DiagramHelper.hxx>
  35 #include <DataSourceHelper.hxx>
  36 #include <ChartModelHelper.hxx>
  37 #include <AxisHelper.hxx>
  38 #include <ThreeDHelper.hxx>
  39
  40 #include "TitleWrapper.hxx"
  41 #include "ChartDataWrapper.hxx"
  42 #include "DiagramWrapper.hxx"
  43 #include "LegendWrapper.hxx"
  44 #include "AreaWrapper.hxx"
  45 #include "WrappedAddInProperty.hxx"
  46 #include <WrappedIgnoreProperty.hxx>
  47 #include <cppuhelper/supportsservice.hxx>
  48 #include <comphelper/processfactory.hxx>
  49 #include <comphelper/sequence.hxx>
  50 #include <comphelper/servicehelper.hxx>
  51 #include <vcl/settings.hxx>
  52
  53 #include <com/sun/star/drawing/ShapeCollection.hpp>
  54 #include <com/sun/star/beans/PropertyAttribute.hpp>
  55 #include <com/sun/star/lang/DisposedException.hpp>
  56 #include <com/sun/star/lang/XInitialization.hpp>
  57 #include <com/sun/star/util/XRefreshable.hpp>
  58 #include <tools/diagnose_ex.h>
  59
  60 #include <vector>
  61 #include <algorithm>
  62 #include <map>
  63
  64 using namespace ::com::sun::star;
  65 using namespace ::com::sun::star::chart;
  66
  67 using ::com::sun::star::uno::Any;
  68 using ::com::sun::star::uno::UNO_QUERY_THROW;
  69 using ::com::sun::star::uno::Reference;
  70 using ::com::sun::star::uno::Sequence;
  71 using ::com::sun::star::beans::Property;
  72
  73 namespace
  74 {
  75 enum eServiceType
  76 {
  77     SERVICE_NAME_AREA_DIAGRAM = 0,
  78     SERVICE_NAME_BAR_DIAGRAM,
  79     SERVICE_NAME_DONUT_DIAGRAM,
  80     SERVICE_NAME_LINE_DIAGRAM,
  81     SERVICE_NAME_NET_DIAGRAM,
  82     SERVICE_NAME_FILLED_NET_DIAGRAM,
  83     SERVICE_NAME_PIE_DIAGRAM,
  84     SERVICE_NAME_STOCK_DIAGRAM,
  85     SERVICE_NAME_XY_DIAGRAM,
  86     SERVICE_NAME_BUBBLE_DIAGRAM,
  87
  88     SERVICE_NAME_DASH_TABLE,
  89     SERVICE_NAME_GARDIENT_TABLE,
  90     SERVICE_NAME_HATCH_TABLE,
  91     SERVICE_NAME_BITMAP_TABLE,
  92     SERVICE_NAME_TRANSP_GRADIENT_TABLE,
  93     SERVICE_NAME_MARKER_TABLE,
  94
  95     SERVICE_NAME_NAMESPACE_MAP,
  96     SERVICE_NAME_EXPORT_GRAPHIC_STORAGE_RESOLVER,
  97     SERVICE_NAME_IMPORT_GRAPHIC_STORAGE_RESOLVER
  98 };
  99
 100 typedef std::map< OUString, enum eServiceType > tServiceNameMap;
 101
 102 tServiceNameMap & lcl_getStaticServiceNameMap()
 103 {
 104     static tServiceNameMap aServiceNameMap {
 105         {"com.sun.star.chart.AreaDiagram",                    SERVICE_NAME_AREA_DIAGRAM},
 106         {"com.sun.star.chart.BarDiagram",                     SERVICE_NAME_BAR_DIAGRAM},
 107         {"com.sun.star.chart.DonutDiagram",                   SERVICE_NAME_DONUT_DIAGRAM},
 108         {"com.sun.star.chart.LineDiagram",                    SERVICE_NAME_LINE_DIAGRAM},
 109         {"com.sun.star.chart.NetDiagram",                     SERVICE_NAME_NET_DIAGRAM},
 110         {"com.sun.star.chart.FilledNetDiagram",               SERVICE_NAME_FILLED_NET_DIAGRAM},
 111         {"com.sun.star.chart.PieDiagram",                     SERVICE_NAME_PIE_DIAGRAM},
 112         {"com.sun.star.chart.StockDiagram",                   SERVICE_NAME_STOCK_DIAGRAM},
 113         {"com.sun.star.chart.XYDiagram",                      SERVICE_NAME_XY_DIAGRAM},
 114         {"com.sun.star.chart.BubbleDiagram",                  SERVICE_NAME_BUBBLE_DIAGRAM},
 115
 116         {"com.sun.star.drawing.DashTable",                    SERVICE_NAME_DASH_TABLE},
 117         {"com.sun.star.drawing.GradientTable",                SERVICE_NAME_GARDIENT_TABLE},
 118         {"com.sun.star.drawing.HatchTable",                   SERVICE_NAME_HATCH_TABLE},
 119         {"com.sun.star.drawing.BitmapTable",                  SERVICE_NAME_BITMAP_TABLE},
 120         {"com.sun.star.drawing.TransparencyGradientTable",    SERVICE_NAME_TRANSP_GRADIENT_TABLE},
 121         {"com.sun.star.drawing.MarkerTable",                  SERVICE_NAME_MARKER_TABLE},
 122
 123         {"com.sun.star.xml.NamespaceMap",                     SERVICE_NAME_NAMESPACE_MAP},
 124         {"com.sun.star.document.ExportGraphicStoreageHandler", SERVICE_NAME_EXPORT_GRAPHIC_STORAGE_RESOLVER},
 125         {"com.sun.star.document.ImportGraphicStoreageHandler", SERVICE_NAME_IMPORT_GRAPHIC_STORAGE_RESOLVER}
 126     };
 127
 128     return aServiceNameMap;
 129 }
 130
 131 enum
 132 {
 133     PROP_DOCUMENT_HAS_MAIN_TITLE,
 134     PROP_DOCUMENT_HAS_SUB_TITLE,
 135     PROP_DOCUMENT_HAS_LEGEND,
 136     PROP_DOCUMENT_LABELS_IN_FIRST_ROW,
 137     PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN,
 138     PROP_DOCUMENT_ADDIN,
 139     PROP_DOCUMENT_BASEDIAGRAM,
 140     PROP_DOCUMENT_ADDITIONAL_SHAPES,
 141     PROP_DOCUMENT_UPDATE_ADDIN,
 142     PROP_DOCUMENT_NULL_DATE,
 143     PROP_DOCUMENT_ENABLE_COMPLEX_CHARTTYPES,
 144     PROP_DOCUMENT_ENABLE_DATATABLE_DIALOG
 145 };
 146
 147 void lcl_AddPropertiesToVector(
 148     std::vector< Property > & rOutProperties )
 149 {
 150     rOutProperties.emplace_back( "HasMainTitle",
 151                   PROP_DOCUMENT_HAS_MAIN_TITLE,
 152                   cppu::UnoType<bool>::get(),
 153                   //#i111967# no PropertyChangeEvent is fired on change so far
 154                   beans::PropertyAttribute::MAYBEDEFAULT );
 155     rOutProperties.emplace_back( "HasSubTitle",
 156                   PROP_DOCUMENT_HAS_SUB_TITLE,
 157                   cppu::UnoType<bool>::get(),
 158                   //#i111967# no PropertyChangeEvent is fired on change so far
 159                   beans::PropertyAttribute::MAYBEDEFAULT );
 160     rOutProperties.emplace_back( "HasLegend",
 161                   PROP_DOCUMENT_HAS_LEGEND,
 162                   cppu::UnoType<bool>::get(),
 163                   //#i111967# no PropertyChangeEvent is fired on change so far
 164                   beans::PropertyAttribute::MAYBEDEFAULT );
 165
 166     // really needed?
 167     rOutProperties.emplace_back( "DataSourceLabelsInFirstRow",
 168                   PROP_DOCUMENT_LABELS_IN_FIRST_ROW,
 169                   cppu::UnoType<bool>::get(),
 170                   beans::PropertyAttribute::BOUND
 171                   | beans::PropertyAttribute::MAYBEDEFAULT );
 172     rOutProperties.emplace_back( "DataSourceLabelsInFirstColumn",
 173                   PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN,
 174                   cppu::UnoType<bool>::get(),
 175                   //#i111967# no PropertyChangeEvent is fired on change so far
 176                   beans::PropertyAttribute::MAYBEDEFAULT );
 177
 178     //add-in
 179     rOutProperties.emplace_back( "AddIn",
 180                   PROP_DOCUMENT_ADDIN,
 181                   cppu::UnoType<util::XRefreshable>::get(),
 182                   beans::PropertyAttribute::BOUND
 183                   | beans::PropertyAttribute::MAYBEVOID );
 184     rOutProperties.emplace_back( "BaseDiagram",
 185                   PROP_DOCUMENT_BASEDIAGRAM,
 186                   cppu::UnoType<OUString>::get(),
 187                   beans::PropertyAttribute::BOUND
 188                   | beans::PropertyAttribute::MAYBEVOID );
 189     rOutProperties.emplace_back( "AdditionalShapes",
 190                   PROP_DOCUMENT_ADDITIONAL_SHAPES,
 191                   cppu::UnoType<drawing::XShapes>::get(),
 192                   beans::PropertyAttribute::BOUND
 193                   | beans::PropertyAttribute::MAYBEVOID
 194                   | beans::PropertyAttribute::READONLY );
 195     rOutProperties.emplace_back( "RefreshAddInAllowed",
 196                   PROP_DOCUMENT_UPDATE_ADDIN,
 197                   cppu::UnoType<bool>::get(),
 198                   //#i111967# no PropertyChangeEvent is fired on change so far
 199                   beans::PropertyAttribute::TRANSIENT );
 200
 201     // table:null-date // i99104
 202     rOutProperties.emplace_back( "NullDate",
 203                   PROP_DOCUMENT_NULL_DATE,
 204                   ::cppu::UnoType<css::util::DateTime>::get(),
 205                   beans::PropertyAttribute::MAYBEVOID );
 206
 207     rOutProperties.emplace_back( "EnableComplexChartTypes",
 208                   PROP_DOCUMENT_ENABLE_COMPLEX_CHARTTYPES,
 209                   cppu::UnoType<bool>::get(),
 210                   //#i112666# no PropertyChangeEvent is fired on change so far
 211                   beans::PropertyAttribute::MAYBEDEFAULT );
 212     rOutProperties.emplace_back( "EnableDataTableDialog",
 213                   PROP_DOCUMENT_ENABLE_DATATABLE_DIALOG,
 214                   cppu::UnoType<bool>::get(),
 215                   //#i112666# no PropertyChangeEvent is fired on change so far
 216                   beans::PropertyAttribute::MAYBEDEFAULT );
 217 }
 218
 219 struct StaticChartDocumentWrapperPropertyArray_Initializer
 220 {
 221     Sequence< Property >* operator()()
 222     {
 223         static Sequence< Property > aPropSeq( lcl_GetPropertySequence() );
 224         return &aPropSeq;
 225     }
 226
 227 private:
 228     static uno::Sequence< Property > lcl_GetPropertySequence()
 229     {
 230         std::vector< css::beans::Property > aProperties;
 231         lcl_AddPropertiesToVector( aProperties );
 232
 233         std::sort( aProperties.begin(), aProperties.end(),
 234                      ::chart::PropertyNameLess() );
 235
 236         return comphelper::containerToSequence( aProperties );
 237     }
 238 };
 239
 240 struct StaticChartDocumentWrapperPropertyArray : public rtl::StaticAggregate< Sequence< Property >, StaticChartDocumentWrapperPropertyArray_Initializer >
 241 {
 242 };
 243
 244 } //  anonymous namespace
 245
 246 namespace chart
 247 {
 248 namespace wrapper
 249 {
 250
 251 //PROP_DOCUMENT_LABELS_IN_FIRST_ROW
 252 class WrappedDataSourceLabelsInFirstRowProperty : public WrappedProperty
 253 {
 254 public:
 255     explicit WrappedDataSourceLabelsInFirstRowProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
 256
 257     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 258
 259     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 260
 261     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
 262
 263 private: //member
 264     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
 265     mutable Any                                 m_aOuterValue;
 266 };
 267
 268 WrappedDataSourceLabelsInFirstRowProperty::WrappedDataSourceLabelsInFirstRowProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 269             : WrappedProperty("DataSourceLabelsInFirstRow",OUString())
 270             , m_spChart2ModelContact( spChart2ModelContact )
 271             , m_aOuterValue()
 272 {
 273     m_aOuterValue = WrappedDataSourceLabelsInFirstRowProperty::getPropertyDefault( nullptr );
 274 }
 275
 276 void WrappedDataSourceLabelsInFirstRowProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 277 {
 278     bool bLabelsInFirstRow = true;
 279     if( ! (rOuterValue >>= bLabelsInFirstRow) )
 280         throw lang::IllegalArgumentException("Property DataSourceLabelsInFirstRow requires value of type boolean", nullptr, 0 );
 281
 282     m_aOuterValue = rOuterValue;
 283     bool bNewValue = bLabelsInFirstRow;
 284
 285     OUString aRangeString;
 286     bool bUseColumns = true;
 287     bool bFirstCellAsLabel = true;
 288     bool bHasCategories = true;
 289     uno::Sequence< sal_Int32 > aSequenceMapping;
 290
 291     if( DataSourceHelper::detectRangeSegmentation(
 292             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 293             , bFirstCellAsLabel, bHasCategories ) )
 294     {
 295         if( bUseColumns && bNewValue != bFirstCellAsLabel )
 296         {
 297             DataSourceHelper::setRangeSegmentation(
 298                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns ,bNewValue, bHasCategories );
 299         }
 300         else if( !bUseColumns && bNewValue != bHasCategories )
 301         {
 302             DataSourceHelper::setRangeSegmentation(
 303                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns , bFirstCellAsLabel, bNewValue );
 304         }
 305     }
 306 }
 307
 308 Any WrappedDataSourceLabelsInFirstRowProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 309 {
 310     OUString aRangeString;
 311     bool bUseColumns = true;
 312     bool bFirstCellAsLabel = true;
 313     bool bHasCategories = true;
 314     uno::Sequence< sal_Int32 > aSequenceMapping;
 315
 316     if( DataSourceHelper::detectRangeSegmentation(
 317             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 318             , bFirstCellAsLabel, bHasCategories ) )
 319     {
 320         bool bLabelsInFirstRow = true;
 321         if( bUseColumns )
 322             bLabelsInFirstRow = bFirstCellAsLabel;
 323         else
 324             bLabelsInFirstRow = bHasCategories;
 325
 326         m_aOuterValue <<= bLabelsInFirstRow;
 327     }
 328     return m_aOuterValue;
 329 }
 330
 331 Any WrappedDataSourceLabelsInFirstRowProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 332 {
 333     Any aRet;
 334     aRet <<= true;
 335     return aRet;
 336 }
 337
 338 //PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN
 339 class WrappedDataSourceLabelsInFirstColumnProperty : public WrappedProperty
 340 {
 341 public:
 342     explicit WrappedDataSourceLabelsInFirstColumnProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
 343
 344     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 345
 346     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 347
 348     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
 349
 350 private: //member
 351     std::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
 352     mutable Any                                 m_aOuterValue;
 353 };
 354
 355 WrappedDataSourceLabelsInFirstColumnProperty::WrappedDataSourceLabelsInFirstColumnProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 356             : WrappedProperty("DataSourceLabelsInFirstColumn",OUString())
 357             , m_spChart2ModelContact( spChart2ModelContact )
 358             , m_aOuterValue()
 359 {
 360     m_aOuterValue = WrappedDataSourceLabelsInFirstColumnProperty::getPropertyDefault( nullptr );
 361 }
 362
 363 void WrappedDataSourceLabelsInFirstColumnProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 364 {
 365     bool bLabelsInFirstRow = true;
 366     if( ! (rOuterValue >>= bLabelsInFirstRow) )
 367         throw lang::IllegalArgumentException("Property DataSourceLabelsInFirstRow requires value of type boolean", nullptr, 0 );
 368
 369     m_aOuterValue = rOuterValue;
 370     bool bNewValue = bLabelsInFirstRow;
 371
 372     OUString aRangeString;
 373     bool bUseColumns = true;
 374     bool bFirstCellAsLabel = true;
 375     bool bHasCategories = true;
 376     uno::Sequence< sal_Int32 > aSequenceMapping;
 377
 378     if( DataSourceHelper::detectRangeSegmentation(
 379             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 380             , bFirstCellAsLabel, bHasCategories ) )
 381     {
 382         if( bUseColumns && bNewValue != bHasCategories )
 383         {
 384             DataSourceHelper::setRangeSegmentation(
 385                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns, bFirstCellAsLabel, bNewValue );
 386         }
 387         else if( !bUseColumns && bNewValue != bFirstCellAsLabel )
 388         {
 389             DataSourceHelper::setRangeSegmentation(
 390                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns , bNewValue, bHasCategories );
 391         }
 392     }
 393 }
 394
 395 Any WrappedDataSourceLabelsInFirstColumnProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 396 {
 397     OUString aRangeString;
 398     bool bUseColumns = true;
 399     bool bFirstCellAsLabel = true;
 400     bool bHasCategories = true;
 401     uno::Sequence< sal_Int32 > aSequenceMapping;
 402
 403     if( DataSourceHelper::detectRangeSegmentation(
 404             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 405             , bFirstCellAsLabel, bHasCategories ) )
 406     {
 407         bool bLabelsInFirstColumn = true;
 408         if( bUseColumns )
 409             bLabelsInFirstColumn = bHasCategories;
 410         else
 411             bLabelsInFirstColumn = bFirstCellAsLabel;
 412
 413         m_aOuterValue <<= bLabelsInFirstColumn;
 414     }
 415     return m_aOuterValue;
 416 }
 417
 418 Any WrappedDataSourceLabelsInFirstColumnProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 419 {
 420     Any aRet;
 421     aRet <<= true;
 422     return aRet;
 423 }
 424
 425 //PROP_DOCUMENT_HAS_LEGEND
 426 class WrappedHasLegendProperty : public WrappedProperty
 427 {
 428 public:
 429     explicit WrappedHasLegendProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
 430
 431     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 432
 433     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 434
 435     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
 436
 437 private: //member
 438     std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
 439 };
 440
 441 WrappedHasLegendProperty::WrappedHasLegendProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 442     : WrappedProperty("HasLegend",OUString())
 443     , m_spChart2ModelContact( spChart2ModelContact )
 444 {
 445 }
 446
 447 void WrappedHasLegendProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 448 {
 449     bool bNewValue = true;
 450     if( ! (rOuterValue >>= bNewValue) )
 451         throw lang::IllegalArgumentException("Property HasLegend requires value of type boolean", nullptr, 0 );
 452
 453     try
 454     {
 455         Reference< chart2::XLegend > xLegend( LegendHelper::getLegend( *m_spChart2ModelContact->getModel(), m_spChart2ModelContact->m_xContext,bNewValue ));
 456         if(xLegend.is())
 457         {
 458             Reference< beans::XPropertySet > xLegendProp( xLegend, uno::UNO_QUERY_THROW );
 459             bool bOldValue = true;
 460             Any aAOld = xLegendProp->getPropertyValue("Show");
 461             aAOld >>= bOldValue;
 462             if( bOldValue != bNewValue )
 463                 xLegendProp->setPropertyValue("Show", uno::Any( bNewValue ));
 464         }
 465     }
 466     catch (const uno::Exception&)
 467     {
 468         DBG_UNHANDLED_EXCEPTION("chart2");
 469     }
 470 }
 471
 472 Any WrappedHasLegendProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 473 {
 474     Any aRet;
 475     try
 476     {
 477         Reference< beans::XPropertySet > xLegendProp(
 478             LegendHelper::getLegend( *m_spChart2ModelContact->getModel() ), uno::UNO_QUERY );
 479         if( xLegendProp.is())
 480             aRet = xLegendProp->getPropertyValue("Show");
 481         else
 482             aRet <<= false;
 483     }
 484     catch (const uno::Exception&)
 485     {
 486         DBG_UNHANDLED_EXCEPTION("chart2");
 487     }
 488     return aRet;
 489 }
 490
 491 Any WrappedHasLegendProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 492 {
 493     Any aRet;
 494     aRet <<= false;
 495     return aRet;
 496 }
 497
 498 //PROP_DOCUMENT_HAS_MAIN_TITLE
 499 class WrappedHasMainTitleProperty : public WrappedProperty
 500 {
 501 public:
 502     explicit WrappedHasMainTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
 503
 504     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 505
 506     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 507
 508     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
 509
 510 private: //member
 511     std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
 512 };
 513
 514 WrappedHasMainTitleProperty::WrappedHasMainTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 515     : WrappedProperty("HasMainTitle",OUString())
 516     , m_spChart2ModelContact( spChart2ModelContact )
 517 {
 518 }
 519
 520 void WrappedHasMainTitleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 521 {
 522     bool bNewValue = true;
 523     if( ! (rOuterValue >>= bNewValue) )
 524         throw lang::IllegalArgumentException("Property HasMainTitle requires value of type boolean", nullptr, 0 );
 525
 526     try
 527     {
 528         if( bNewValue )
 529             TitleHelper::createTitle( TitleHelper::MAIN_TITLE, "main-title", m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext );
 530         else
 531             TitleHelper::removeTitle( TitleHelper::MAIN_TITLE, m_spChart2ModelContact->getChartModel() );
 532     }
 533     catch (const uno::Exception&)
 534     {
 535         DBG_UNHANDLED_EXCEPTION("chart2");
 536     }
 537 }
 538
 539 Any WrappedHasMainTitleProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 540 {
 541     Any aRet;
 542     try
 543     {
 544         aRet <<= TitleHelper::getTitle( TitleHelper::MAIN_TITLE, m_spChart2ModelContact->getChartModel() ).is();
 545     }
 546     catch (const uno::Exception&)
 547     {
 548         DBG_UNHANDLED_EXCEPTION("chart2");
 549     }
 550     return aRet;
 551 }
 552
 553 Any WrappedHasMainTitleProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 554 {
 555     Any aRet;
 556     aRet <<= false;
 557     return aRet;
 558 }
 559
 560 //PROP_DOCUMENT_HAS_SUB_TITLE
 561 class WrappedHasSubTitleProperty : public WrappedProperty
 562 {
 563 public:
 564     explicit WrappedHasSubTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
 565
 566     virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 567
 568     virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
 569
 570     virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
 571
 572 private: //member
 573     std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
 574 };
 575
 576 WrappedHasSubTitleProperty::WrappedHasSubTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
 577             : WrappedProperty("HasSubTitle",OUString())
 578             , m_spChart2ModelContact( spChart2ModelContact )
 579 {
 580 }
 581
 582 void WrappedHasSubTitleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 583 {
 584     bool bNewValue = true;
 585     if( ! (rOuterValue >>= bNewValue) )
 586         throw lang::IllegalArgumentException("Property HasSubTitle requires value of type boolean", nullptr, 0 );
 587
 588     try
 589     {
 590         if( bNewValue )
 591             TitleHelper::createTitle( TitleHelper::SUB_TITLE, "", m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext );
 592         else
 593             TitleHelper::removeTitle( TitleHelper::SUB_TITLE, m_spChart2ModelContact->getChartModel() );
 594     }
 595     catch (const uno::Exception&)
 596     {
 597         DBG_UNHANDLED_EXCEPTION("chart2");
 598     }
 599 }
 600
 601 Any WrappedHasSubTitleProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 602 {
 603     Any aRet;
 604     try
 605     {
 606         aRet <<= TitleHelper::getTitle( TitleHelper::SUB_TITLE, m_spChart2ModelContact->getChartModel() ).is();
 607     }
 608     catch (const uno::Exception&)
 609     {
 610         DBG_UNHANDLED_EXCEPTION("chart2");
 611     }
 612     return aRet;
 613 }
 614
 615 Any WrappedHasSubTitleProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 616 {
 617     Any aRet;
 618     aRet <<= false;
 619     return aRet;
 620 }
 621
 622 ChartDocumentWrapper::ChartDocumentWrapper(
 623     const Reference< uno::XComponentContext > & xContext ) :
 624         m_spChart2ModelContact( new Chart2ModelContact( xContext ) ),
 625         m_bUpdateAddIn( true ),
 626         m_bIsDisposed( false )
 627 {
 628 }
 629
 630 ChartDocumentWrapper::~ChartDocumentWrapper()
 631 {
 632     stopAllComponentListening();
 633 }
 634
 635 // ____ XInterface (for new interfaces) ____
 636 uno::Any SAL_CALL ChartDocumentWrapper::queryInterface( const uno::Type& aType )
 637 {
 638     if( m_xDelegator.is())
 639         // calls queryAggregation if the delegator doesn't know aType
 640         return m_xDelegator->queryInterface( aType );
 641     else
 642         return queryAggregation( aType );
 643 }
 644
 645 // ____ chart::XChartDocument (old API wrapper) ____
 646 Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getTitle()
 647 {
 648     if( !m_xTitle.is()  )
 649     {
 650         ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChart2Document() );
 651         m_xTitle = new TitleWrapper( TitleHelper::MAIN_TITLE, m_spChart2ModelContact );
 652     }
 653     return m_xTitle;
 654 }
 655
 656 Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getSubTitle()
 657 {
 658     if( !m_xSubTitle.is() )
 659     {
 660         ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChart2Document() );
 661         m_xSubTitle = new TitleWrapper( TitleHelper::SUB_TITLE, m_spChart2ModelContact );
 662     }
 663     return m_xSubTitle;
 664 }
 665
 666 Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getLegend()
 667 {
 668     if( ! m_xLegend.is())
 669     {
 670         m_xLegend = new LegendWrapper( m_spChart2ModelContact );
 671     }
 672
 673     return m_xLegend;
 674 }
 675
 676 Reference< beans::XPropertySet > SAL_CALL ChartDocumentWrapper::getArea()
 677 {
 678     if( ! m_xArea.is())
 679     {
 680         m_xArea.set( new AreaWrapper( m_spChart2ModelContact ) );
 681     }
 682
 683     return m_xArea;
 684 }
 685
 686 Reference< XDiagram > SAL_CALL ChartDocumentWrapper::getDiagram()
 687 {
 688     if( !m_xDiagram.is()  )
 689     {
 690         try
 691         {
 692             m_xDiagram = new DiagramWrapper( m_spChart2ModelContact );
 693         }
 694         catch (const uno::Exception&)
 695         {
 696             DBG_UNHANDLED_EXCEPTION("chart2");
 697         }
 698     }
 699
 700     return m_xDiagram;
 701 }
 702
 703 void SAL_CALL ChartDocumentWrapper::setDiagram( const Reference< XDiagram >& xDiagram )
 704 {
 705     uno::Reference< util::XRefreshable > xAddIn( xDiagram, uno::UNO_QUERY );
 706     if( xAddIn.is() )
 707     {
 708         setAddIn( xAddIn );
 709     }
 710     else if( xDiagram.is() && xDiagram != m_xDiagram )
 711     {
 712         // set new wrapped diagram at new chart.  This requires the old
 713         // diagram given as parameter to implement the new interface.  If
 714         // this is not possible throw an exception
 715         Reference< chart2::XDiagramProvider > xNewDiaProvider( xDiagram, uno::UNO_QUERY_THROW );
 716         Reference< chart2::XDiagram > xNewDia( xNewDiaProvider->getDiagram());
 717
 718         try
 719         {
 720             Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 721             if( xChartDoc.is() )
 722             {
 723                 // set the new diagram
 724                 xChartDoc->setFirstDiagram( xNewDia );
 725                 m_xDiagram = xDiagram;
 726             }
 727         }
 728         catch (const uno::Exception&)
 729         {
 730             DBG_UNHANDLED_EXCEPTION("chart2");
 731         }
 732     }
 733 }
 734
 735 Reference< XChartData > SAL_CALL ChartDocumentWrapper::getData()
 736 {
 737     if( !m_xChartData.is() )
 738     {
 739         m_xChartData.set( new ChartDataWrapper( m_spChart2ModelContact ) );
 740     }
 741     //@todo: check hasInternalDataProvider also in else?
 742
 743     return m_xChartData;
 744 }
 745
 746 void SAL_CALL ChartDocumentWrapper::attachData( const Reference< XChartData >& xNewData )
 747 {
 748     if( !xNewData.is() )
 749         return;
 750
 751     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChart2Document() );
 752     m_xChartData.set( new ChartDataWrapper( m_spChart2ModelContact, xNewData ) );
 753 }
 754
 755 // ____ XModel ____
 756 sal_Bool SAL_CALL ChartDocumentWrapper::attachResource(
 757     const OUString& URL,
 758     const Sequence< beans::PropertyValue >& Arguments )
 759 {
 760     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 761     if( xModel.is() )
 762         return xModel->attachResource( URL, Arguments );
 763     return false;
 764 }
 765
 766 OUString SAL_CALL ChartDocumentWrapper::getURL()
 767 {
 768     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 769     if( xModel.is() )
 770         return xModel->getURL();
 771     return OUString();
 772 }
 773
 774 Sequence< beans::PropertyValue > SAL_CALL ChartDocumentWrapper::getArgs()
 775 {
 776     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 777     if( xModel.is() )
 778         return xModel->getArgs();
 779     return Sequence< beans::PropertyValue >();
 780 }
 781
 782 void SAL_CALL ChartDocumentWrapper::connectController( const Reference< frame::XController >& Controller )
 783 {
 784     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 785     if( xModel.is() )
 786         xModel->connectController( Controller );
 787 }
 788
 789 void SAL_CALL ChartDocumentWrapper::disconnectController(
 790     const Reference< frame::XController >& Controller )
 791 {
 792     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 793     if( xModel.is() )
 794         xModel->disconnectController( Controller );
 795 }
 796
 797 void SAL_CALL ChartDocumentWrapper::lockControllers()
 798 {
 799     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 800     if( xModel.is() )
 801         xModel->lockControllers();
 802 }
 803
 804 void SAL_CALL ChartDocumentWrapper::unlockControllers()
 805 {
 806     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 807     if( xModel.is() )
 808         xModel->unlockControllers();
 809 }
 810
 811 sal_Bool SAL_CALL ChartDocumentWrapper::hasControllersLocked()
 812 {
 813     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 814     if( xModel.is() )
 815         return xModel->hasControllersLocked();
 816     return false;
 817 }
 818
 819 Reference< frame::XController > SAL_CALL ChartDocumentWrapper::getCurrentController()
 820 {
 821     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 822     if( xModel.is() )
 823         return xModel->getCurrentController();
 824     return nullptr;
 825 }
 826
 827 void SAL_CALL ChartDocumentWrapper::setCurrentController(
 828     const Reference< frame::XController >& Controller )
 829 {
 830     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 831     if( xModel.is() )
 832         xModel->setCurrentController( Controller );
 833 }
 834
 835 Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::getCurrentSelection()
 836 {
 837     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 838     if( xModel.is() )
 839         return xModel->getCurrentSelection();
 840     return nullptr;
 841 }
 842
 843 // ____ XComponent ____
 844 void SAL_CALL ChartDocumentWrapper::dispose()
 845 {
 846     if( m_bIsDisposed )
 847         throw lang::DisposedException("ChartDocumentWrapper is disposed",
 848             static_cast< ::cppu::OWeakObject* >( this ));
 849
 850     m_bIsDisposed = true;
 851
 852     try
 853     {
 854         Reference< lang::XComponent > xFormerDelegator( m_xDelegator, uno::UNO_QUERY );
 855         DisposeHelper::DisposeAndClear( m_xTitle );
 856         DisposeHelper::DisposeAndClear( m_xSubTitle );
 857         DisposeHelper::DisposeAndClear( m_xLegend );
 858         DisposeHelper::DisposeAndClear( m_xChartData );
 859         DisposeHelper::DisposeAndClear( m_xDiagram );
 860         DisposeHelper::DisposeAndClear( m_xArea );
 861         m_xChartView.set( nullptr );
 862         m_xShapeFactory.set( nullptr );
 863         m_xDelegator.set( nullptr );
 864
 865         clearWrappedPropertySet();
 866         m_spChart2ModelContact->clear();
 867         impl_resetAddIn();
 868
 869         stopAllComponentListening();
 870
 871         try
 872         {
 873             if( xFormerDelegator.is())
 874                 xFormerDelegator->dispose();
 875         }
 876         catch (const lang::DisposedException&)
 877         {
 878             // this is ok, don't panic
 879         }
 880     }
 881     catch (const uno::Exception &)
 882     {
 883         DBG_UNHANDLED_EXCEPTION("chart2");
 884     }
 885 }
 886
 887 void ChartDocumentWrapper::impl_resetAddIn()
 888 {
 889     Reference< util::XRefreshable > xAddIn( m_xAddIn );
 890     m_xAddIn.set( nullptr );
 891
 892     if( xAddIn.is() )
 893     {
 894         try
 895         {
 896             //make sure that the add-in does not hold a references to us anymore:
 897             Reference< lang::XComponent > xComp( xAddIn, uno::UNO_QUERY );
 898             if( xComp.is())
 899                 xComp->dispose();
 900             else
 901             {
 902                 uno::Reference< lang::XInitialization > xInit( xAddIn, uno::UNO_QUERY );
 903                 if( xInit.is() )
 904                 {
 905                     uno::Any aParam;
 906                     uno::Reference< css::chart::XChartDocument > xDoc;
 907                     aParam <<= xDoc;
 908                     uno::Sequence< uno::Any > aSeq( &aParam, 1 );
 909                     xInit->initialize( aSeq );
 910                 }
 911             }
 912         }
 913         catch (const uno::RuntimeException&)
 914         {
 915             DBG_UNHANDLED_EXCEPTION("chart2");
 916         }
 917         catch (const uno::Exception&)
 918         {
 919             DBG_UNHANDLED_EXCEPTION("chart2");
 920         }
 921     }
 922 }
 923
 924 void ChartDocumentWrapper::setBaseDiagram( const OUString& rBaseDiagram )
 925 {
 926     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 927     m_aBaseDiagram = rBaseDiagram;
 928
 929     uno::Reference< XDiagram > xDiagram( ChartDocumentWrapper::createInstance( rBaseDiagram ), uno::UNO_QUERY );
 930     if( xDiagram.is() )
 931         setDiagram( xDiagram );
 932 }
 933
 934 void ChartDocumentWrapper::setAddIn( const Reference< util::XRefreshable >& xAddIn )
 935 {
 936     if( m_xAddIn == xAddIn )
 937         return;
 938
 939     ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
 940     impl_resetAddIn();
 941     m_xAddIn = xAddIn;
 942     // initialize AddIn with this as chart document
 943     uno::Reference< lang::XInitialization > xInit( m_xAddIn, uno::UNO_QUERY );
 944     if( xInit.is() )
 945     {
 946         uno::Any aParam;
 947         uno::Reference< XChartDocument > xDoc( static_cast<XChartDocument*>(this), uno::UNO_QUERY );
 948         aParam <<= xDoc;
 949         uno::Sequence< uno::Any > aSeq( &aParam, 1 );
 950         xInit->initialize( aSeq );
 951     }
 952 }
 953
 954 void ChartDocumentWrapper::setUpdateAddIn( bool bUpdateAddIn )
 955 {
 956     m_bUpdateAddIn = bUpdateAddIn;
 957 }
 958
 959 Reference< drawing::XShapes > ChartDocumentWrapper::getAdditionalShapes() const
 960 {
 961     // get additional non-chart shapes for XML export
 962     uno::Reference< drawing::XShapes > xFoundShapes;
 963     uno::Reference< drawing::XDrawPage > xDrawPage( impl_getDrawPage() );
 964
 965     if( !xDrawPage.is() )
 966         return xFoundShapes;
 967
 968     uno::Reference<drawing::XShapes> xChartRoot( DrawModelWrapper::getChartRootShape( xDrawPage ) );
 969
 970     // iterate 'flat' over all top-level objects
 971     // and determine all that are no chart objects
 972     std::vector< uno::Reference< drawing::XShape > > aShapeVector;
 973     sal_Int32 nSubCount = xDrawPage->getCount();
 974     uno::Reference< drawing::XShape > xShape;
 975     for( sal_Int32 nS = 0; nS < nSubCount; nS++ )
 976     {
 977         if( xDrawPage->getByIndex( nS ) >>= xShape )
 978         {
 979             if( xShape.is() && xChartRoot!=xShape )
 980                 aShapeVector.push_back( xShape );
 981         }
 982     }
 983
 984     if( !aShapeVector.empty() )
 985     {
 986         // create a shape collection
 987         xFoundShapes = drawing::ShapeCollection::create(
 988                     comphelper::getProcessComponentContext());
 989
 990         OSL_ENSURE( xFoundShapes.is(), "Couldn't create a shape collection!" );
 991         if( xFoundShapes.is())
 992         {
 993             for (auto const& shape : aShapeVector)
 994                 xFoundShapes->add(shape);
 995         }
 996     }
 997
 998     return xFoundShapes;
 999 }
1000
1001 void SAL_CALL ChartDocumentWrapper::addEventListener( const Reference< lang::XEventListener >& xListener )
1002 {
1003     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1004     if( xModel.is() )
1005         xModel->addEventListener( xListener );
1006 }
1007
1008 void SAL_CALL ChartDocumentWrapper::removeEventListener( const Reference< lang::XEventListener >& aListener )
1009 {
1010     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1011     if( xModel.is() )
1012         xModel->removeEventListener( aListener );
1013 }
1014
1015 // ____ XDrawPageSupplier ____
1016 uno::Reference< drawing::XDrawPage > SAL_CALL ChartDocumentWrapper::getDrawPage()
1017 {
1018     return impl_getDrawPage();
1019 }
1020
1021 uno::Reference< drawing::XDrawPage > ChartDocumentWrapper::impl_getDrawPage() const
1022 {
1023     return m_spChart2ModelContact->getDrawPage();
1024 }
1025
1026 namespace {
1027
1028 uno::Reference< lang::XMultiServiceFactory > getShapeFactory(const uno::Reference<uno::XInterface>& xChartView)
1029 {
1030     auto pProvider = comphelper::getUnoTunnelImplementation<ExplicitValueProvider>(xChartView);
1031     if( pProvider )
1032         return pProvider->getDrawModelWrapper()->getShapeFactory();
1033
1034     return uno::Reference< lang::XMultiServiceFactory >();
1035 }
1036
1037 }
1038
1039 // ____ XMultiServiceFactory ____
1040 uno::Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::createInstance(
1041     const OUString& aServiceSpecifier )
1042 {
1043     uno::Reference< uno::XInterface > xResult;
1044
1045     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
1046     if( !xChartDoc.is() )
1047         return xResult;
1048
1049     bool bServiceFound = false;
1050     tServiceNameMap & rMap = lcl_getStaticServiceNameMap();
1051
1052     tServiceNameMap::const_iterator aIt( rMap.find( aServiceSpecifier ));
1053     if( aIt != rMap.end())
1054     {
1055         bool bCreateDiagram = false;
1056         uno::Reference< lang::XMultiServiceFactory > xManagerFact(
1057             xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
1058         uno::Reference< chart2::XChartTypeTemplate > xTemplate;
1059
1060         switch( (*aIt).second )
1061         {
1062             case SERVICE_NAME_AREA_DIAGRAM:
1063                 if( xManagerFact.is())
1064                 {
1065                     xTemplate.set(
1066                         xManagerFact->createInstance("com.sun.star.chart2.template.Area"),
1067                                 uno::UNO_QUERY );
1068                     bCreateDiagram = true;
1069                 }
1070                 break;
1071             case SERVICE_NAME_BAR_DIAGRAM:
1072                 if( xManagerFact.is())
1073                 {
1074                     // this is for bar and column (the latter is the default if
1075                     // no "Vertical=false" property was set)
1076                     xTemplate.set(
1077                         xManagerFact->createInstance("com.sun.star.chart2.template.Column"),
1078                                 uno::UNO_QUERY );
1079                     bCreateDiagram = true;
1080                 }
1081                 break;
1082             case SERVICE_NAME_DONUT_DIAGRAM:
1083                 if( xManagerFact.is())
1084                 {
1085                     xTemplate.set(
1086                         xManagerFact->createInstance("com.sun.star.chart2.template.Donut"),
1087                                 uno::UNO_QUERY );
1088                     bCreateDiagram = true;
1089                 }
1090                 break;
1091             case SERVICE_NAME_LINE_DIAGRAM:
1092                 if( xManagerFact.is())
1093                 {
1094                     xTemplate.set(
1095                         xManagerFact->createInstance("com.sun.star.chart2.template.Line"),
1096                                 uno::UNO_QUERY );
1097                     bCreateDiagram = true;
1098                 }
1099                 break;
1100             case SERVICE_NAME_NET_DIAGRAM:
1101                 if( xManagerFact.is())
1102                 {
1103                     xTemplate.set(
1104                         xManagerFact->createInstance("com.sun.star.chart2.template.Net"),
1105                                 uno::UNO_QUERY );
1106                     bCreateDiagram = true;
1107                 }
1108                 break;
1109             case SERVICE_NAME_FILLED_NET_DIAGRAM:
1110                 if( xManagerFact.is())
1111                 {
1112                     xTemplate.set(
1113                         xManagerFact->createInstance("com.sun.star.chart2.template.FilledNet"),
1114                                 uno::UNO_QUERY );
1115                     bCreateDiagram = true;
1116                 }
1117                 break;
1118             case SERVICE_NAME_PIE_DIAGRAM:
1119                 if( xManagerFact.is())
1120                 {
1121                     xTemplate.set(
1122                         xManagerFact->createInstance("com.sun.star.chart2.template.Pie"),
1123                                 uno::UNO_QUERY );
1124                     bCreateDiagram = true;
1125                 }
1126                 break;
1127             case SERVICE_NAME_STOCK_DIAGRAM:
1128                 if( xManagerFact.is())
1129                 {
1130                     xTemplate.set(
1131                         xManagerFact->createInstance("com.sun.star.chart2.template.StockLowHighClose"),
1132                                 uno::UNO_QUERY );
1133                     bCreateDiagram = true;
1134                 }
1135                 break;
1136             case SERVICE_NAME_XY_DIAGRAM:
1137                 if( xManagerFact.is())
1138                 {
1139                     xTemplate.set(
1140                         xManagerFact->createInstance("com.sun.star.chart2.template.ScatterLineSymbol"),
1141                                 uno::UNO_QUERY );
1142                     bCreateDiagram = true;
1143                 }
1144                 break;
1145
1146             case SERVICE_NAME_BUBBLE_DIAGRAM:
1147                 if( xManagerFact.is())
1148                 {
1149                     xTemplate.set(
1150                         xManagerFact->createInstance("com.sun.star.chart2.template.Bubble"),
1151                                 uno::UNO_QUERY );
1152                     bCreateDiagram = true;
1153                 }
1154                 break;
1155
1156             case SERVICE_NAME_DASH_TABLE:
1157             case SERVICE_NAME_GARDIENT_TABLE:
1158             case SERVICE_NAME_HATCH_TABLE:
1159             case SERVICE_NAME_BITMAP_TABLE:
1160             case SERVICE_NAME_TRANSP_GRADIENT_TABLE:
1161             case SERVICE_NAME_MARKER_TABLE:
1162                 {
1163                     uno::Reference< lang::XMultiServiceFactory > xTableFactory( xChartDoc, uno::UNO_QUERY );
1164                     OSL_ENSURE( xTableFactory.get() != this, "new model is expected to implement service factory for gradient table etc" );
1165                     if( xTableFactory.is() && xTableFactory.get() != this )
1166                         xResult.set( xTableFactory->createInstance( aIt->first ), uno::UNO_QUERY );
1167                 }
1168                 break;
1169
1170             case SERVICE_NAME_NAMESPACE_MAP:
1171                 break;
1172             case SERVICE_NAME_EXPORT_GRAPHIC_STORAGE_RESOLVER:
1173                 break;
1174             case SERVICE_NAME_IMPORT_GRAPHIC_STORAGE_RESOLVER:
1175                 break;
1176         }
1177
1178         if( bCreateDiagram && xTemplate.is() )
1179         {
1180             try
1181             {
1182                 uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram());
1183                 if( xDia.is())
1184                 {
1185                     // locked controllers
1186                     ControllerLockGuardUNO aCtrlLockGuard( xChartDoc );
1187                     Reference< chart2::XDiagram > xDiagram = ChartModelHelper::findDiagram( xChartDoc );
1188                     ThreeDLookScheme e3DScheme = ThreeDHelper::detectScheme( xDiagram );
1189                     Reference< lang::XMultiServiceFactory > xTemplateManager( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
1190                     DiagramHelper::tTemplateWithServiceName aTemplateWithService(
1191                         DiagramHelper::getTemplateForDiagram( xDiagram, xTemplateManager ));
1192                     if( aTemplateWithService.first.is())
1193                         aTemplateWithService.first->resetStyles( xDiagram );//#i109371#
1194                     xTemplate->changeDiagram( xDiagram );
1195                     if( AllSettings::GetMathLayoutRTL() )
1196                         AxisHelper::setRTLAxisLayout( AxisHelper::getCoordinateSystemByIndex( xDiagram, 0 ) );
1197                     ThreeDHelper::setScheme( xDiagram, e3DScheme );
1198                 }
1199                 else
1200                 {
1201                     // locked controllers
1202                     ControllerLockGuardUNO aCtrlLockGuard( xChartDoc );
1203                     xDia.set( xTemplate->createDiagramByDataSource(
1204                                   uno::Reference< chart2::data::XDataSource >(),
1205                                   uno::Sequence< beans::PropertyValue >()));
1206                     xChartDoc->setFirstDiagram( xDia );
1207                 }
1208
1209                 xResult = static_cast< ::cppu::OWeakObject* >( new DiagramWrapper( m_spChart2ModelContact ));
1210             }
1211             catch (const uno::Exception&)
1212             {
1213                 DBG_UNHANDLED_EXCEPTION("chart2");
1214             }
1215         }
1216
1217         bServiceFound = true;
1218     }
1219     else if( aServiceSpecifier == "com.sun.star.comp.chart2.DataSeriesWrapper" )
1220     {
1221         Reference< beans::XPropertySet > xDataSeries( new DataSeriesPointWrapper( m_spChart2ModelContact ) );
1222         xResult.set( xDataSeries );
1223         bServiceFound = true;
1224     }
1225     else if( aServiceSpecifier == CHART_VIEW_SERVICE_NAME )
1226     {
1227         if( !m_xChartView.is() )
1228         {
1229             Reference< lang::XMultiServiceFactory > xFact(
1230                 m_spChart2ModelContact->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
1231             Reference< lang::XInitialization > xViewInit( xFact->createInstance(
1232                     CHART_VIEW_SERVICE_NAME ), uno::UNO_QUERY );
1233             if(xViewInit.is())
1234             {
1235                 try
1236                 {
1237                     m_xChartView = xViewInit;
1238
1239                     Sequence< Any > aArguments(2);
1240                     aArguments[0] <<= Reference<frame::XModel>(this);
1241                     aArguments[1] <<= true; // bRefreshAddIn
1242                     xViewInit->initialize(aArguments);
1243                 }
1244                 catch (const uno::Exception&)
1245                 {
1246                     DBG_UNHANDLED_EXCEPTION("chart2");
1247                 }
1248             }
1249         }
1250         xResult.set( m_xChartView );
1251         bServiceFound = true;
1252     }
1253     else
1254     {
1255         // try to create a shape
1256         try
1257         {
1258             if( !m_xShapeFactory.is() && m_xChartView.is() )
1259             {
1260                 m_xShapeFactory = getShapeFactory( m_xChartView );
1261             }
1262             else
1263             {
1264                 ChartModel* pModel = m_spChart2ModelContact->getModel();
1265                 if(pModel)
1266                 {
1267                     m_xChartView = pModel->getChartView();
1268                     m_xShapeFactory = getShapeFactory( m_xChartView );
1269                 }
1270             }
1271
1272             if( m_xShapeFactory.is() )
1273             {
1274                 xResult = m_xShapeFactory->createInstance( aServiceSpecifier );
1275                 bServiceFound = true;
1276             }
1277         }
1278         catch (const uno::Exception&)
1279         {
1280             // couldn't create shape
1281         }
1282     }
1283
1284     // finally, try to create an addin
1285     if( !bServiceFound )
1286     {
1287         try
1288         {
1289             Reference< lang::XMultiServiceFactory > xFact(
1290                 m_spChart2ModelContact->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
1291             uno::Reference< util::XRefreshable > xAddIn(
1292                 xFact->createInstance( aServiceSpecifier ), uno::UNO_QUERY );
1293             if( xAddIn.is() )
1294             {
1295                 xResult = xAddIn;
1296             }
1297         }
1298         catch (const uno::Exception&)
1299         {
1300             // couldn't create service
1301         }
1302     }
1303
1304     return xResult;
1305 }
1306
1307 uno::Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::createInstanceWithArguments(
1308     const OUString& ServiceSpecifier,
1309     const uno::Sequence< uno::Any >& Arguments )
1310 {
1311     OSL_ENSURE( Arguments.hasElements(), "createInstanceWithArguments: Warning: Arguments are ignored" );
1312
1313     return createInstance( ServiceSpecifier );
1314 }
1315
1316 uno::Sequence< OUString > SAL_CALL ChartDocumentWrapper::getAvailableServiceNames()
1317 {
1318     return comphelper::mapKeysToSequence( lcl_getStaticServiceNameMap() );
1319 }
1320
1321 // ____ XAggregation ____
1322 void SAL_CALL ChartDocumentWrapper::setDelegator(
1323     const uno::Reference< uno::XInterface >& rDelegator )
1324 {
1325     if( m_bIsDisposed )
1326     {
1327         if( rDelegator.is() )
1328             throw lang::DisposedException("ChartDocumentWrapper is disposed",
1329                 static_cast< ::cppu::OWeakObject* >( this ));
1330         return;
1331     }
1332
1333     if( rDelegator.is())
1334     {
1335         m_xDelegator = rDelegator;
1336         m_spChart2ModelContact->setModel( uno::Reference< frame::XModel >(m_xDelegator, uno::UNO_QUERY) );
1337     }
1338     else
1339     {
1340         // this is a sort of dispose() from the new model,so release resources here
1341         try
1342         {
1343             dispose();
1344         }
1345         catch (const uno::Exception&)
1346         {
1347             DBG_UNHANDLED_EXCEPTION("chart2");
1348         }
1349     }
1350 }
1351
1352 uno::Any SAL_CALL ChartDocumentWrapper::queryAggregation( const uno::Type& rType )
1353 {
1354     return ChartDocumentWrapper_Base::queryInterface( rType );
1355 }
1356
1357 // ____ ::utl::OEventListenerAdapter ____
1358 void ChartDocumentWrapper::_disposing( const lang::EventObject& rSource )
1359 {
1360     if( rSource.Source == m_xTitle )
1361         m_xTitle.set( nullptr );
1362     else if( rSource.Source == m_xSubTitle )
1363         m_xSubTitle.set( nullptr );
1364     else if( rSource.Source == m_xLegend )
1365         m_xLegend.set( nullptr );
1366     else if( rSource.Source == m_xChartData )
1367         m_xChartData.set( nullptr );
1368     else if( rSource.Source == m_xDiagram )
1369         m_xDiagram.set( nullptr );
1370     else if( rSource.Source == m_xArea )
1371         m_xArea.set( nullptr );
1372     else if( rSource.Source == m_xAddIn )
1373         m_xAddIn.set( nullptr );
1374     else if( rSource.Source == m_xChartView )
1375         m_xChartView.set( nullptr );
1376 }
1377
1378 // WrappedPropertySet
1379 Reference< beans::XPropertySet > ChartDocumentWrapper::getInnerPropertySet()
1380 {
1381     return nullptr;
1382 }
1383 const Sequence< beans::Property >& ChartDocumentWrapper::getPropertySequence()
1384 {
1385     return *StaticChartDocumentWrapperPropertyArray::get();
1386 }
1387
1388 std::vector< std::unique_ptr<WrappedProperty> > ChartDocumentWrapper::createWrappedProperties()
1389 {
1390     std::vector< std::unique_ptr<WrappedProperty> > aWrappedProperties;
1391     aWrappedProperties.emplace_back( new WrappedDataSourceLabelsInFirstRowProperty( m_spChart2ModelContact ) );
1392     aWrappedProperties.emplace_back( new WrappedDataSourceLabelsInFirstColumnProperty( m_spChart2ModelContact ) );
1393     aWrappedProperties.emplace_back( new WrappedHasLegendProperty( m_spChart2ModelContact ) );
1394     aWrappedProperties.emplace_back( new WrappedHasMainTitleProperty( m_spChart2ModelContact ) );
1395     aWrappedProperties.emplace_back( new WrappedHasSubTitleProperty( m_spChart2ModelContact ) );
1396     aWrappedProperties.emplace_back( new WrappedAddInProperty( *this ) );
1397     aWrappedProperties.emplace_back( new WrappedBaseDiagramProperty( *this ) );
1398     aWrappedProperties.emplace_back( new WrappedAdditionalShapesProperty( *this ) );
1399     aWrappedProperties.emplace_back( new WrappedRefreshAddInAllowedProperty( *this ) );
1400     aWrappedProperties.emplace_back( new WrappedIgnoreProperty("NullDate",Any() ) ); // i99104
1401     aWrappedProperties.emplace_back( new WrappedIgnoreProperty("EnableComplexChartTypes", uno::Any(true) ) );
1402     aWrappedProperties.emplace_back( new WrappedIgnoreProperty("EnableDataTableDialog", uno::Any(true) ) );
1403
1404     return aWrappedProperties;
1405 }
1406
1407 OUString SAL_CALL ChartDocumentWrapper::getImplementationName()
1408 {
1409     return CHART_CHARTAPIWRAPPER_IMPLEMENTATION_NAME;
1410 }
1411
1412 sal_Bool SAL_CALL ChartDocumentWrapper::supportsService( const OUString& rServiceName )
1413 {
1414     return cppu::supportsService(this, rServiceName);
1415 }
1416
1417 css::uno::Sequence< OUString > SAL_CALL ChartDocumentWrapper::getSupportedServiceNames()
1418 {
1419     return {
1420         "com.sun.star.chart.ChartDocument",
1421         CHART_CHARTAPIWRAPPER_SERVICE_NAME,
1422         "com.sun.star.xml.UserDefinedAttributesSupplier",
1423         "com.sun.star.beans.PropertySet"
1424     };
1425 }
1426
1427 } //  namespace wrapper
1428 } //  namespace chart
1429
1430 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1431 com_sun_star_comp_chart2_ChartDocumentWrapper_get_implementation(css::uno::XComponentContext *context,
1432                                                                 css::uno::Sequence<css::uno::Any> const &)
1433 {
1434     return cppu::acquire(new ::chart::wrapper::ChartDocumentWrapper(context));
1435 }
1436
1437 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */