xmloff/source/chart/SchXMLImport.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
  21 #include "SchXMLImport.hxx"
  22 #include "SchXMLChartContext.hxx"
  23 #include "contexts.hxx"
  24 #include "XMLChartPropertySetMapper.hxx"
  25 #include "SchXMLTools.hxx"
  26
  27 #include <tools/debug.hxx>
  28 #include <rtl/ustrbuf.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include "xmloff/xmlnmspe.hxx"
  31 #include <xmloff/xmltoken.hxx>
  32 #include <xmloff/xmluconv.hxx>
  33 #include <xmloff/nmspmap.hxx>
  34 #include <xmloff/xmlictxt.hxx>
  35 #include <xmloff/xmlstyle.hxx>
  36 #include <com/sun/star/task/XStatusIndicatorSupplier.hpp>
  37 #include <com/sun/star/chart/XChartDocument.hpp>
  38 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  39 #include <com/sun/star/container/XChild.hpp>
  40 #include <com/sun/star/uno/XComponentContext.hpp>
  41 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
  42 #include <com/sun/star/chart2/data/XDataProvider.hpp>
  43 #include <com/sun/star/chart2/XChartDocument.hpp>
  44 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  45 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  46 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  47
  48 #include <com/sun/star/document/XDocumentProperties.hpp>
  49 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
  50
  51 #include <typeinfo>
  52
  53 using namespace com::sun::star;
  54 using namespace ::xmloff::token;
  55
  56 using ::com::sun::star::uno::Reference;
  57 using ::com::sun::star::uno::Sequence;
  58
  59 namespace
  60 {
  61 class lcl_MatchesChartType : public ::std::unary_function< Reference< chart2::XChartType >, bool >
  62 {
  63 public:
  64     explicit lcl_MatchesChartType( const OUString & aChartTypeName ) :
  65             m_aChartTypeName( aChartTypeName )
  66     {}
  67
  68     bool operator () ( const Reference< chart2::XChartType > & xChartType ) const
  69     {
  70         return (xChartType.is() &&
  71                 xChartType->getChartType().equals( m_aChartTypeName ));
  72     }
  73
  74 private:
  75     OUString m_aChartTypeName;
  76 };
  77 } // anonymous namespace
  78
  79 /* ----------------------------------------
  80    TokenMaps for distinguishing different
  81    tokens in different contexts
  82    ----------------------------------------*/
  83
  84 // ----------------------------------------
  85 // element maps
  86 // ----------------------------------------
  87
  88
  89
  90
  91
  92
  93
  94 // ----------------------------------------
  95 // attribute maps
  96 // ----------------------------------------
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106 // ========================================
 107
 108 SchXMLImportHelper::SchXMLImportHelper() :
 109         mpAutoStyles( 0 ),
 110
 111         mpChartDocElemTokenMap( 0 ),
 112         mpTableElemTokenMap( 0 ),
 113         mpChartElemTokenMap( 0 ),
 114         mpPlotAreaElemTokenMap( 0 ),
 115         mpSeriesElemTokenMap( 0 ),
 116
 117         mpChartAttrTokenMap( 0 ),
 118         mpPlotAreaAttrTokenMap( 0 ),
 119         mpAutoStyleAttrTokenMap( 0 ),
 120         mpCellAttrTokenMap( 0 ),
 121         mpSeriesAttrTokenMap( 0 ),
 122         mpRegEquationAttrTokenMap( 0 )
 123 {
 124 }
 125
 126 SchXMLImportHelper::~SchXMLImportHelper()
 127 {
 128         // delete token maps
 129     if( mpChartDocElemTokenMap )
 130         delete mpChartDocElemTokenMap;
 131     if( mpTableElemTokenMap )
 132         delete mpTableElemTokenMap;
 133     if( mpChartElemTokenMap )
 134         delete mpChartElemTokenMap;
 135     if( mpPlotAreaElemTokenMap )
 136         delete mpPlotAreaElemTokenMap;
 137     if( mpSeriesElemTokenMap )
 138         delete mpSeriesElemTokenMap;
 139
 140     if( mpChartAttrTokenMap )
 141         delete mpChartAttrTokenMap;
 142     if( mpPlotAreaAttrTokenMap )
 143         delete mpPlotAreaAttrTokenMap;
 144     if( mpAutoStyleAttrTokenMap )
 145         delete mpAutoStyleAttrTokenMap;
 146     if( mpCellAttrTokenMap )
 147         delete mpCellAttrTokenMap;
 148     if( mpSeriesAttrTokenMap )
 149         delete mpSeriesAttrTokenMap;
 150 }
 151
 152 SvXMLImportContext* SchXMLImportHelper::CreateChartContext(
 153     SvXMLImport& rImport,
 154     sal_uInt16 nPrefix, const OUString& rLocalName,
 155     const Reference< frame::XModel > xChartModel,
 156     const Reference< xml::sax::XAttributeList >& )
 157 {
 158     SvXMLImportContext* pContext = 0;
 159
 160     Reference< chart::XChartDocument > xDoc( xChartModel, uno::UNO_QUERY );
 161     if( xDoc.is())
 162     {
 163         mxChartDoc = xDoc;
 164         pContext = new SchXMLChartContext( *this, rImport, rLocalName );
 165     }
 166     else
 167     {
 168         SAL_WARN("xmloff.chart", "No valid XChartDocument given as XModel" );
 169         pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName );
 170     }
 171
 172     return pContext;
 173 }
 174
 175 /* ----------------------------------------
 176    get various token maps
 177    ----------------------------------------*/
 178
 179 const SvXMLTokenMap& SchXMLImportHelper::GetDocElemTokenMap()
 180 {
 181     if( ! mpChartDocElemTokenMap )
 182     {
 183         static SvXMLTokenMapEntry aDocElemTokenMap[] =
 184         {
 185             { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_STYLES,   XML_TOK_DOC_AUTOSTYLES  },
 186             { XML_NAMESPACE_OFFICE, XML_STYLES,             XML_TOK_DOC_STYLES  },
 187             { XML_NAMESPACE_OFFICE, XML_META,               XML_TOK_DOC_META    },
 188             { XML_NAMESPACE_OFFICE, XML_BODY,               XML_TOK_DOC_BODY    },
 189             XML_TOKEN_MAP_END
 190         };
 191
 192         mpChartDocElemTokenMap = new SvXMLTokenMap( aDocElemTokenMap );
 193     } // if( ! mpChartDocElemTokenMap )
 194
 195     return *mpChartDocElemTokenMap;
 196 }
 197
 198 const SvXMLTokenMap& SchXMLImportHelper::GetTableElemTokenMap()
 199 {
 200     if( ! mpTableElemTokenMap )
 201     {
 202         static SvXMLTokenMapEntry aTableElemTokenMap[] =
 203     {
 204         { XML_NAMESPACE_TABLE,  XML_TABLE_HEADER_COLUMNS,   XML_TOK_TABLE_HEADER_COLS   },
 205         { XML_NAMESPACE_TABLE,  XML_TABLE_COLUMNS,          XML_TOK_TABLE_COLUMNS       },
 206         { XML_NAMESPACE_TABLE,  XML_TABLE_COLUMN,           XML_TOK_TABLE_COLUMN        },
 207         { XML_NAMESPACE_TABLE,  XML_TABLE_HEADER_ROWS,      XML_TOK_TABLE_HEADER_ROWS   },
 208         { XML_NAMESPACE_TABLE,  XML_TABLE_ROWS,             XML_TOK_TABLE_ROWS          },
 209         { XML_NAMESPACE_TABLE,  XML_TABLE_ROW,              XML_TOK_TABLE_ROW           },
 210         XML_TOKEN_MAP_END
 211     };
 212
 213         mpTableElemTokenMap = new SvXMLTokenMap( aTableElemTokenMap );
 214     } // if( ! mpTableElemTokenMap )
 215
 216     return *mpTableElemTokenMap;
 217 }
 218
 219 const SvXMLTokenMap& SchXMLImportHelper::GetChartElemTokenMap()
 220 {
 221     if( ! mpChartElemTokenMap )
 222     {
 223         static SvXMLTokenMapEntry aChartElemTokenMap[] =
 224         {
 225             { XML_NAMESPACE_CHART,  XML_PLOT_AREA,              XML_TOK_CHART_PLOT_AREA     },
 226             { XML_NAMESPACE_CHART,  XML_TITLE,                  XML_TOK_CHART_TITLE         },
 227             { XML_NAMESPACE_CHART,  XML_SUBTITLE,               XML_TOK_CHART_SUBTITLE      },
 228             { XML_NAMESPACE_CHART,  XML_LEGEND,             XML_TOK_CHART_LEGEND        },
 229             { XML_NAMESPACE_TABLE,  XML_TABLE,                  XML_TOK_CHART_TABLE         },
 230             XML_TOKEN_MAP_END
 231         };
 232
 233         mpChartElemTokenMap = new SvXMLTokenMap( aChartElemTokenMap );
 234     } // if( ! mpChartElemTokenMap )
 235
 236     return *mpChartElemTokenMap;
 237 }
 238
 239 const SvXMLTokenMap& SchXMLImportHelper::GetPlotAreaElemTokenMap()
 240 {
 241     if( ! mpPlotAreaElemTokenMap )
 242     {
 243         static SvXMLTokenMapEntry aPlotAreaElemTokenMap[] =
 244 {
 245     { XML_NAMESPACE_CHART_EXT,  XML_COORDINATE_REGION,      XML_TOK_PA_COORDINATE_REGION_EXT },
 246     { XML_NAMESPACE_CHART,  XML_COORDINATE_REGION,      XML_TOK_PA_COORDINATE_REGION },
 247     { XML_NAMESPACE_CHART,  XML_AXIS,                   XML_TOK_PA_AXIS             },
 248     { XML_NAMESPACE_CHART,  XML_SERIES,                 XML_TOK_PA_SERIES           },
 249     { XML_NAMESPACE_CHART,  XML_WALL,                   XML_TOK_PA_WALL             },
 250     { XML_NAMESPACE_CHART,  XML_FLOOR,                  XML_TOK_PA_FLOOR            },
 251     { XML_NAMESPACE_DR3D,   XML_LIGHT,                  XML_TOK_PA_LIGHT_SOURCE     },
 252     { XML_NAMESPACE_CHART,  XML_STOCK_GAIN_MARKER,      XML_TOK_PA_STOCK_GAIN       },
 253     { XML_NAMESPACE_CHART,  XML_STOCK_LOSS_MARKER,      XML_TOK_PA_STOCK_LOSS       },
 254     { XML_NAMESPACE_CHART,  XML_STOCK_RANGE_LINE,       XML_TOK_PA_STOCK_RANGE      },
 255     XML_TOKEN_MAP_END
 256 };
 257
 258         mpPlotAreaElemTokenMap = new SvXMLTokenMap( aPlotAreaElemTokenMap );
 259     } // if( ! mpPlotAreaElemTokenMap )
 260
 261     return *mpPlotAreaElemTokenMap;
 262 }
 263
 264 const SvXMLTokenMap& SchXMLImportHelper::GetSeriesElemTokenMap()
 265 {
 266     if( ! mpSeriesElemTokenMap )
 267     {
 268         static SvXMLTokenMapEntry aSeriesElemTokenMap[] =
 269 {
 270     { XML_NAMESPACE_CHART,  XML_DATA_POINT,       XML_TOK_SERIES_DATA_POINT       },
 271     { XML_NAMESPACE_CHART,  XML_DOMAIN,           XML_TOK_SERIES_DOMAIN           },
 272     { XML_NAMESPACE_CHART,  XML_MEAN_VALUE,       XML_TOK_SERIES_MEAN_VALUE_LINE  },
 273     { XML_NAMESPACE_CHART,  XML_REGRESSION_CURVE, XML_TOK_SERIES_REGRESSION_CURVE },
 274     { XML_NAMESPACE_CHART,  XML_ERROR_INDICATOR,  XML_TOK_SERIES_ERROR_INDICATOR  },
 275     XML_TOKEN_MAP_END
 276 };
 277
 278         mpSeriesElemTokenMap = new SvXMLTokenMap( aSeriesElemTokenMap );
 279     } // if( ! mpSeriesElemTokenMap )
 280
 281     return *mpSeriesElemTokenMap;
 282 }
 283
 284 // ----------------------------------------
 285
 286 const SvXMLTokenMap& SchXMLImportHelper::GetChartAttrTokenMap()
 287 {
 288     if( ! mpChartAttrTokenMap )
 289     {
 290         static SvXMLTokenMapEntry aChartAttrTokenMap[] =
 291 {
 292     { XML_NAMESPACE_XLINK,  XML_HREF,                   XML_TOK_CHART_HREF          },
 293     { XML_NAMESPACE_CHART,  XML_CLASS,                  XML_TOK_CHART_CLASS         },
 294     { XML_NAMESPACE_SVG,    XML_WIDTH,                  XML_TOK_CHART_WIDTH         },
 295     { XML_NAMESPACE_SVG,    XML_HEIGHT,                 XML_TOK_CHART_HEIGHT        },
 296     { XML_NAMESPACE_CHART,  XML_STYLE_NAME,             XML_TOK_CHART_STYLE_NAME    },
 297     { XML_NAMESPACE_CHART,  XML_COLUMN_MAPPING,         XML_TOK_CHART_COL_MAPPING   },
 298     { XML_NAMESPACE_CHART,  XML_ROW_MAPPING,            XML_TOK_CHART_ROW_MAPPING   },
 299     XML_TOKEN_MAP_END
 300 };
 301
 302         mpChartAttrTokenMap = new SvXMLTokenMap( aChartAttrTokenMap );
 303     } // if( ! mpChartAttrTokenMap )
 304
 305     return *mpChartAttrTokenMap;
 306 }
 307
 308 const SvXMLTokenMap& SchXMLImportHelper::GetPlotAreaAttrTokenMap()
 309 {
 310     if( ! mpPlotAreaAttrTokenMap )
 311     {
 312         static SvXMLTokenMapEntry aPlotAreaAttrTokenMap[] =
 313 {
 314     { XML_NAMESPACE_SVG,    XML_X,                      XML_TOK_PA_X                 },
 315     { XML_NAMESPACE_SVG,    XML_Y,                      XML_TOK_PA_Y                 },
 316     { XML_NAMESPACE_SVG,    XML_WIDTH,                  XML_TOK_PA_WIDTH             },
 317     { XML_NAMESPACE_SVG,    XML_HEIGHT,                 XML_TOK_PA_HEIGHT            },
 318     { XML_NAMESPACE_CHART,  XML_STYLE_NAME,             XML_TOK_PA_STYLE_NAME        },
 319     { XML_NAMESPACE_TABLE,  XML_CELL_RANGE_ADDRESS,     XML_TOK_PA_CHART_ADDRESS     },
 320     { XML_NAMESPACE_CHART,  XML_DATA_SOURCE_HAS_LABELS, XML_TOK_PA_DS_HAS_LABELS     },
 321     { XML_NAMESPACE_DR3D,   XML_TRANSFORM,              XML_TOK_PA_TRANSFORM         },
 322     { XML_NAMESPACE_DR3D,   XML_VRP,                    XML_TOK_PA_VRP               },
 323     { XML_NAMESPACE_DR3D,   XML_VPN,                    XML_TOK_PA_VPN               },
 324     { XML_NAMESPACE_DR3D,   XML_VUP,                    XML_TOK_PA_VUP               },
 325     { XML_NAMESPACE_DR3D,   XML_PROJECTION,             XML_TOK_PA_PROJECTION        },
 326     { XML_NAMESPACE_DR3D,   XML_DISTANCE,               XML_TOK_PA_DISTANCE          },
 327     { XML_NAMESPACE_DR3D,   XML_FOCAL_LENGTH,           XML_TOK_PA_FOCAL_LENGTH      },
 328     { XML_NAMESPACE_DR3D,   XML_SHADOW_SLANT,           XML_TOK_PA_SHADOW_SLANT      },
 329     { XML_NAMESPACE_DR3D,   XML_SHADE_MODE,             XML_TOK_PA_SHADE_MODE        },
 330     { XML_NAMESPACE_DR3D,   XML_AMBIENT_COLOR,          XML_TOK_PA_AMBIENT_COLOR     },
 331     { XML_NAMESPACE_DR3D,   XML_LIGHTING_MODE,          XML_TOK_PA_LIGHTING_MODE     },
 332     XML_TOKEN_MAP_END
 333 };
 334
 335         mpPlotAreaAttrTokenMap = new SvXMLTokenMap( aPlotAreaAttrTokenMap );
 336     } // if( ! mpPlotAreaAttrTokenMap )
 337
 338     return *mpPlotAreaAttrTokenMap;
 339 }
 340
 341 const SvXMLTokenMap& SchXMLImportHelper::GetCellAttrTokenMap()
 342 {
 343     if( ! mpCellAttrTokenMap )
 344     {
 345         static SvXMLTokenMapEntry aCellAttrTokenMap[] =
 346 {
 347     { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE,             XML_TOK_CELL_VAL_TYPE       },
 348     { XML_NAMESPACE_OFFICE, XML_VALUE,                  XML_TOK_CELL_VALUE          },
 349     XML_TOKEN_MAP_END
 350 };
 351
 352         mpCellAttrTokenMap = new SvXMLTokenMap( aCellAttrTokenMap );
 353     } // if( ! mpCellAttrTokenMap )
 354
 355     return *mpCellAttrTokenMap;
 356 }
 357
 358 const SvXMLTokenMap& SchXMLImportHelper::GetSeriesAttrTokenMap()
 359 {
 360     if( ! mpSeriesAttrTokenMap )
 361     {
 362         static SvXMLTokenMapEntry aSeriesAttrTokenMap[] =
 363 {
 364     { XML_NAMESPACE_CHART,  XML_VALUES_CELL_RANGE_ADDRESS,  XML_TOK_SERIES_CELL_RANGE    },
 365     { XML_NAMESPACE_CHART,  XML_LABEL_CELL_ADDRESS,         XML_TOK_SERIES_LABEL_ADDRESS },
 366     { XML_NAMESPACE_CHART,  XML_ATTACHED_AXIS,              XML_TOK_SERIES_ATTACHED_AXIS },
 367     { XML_NAMESPACE_CHART,  XML_STYLE_NAME,                 XML_TOK_SERIES_STYLE_NAME    },
 368     { XML_NAMESPACE_CHART,  XML_CLASS,                      XML_TOK_SERIES_CHART_CLASS   },
 369     XML_TOKEN_MAP_END
 370 };
 371
 372         mpSeriesAttrTokenMap = new SvXMLTokenMap( aSeriesAttrTokenMap );
 373     } // if( ! mpSeriesAttrTokenMap )
 374
 375     return *mpSeriesAttrTokenMap;
 376 }
 377
 378 const SvXMLTokenMap& SchXMLImportHelper::GetRegEquationAttrTokenMap()
 379 {
 380     if( ! mpRegEquationAttrTokenMap )
 381     {
 382         static SvXMLTokenMapEntry aRegressionEquationAttrTokenMap[] =
 383 {
 384     { XML_NAMESPACE_CHART,  XML_STYLE_NAME,             XML_TOK_REGEQ_STYLE_NAME         },
 385     { XML_NAMESPACE_CHART,  XML_DISPLAY_EQUATION,       XML_TOK_REGEQ_DISPLAY_EQUATION   },
 386     { XML_NAMESPACE_CHART,  XML_DISPLAY_R_SQUARE,       XML_TOK_REGEQ_DISPLAY_R_SQUARE   },
 387     { XML_NAMESPACE_SVG,    XML_X,                      XML_TOK_REGEQ_POS_X              },
 388     { XML_NAMESPACE_SVG,    XML_Y,                      XML_TOK_REGEQ_POS_Y              },
 389     XML_TOKEN_MAP_END
 390 };
 391
 392         mpRegEquationAttrTokenMap = new SvXMLTokenMap( aRegressionEquationAttrTokenMap );
 393     } // if( ! mpRegEquationAttrTokenMap )
 394
 395     return *mpRegEquationAttrTokenMap;
 396 }
 397
 398 // ----------------------------------------
 399
 400 //static
 401 void SchXMLImportHelper::DeleteDataSeries(
 402                     const Reference< chart2::XDataSeries > & xSeries,
 403                     const Reference< chart2::XChartDocument > & xDoc )
 404 {
 405     if( xDoc.is() )
 406     try
 407     {
 408         Reference< chart2::XCoordinateSystemContainer > xCooSysCnt(
 409             xDoc->getFirstDiagram(), uno::UNO_QUERY_THROW );
 410         Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq(
 411             xCooSysCnt->getCoordinateSystems());
 412
 413         sal_Int32 nCooSysIndex = 0;
 414         for( nCooSysIndex=0; nCooSysIndex<aCooSysSeq.getLength(); nCooSysIndex++ )
 415         {
 416             Reference< chart2::XChartTypeContainer > xCTCnt( aCooSysSeq[ nCooSysIndex ], uno::UNO_QUERY_THROW );
 417             Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes());
 418
 419             sal_Int32 nChartTypeIndex = 0;
 420             for( nChartTypeIndex=0; nChartTypeIndex<aChartTypes.getLength(); nChartTypeIndex++ )
 421             {
 422                 Reference< chart2::XDataSeriesContainer > xSeriesCnt( aChartTypes[nChartTypeIndex], uno::UNO_QUERY_THROW );
 423                 Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xSeriesCnt->getDataSeries());
 424
 425                 sal_Int32 nSeriesIndex = 0;
 426                 for( nSeriesIndex=0; nSeriesIndex<aSeriesSeq.getLength(); nSeriesIndex++ )
 427                 {
 428                     if( xSeries==aSeriesSeq[nSeriesIndex] )
 429                     {
 430                         xSeriesCnt->removeDataSeries(xSeries);
 431                         return;
 432                     }
 433                 }
 434             }
 435         }
 436     }
 437     catch( const uno::Exception & ex )
 438     {
 439        SAL_WARN("xmloff.chart",  "Exception caught. Type: " << OUString::createFromAscii( typeid( ex ).name()) << ", Message: " << ex.Message);
 440     }
 441 }
 442
 443 // static
 444 Reference< chart2::XDataSeries > SchXMLImportHelper::GetNewDataSeries(
 445     const Reference< chart2::XChartDocument > & xDoc,
 446     sal_Int32 nCoordinateSystemIndex,
 447     const OUString & rChartTypeName,
 448     bool bPushLastChartType /* = false */ )
 449 {
 450     Reference< chart2::XDataSeries > xResult;
 451     if(!xDoc.is())
 452         return xResult;
 453
 454     try
 455     {
 456         Reference< chart2::XCoordinateSystemContainer > xCooSysCnt(
 457             xDoc->getFirstDiagram(), uno::UNO_QUERY_THROW );
 458         Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq(
 459             xCooSysCnt->getCoordinateSystems());
 460         Reference< uno::XComponentContext > xContext(
 461             comphelper::getProcessComponentContext() );
 462
 463         if( nCoordinateSystemIndex < aCooSysSeq.getLength())
 464         {
 465             Reference< chart2::XChartType > xCurrentType;
 466             {
 467                 Reference< chart2::XChartTypeContainer > xCTCnt( aCooSysSeq[ nCoordinateSystemIndex ], uno::UNO_QUERY_THROW );
 468                 Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes());
 469                 // find matching chart type group
 470                 const Reference< chart2::XChartType > * pBegin = aChartTypes.getConstArray();
 471                 const Reference< chart2::XChartType > * pEnd = pBegin + aChartTypes.getLength();
 472                 const Reference< chart2::XChartType > * pIt =
 473                     ::std::find_if( pBegin, pEnd, lcl_MatchesChartType( rChartTypeName ));
 474                 if( pIt != pEnd )
 475                     xCurrentType.set( *pIt );
 476                 // if chart type is set at series and differs from current one,
 477                 // create a new chart type
 478                 if( !xCurrentType.is())
 479                 {
 480                     xCurrentType.set(
 481                         xContext->getServiceManager()->createInstanceWithContext( rChartTypeName, xContext ),
 482                         uno::UNO_QUERY );
 483                     if( xCurrentType.is())
 484                     {
 485                         if( bPushLastChartType && aChartTypes.getLength())
 486                         {
 487                             sal_Int32 nIndex( aChartTypes.getLength() - 1 );
 488                             aChartTypes.realloc( aChartTypes.getLength() + 1 );
 489                             aChartTypes[ nIndex + 1 ] = aChartTypes[ nIndex ];
 490                             aChartTypes[ nIndex ] = xCurrentType;
 491                             xCTCnt->setChartTypes( aChartTypes );
 492                         }
 493                         else
 494                             xCTCnt->addChartType( xCurrentType );
 495                     }
 496                 }
 497             }
 498
 499             if( xCurrentType.is())
 500             {
 501                 Reference< chart2::XDataSeriesContainer > xSeriesCnt( xCurrentType, uno::UNO_QUERY_THROW );
 502                 Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xSeriesCnt->getDataSeries());
 503
 504                 if( xContext.is() )
 505                 {
 506                     xResult.set(
 507                         xContext->getServiceManager()->createInstanceWithContext(
 508                             OUString( "com.sun.star.chart2.DataSeries" ),
 509                             xContext ), uno::UNO_QUERY_THROW );
 510                 }
 511                 if( xResult.is() )
 512                     xSeriesCnt->addDataSeries( xResult );
 513             }
 514         }
 515     }
 516     catch( const uno::Exception & ex )
 517     {
 518         SAL_WARN("xmloff.chart", "Exception caught. Type: " << OUString::createFromAscii( typeid( ex ).name()) << ", Message: " << ex.Message);
 519     }
 520     return xResult;
 521 }
 522
 523 // ========================================
 524
 525 // #110680#
 526 SchXMLImport::SchXMLImport(
 527     const Reference< uno::XComponentContext >& xContext,
 528     sal_uInt16 nImportFlags ) :
 529         SvXMLImport( xContext, nImportFlags )
 530 {
 531     GetNamespaceMap().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
 532     GetNamespaceMap().Add( GetXMLToken(XML_NP_CHART_EXT), GetXMLToken(XML_N_CHART_EXT), XML_NAMESPACE_CHART_EXT);
 533
 534     mbIsGraphicLoadOnDemandSupported = false;
 535 }
 536
 537 SchXMLImport::~SchXMLImport() throw ()
 538 {
 539     // stop progress view
 540     if( mxStatusIndicator.is())
 541     {
 542         mxStatusIndicator->end();
 543         mxStatusIndicator->reset();
 544     }
 545
 546     uno::Reference< chart2::XChartDocument > xChartDoc( GetModel(), uno::UNO_QUERY );
 547     if( xChartDoc.is() && xChartDoc->hasControllersLocked() )
 548         xChartDoc->unlockControllers();
 549 }
 550
 551 // create the main context (subcontexts are created
 552 // by the one created here)
 553 SvXMLImportContext *SchXMLImport::CreateContext( sal_uInt16 nPrefix, const OUString& rLocalName,
 554     const Reference< xml::sax::XAttributeList >& xAttrList )
 555 {
 556     SvXMLImportContext* pContext = 0;
 557
 558     // accept <office:document>
 559     if( XML_NAMESPACE_OFFICE == nPrefix &&
 560         ( IsXMLToken( rLocalName, XML_DOCUMENT_STYLES) ||
 561           IsXMLToken( rLocalName, XML_DOCUMENT_CONTENT) ))
 562     {
 563         pContext = new SchXMLDocContext( maImportHelper, *this, nPrefix, rLocalName );
 564     } else if ( (XML_NAMESPACE_OFFICE == nPrefix) &&
 565                 ( IsXMLToken(rLocalName, XML_DOCUMENT) ||
 566                   (IsXMLToken(rLocalName, XML_DOCUMENT_META)
 567                    && (getImportFlags() & IMPORT_META) )) )
 568     {
 569         uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
 570             GetModel(), uno::UNO_QUERY);
 571         // mst@: right now, this seems to be not supported, so it is untested
 572         if (xDPS.is()) {
 573             pContext = (IsXMLToken(rLocalName, XML_DOCUMENT_META))
 574                 ? new SvXMLMetaDocumentContext(*this,
 575                             XML_NAMESPACE_OFFICE, rLocalName,
 576                             xDPS->getDocumentProperties())
 577                 // flat OpenDocument file format
 578                 : new SchXMLFlatDocContext_Impl(
 579                             maImportHelper, *this, nPrefix, rLocalName,
 580                             xDPS->getDocumentProperties());
 581         } else {
 582             pContext = (IsXMLToken(rLocalName, XML_DOCUMENT_META))
 583                 ? SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList )
 584                 : new SchXMLDocContext( maImportHelper, *this,
 585                                         nPrefix, rLocalName );
 586         }
 587     } else {
 588         pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList );
 589     }
 590
 591     return pContext;
 592 }
 593
 594 SvXMLImportContext* SchXMLImport::CreateStylesContext(
 595     const OUString& rLocalName,
 596     const Reference<xml::sax::XAttributeList>& xAttrList )
 597 {
 598     //#i103287# make sure that the version information is set before importing all the properties (especially stroke-opacity!)
 599     SchXMLTools::setBuildIDAtImportInfo( GetModel(), getImportInfo() );
 600
 601     SvXMLStylesContext* pStylesCtxt =
 602         new SvXMLStylesContext( *(this), XML_NAMESPACE_OFFICE, rLocalName, xAttrList );
 603
 604     // set context at base class, so that all auto-style classes are imported
 605     SetAutoStyles( pStylesCtxt );
 606     maImportHelper.SetAutoStylesContext( pStylesCtxt );
 607
 608     return pStylesCtxt;
 609 }
 610
 611 void SAL_CALL SchXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
 612     throw(lang::IllegalArgumentException, uno::RuntimeException)
 613 {
 614     uno::Reference< chart2::XChartDocument > xOldDoc( GetModel(), uno::UNO_QUERY );
 615     if( xOldDoc.is() && xOldDoc->hasControllersLocked() )
 616         xOldDoc->unlockControllers();
 617
 618     SvXMLImport::setTargetDocument( xDoc );
 619
 620     //set data provider and number formatter
 621     // try to get an XDataProvider and set it
 622     // @todo: if we have our own data, we must not use the parent as data provider
 623     uno::Reference< chart2::XChartDocument > xChartDoc( GetModel(), uno::UNO_QUERY );
 624
 625     if( xChartDoc.is() )
 626     try
 627     {
 628         //prevent rebuild of view during load ( necesarry especially if loaded not via load api, which is the case for example if binary files are loaded )
 629         xChartDoc->lockControllers();
 630
 631         uno::Reference< container::XChild > xChild( xChartDoc, uno::UNO_QUERY );
 632         uno::Reference< chart2::data::XDataReceiver > xDataReceiver( xChartDoc, uno::UNO_QUERY );
 633         bool bHasOwnData = true;
 634         if( xChild.is() && xDataReceiver.is())
 635         {
 636             Reference< lang::XMultiServiceFactory > xFact( xChild->getParent(), uno::UNO_QUERY );
 637             if( xFact.is() )
 638             {
 639                 //if the parent has a number formatter we will use the numberformatter of the parent
 640                 Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( xFact, uno::UNO_QUERY );
 641                 xDataReceiver->attachNumberFormatsSupplier( xNumberFormatsSupplier );
 642
 643                 if ( !xChartDoc->getDataProvider().is() )
 644                 {
 645                     const OUString aDataProviderServiceName( "com.sun.star.chart2.data.DataProvider");
 646                     const uno::Sequence< OUString > aServiceNames( xFact->getAvailableServiceNames());
 647                     const OUString * pBegin = aServiceNames.getConstArray();
 648                     const OUString * pEnd = pBegin + aServiceNames.getLength();
 649                     if( ::std::find( pBegin, pEnd, aDataProviderServiceName ) != pEnd )
 650                     {
 651                         Reference< chart2::data::XDataProvider > xProvider(
 652                             xFact->createInstance( aDataProviderServiceName ), uno::UNO_QUERY );
 653                         if( xProvider.is())
 654                         {
 655                             xDataReceiver->attachDataProvider( xProvider );
 656                             bHasOwnData = false;
 657                         }
 658                     }
 659                 }
 660                 else
 661                     bHasOwnData = false;
 662             }
 663 //             else we have no parent => we have our own data
 664
 665             if( bHasOwnData && ! xChartDoc->hasInternalDataProvider() )
 666                 xChartDoc->createInternalDataProvider( sal_False );
 667         }
 668     }
 669     catch( const uno::Exception & rEx )
 670     {
 671         OString aBStr(OUStringToOString(rEx.Message, RTL_TEXTENCODING_ASCII_US));
 672         SAL_INFO("xmloff.chart", "SchXMLChartContext::StartElement(): Exception caught: " << aBStr);
 673     }
 674 }
 675
 676 // export components ========================================
 677
 678 // first version: everything comes from one storage
 679
 680 Sequence< OUString > SAL_CALL SchXMLImport_getSupportedServiceNames() throw()
 681 {
 682     const OUString aServiceName(  "com.sun.star.comp.Chart.XMLOasisImporter"  );
 683     const Sequence< OUString > aSeq( &aServiceName, 1 );
 684     return aSeq;
 685 }
 686
 687 OUString SAL_CALL SchXMLImport_getImplementationName() throw()
 688 {
 689     return OUString(  "SchXMLImport"  );
 690 }
 691
 692 Reference< uno::XInterface > SAL_CALL SchXMLImport_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception )
 693 {
 694     // #110680#
 695     return (cppu::OWeakObject*)new SchXMLImport( comphelper::getComponentContext(rSMgr));
 696 }
 697
 698 // ============================================================
 699
 700 // multiple storage version: one for content / styles / meta
 701
 702 Sequence< OUString > SAL_CALL SchXMLImport_Styles_getSupportedServiceNames() throw()
 703 {
 704     const OUString aServiceName(  "com.sun.star.comp.Chart.XMLOasisStylesImporter"  );
 705     const Sequence< OUString > aSeq( &aServiceName, 1 );
 706     return aSeq;
 707 }
 708
 709 OUString SAL_CALL SchXMLImport_Styles_getImplementationName() throw()
 710 {
 711     return OUString(  "SchXMLImport.Styles"  );
 712 }
 713
 714 Reference< uno::XInterface > SAL_CALL SchXMLImport_Styles_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception )
 715 {
 716     // #110680#
 717     return (cppu::OWeakObject*)new SchXMLImport( comphelper::getComponentContext(rSMgr), IMPORT_STYLES );
 718 }
 719
 720 // ------------------------------------------------------------
 721
 722 Sequence< OUString > SAL_CALL SchXMLImport_Content_getSupportedServiceNames() throw()
 723 {
 724     const OUString aServiceName(  "com.sun.star.comp.Chart.XMLOasisContentImporter"  );
 725     const Sequence< OUString > aSeq( &aServiceName, 1 );
 726     return aSeq;
 727 }
 728
 729 OUString SAL_CALL SchXMLImport_Content_getImplementationName() throw()
 730 {
 731     return OUString(  "SchXMLImport.Content"  );
 732 }
 733
 734 Reference< uno::XInterface > SAL_CALL SchXMLImport_Content_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception )
 735 {
 736     // #110680#
 737     return (cppu::OWeakObject*)new SchXMLImport( comphelper::getComponentContext(rSMgr), IMPORT_CONTENT | IMPORT_AUTOSTYLES | IMPORT_FONTDECLS );
 738 }
 739
 740 // ------------------------------------------------------------
 741
 742 Sequence< OUString > SAL_CALL SchXMLImport_Meta_getSupportedServiceNames() throw()
 743 {
 744     const OUString aServiceName(  "com.sun.star.comp.Chart.XMLOasisMetaImporter"  );
 745     const Sequence< OUString > aSeq( &aServiceName, 1 );
 746     return aSeq;
 747 }
 748
 749 OUString SAL_CALL SchXMLImport_Meta_getImplementationName() throw()
 750 {
 751     return OUString(  "SchXMLImport.Meta"  );
 752 }
 753
 754 Reference< uno::XInterface > SAL_CALL SchXMLImport_Meta_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception )
 755 {
 756     // #110680#
 757     return (cppu::OWeakObject*)new SchXMLImport( comphelper::getComponentContext(rSMgr), IMPORT_META );
 758 }
 759
 760 // XServiceInfo
 761 OUString SAL_CALL SchXMLImport::getImplementationName() throw( uno::RuntimeException )
 762 {
 763     switch( getImportFlags())
 764     {
 765         case IMPORT_ALL:
 766             return SchXMLImport_getImplementationName();
 767         case IMPORT_STYLES:
 768             return SchXMLImport_Styles_getImplementationName();
 769         case ( IMPORT_CONTENT | IMPORT_AUTOSTYLES | IMPORT_FONTDECLS ):
 770             return SchXMLImport_Content_getImplementationName();
 771         case IMPORT_META:
 772             return SchXMLImport_Meta_getImplementationName();
 773
 774         case IMPORT_SETTINGS:
 775         // there is no settings component in chart
 776         default:
 777             return OUString( "SchXMLImport" );
 778     }
 779 }
 780
 781 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */