chart2/source/controller/chartapiwrapper/ChartDocumentWrapper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ChartDocumentWrapper.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33 #include "ChartDocumentWrapper.hxx"
  34 #include "macros.hxx"
  35 #include "servicenames.hxx"
  36 #include "PropertyHelper.hxx"
  37 #include "TitleHelper.hxx"
  38 #include "LegendHelper.hxx"
  39 #include "ControllerLockGuard.hxx"
  40 #include "ModifyListenerHelper.hxx"
  41 #include "DisposeHelper.hxx"
  42 #include "DataSeriesPointWrapper.hxx"
  43 #include "chartview/ExplicitValueProvider.hxx"
  44 #include "chartview/DrawModelWrapper.hxx"
  45 #include "Chart2ModelContact.hxx"
  46
  47 #include "DiagramHelper.hxx"
  48 #include "DataSourceHelper.hxx"
  49 #include "ChartModelHelper.hxx"
  50 #include "ContainerHelper.hxx"
  51
  52 #include "TitleWrapper.hxx"
  53 #include "ChartDataWrapper.hxx"
  54 #include "DiagramWrapper.hxx"
  55 #include "LegendWrapper.hxx"
  56 #include "AreaWrapper.hxx"
  57 #include "WrappedAddInProperty.hxx"
  58 #include "WrappedIgnoreProperty.hxx"
  59 #include "ChartRenderer.hxx"
  60 #include <com/sun/star/chart2/XTitled.hpp>
  61 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
  62 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  63 #include <com/sun/star/chart/XChartDataArray.hpp>
  64 #include <comphelper/InlineContainer.hxx>
  65 // header for function SvxShapeCollection_NewInstance
  66 #include <svx/unoshcol.hxx>
  67 // header for define DBG_ASSERT
  68 #include <tools/debug.hxx>
  69 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  70 #include <com/sun/star/beans/PropertyAttribute.hpp>
  71 #include <com/sun/star/lang/DisposedException.hpp>
  72 #include <com/sun/star/lang/XInitialization.hpp>
  73 #include <com/sun/star/util/DateTime.hpp>
  74
  75 #include <vector>
  76 #include <algorithm>
  77 #include <functional>
  78
  79 using namespace ::com::sun::star;
  80 using namespace ::com::sun::star::chart;
  81
  82 using ::com::sun::star::uno::Any;
  83 using ::com::sun::star::uno::Reference;
  84 using ::com::sun::star::uno::Sequence;
  85 using ::com::sun::star::beans::Property;
  86 using ::osl::MutexGuard;
  87 using ::rtl::OUString;
  88
  89 namespace
  90 {
  91 enum eServiceType
  92 {
  93     SERVICE_NAME_AREA_DIAGRAM = 0,
  94     SERVICE_NAME_BAR_DIAGRAM,
  95     SERVICE_NAME_DONUT_DIAGRAM,
  96     SERVICE_NAME_LINE_DIAGRAM,
  97     SERVICE_NAME_NET_DIAGRAM,
  98     SERVICE_NAME_FILLED_NET_DIAGRAM,
  99     SERVICE_NAME_PIE_DIAGRAM,
 100     SERVICE_NAME_STOCK_DIAGRAM,
 101     SERVICE_NAME_XY_DIAGRAM,
 102     SERVICE_NAME_BUBBLE_DIAGRAM,
 103
 104     SERVICE_NAME_DASH_TABLE,
 105     SERVICE_NAME_GARDIENT_TABLE,
 106     SERVICE_NAME_HATCH_TABLE,
 107     SERVICE_NAME_BITMAP_TABLE,
 108     SERVICE_NAME_TRANSP_GRADIENT_TABLE,
 109     SERVICE_NAME_MARKER_TABLE,
 110
 111     SERVICE_NAME_NAMESPACE_MAP,
 112     SERVICE_NAME_EXPORT_GRAPHIC_RESOLVER,
 113     SERVICE_NAME_IMPORT_GRAPHIC_RESOLVER
 114 };
 115
 116 typedef ::std::map< ::rtl::OUString, enum eServiceType > tServiceNameMap;
 117 typedef ::comphelper::MakeMap< ::rtl::OUString, enum eServiceType > tMakeServiceNameMap;
 118
 119 tServiceNameMap & lcl_getStaticServiceNameMap()
 120 {
 121     static tServiceNameMap aServiceNameMap(
 122         tMakeServiceNameMap
 123         ( C2U( "com.sun.star.chart.AreaDiagram" ),                    SERVICE_NAME_AREA_DIAGRAM )
 124         ( C2U( "com.sun.star.chart.BarDiagram" ),                     SERVICE_NAME_BAR_DIAGRAM )
 125         ( C2U( "com.sun.star.chart.DonutDiagram" ),                   SERVICE_NAME_DONUT_DIAGRAM )
 126         ( C2U( "com.sun.star.chart.LineDiagram" ),                    SERVICE_NAME_LINE_DIAGRAM )
 127         ( C2U( "com.sun.star.chart.NetDiagram" ),                     SERVICE_NAME_NET_DIAGRAM )
 128         ( C2U( "com.sun.star.chart.FilledNetDiagram" ),               SERVICE_NAME_FILLED_NET_DIAGRAM )
 129         ( C2U( "com.sun.star.chart.PieDiagram" ),                     SERVICE_NAME_PIE_DIAGRAM )
 130         ( C2U( "com.sun.star.chart.StockDiagram" ),                   SERVICE_NAME_STOCK_DIAGRAM )
 131         ( C2U( "com.sun.star.chart.XYDiagram" ),                      SERVICE_NAME_XY_DIAGRAM )
 132         ( C2U( "com.sun.star.chart.BubbleDiagram" ),                  SERVICE_NAME_BUBBLE_DIAGRAM )
 133
 134         ( C2U( "com.sun.star.drawing.DashTable" ),                    SERVICE_NAME_DASH_TABLE )
 135         ( C2U( "com.sun.star.drawing.GradientTable" ),                SERVICE_NAME_GARDIENT_TABLE )
 136         ( C2U( "com.sun.star.drawing.HatchTable" ),                   SERVICE_NAME_HATCH_TABLE )
 137         ( C2U( "com.sun.star.drawing.BitmapTable" ),                  SERVICE_NAME_BITMAP_TABLE )
 138         ( C2U( "com.sun.star.drawing.TransparencyGradientTable" ),    SERVICE_NAME_TRANSP_GRADIENT_TABLE )
 139         ( C2U( "com.sun.star.drawing.MarkerTable" ),                  SERVICE_NAME_MARKER_TABLE )
 140
 141         ( C2U( "com.sun.star.xml.NamespaceMap" ),                     SERVICE_NAME_NAMESPACE_MAP )
 142         ( C2U( "com.sun.star.document.ExportGraphicObjectResolver" ), SERVICE_NAME_EXPORT_GRAPHIC_RESOLVER )
 143         ( C2U( "com.sun.star.document.ImportGraphicObjectResolver" ), SERVICE_NAME_IMPORT_GRAPHIC_RESOLVER )
 144         );
 145
 146     return aServiceNameMap;
 147 }
 148
 149 enum
 150 {
 151     PROP_DOCUMENT_HAS_MAIN_TITLE,
 152     PROP_DOCUMENT_HAS_SUB_TITLE,
 153     PROP_DOCUMENT_HAS_LEGEND,
 154     PROP_DOCUMENT_LABELS_IN_FIRST_ROW,
 155     PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN,
 156     PROP_DOCUMENT_ADDIN,
 157     PROP_DOCUMENT_BASEDIAGRAM,
 158     PROP_DOCUMENT_ADDITIONAL_SHAPES,
 159     PROP_DOCUMENT_UPDATE_ADDIN,
 160     PROP_DOCUMENT_NULL_DATE
 161 };
 162
 163 void lcl_AddPropertiesToVector(
 164     ::std::vector< Property > & rOutProperties )
 165 {
 166     rOutProperties.push_back(
 167         Property( C2U( "HasMainTitle" ),
 168                   PROP_DOCUMENT_HAS_MAIN_TITLE,
 169                   ::getBooleanCppuType(),
 170                   beans::PropertyAttribute::BOUND
 171                   | beans::PropertyAttribute::MAYBEDEFAULT ));
 172     rOutProperties.push_back(
 173         Property( C2U( "HasSubTitle" ),
 174                   PROP_DOCUMENT_HAS_SUB_TITLE,
 175                   ::getBooleanCppuType(),
 176                   beans::PropertyAttribute::BOUND
 177                   | beans::PropertyAttribute::MAYBEDEFAULT ));
 178     rOutProperties.push_back(
 179         Property( C2U( "HasLegend" ),
 180                   PROP_DOCUMENT_HAS_LEGEND,
 181                   ::getBooleanCppuType(),
 182                   beans::PropertyAttribute::BOUND
 183                   | beans::PropertyAttribute::MAYBEDEFAULT ));
 184
 185     // really needed?
 186     rOutProperties.push_back(
 187         Property( C2U( "DataSourceLabelsInFirstRow" ),
 188                   PROP_DOCUMENT_LABELS_IN_FIRST_ROW,
 189                   ::getBooleanCppuType(),
 190                   beans::PropertyAttribute::BOUND
 191                   | beans::PropertyAttribute::MAYBEDEFAULT ));
 192     rOutProperties.push_back(
 193         Property( C2U( "DataSourceLabelsInFirstColumn" ),
 194                   PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN,
 195                   ::getBooleanCppuType(),
 196                   beans::PropertyAttribute::BOUND
 197                   | beans::PropertyAttribute::MAYBEDEFAULT ));
 198
 199     //add-in
 200     rOutProperties.push_back(
 201         Property( C2U( "AddIn" ),
 202                   PROP_DOCUMENT_ADDIN,
 203                   ::getCppuType( reinterpret_cast< Reference< util::XRefreshable > * >(0)),
 204                   beans::PropertyAttribute::BOUND
 205                   | beans::PropertyAttribute::MAYBEVOID ));
 206     rOutProperties.push_back(
 207         Property( C2U( "BaseDiagram" ),
 208                   PROP_DOCUMENT_BASEDIAGRAM,
 209                   ::getCppuType( reinterpret_cast< const ::rtl::OUString * >(0)),
 210                   beans::PropertyAttribute::BOUND
 211                   | beans::PropertyAttribute::MAYBEVOID ));
 212     rOutProperties.push_back(
 213         Property( C2U( "AdditionalShapes" ),
 214                   PROP_DOCUMENT_ADDITIONAL_SHAPES,
 215                   ::getCppuType( reinterpret_cast< Reference< drawing::XShapes > * >(0)),
 216                   beans::PropertyAttribute::BOUND
 217                   | beans::PropertyAttribute::MAYBEVOID
 218                   | beans::PropertyAttribute::READONLY ));
 219     rOutProperties.push_back(
 220         Property( C2U( "RefreshAddInAllowed" ),
 221                   PROP_DOCUMENT_UPDATE_ADDIN,
 222                   ::getBooleanCppuType(),
 223                   beans::PropertyAttribute::BOUND ));
 224
 225     // table:null-date // i99104
 226     rOutProperties.push_back(
 227         Property( C2U( "NullDate" ),
 228                   PROP_DOCUMENT_NULL_DATE,
 229                   ::getCppuType( static_cast< const ::com::sun::star::util::DateTime * >(0)),
 230                   beans::PropertyAttribute::MAYBEVOID ));
 231 }
 232
 233 const uno::Sequence< Property > & lcl_GetPropertySequence()
 234 {
 235     static uno::Sequence< Property > aPropSeq;
 236
 237     // /--
 238     MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 239     if( 0 == aPropSeq.getLength() )
 240     {
 241         // get properties
 242         ::std::vector< ::com::sun::star::beans::Property > aProperties;
 243         lcl_AddPropertiesToVector( aProperties );
 244
 245         // and sort them for access via bsearch
 246         ::std::sort( aProperties.begin(), aProperties.end(),
 247                      ::chart::PropertyNameLess() );
 248
 249         // transfer result to static Sequence
 250         aPropSeq = ::chart::ContainerHelper::ContainerToSequence( aProperties );
 251     }
 252
 253     return aPropSeq;
 254 }
 255
 256 } //  anonymous namespace
 257
 258 namespace chart
 259 {
 260 namespace wrapper
 261 {
 262 //-----------------------------------------------------------------------------------------------------------------
 263 //-----------------------------------------------------------------------------------------------------------------
 264 //-----------------------------------------------------------------------------------------------------------------
 265
 266 //PROP_DOCUMENT_LABELS_IN_FIRST_ROW
 267 class WrappedDataSourceLabelsInFirstRowProperty : public WrappedProperty
 268 {
 269 public:
 270     WrappedDataSourceLabelsInFirstRowProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact );
 271     virtual ~WrappedDataSourceLabelsInFirstRowProperty();
 272
 273     virtual void setPropertyValue( const ::com::sun::star::uno::Any& rOuterValue, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 274                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 275
 276     virtual ::com::sun::star::uno::Any getPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 277                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 278
 279     virtual ::com::sun::star::uno::Any getPropertyDefault( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState >& xInnerPropertyState ) const
 280                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 281
 282 private: //member
 283     ::boost::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
 284     mutable Any                                 m_aOuterValue;
 285 };
 286
 287 WrappedDataSourceLabelsInFirstRowProperty::WrappedDataSourceLabelsInFirstRowProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 288             : WrappedProperty(C2U("DataSourceLabelsInFirstRow"),OUString())
 289             , m_spChart2ModelContact( spChart2ModelContact )
 290             , m_aOuterValue()
 291 {
 292     m_aOuterValue = WrappedDataSourceLabelsInFirstRowProperty::getPropertyDefault( 0 );
 293 }
 294
 295 WrappedDataSourceLabelsInFirstRowProperty::~WrappedDataSourceLabelsInFirstRowProperty()
 296 {
 297 }
 298
 299 void WrappedDataSourceLabelsInFirstRowProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 300                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 301 {
 302     sal_Bool bLabelsInFirstRow = sal_True;
 303     if( ! (rOuterValue >>= bLabelsInFirstRow) )
 304         throw lang::IllegalArgumentException( C2U("Property DataSourceLabelsInFirstRow requires value of type boolean"), 0, 0 );
 305
 306     m_aOuterValue = rOuterValue;
 307     bool bNewValue = bLabelsInFirstRow;
 308
 309     ::rtl::OUString aRangeString;
 310     bool bUseColumns = true;
 311     bool bFirstCellAsLabel = true;
 312     bool bHasCategories = true;
 313     uno::Sequence< sal_Int32 > aSequenceMapping;
 314
 315     if( DataSourceHelper::detectRangeSegmentation(
 316             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 317             , bFirstCellAsLabel, bHasCategories ) )
 318     {
 319         if( bUseColumns && bNewValue != bFirstCellAsLabel )
 320         {
 321             DataSourceHelper::setRangeSegmentation(
 322                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns ,bNewValue, bHasCategories );
 323         }
 324         else if( !bUseColumns && bNewValue != bHasCategories )
 325         {
 326             DataSourceHelper::setRangeSegmentation(
 327                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns , bFirstCellAsLabel, bNewValue );
 328         }
 329     }
 330 }
 331
 332 Any WrappedDataSourceLabelsInFirstRowProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 333                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 334 {
 335     ::rtl::OUString aRangeString;
 336     bool bUseColumns = true;
 337     bool bFirstCellAsLabel = true;
 338     bool bHasCategories = true;
 339     uno::Sequence< sal_Int32 > aSequenceMapping;
 340
 341     if( DataSourceHelper::detectRangeSegmentation(
 342             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 343             , bFirstCellAsLabel, bHasCategories ) )
 344     {
 345         sal_Bool bLabelsInFirstRow = sal_True;
 346         if( bUseColumns )
 347             bLabelsInFirstRow = bFirstCellAsLabel;
 348         else
 349             bLabelsInFirstRow = bHasCategories;
 350
 351         m_aOuterValue <<= bLabelsInFirstRow;
 352     }
 353     return m_aOuterValue;
 354 }
 355
 356 Any WrappedDataSourceLabelsInFirstRowProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 357                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 358 {
 359     Any aRet;
 360     aRet <<= sal_True;
 361     return aRet;
 362 }
 363
 364 //-----------------------------------------------------------------------------------------------------------------
 365 //-----------------------------------------------------------------------------------------------------------------
 366 //-----------------------------------------------------------------------------------------------------------------
 367
 368 //PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN
 369 class WrappedDataSourceLabelsInFirstColumnProperty : public WrappedProperty
 370 {
 371 public:
 372     WrappedDataSourceLabelsInFirstColumnProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact );
 373     virtual ~WrappedDataSourceLabelsInFirstColumnProperty();
 374
 375     virtual void setPropertyValue( const ::com::sun::star::uno::Any& rOuterValue, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 376                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 377
 378     virtual ::com::sun::star::uno::Any getPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 379                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 380
 381     virtual ::com::sun::star::uno::Any getPropertyDefault( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState >& xInnerPropertyState ) const
 382                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 383
 384 private: //member
 385     ::boost::shared_ptr< Chart2ModelContact >   m_spChart2ModelContact;
 386     mutable Any                                 m_aOuterValue;
 387 };
 388
 389 WrappedDataSourceLabelsInFirstColumnProperty::WrappedDataSourceLabelsInFirstColumnProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 390             : WrappedProperty(C2U("DataSourceLabelsInFirstColumn"),OUString())
 391             , m_spChart2ModelContact( spChart2ModelContact )
 392             , m_aOuterValue()
 393 {
 394     m_aOuterValue = WrappedDataSourceLabelsInFirstColumnProperty::getPropertyDefault( 0 );
 395 }
 396
 397 WrappedDataSourceLabelsInFirstColumnProperty::~WrappedDataSourceLabelsInFirstColumnProperty()
 398 {
 399 }
 400
 401 void WrappedDataSourceLabelsInFirstColumnProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 402                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 403 {
 404     sal_Bool bLabelsInFirstRow = sal_True;
 405     if( ! (rOuterValue >>= bLabelsInFirstRow) )
 406         throw lang::IllegalArgumentException( C2U("Property DataSourceLabelsInFirstRow requires value of type boolean"), 0, 0 );
 407
 408     m_aOuterValue = rOuterValue;
 409     bool bNewValue = bLabelsInFirstRow;
 410
 411     ::rtl::OUString aRangeString;
 412     bool bUseColumns = true;
 413     bool bFirstCellAsLabel = true;
 414     bool bHasCategories = true;
 415     uno::Sequence< sal_Int32 > aSequenceMapping;
 416
 417     if( DataSourceHelper::detectRangeSegmentation(
 418             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 419             , bFirstCellAsLabel, bHasCategories ) )
 420     {
 421         if( bUseColumns && bNewValue != bHasCategories )
 422         {
 423             DataSourceHelper::setRangeSegmentation(
 424                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns, bFirstCellAsLabel, bNewValue );
 425         }
 426         else if( !bUseColumns && bNewValue != bFirstCellAsLabel )
 427         {
 428             DataSourceHelper::setRangeSegmentation(
 429                 m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns , bNewValue, bHasCategories );
 430         }
 431     }
 432 }
 433
 434 Any WrappedDataSourceLabelsInFirstColumnProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 435                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 436 {
 437     ::rtl::OUString aRangeString;
 438     bool bUseColumns = true;
 439     bool bFirstCellAsLabel = true;
 440     bool bHasCategories = true;
 441     uno::Sequence< sal_Int32 > aSequenceMapping;
 442
 443     if( DataSourceHelper::detectRangeSegmentation(
 444             m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
 445             , bFirstCellAsLabel, bHasCategories ) )
 446     {
 447         sal_Bool bLabelsInFirstColumn = sal_True;
 448         if( bUseColumns )
 449             bLabelsInFirstColumn = bHasCategories;
 450         else
 451             bLabelsInFirstColumn = bFirstCellAsLabel;
 452
 453         m_aOuterValue <<= bLabelsInFirstColumn;
 454     }
 455     return m_aOuterValue;
 456 }
 457
 458 Any WrappedDataSourceLabelsInFirstColumnProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 459                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 460 {
 461     Any aRet;
 462     aRet <<= sal_True;
 463     return aRet;
 464 }
 465
 466 //-----------------------------------------------------------------------------------------------------------------
 467 //-----------------------------------------------------------------------------------------------------------------
 468 //-----------------------------------------------------------------------------------------------------------------
 469
 470 //PROP_DOCUMENT_HAS_LEGEND
 471 class WrappedHasLegendProperty : public WrappedProperty
 472 {
 473 public:
 474     WrappedHasLegendProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact );
 475     virtual ~WrappedHasLegendProperty();
 476
 477     virtual void setPropertyValue( const ::com::sun::star::uno::Any& rOuterValue, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 478                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 479
 480     virtual ::com::sun::star::uno::Any getPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 481                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 482
 483     virtual ::com::sun::star::uno::Any getPropertyDefault( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState >& xInnerPropertyState ) const
 484                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 485
 486 private: //member
 487     ::boost::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
 488 };
 489
 490 WrappedHasLegendProperty::WrappedHasLegendProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 491             : WrappedProperty(C2U("HasLegend"),OUString())
 492             , m_spChart2ModelContact( spChart2ModelContact )
 493 {
 494 }
 495
 496 WrappedHasLegendProperty::~WrappedHasLegendProperty()
 497 {
 498 }
 499
 500 void WrappedHasLegendProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 501                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 502 {
 503     sal_Bool bNewValue = sal_True;
 504     if( ! (rOuterValue >>= bNewValue) )
 505         throw lang::IllegalArgumentException( C2U("Property HasLegend requires value of type boolean"), 0, 0 );
 506
 507     try
 508     {
 509         Reference< chart2::XLegend > xLegend( LegendHelper::getLegend( m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext,bNewValue ));
 510         if(xLegend.is())
 511         {
 512             Reference< beans::XPropertySet > xLegendProp( xLegend, uno::UNO_QUERY_THROW );
 513             sal_Bool bOldValue = sal_True;
 514             Any aAOld = xLegendProp->getPropertyValue( C2U("Show") );
 515             aAOld >>= bOldValue;
 516             if( bOldValue != bNewValue )
 517                 xLegendProp->setPropertyValue( C2U("Show"), uno::makeAny( bNewValue ));
 518         }
 519     }
 520     catch( uno::Exception & ex )
 521     {
 522         ASSERT_EXCEPTION( ex );
 523     }
 524 }
 525
 526 Any WrappedHasLegendProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 527                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 528 {
 529     Any aRet;
 530     try
 531     {
 532         Reference< beans::XPropertySet > xLegendProp(
 533             LegendHelper::getLegend( m_spChart2ModelContact->getChartModel() ), uno::UNO_QUERY );
 534         if( xLegendProp.is())
 535             aRet = xLegendProp->getPropertyValue( C2U("Show"));
 536         else
 537             aRet <<= sal_False;
 538     }
 539     catch( uno::Exception & ex )
 540     {
 541         ASSERT_EXCEPTION( ex );
 542     }
 543     return aRet;
 544 }
 545
 546 Any WrappedHasLegendProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 547                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 548 {
 549     Any aRet;
 550     aRet <<= sal_False;
 551     return aRet;
 552 }
 553
 554 //-----------------------------------------------------------------------------------------------------------------
 555 //-----------------------------------------------------------------------------------------------------------------
 556 //-----------------------------------------------------------------------------------------------------------------
 557
 558 //PROP_DOCUMENT_HAS_MAIN_TITLE
 559 class WrappedHasMainTitleProperty : public WrappedProperty
 560 {
 561 public:
 562     WrappedHasMainTitleProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact );
 563     virtual ~WrappedHasMainTitleProperty();
 564
 565     virtual void setPropertyValue( const ::com::sun::star::uno::Any& rOuterValue, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 566                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 567
 568     virtual ::com::sun::star::uno::Any getPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 569                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 570
 571     virtual ::com::sun::star::uno::Any getPropertyDefault( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState >& xInnerPropertyState ) const
 572                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 573
 574 private: //member
 575     ::boost::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
 576 };
 577
 578 WrappedHasMainTitleProperty::WrappedHasMainTitleProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 579             : WrappedProperty(C2U("HasMainTitle"),OUString())
 580             , m_spChart2ModelContact( spChart2ModelContact )
 581 {
 582 }
 583
 584 WrappedHasMainTitleProperty::~WrappedHasMainTitleProperty()
 585 {
 586 }
 587
 588 void WrappedHasMainTitleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 589                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 590 {
 591     sal_Bool bNewValue = sal_True;
 592     if( ! (rOuterValue >>= bNewValue) )
 593         throw lang::IllegalArgumentException( C2U("Property HasMainTitle requires value of type boolean"), 0, 0 );
 594
 595     try
 596     {
 597         if( bNewValue )
 598             TitleHelper::createTitle( TitleHelper::MAIN_TITLE, C2U("main-title"), m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext );
 599         else
 600             TitleHelper::removeTitle( TitleHelper::MAIN_TITLE, m_spChart2ModelContact->getChartModel() );
 601     }
 602     catch( uno::Exception & ex )
 603     {
 604         ASSERT_EXCEPTION( ex );
 605     }
 606 }
 607
 608 Any WrappedHasMainTitleProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 609                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 610 {
 611     Any aRet;
 612     try
 613     {
 614         aRet <<= sal_Bool( TitleHelper::getTitle( TitleHelper::MAIN_TITLE, m_spChart2ModelContact->getChartModel() ).is() );
 615     }
 616     catch( uno::Exception & ex )
 617     {
 618         ASSERT_EXCEPTION( ex );
 619     }
 620     return aRet;
 621 }
 622
 623 Any WrappedHasMainTitleProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 624                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 625 {
 626     Any aRet;
 627     aRet <<= sal_False;
 628     return aRet;
 629 }
 630
 631 //-----------------------------------------------------------------------------------------------------------------
 632 //-----------------------------------------------------------------------------------------------------------------
 633 //-----------------------------------------------------------------------------------------------------------------
 634
 635 //PROP_DOCUMENT_HAS_SUB_TITLE
 636 class WrappedHasSubTitleProperty : public WrappedProperty
 637 {
 638 public:
 639     WrappedHasSubTitleProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact );
 640     virtual ~WrappedHasSubTitleProperty();
 641
 642     virtual void setPropertyValue( const ::com::sun::star::uno::Any& rOuterValue, const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 643                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 644
 645     virtual ::com::sun::star::uno::Any getPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xInnerPropertySet ) const
 646                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 647
 648     virtual ::com::sun::star::uno::Any getPropertyDefault( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState >& xInnerPropertyState ) const
 649                         throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 650
 651 private: //member
 652     ::boost::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
 653 };
 654
 655 WrappedHasSubTitleProperty::WrappedHasSubTitleProperty( ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 656             : WrappedProperty(C2U("HasSubTitle"),OUString())
 657             , m_spChart2ModelContact( spChart2ModelContact )
 658 {
 659 }
 660
 661 WrappedHasSubTitleProperty::~WrappedHasSubTitleProperty()
 662 {
 663 }
 664
 665 void WrappedHasSubTitleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 666                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 667 {
 668     sal_Bool bNewValue = sal_True;
 669     if( ! (rOuterValue >>= bNewValue) )
 670         throw lang::IllegalArgumentException( C2U("Property HasSubTitle requires value of type boolean"), 0, 0 );
 671
 672
 673     try
 674     {
 675         if( bNewValue )
 676             TitleHelper::createTitle( TitleHelper::SUB_TITLE, C2U("sub-title"), m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext );
 677         else
 678             TitleHelper::removeTitle( TitleHelper::SUB_TITLE, m_spChart2ModelContact->getChartModel() );
 679     }
 680     catch( uno::Exception & ex )
 681     {
 682         ASSERT_EXCEPTION( ex );
 683     }
 684 }
 685
 686 Any WrappedHasSubTitleProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
 687                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 688 {
 689     Any aRet;
 690     try
 691     {
 692         aRet <<= sal_Bool( TitleHelper::getTitle( TitleHelper::SUB_TITLE, m_spChart2ModelContact->getChartModel() ).is() );
 693     }
 694     catch( uno::Exception & ex )
 695     {
 696         ASSERT_EXCEPTION( ex );
 697     }
 698     return aRet;
 699 }
 700
 701 Any WrappedHasSubTitleProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
 702                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 703 {
 704     Any aRet;
 705     aRet <<= sal_False;
 706     return aRet;
 707 }
 708
 709 //-----------------------------------------------------------------------------------------------------------------
 710 //-----------------------------------------------------------------------------------------------------------------
 711 //-----------------------------------------------------------------------------------------------------------------
 712 ChartDocumentWrapper::ChartDocumentWrapper(
 713     const Reference< uno::XComponentContext > & xContext ) :
 714         m_spChart2ModelContact( new Chart2ModelContact( xContext ) ),
 715         m_bUpdateAddIn( sal_True ),
 716         m_bIsDisposed( false )
 717 {
 718 }
 719
 720 ChartDocumentWrapper::~ChartDocumentWrapper()
 721 {
 722     stopAllComponentListening();
 723 }
 724
 725 // ____ XInterface (for new interfaces) ____
 726 uno::Any SAL_CALL ChartDocumentWrapper::queryInterface( const uno::Type& aType )
 727     throw (uno::RuntimeException)
 728 {
 729     if( m_xDelegator.is())
 730         // calls queryAggregation if the delegator doesn't know aType
 731         return m_xDelegator->queryInterface( aType );
 732     else
 733         return queryAggregation( aType );
 734 }
 735
 736 // ____ chart::XChartDocument (old API wrapper) ____
 737 Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getTitle()
 738     throw (uno::RuntimeException)
 739 {
 740     if( !m_xTitle.is()  )
 741     {
 742         m_xTitle = new TitleWrapper( TitleHelper::MAIN_TITLE, m_spChart2ModelContact );
 743     }
 744     return m_xTitle;
 745 }
 746
 747 Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getSubTitle()
 748     throw (uno::RuntimeException)
 749 {
 750     if( !m_xSubTitle.is() )
 751     {
 752         m_xSubTitle = new TitleWrapper( TitleHelper::SUB_TITLE, m_spChart2ModelContact );
 753     }
 754     return m_xSubTitle;
 755 }
 756
 757 Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getLegend()
 758     throw (uno::RuntimeException)
 759 {
 760     if( ! m_xLegend.is())
 761     {
 762         m_xLegend = new LegendWrapper( m_spChart2ModelContact );
 763         Reference< lang::XComponent > xComp( m_xLegend, uno::UNO_QUERY );
 764     }
 765
 766     return m_xLegend;
 767 }
 768
 769 Reference< beans::XPropertySet > SAL_CALL ChartDocumentWrapper::getArea()
 770     throw (uno::RuntimeException)
 771 {
 772     if( ! m_xArea.is())
 773     {
 774         m_xArea.set( new AreaWrapper( m_spChart2ModelContact ) );
 775         Reference< lang::XComponent > xComp( m_xArea, uno::UNO_QUERY );
 776     }
 777
 778     return m_xArea;
 779 }
 780
 781 Reference< XDiagram > SAL_CALL ChartDocumentWrapper::getDiagram()
 782     throw (uno::RuntimeException)
 783 {
 784     if( !m_xDiagram.is()  )
 785     {
 786         try
 787         {
 788             m_xDiagram = new DiagramWrapper( m_spChart2ModelContact );
 789         }
 790         catch( uno::Exception & ex )
 791         {
 792             ASSERT_EXCEPTION( ex );
 793         }
 794     }
 795
 796     return m_xDiagram;
 797 }
 798
 799 void SAL_CALL ChartDocumentWrapper::setDiagram( const Reference< XDiagram >& xDiagram )
 800     throw (uno::RuntimeException)
 801 {
 802     uno::Reference< util::XRefreshable > xAddIn( xDiagram, uno::UNO_QUERY );
 803     if( xAddIn.is() )
 804     {
 805         setAddIn( xAddIn );
 806     }
 807     else if( xDiagram.is() && xDiagram != m_xDiagram )
 808     {
 809         // set new wrapped diagram at new chart.  This requires the old
 810         // diagram given as parameter to implement the new interface.  If
 811         // this is not possible throw an exception
 812         Reference< chart2::XDiagramProvider > xNewDiaProvider( xDiagram, uno::UNO_QUERY_THROW );
 813         Reference< chart2::XDiagram > xNewDia( xNewDiaProvider->getDiagram());
 814
 815         try
 816         {
 817             Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 818             if( xChartDoc.is() )
 819             {
 820                 // set the new diagram
 821                 xChartDoc->setFirstDiagram( xNewDia );
 822                 m_xDiagram = xDiagram;
 823             }
 824         }
 825         catch( uno::Exception & ex )
 826         {
 827             ASSERT_EXCEPTION( ex );
 828         }
 829     }
 830 }
 831
 832 Reference< XChartData > SAL_CALL ChartDocumentWrapper::getData()
 833     throw (uno::RuntimeException)
 834 {
 835     if( ! m_xChartData.is())
 836     {
 837         m_xChartData.set( new ChartDataWrapper( m_spChart2ModelContact ) );
 838     }
 839     //@todo: check hasInternalDataProvider also in else?
 840
 841     return m_xChartData;
 842 }
 843
 844 void SAL_CALL ChartDocumentWrapper::attachData( const Reference< XChartData >& xData )
 845     throw (uno::RuntimeException)
 846 {
 847     if( !xData.is())
 848         return;
 849
 850     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
 851     if( !xChartDoc.is() )
 852         return;
 853
 854     uno::Reference< chart2::data::XDataProvider > xDataProvider( xChartDoc->getDataProvider());
 855     uno::Reference< XChartDataArray > xDocDataArray( xDataProvider, uno::UNO_QUERY );
 856     uno::Reference< XChartDataArray > xDataArray( xData, uno::UNO_QUERY );
 857     OSL_ASSERT( xDataArray.is());
 858     if( ! xDataArray.is() ||
 859         xDocDataArray == xDataArray )
 860         return;
 861
 862     // remember some diagram properties to reset later
 863     ChartDataRowSource eSeriesSource = ChartDataRowSource_ROWS;
 864     sal_Bool bStacked = sal_False;
 865     sal_Bool bPercent = sal_False;
 866     sal_Bool bDeep = sal_False;
 867     Reference< beans::XPropertySet > xDiaProp( getDiagram(), uno::UNO_QUERY );
 868     if( xDiaProp.is())
 869     {
 870         xDiaProp->getPropertyValue( C2U("DataRowSource")) >>= eSeriesSource;
 871         xDiaProp->getPropertyValue( C2U("Stacked")) >>= bStacked;
 872         xDiaProp->getPropertyValue( C2U("Percent")) >>= bPercent;
 873         xDiaProp->getPropertyValue( C2U("Deep")) >>= bDeep;
 874     }
 875
 876     // create and attach new data source
 877     uno::Reference< chart2::data::XDataSource > xSource;
 878     Sequence< beans::PropertyValue > aArguments( 4 );
 879     aArguments[0] = beans::PropertyValue(
 880         C2U("CellRangeRepresentation"), -1, uno::makeAny( C2U("all") ),
 881         beans::PropertyState_DIRECT_VALUE );
 882     aArguments[1] = beans::PropertyValue(
 883         C2U("DataRowSource"), -1, uno::makeAny( eSeriesSource ),
 884         beans::PropertyState_DIRECT_VALUE );
 885     aArguments[2] = beans::PropertyValue(
 886         C2U("FirstCellAsLabel"), -1, uno::makeAny( true ), beans::PropertyState_DIRECT_VALUE );
 887     aArguments[3] = beans::PropertyValue(
 888         C2U("HasCategories"), -1, uno::makeAny( true ), beans::PropertyState_DIRECT_VALUE );
 889
 890     // /-- locked controllers
 891     ControllerLockGuard aCtrlLockGuard( Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ));
 892     if( xDocDataArray.is())
 893     {
 894         // we have an internal data provider that supports the XChartDataArray
 895         // interface
 896         xDocDataArray->setData( xDataArray->getData());
 897         xDocDataArray->setRowDescriptions( xDataArray->getRowDescriptions());
 898         xDocDataArray->setColumnDescriptions( xDataArray->getColumnDescriptions());
 899
 900         xSource.set( xDataProvider->createDataSource( aArguments ));
 901     }
 902     else
 903     {
 904         uno::Reference< chart2::data::XDataReceiver > xReceiver( xChartDoc, uno::UNO_QUERY );
 905         OSL_ASSERT( xChartDoc.is());
 906         OSL_ASSERT( xReceiver.is());
 907         OSL_ASSERT( xDataArray.is());
 908         if( ! (xChartDoc.is() &&
 909                xReceiver.is()))
 910             return;
 911
 912         // create a data provider containing the new data
 913         Reference< chart2::data::XDataProvider > xTempDataProvider(
 914             ChartModelHelper::createInternalDataProvider( xDataArray ));
 915
 916         if( ! xTempDataProvider.is())
 917             throw uno::RuntimeException( C2U("Couldn't create temporary data provider"),
 918                                          static_cast< ::cppu::OWeakObject * >( this ));
 919
 920         // removes existing data provider and attaches the new one
 921         xReceiver->attachDataProvider( xTempDataProvider );
 922         xSource.set( xTempDataProvider->createDataSource( aArguments));
 923     }
 924
 925     // determine a template
 926     Reference< lang::XMultiServiceFactory > xFact( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
 927     Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram());
 928     DiagramHelper::tTemplateWithServiceName aTemplateAndService =
 929         DiagramHelper::getTemplateForDiagram( xDia, xFact );
 930     OUString aServiceName( aTemplateAndService.second );
 931     Reference< chart2::XChartTypeTemplate > xTemplate = aTemplateAndService.first;
 932
 933     // (fall-back)
 934     if( ! xTemplate.is())
 935     {
 936         if( aServiceName.getLength() == 0 )
 937             aServiceName = C2U("com.sun.star.chart2.template.Column");
 938         xTemplate.set( xFact->createInstance( aServiceName ), uno::UNO_QUERY );
 939     }
 940     OSL_ASSERT( xTemplate.is());
 941
 942     if( xTemplate.is() && xSource.is())
 943     {
 944         // argument detection works with internal knowledge of the
 945         // ArrayDataProvider
 946         OSL_ASSERT( xDia.is());
 947         xTemplate->changeDiagramData(
 948             xDia, xSource, aArguments );
 949     }
 950
 951     // should do nothing if we already have an internal data provider
 952     xChartDoc->createInternalDataProvider( sal_True /* bCloneExistingData */ );
 953
 954     //correct stacking mode
 955     if( bStacked || bPercent || bDeep )
 956     {
 957         StackMode eStackMode = StackMode_Y_STACKED;
 958         if( bDeep )
 959             eStackMode = StackMode_Z_STACKED;
 960         else if( bPercent )
 961             eStackMode = StackMode_Y_STACKED_PERCENT;
 962         DiagramHelper::setStackMode( xDia, eStackMode );
 963     }
 964
 965     m_xChartData = xData;
 966     // \-- locked controllers
 967 }
 968
 969 // ____ XModel ____
 970 sal_Bool SAL_CALL ChartDocumentWrapper::attachResource(
 971     const ::rtl::OUString& URL,
 972     const Sequence< beans::PropertyValue >& Arguments )
 973     throw (uno::RuntimeException)
 974 {
 975     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 976     if( xModel.is() )
 977         return xModel->attachResource( URL, Arguments );
 978     return sal_False;
 979 }
 980
 981 ::rtl::OUString SAL_CALL ChartDocumentWrapper::getURL()
 982     throw (uno::RuntimeException)
 983 {
 984     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 985     if( xModel.is() )
 986         return xModel->getURL();
 987     return ::rtl::OUString();
 988 }
 989
 990 Sequence< beans::PropertyValue > SAL_CALL ChartDocumentWrapper::getArgs()
 991     throw (uno::RuntimeException)
 992 {
 993     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
 994     if( xModel.is() )
 995         return xModel->getArgs();
 996     return Sequence< beans::PropertyValue >();
 997 }
 998
 999 void SAL_CALL ChartDocumentWrapper::connectController( const Reference< frame::XController >& Controller )
1000     throw (uno::RuntimeException)
1001 {
1002     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1003     if( xModel.is() )
1004         xModel->connectController( Controller );
1005 }
1006
1007 void SAL_CALL ChartDocumentWrapper::disconnectController(
1008     const Reference< frame::XController >& Controller )
1009     throw (uno::RuntimeException)
1010 {
1011     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1012     if( xModel.is() )
1013         xModel->disconnectController( Controller );
1014 }
1015
1016 void SAL_CALL ChartDocumentWrapper::lockControllers()
1017     throw (uno::RuntimeException)
1018 {
1019     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1020     if( xModel.is() )
1021         xModel->lockControllers();
1022 }
1023
1024 void SAL_CALL ChartDocumentWrapper::unlockControllers()
1025     throw (uno::RuntimeException)
1026 {
1027     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1028     if( xModel.is() )
1029         xModel->unlockControllers();
1030 }
1031
1032 sal_Bool SAL_CALL ChartDocumentWrapper::hasControllersLocked()
1033     throw (uno::RuntimeException)
1034 {
1035     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1036     if( xModel.is() )
1037         return xModel->hasControllersLocked();
1038     return sal_False;
1039 }
1040
1041 Reference< frame::XController > SAL_CALL ChartDocumentWrapper::getCurrentController()
1042     throw (uno::RuntimeException)
1043 {
1044     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1045     if( xModel.is() )
1046         return xModel->getCurrentController();
1047     return 0;
1048 }
1049
1050 void SAL_CALL ChartDocumentWrapper::setCurrentController(
1051     const Reference< frame::XController >& Controller )
1052     throw (container::NoSuchElementException,
1053            uno::RuntimeException)
1054 {
1055     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1056     if( xModel.is() )
1057         xModel->setCurrentController( Controller );
1058 }
1059
1060 Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::getCurrentSelection()
1061     throw (uno::RuntimeException)
1062 {
1063     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1064     if( xModel.is() )
1065         return xModel->getCurrentSelection();
1066     return 0;
1067 }
1068
1069
1070 // ____ XComponent ____
1071 void SAL_CALL ChartDocumentWrapper::dispose()
1072     throw (uno::RuntimeException)
1073 {
1074     if( m_bIsDisposed )
1075         throw lang::DisposedException(
1076             C2U("ChartDocumentWrapper is disposed" ),
1077             static_cast< ::cppu::OWeakObject* >( this ));
1078
1079     m_bIsDisposed = true;
1080
1081     try
1082     {
1083         Reference< lang::XComponent > xFormerDelegator( m_xDelegator, uno::UNO_QUERY );
1084         DisposeHelper::DisposeAndClear( m_xTitle );
1085         DisposeHelper::DisposeAndClear( m_xSubTitle );
1086         DisposeHelper::DisposeAndClear( m_xLegend );
1087         DisposeHelper::DisposeAndClear( m_xChartData );
1088         DisposeHelper::DisposeAndClear( m_xDiagram );
1089         DisposeHelper::DisposeAndClear( m_xArea );
1090         m_xChartView.set( 0 );
1091         m_xShapeFactory.set( 0 );
1092         m_xDelegator.set( 0 );
1093
1094         clearWrappedPropertySet();
1095         m_spChart2ModelContact->clear();
1096         impl_resetAddIn();
1097
1098         stopAllComponentListening();
1099
1100         try
1101         {
1102             if( xFormerDelegator.is())
1103                 xFormerDelegator->dispose();
1104         }
1105         catch( lang::DisposedException )
1106         {
1107             // this is ok, don't panic
1108         }
1109     }
1110     catch( uno::Exception &ex )
1111     {
1112         ASSERT_EXCEPTION( ex );
1113     }
1114 }
1115
1116 void ChartDocumentWrapper::impl_resetAddIn()
1117 {
1118     Reference< util::XRefreshable > xAddIn( m_xAddIn );
1119     m_xAddIn.set( 0 );
1120
1121     if( xAddIn.is() )
1122     {
1123         try
1124         {
1125             //make sure that the add-in does not hold a refernce to us anymore:
1126             Reference< lang::XComponent > xComp( xAddIn, uno::UNO_QUERY );
1127             if( xComp.is())
1128                 xComp->dispose();
1129             else
1130             {
1131                 uno::Reference< lang::XInitialization > xInit( xAddIn, uno::UNO_QUERY );
1132                 if( xInit.is() )
1133                 {
1134                     uno::Any aParam;
1135                     uno::Reference< com::sun::star::chart::XChartDocument > xDoc( 0 );
1136                     aParam <<= xDoc;
1137                     uno::Sequence< uno::Any > aSeq( &aParam, 1 );
1138                     xInit->initialize( aSeq );
1139                 }
1140             }
1141         }
1142         catch( const uno::RuntimeException& ex )
1143         {
1144             ASSERT_EXCEPTION( ex );
1145         }
1146         catch( const uno::Exception& ex )
1147         {
1148             ASSERT_EXCEPTION( ex );
1149         }
1150     }
1151 }
1152
1153 void ChartDocumentWrapper::setBaseDiagram( const rtl::OUString& rBaseDiagram )
1154 {
1155     ControllerLockGuard aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
1156     m_aBaseDiagram = rBaseDiagram;
1157
1158     uno::Reference< XDiagram > xDiagram( ChartDocumentWrapper::createInstance( rBaseDiagram ), uno::UNO_QUERY );
1159     if( xDiagram.is() )
1160         this->setDiagram( xDiagram );
1161 }
1162
1163 rtl::OUString ChartDocumentWrapper::getBaseDiagram() const
1164 {
1165     return m_aBaseDiagram;
1166 }
1167
1168 Reference< util::XRefreshable > ChartDocumentWrapper::getAddIn() const
1169 {
1170     return m_xAddIn;
1171 }
1172
1173 void ChartDocumentWrapper::setAddIn( const Reference< util::XRefreshable >& xAddIn )
1174 {
1175     if( m_xAddIn == xAddIn )
1176         return;
1177
1178     ControllerLockGuard aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
1179     impl_resetAddIn();
1180     m_xAddIn = xAddIn;
1181     // initialize AddIn with this as chart document
1182     uno::Reference< lang::XInitialization > xInit( m_xAddIn, uno::UNO_QUERY );
1183     if( xInit.is() )
1184     {
1185         uno::Any aParam;
1186         uno::Reference< XChartDocument > xDoc( (XChartDocument*)this, uno::UNO_QUERY );
1187         aParam <<= xDoc;
1188         uno::Sequence< uno::Any > aSeq( &aParam, 1 );
1189         xInit->initialize( aSeq );
1190     }
1191 }
1192
1193 void ChartDocumentWrapper::setUpdateAddIn( sal_Bool bUpdateAddIn )
1194 {
1195     m_bUpdateAddIn = bUpdateAddIn;
1196 }
1197 sal_Bool ChartDocumentWrapper::getUpdateAddIn() const
1198 {
1199     return m_bUpdateAddIn;
1200 }
1201
1202 Reference< drawing::XShapes > ChartDocumentWrapper::getAdditionalShapes() const
1203 {
1204     // get additional non-chart shapes for XML export
1205     uno::Reference< drawing::XShapes > xFoundShapes;
1206     uno::Reference< drawing::XDrawPage > xDrawPage( this->impl_getDrawPage() );
1207
1208     uno::Reference< drawing::XShapes > xDrawPageShapes( xDrawPage, uno::UNO_QUERY );
1209     if( !xDrawPageShapes.is() )
1210         return xFoundShapes;
1211
1212     uno::Reference<drawing::XShapes> xChartRoot( DrawModelWrapper::getChartRootShape( xDrawPage ) );
1213
1214     // iterate 'flat' over all top-level objects
1215     // and determine all that are no chart objects
1216     ::std::vector< uno::Reference< drawing::XShape > > aShapeVector;
1217     sal_Int32 nSubCount = xDrawPageShapes->getCount();
1218     uno::Reference< drawing::XShape > xShape;
1219     for( sal_Int32 nS = 0; nS < nSubCount; nS++ )
1220     {
1221         if( xDrawPageShapes->getByIndex( nS ) >>= xShape )
1222         {
1223             if( xShape.is() && xChartRoot!=xShape )
1224                 aShapeVector.push_back( xShape );
1225         }
1226     }
1227
1228     if( !aShapeVector.empty() )
1229     {
1230         // create a shape collection
1231         xFoundShapes = uno::Reference< drawing::XShapes >( SvxShapeCollection_NewInstance(), uno::UNO_QUERY );
1232
1233         DBG_ASSERT( xFoundShapes.is(), "Couldn't create a shape collection!" );
1234         if( xFoundShapes.is())
1235         {
1236             ::std::vector< uno::Reference< drawing::XShape > >::iterator aIter;
1237             for( aIter = aShapeVector.begin(); aIter != aShapeVector.end(); ++aIter )
1238                 xFoundShapes->add( *aIter );
1239         }
1240     }
1241
1242     return xFoundShapes;
1243 }
1244
1245 void SAL_CALL ChartDocumentWrapper::addEventListener( const Reference< lang::XEventListener >& xListener )
1246     throw (uno::RuntimeException)
1247 {
1248     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1249     if( xModel.is() )
1250         xModel->addEventListener( xListener );
1251 }
1252
1253 void SAL_CALL ChartDocumentWrapper::removeEventListener( const Reference< lang::XEventListener >& aListener )
1254     throw (uno::RuntimeException)
1255 {
1256     Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
1257     if( xModel.is() )
1258         xModel->removeEventListener( aListener );
1259 }
1260
1261 // ____ XDrawPageSupplier ____
1262 uno::Reference< drawing::XDrawPage > SAL_CALL ChartDocumentWrapper::getDrawPage()
1263     throw (uno::RuntimeException)
1264 {
1265     return this->impl_getDrawPage();
1266 }
1267
1268 uno::Reference< drawing::XDrawPage > ChartDocumentWrapper::impl_getDrawPage() const
1269     throw (uno::RuntimeException)
1270 {
1271     return m_spChart2ModelContact->getDrawPage();
1272 }
1273
1274 // ____ XMultiServiceFactory ____
1275 uno::Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::createInstance(
1276     const ::rtl::OUString& aServiceSpecifier )
1277     throw (uno::Exception,
1278            uno::RuntimeException)
1279 {
1280     uno::Reference< uno::XInterface > xResult;
1281
1282     Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
1283     if( !xChartDoc.is() )
1284         return xResult;
1285
1286     bool bServiceFound = false;
1287     tServiceNameMap & rMap = lcl_getStaticServiceNameMap();
1288
1289     tServiceNameMap::const_iterator aIt( rMap.find( aServiceSpecifier ));
1290     if( aIt != rMap.end())
1291     {
1292         bool bCreateDiagram = false;
1293         uno::Reference< lang::XMultiServiceFactory > xManagerFact(
1294             xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
1295         uno::Reference< chart2::XChartTypeTemplate > xTemplate;
1296
1297         switch( (*aIt).second )
1298         {
1299             case SERVICE_NAME_AREA_DIAGRAM:
1300                 if( xManagerFact.is())
1301                 {
1302                     xTemplate.set(
1303                         xManagerFact->createInstance(
1304                             C2U( "com.sun.star.chart2.template.Area" )), uno::UNO_QUERY );
1305                     bCreateDiagram = true;
1306                 }
1307                 break;
1308             case SERVICE_NAME_BAR_DIAGRAM:
1309                 if( xManagerFact.is())
1310                 {
1311                     // this is for bar and column (the latter is the default if
1312                     // no "Vertical=false" property was set)
1313                     xTemplate.set(
1314                         xManagerFact->createInstance(
1315                             C2U( "com.sun.star.chart2.template.Column" )), uno::UNO_QUERY );
1316                     bCreateDiagram = true;
1317                 }
1318                 break;
1319             case SERVICE_NAME_DONUT_DIAGRAM:
1320                 if( xManagerFact.is())
1321                 {
1322                     xTemplate.set(
1323                         xManagerFact->createInstance(
1324                             C2U( "com.sun.star.chart2.template.Donut" )), uno::UNO_QUERY );
1325                     bCreateDiagram = true;
1326                 }
1327                 break;
1328             case SERVICE_NAME_LINE_DIAGRAM:
1329                 if( xManagerFact.is())
1330                 {
1331                     xTemplate.set(
1332                         xManagerFact->createInstance(
1333                             C2U( "com.sun.star.chart2.template.Line" )), uno::UNO_QUERY );
1334                     bCreateDiagram = true;
1335                 }
1336                 break;
1337             case SERVICE_NAME_NET_DIAGRAM:
1338                 if( xManagerFact.is())
1339                 {
1340                     xTemplate.set(
1341                         xManagerFact->createInstance(
1342                             C2U( "com.sun.star.chart2.template.Net" )), uno::UNO_QUERY );
1343                     bCreateDiagram = true;
1344                 }
1345                 break;
1346             case SERVICE_NAME_FILLED_NET_DIAGRAM:
1347                 if( xManagerFact.is())
1348                 {
1349                     xTemplate.set(
1350                         xManagerFact->createInstance(
1351                             C2U( "com.sun.star.chart2.template.FilledNet" )), uno::UNO_QUERY );
1352                     bCreateDiagram = true;
1353                 }
1354             case SERVICE_NAME_PIE_DIAGRAM:
1355                 if( xManagerFact.is())
1356                 {
1357                     xTemplate.set(
1358                         xManagerFact->createInstance(
1359                             C2U( "com.sun.star.chart2.template.Pie" )), uno::UNO_QUERY );
1360                     bCreateDiagram = true;
1361                 }
1362                 break;
1363             case SERVICE_NAME_STOCK_DIAGRAM:
1364                 if( xManagerFact.is())
1365                 {
1366                     xTemplate.set(
1367                         xManagerFact->createInstance(
1368                             C2U( "com.sun.star.chart2.template.StockLowHighClose" )), uno::UNO_QUERY );
1369                     bCreateDiagram = true;
1370                 }
1371                 break;
1372             case SERVICE_NAME_XY_DIAGRAM:
1373                 if( xManagerFact.is())
1374                 {
1375                     xTemplate.set(
1376                         xManagerFact->createInstance(
1377                             C2U( "com.sun.star.chart2.template.ScatterLineSymbol" )), uno::UNO_QUERY );
1378                     bCreateDiagram = true;
1379                 }
1380                 break;
1381
1382             case SERVICE_NAME_BUBBLE_DIAGRAM:
1383                 if( xManagerFact.is())
1384                 {
1385                     xTemplate.set(
1386                         xManagerFact->createInstance(
1387                             C2U( "com.sun.star.chart2.template.Bubble" )), uno::UNO_QUERY );
1388                     bCreateDiagram = true;
1389                 }
1390                 break;
1391
1392             case SERVICE_NAME_DASH_TABLE:
1393             case SERVICE_NAME_GARDIENT_TABLE:
1394             case SERVICE_NAME_HATCH_TABLE:
1395             case SERVICE_NAME_BITMAP_TABLE:
1396             case SERVICE_NAME_TRANSP_GRADIENT_TABLE:
1397             case SERVICE_NAME_MARKER_TABLE:
1398                 {
1399                     uno::Reference< lang::XMultiServiceFactory > xTableFactory( xChartDoc, uno::UNO_QUERY );
1400                     DBG_ASSERT( xTableFactory.get() != this, "new model is expected to implement service factory for gradient table etc" );
1401                     if( xTableFactory.is() && xTableFactory.get() != this )
1402                         xResult.set( xTableFactory->createInstance( aIt->first ), uno::UNO_QUERY );
1403                 }
1404                 break;
1405
1406             case SERVICE_NAME_NAMESPACE_MAP:
1407 //                 xResult = svx::NamespaceMap_createInstance( aWhichIds, &m_pModel->GetPool() );
1408                 break;
1409             case SERVICE_NAME_EXPORT_GRAPHIC_RESOLVER:
1410 //                 xResult = static_cast< ::cppu::OWeakObject * >( new SvXMLGraphicHelper( GRAPHICHELPER_MODE_WRITE ));
1411                 break;
1412             case SERVICE_NAME_IMPORT_GRAPHIC_RESOLVER:
1413 //                 xResult = static_cast< ::cppu::OWeakObject * >( new SvXMLGraphicHelper( GRAPHICHELPER_MODE_READ ));
1414                 break;
1415         }
1416
1417         if( bCreateDiagram && xTemplate.is() )
1418         {
1419             try
1420             {
1421                 uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram());
1422                 if( xDia.is())
1423                 {
1424                     // /-- locked controllers
1425                     ControllerLockGuard aCtrlLockGuard( Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ));
1426                     xTemplate->changeDiagram( xDia );
1427                     // \-- locked controllers
1428                 }
1429                 else
1430                 {
1431                     // /-- locked controllers
1432                     ControllerLockGuard aCtrlLockGuard( Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ));
1433                     xDia.set( xTemplate->createDiagramByDataSource(
1434                                   uno::Reference< chart2::data::XDataSource >(),
1435                                   uno::Sequence< beans::PropertyValue >()));
1436                     xChartDoc->setFirstDiagram( xDia );
1437                     // \-- locked controllers
1438                 }
1439
1440                 xResult = static_cast< ::cppu::OWeakObject* >( new DiagramWrapper( m_spChart2ModelContact ));
1441             }
1442             catch( uno::Exception & ex )
1443             {
1444                 ASSERT_EXCEPTION( ex );
1445             }
1446         }
1447
1448         bServiceFound = true;
1449     }
1450     else if( aServiceSpecifier.equals( CHART_RENDERER_SERVICE_IMPLEMENTATION_NAME ) )
1451     {
1452         Reference< lang::XUnoTunnel > xChartRenderer( new ChartRenderer( m_spChart2ModelContact->getChartModel() ) );
1453         xResult.set( xChartRenderer );
1454         bServiceFound = true;
1455     }
1456     else if( aServiceSpecifier.equals( C2U("com.sun.star.comp.chart2.DataSeriesWrapper") ) )
1457     {
1458         Reference< beans::XPropertySet > xDataSeries( new DataSeriesPointWrapper( m_spChart2ModelContact ) );
1459         xResult.set( xDataSeries );
1460         bServiceFound = true;
1461     }
1462     else if( aServiceSpecifier.equals( CHART_VIEW_SERVICE_NAME ) )
1463     {
1464         if( !m_xChartView.is() )
1465         {
1466             Reference< lang::XMultiServiceFactory > xFact(
1467                 m_spChart2ModelContact->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
1468             if( xFact.is() )
1469             {
1470                 Reference< lang::XInitialization > xViewInit( xFact->createInstance(
1471                         CHART_VIEW_SERVICE_NAME ), uno::UNO_QUERY );
1472                 if(xViewInit.is())
1473                 {
1474                     try
1475                     {
1476                         m_xChartView = xViewInit;
1477
1478                         Sequence< Any > aArguments(2);
1479                         Reference<frame::XModel> xModel(this);
1480                         aArguments[0]=uno::makeAny(xModel);
1481                         sal_Bool bRefreshAddIn = sal_True;
1482                         aArguments[1]=uno::makeAny(bRefreshAddIn);
1483                         xViewInit->initialize(aArguments);
1484                     }
1485                     catch( uno::Exception & ex )
1486                     {
1487                         ASSERT_EXCEPTION( ex );
1488                     }
1489                 }
1490             }
1491         }
1492         xResult.set( m_xChartView );
1493         bServiceFound = true;
1494     }
1495     else
1496     {
1497         // try to create a shape
1498         try
1499         {
1500             if( !m_xShapeFactory.is() && m_xChartView.is() )
1501             {
1502                 Reference< lang::XUnoTunnel> xUnoTunnel(m_xChartView,uno::UNO_QUERY);
1503                 if(xUnoTunnel.is())
1504                 {
1505                     ExplicitValueProvider* pProvider = reinterpret_cast<ExplicitValueProvider*>(xUnoTunnel->getSomething(
1506                         ExplicitValueProvider::getUnoTunnelId() ));
1507                     if( pProvider )
1508                         m_xShapeFactory.set( pProvider->getDrawModelWrapper()->getShapeFactory() );
1509                 }
1510             }
1511             if( m_xShapeFactory.is() )
1512             {
1513                 xResult = m_xShapeFactory->createInstance( aServiceSpecifier );
1514                 bServiceFound = true;
1515             }
1516         }
1517         catch( const uno::Exception )
1518         {
1519             // couldn't create shape
1520         }
1521     }
1522
1523     // finally, try to create an addin
1524     if( !bServiceFound )
1525     {
1526         try
1527         {
1528             Reference< lang::XMultiServiceFactory > xFact(
1529                 m_spChart2ModelContact->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
1530             if( xFact.is() )
1531             {
1532                 uno::Reference< util::XRefreshable > xAddIn(
1533                     xFact->createInstance( aServiceSpecifier ), uno::UNO_QUERY );
1534                 if( xAddIn.is() )
1535                 {
1536                     xResult = xAddIn;
1537                     bServiceFound = true;
1538                 }
1539             }
1540         }
1541         catch( const uno::Exception& ex )
1542         {
1543             (void)ex;
1544             // couldn't create service
1545         }
1546     }
1547
1548     return xResult;
1549 }
1550
1551 uno::Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::createInstanceWithArguments(
1552     const ::rtl::OUString& ServiceSpecifier,
1553     const uno::Sequence< uno::Any >& Arguments )
1554     throw (uno::Exception,
1555            uno::RuntimeException)
1556 {
1557     OSL_ENSURE( Arguments.getLength(), "createInstanceWithArguments: Warning: Arguments are ignored" );
1558     (void)(Arguments);
1559
1560     return createInstance( ServiceSpecifier );
1561 }
1562
1563 uno::Sequence< ::rtl::OUString > SAL_CALL ChartDocumentWrapper::getAvailableServiceNames()
1564     throw (uno::RuntimeException)
1565 {
1566     tServiceNameMap & rMap = lcl_getStaticServiceNameMap();
1567     uno::Sequence< ::rtl::OUString > aResult( rMap.size());
1568
1569     ::std::transform( rMap.begin(), rMap.end(),
1570                       aResult.getArray(),
1571                       ::std::select1st< tServiceNameMap::value_type >() );
1572
1573     return aResult;
1574
1575 //         // shapes
1576 // //         uno::Sequence< OUString > aDrawServices( SvxUnoDrawMSFactory::getAvailableServiceNames() );
1577 // //         const OUString * pArr = aDrawServices.getConstArray();
1578 // //         aServices.insert( aServices.end(), pArr, pArr + aDrawServices.getLength() );
1579 //     }
1580
1581
1582     // add-ins
1583  //    uno::Sequence< OUString > aAddIns( GetAddInCollection().GetAddInNames() );
1584 //     pArr = aAddIns.getConstArray();
1585 //     aServices.insert( aServices.end(), pArr, pArr + aAddIns.getLength() );
1586
1587 //     return ContainerToSequence( aServices );
1588 }
1589
1590 // ____ XAggregation ____
1591 void SAL_CALL ChartDocumentWrapper::setDelegator(
1592     const uno::Reference< uno::XInterface >& rDelegator )
1593     throw (uno::RuntimeException)
1594 {
1595     if( rDelegator.is())
1596     {
1597         m_xDelegator = rDelegator;
1598         m_spChart2ModelContact->setModel( uno::Reference< frame::XModel >(m_xDelegator, uno::UNO_QUERY) );
1599     }
1600     else
1601     {
1602         // this is a sort of dispose() from the new model,so release ressources here
1603         try
1604         {
1605             this->dispose();
1606         }
1607         catch( uno::Exception &ex )
1608         {
1609             ASSERT_EXCEPTION( ex );
1610         }
1611     }
1612 }
1613
1614 uno::Any SAL_CALL ChartDocumentWrapper::queryAggregation( const uno::Type& rType )
1615     throw (uno::RuntimeException)
1616 {
1617     return ChartDocumentWrapper_Base::queryInterface( rType );
1618 }
1619
1620 // ____ ::utl::OEventListenerAdapter ____
1621 void ChartDocumentWrapper::_disposing( const lang::EventObject& rSource )
1622 {
1623     if( rSource.Source == m_xTitle )
1624         m_xTitle.set( 0 );
1625     else if( rSource.Source == m_xSubTitle )
1626         m_xSubTitle.set( 0 );
1627     else if( rSource.Source == m_xLegend )
1628         m_xLegend.set( 0 );
1629     else if( rSource.Source == m_xChartData )
1630         m_xChartData.set( 0 );
1631     else if( rSource.Source == m_xDiagram )
1632         m_xDiagram.set( 0 );
1633     else if( rSource.Source == m_xArea )
1634         m_xArea.set( 0 );
1635     else if( rSource.Source == m_xAddIn )
1636         m_xAddIn.set( 0 );
1637     else if( rSource.Source == m_xChartView )
1638         m_xChartView.set( 0 );
1639 }
1640
1641 // ================================================================================
1642
1643 // WrappedPropertySet
1644 Reference< beans::XPropertySet > ChartDocumentWrapper::getInnerPropertySet()
1645 {
1646     return 0;
1647 }
1648 const Sequence< beans::Property >& ChartDocumentWrapper::getPropertySequence()
1649 {
1650     return lcl_GetPropertySequence();
1651 }
1652
1653 const std::vector< WrappedProperty* > ChartDocumentWrapper::createWrappedProperties()
1654 {
1655     ::std::vector< ::chart::WrappedProperty* > aWrappedProperties;
1656     aWrappedProperties.push_back( new WrappedDataSourceLabelsInFirstRowProperty( m_spChart2ModelContact ) );
1657     aWrappedProperties.push_back( new WrappedDataSourceLabelsInFirstColumnProperty( m_spChart2ModelContact ) );
1658     aWrappedProperties.push_back( new WrappedHasLegendProperty( m_spChart2ModelContact ) );
1659     aWrappedProperties.push_back( new WrappedHasMainTitleProperty( m_spChart2ModelContact ) );
1660     aWrappedProperties.push_back( new WrappedHasSubTitleProperty( m_spChart2ModelContact ) );
1661     aWrappedProperties.push_back( new WrappedAddInProperty( *this ) );
1662     aWrappedProperties.push_back( new WrappedBaseDiagramProperty( *this ) );
1663     aWrappedProperties.push_back( new WrappedAdditionalShapesProperty( *this ) );
1664     aWrappedProperties.push_back( new WrappedRefreshAddInAllowedProperty( *this ) );
1665     aWrappedProperties.push_back( new WrappedIgnoreProperty( C2U("NullDate"),Any() ) ); // i99104
1666
1667     return aWrappedProperties;
1668 }
1669
1670 // ================================================================================
1671
1672 uno::Sequence< ::rtl::OUString > ChartDocumentWrapper::getSupportedServiceNames_Static()
1673 {
1674     uno::Sequence< ::rtl::OUString > aServices( 4 );
1675     aServices[ 0 ] = C2U( "com.sun.star.chart.ChartDocument" );
1676     aServices[ 1 ] = CHART_CHARTAPIWRAPPER_SERVICE_NAME;
1677     aServices[ 2 ] = C2U( "com.sun.star.xml.UserDefinedAttributeSupplier" );
1678     aServices[ 3 ] = C2U( "com.sun.star.beans.PropertySet" );
1679     return aServices;
1680 }
1681
1682 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
1683 APPHELPER_XSERVICEINFO_IMPL( ChartDocumentWrapper, CHART_CHARTAPIWRAPPER_IMPLEMENTATION_NAME );
1684
1685 } //  namespace wrapper
1686 } //  namespace chart