| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmloff.hxx" |
| |
| #include "SchXMLImport.hxx" |
| #include "SchXMLChartContext.hxx" |
| #include "contexts.hxx" |
| #include "XMLChartPropertySetMapper.hxx" |
| #include "SchXMLTools.hxx" |
| |
| #include <tools/debug.hxx> |
| #include <rtl/ustrbuf.hxx> |
| // header for class ByteString |
| #include <tools/string.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include "xmloff/xmlnmspe.hxx" |
| #include <xmloff/xmltoken.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmlictxt.hxx> |
| #include <xmloff/xmlstyle.hxx> |
| #include <com/sun/star/task/XStatusIndicatorSupplier.hpp> |
| #include <com/sun/star/chart/XChartDocument.hpp> |
| #include <com/sun/star/chart/ChartDataRowSource.hpp> |
| #include <com/sun/star/container/XChild.hpp> |
| #include <com/sun/star/uno/XComponentContext.hpp> |
| #include <com/sun/star/chart2/data/XDataReceiver.hpp> |
| #include <com/sun/star/chart2/data/XDataProvider.hpp> |
| #include <com/sun/star/chart2/XChartDocument.hpp> |
| #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp> |
| #include <com/sun/star/chart2/XChartTypeContainer.hpp> |
| #include <com/sun/star/chart2/XDataSeriesContainer.hpp> |
| |
| #include <com/sun/star/document/XDocumentProperties.hpp> |
| #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> |
| |
| #include <typeinfo> |
| |
| using namespace com::sun::star; |
| using namespace ::xmloff::token; |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| using ::rtl::OUStringToOString; |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::Sequence; |
| |
| namespace |
| { |
| Reference< uno::XComponentContext > lcl_getComponentContext() |
| { |
| Reference< uno::XComponentContext > xContext; |
| try |
| { |
| Reference< beans::XPropertySet > xFactProp( comphelper::getProcessServiceFactory(), uno::UNO_QUERY ); |
| if( xFactProp.is()) |
| xFactProp->getPropertyValue(OUString::createFromAscii("DefaultContext")) >>= xContext; |
| } |
| catch( uno::Exception& ) |
| {} |
| |
| return xContext; |
| } |
| |
| class lcl_MatchesChartType : public ::std::unary_function< Reference< chart2::XChartType >, bool > |
| { |
| public: |
| explicit lcl_MatchesChartType( const OUString & aChartTypeName ) : |
| m_aChartTypeName( aChartTypeName ) |
| {} |
| |
| bool operator () ( const Reference< chart2::XChartType > & xChartType ) const |
| { |
| return (xChartType.is() && |
| xChartType->getChartType().equals( m_aChartTypeName )); |
| } |
| |
| private: |
| OUString m_aChartTypeName; |
| }; |
| } // anonymous namespace |
| |
| /* ---------------------------------------- |
| TokenMaps for distinguishing different |
| tokens in different contexts |
| ----------------------------------------*/ |
| |
| // ---------------------------------------- |
| // element maps |
| // ---------------------------------------- |
| |
| |
| |
| |
| |
| |
| |
| // ---------------------------------------- |
| // attribute maps |
| // ---------------------------------------- |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // ======================================== |
| |
| SchXMLImportHelper::SchXMLImportHelper() : |
| mpAutoStyles( 0 ), |
| |
| mpChartDocElemTokenMap( 0 ), |
| mpTableElemTokenMap( 0 ), |
| mpChartElemTokenMap( 0 ), |
| mpPlotAreaElemTokenMap( 0 ), |
| mpSeriesElemTokenMap( 0 ), |
| |
| mpChartAttrTokenMap( 0 ), |
| mpPlotAreaAttrTokenMap( 0 ), |
| mpAutoStyleAttrTokenMap( 0 ), |
| mpCellAttrTokenMap( 0 ), |
| mpSeriesAttrTokenMap( 0 ), |
| mpRegEquationAttrTokenMap( 0 ) |
| { |
| } |
| |
| SchXMLImportHelper::~SchXMLImportHelper() |
| { |
| // delete token maps |
| if( mpChartDocElemTokenMap ) |
| delete mpChartDocElemTokenMap; |
| if( mpTableElemTokenMap ) |
| delete mpTableElemTokenMap; |
| if( mpChartElemTokenMap ) |
| delete mpChartElemTokenMap; |
| if( mpPlotAreaElemTokenMap ) |
| delete mpPlotAreaElemTokenMap; |
| if( mpSeriesElemTokenMap ) |
| delete mpSeriesElemTokenMap; |
| |
| if( mpChartAttrTokenMap ) |
| delete mpChartAttrTokenMap; |
| if( mpPlotAreaAttrTokenMap ) |
| delete mpPlotAreaAttrTokenMap; |
| if( mpAutoStyleAttrTokenMap ) |
| delete mpAutoStyleAttrTokenMap; |
| if( mpCellAttrTokenMap ) |
| delete mpCellAttrTokenMap; |
| if( mpSeriesAttrTokenMap ) |
| delete mpSeriesAttrTokenMap; |
| } |
| |
| SvXMLImportContext* SchXMLImportHelper::CreateChartContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrefix, const OUString& rLocalName, |
| const Reference< frame::XModel > xChartModel, |
| const Reference< xml::sax::XAttributeList >& ) |
| { |
| SvXMLImportContext* pContext = 0; |
| |
| Reference< chart::XChartDocument > xDoc( xChartModel, uno::UNO_QUERY ); |
| if( xDoc.is()) |
| { |
| mxChartDoc = xDoc; |
| pContext = new SchXMLChartContext( *this, rImport, rLocalName ); |
| } |
| else |
| { |
| DBG_ERROR( "No valid XChartDocument given as XModel" ); |
| pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName ); |
| } |
| |
| return pContext; |
| } |
| |
| /* ---------------------------------------- |
| get various token maps |
| ----------------------------------------*/ |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetDocElemTokenMap() |
| { |
| if( ! mpChartDocElemTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aDocElemTokenMap[] = |
| { |
| { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES }, |
| { XML_NAMESPACE_OFFICE, XML_STYLES, XML_TOK_DOC_STYLES }, |
| { XML_NAMESPACE_OFFICE, XML_META, XML_TOK_DOC_META }, |
| { XML_NAMESPACE_OFFICE, XML_BODY, XML_TOK_DOC_BODY }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpChartDocElemTokenMap = new SvXMLTokenMap( aDocElemTokenMap ); |
| } // if( ! mpChartDocElemTokenMap ) |
| |
| return *mpChartDocElemTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetTableElemTokenMap() |
| { |
| if( ! mpTableElemTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aTableElemTokenMap[] = |
| { |
| { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, XML_TOK_TABLE_HEADER_COLS }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_COLUMNS, XML_TOK_TABLE_COLUMNS }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, XML_TOK_TABLE_COLUMN }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, XML_TOK_TABLE_HEADER_ROWS }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_ROWS, XML_TOK_TABLE_ROWS }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_ROW, XML_TOK_TABLE_ROW }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpTableElemTokenMap = new SvXMLTokenMap( aTableElemTokenMap ); |
| } // if( ! mpTableElemTokenMap ) |
| |
| return *mpTableElemTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetChartElemTokenMap() |
| { |
| if( ! mpChartElemTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aChartElemTokenMap[] = |
| { |
| { XML_NAMESPACE_CHART, XML_PLOT_AREA, XML_TOK_CHART_PLOT_AREA }, |
| { XML_NAMESPACE_CHART, XML_TITLE, XML_TOK_CHART_TITLE }, |
| { XML_NAMESPACE_CHART, XML_SUBTITLE, XML_TOK_CHART_SUBTITLE }, |
| { XML_NAMESPACE_CHART, XML_LEGEND, XML_TOK_CHART_LEGEND }, |
| { XML_NAMESPACE_TABLE, XML_TABLE, XML_TOK_CHART_TABLE }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpChartElemTokenMap = new SvXMLTokenMap( aChartElemTokenMap ); |
| } // if( ! mpChartElemTokenMap ) |
| |
| return *mpChartElemTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetPlotAreaElemTokenMap() |
| { |
| if( ! mpPlotAreaElemTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aPlotAreaElemTokenMap[] = |
| { |
| { XML_NAMESPACE_CHART_EXT, XML_COORDINATE_REGION, XML_TOK_PA_COORDINATE_REGION_EXT }, |
| { XML_NAMESPACE_CHART, XML_COORDINATE_REGION, XML_TOK_PA_COORDINATE_REGION }, |
| { XML_NAMESPACE_CHART, XML_AXIS, XML_TOK_PA_AXIS }, |
| { XML_NAMESPACE_CHART, XML_SERIES, XML_TOK_PA_SERIES }, |
| { XML_NAMESPACE_CHART, XML_WALL, XML_TOK_PA_WALL }, |
| { XML_NAMESPACE_CHART, XML_FLOOR, XML_TOK_PA_FLOOR }, |
| { XML_NAMESPACE_DR3D, XML_LIGHT, XML_TOK_PA_LIGHT_SOURCE }, |
| { XML_NAMESPACE_CHART, XML_STOCK_GAIN_MARKER, XML_TOK_PA_STOCK_GAIN }, |
| { XML_NAMESPACE_CHART, XML_STOCK_LOSS_MARKER, XML_TOK_PA_STOCK_LOSS }, |
| { XML_NAMESPACE_CHART, XML_STOCK_RANGE_LINE, XML_TOK_PA_STOCK_RANGE }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpPlotAreaElemTokenMap = new SvXMLTokenMap( aPlotAreaElemTokenMap ); |
| } // if( ! mpPlotAreaElemTokenMap ) |
| |
| return *mpPlotAreaElemTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetSeriesElemTokenMap() |
| { |
| if( ! mpSeriesElemTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aSeriesElemTokenMap[] = |
| { |
| { XML_NAMESPACE_CHART, XML_DATA_POINT, XML_TOK_SERIES_DATA_POINT }, |
| { XML_NAMESPACE_CHART, XML_DOMAIN, XML_TOK_SERIES_DOMAIN }, |
| { XML_NAMESPACE_CHART, XML_MEAN_VALUE, XML_TOK_SERIES_MEAN_VALUE_LINE }, |
| { XML_NAMESPACE_CHART, XML_REGRESSION_CURVE, XML_TOK_SERIES_REGRESSION_CURVE }, |
| { XML_NAMESPACE_CHART, XML_ERROR_INDICATOR, XML_TOK_SERIES_ERROR_INDICATOR }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpSeriesElemTokenMap = new SvXMLTokenMap( aSeriesElemTokenMap ); |
| } // if( ! mpSeriesElemTokenMap ) |
| |
| return *mpSeriesElemTokenMap; |
| } |
| |
| // ---------------------------------------- |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetChartAttrTokenMap() |
| { |
| if( ! mpChartAttrTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aChartAttrTokenMap[] = |
| { |
| { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_CHART_HREF }, |
| { XML_NAMESPACE_CHART, XML_CLASS, XML_TOK_CHART_CLASS }, |
| { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_CHART_WIDTH }, |
| { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_CHART_HEIGHT }, |
| { XML_NAMESPACE_CHART, XML_STYLE_NAME, XML_TOK_CHART_STYLE_NAME }, |
| { XML_NAMESPACE_CHART, XML_COLUMN_MAPPING, XML_TOK_CHART_COL_MAPPING }, |
| { XML_NAMESPACE_CHART, XML_ROW_MAPPING, XML_TOK_CHART_ROW_MAPPING }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpChartAttrTokenMap = new SvXMLTokenMap( aChartAttrTokenMap ); |
| } // if( ! mpChartAttrTokenMap ) |
| |
| return *mpChartAttrTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetPlotAreaAttrTokenMap() |
| { |
| if( ! mpPlotAreaAttrTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aPlotAreaAttrTokenMap[] = |
| { |
| { XML_NAMESPACE_SVG, XML_X, XML_TOK_PA_X }, |
| { XML_NAMESPACE_SVG, XML_Y, XML_TOK_PA_Y }, |
| { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_PA_WIDTH }, |
| { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_PA_HEIGHT }, |
| { XML_NAMESPACE_CHART, XML_STYLE_NAME, XML_TOK_PA_STYLE_NAME }, |
| { XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, XML_TOK_PA_CHART_ADDRESS }, |
| { XML_NAMESPACE_CHART, XML_DATA_SOURCE_HAS_LABELS, XML_TOK_PA_DS_HAS_LABELS }, |
| { XML_NAMESPACE_DR3D, XML_TRANSFORM, XML_TOK_PA_TRANSFORM }, |
| { XML_NAMESPACE_DR3D, XML_VRP, XML_TOK_PA_VRP }, |
| { XML_NAMESPACE_DR3D, XML_VPN, XML_TOK_PA_VPN }, |
| { XML_NAMESPACE_DR3D, XML_VUP, XML_TOK_PA_VUP }, |
| { XML_NAMESPACE_DR3D, XML_PROJECTION, XML_TOK_PA_PROJECTION }, |
| { XML_NAMESPACE_DR3D, XML_DISTANCE, XML_TOK_PA_DISTANCE }, |
| { XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, XML_TOK_PA_FOCAL_LENGTH }, |
| { XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, XML_TOK_PA_SHADOW_SLANT }, |
| { XML_NAMESPACE_DR3D, XML_SHADE_MODE, XML_TOK_PA_SHADE_MODE }, |
| { XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, XML_TOK_PA_AMBIENT_COLOR }, |
| { XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, XML_TOK_PA_LIGHTING_MODE }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpPlotAreaAttrTokenMap = new SvXMLTokenMap( aPlotAreaAttrTokenMap ); |
| } // if( ! mpPlotAreaAttrTokenMap ) |
| |
| return *mpPlotAreaAttrTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetAutoStyleAttrTokenMap() |
| { |
| if( ! mpAutoStyleAttrTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aAutoStyleAttrTokenMap[] = |
| { |
| { XML_NAMESPACE_STYLE, XML_FAMILY, XML_TOK_AS_FAMILY }, |
| { XML_NAMESPACE_STYLE, XML_NAME, XML_TOK_AS_NAME }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpAutoStyleAttrTokenMap = new SvXMLTokenMap( aAutoStyleAttrTokenMap ); |
| } // if( ! mpAutoStyleAttrTokenMap ) |
| |
| return *mpAutoStyleAttrTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetCellAttrTokenMap() |
| { |
| if( ! mpCellAttrTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aCellAttrTokenMap[] = |
| { |
| { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TOK_CELL_VAL_TYPE }, |
| { XML_NAMESPACE_OFFICE, XML_VALUE, XML_TOK_CELL_VALUE }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpCellAttrTokenMap = new SvXMLTokenMap( aCellAttrTokenMap ); |
| } // if( ! mpCellAttrTokenMap ) |
| |
| return *mpCellAttrTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetSeriesAttrTokenMap() |
| { |
| if( ! mpSeriesAttrTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aSeriesAttrTokenMap[] = |
| { |
| { XML_NAMESPACE_CHART, XML_VALUES_CELL_RANGE_ADDRESS, XML_TOK_SERIES_CELL_RANGE }, |
| { XML_NAMESPACE_CHART, XML_LABEL_CELL_ADDRESS, XML_TOK_SERIES_LABEL_ADDRESS }, |
| { XML_NAMESPACE_CHART, XML_ATTACHED_AXIS, XML_TOK_SERIES_ATTACHED_AXIS }, |
| { XML_NAMESPACE_CHART, XML_STYLE_NAME, XML_TOK_SERIES_STYLE_NAME }, |
| { XML_NAMESPACE_CHART, XML_CLASS, XML_TOK_SERIES_CHART_CLASS }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpSeriesAttrTokenMap = new SvXMLTokenMap( aSeriesAttrTokenMap ); |
| } // if( ! mpSeriesAttrTokenMap ) |
| |
| return *mpSeriesAttrTokenMap; |
| } |
| |
| const SvXMLTokenMap& SchXMLImportHelper::GetRegEquationAttrTokenMap() |
| { |
| if( ! mpRegEquationAttrTokenMap ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aRegressionEquationAttrTokenMap[] = |
| { |
| { XML_NAMESPACE_CHART, XML_STYLE_NAME, XML_TOK_REGEQ_STYLE_NAME }, |
| { XML_NAMESPACE_CHART, XML_DISPLAY_EQUATION, XML_TOK_REGEQ_DISPLAY_EQUATION }, |
| { XML_NAMESPACE_CHART, XML_DISPLAY_R_SQUARE, XML_TOK_REGEQ_DISPLAY_R_SQUARE }, |
| { XML_NAMESPACE_SVG, XML_X, XML_TOK_REGEQ_POS_X }, |
| { XML_NAMESPACE_SVG, XML_Y, XML_TOK_REGEQ_POS_Y }, |
| XML_TOKEN_MAP_END |
| }; |
| |
| mpRegEquationAttrTokenMap = new SvXMLTokenMap( aRegressionEquationAttrTokenMap ); |
| } // if( ! mpRegEquationAttrTokenMap ) |
| |
| return *mpRegEquationAttrTokenMap; |
| } |
| |
| // ---------------------------------------- |
| |
| //static |
| void SchXMLImportHelper::DeleteDataSeries( |
| const Reference< chart2::XDataSeries > & xSeries, |
| const Reference< chart2::XChartDocument > & xDoc ) |
| { |
| if( xDoc.is() ) |
| try |
| { |
| Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( |
| xDoc->getFirstDiagram(), uno::UNO_QUERY_THROW ); |
| Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( |
| xCooSysCnt->getCoordinateSystems()); |
| |
| sal_Int32 nCooSysIndex = 0; |
| for( nCooSysIndex=0; nCooSysIndex<aCooSysSeq.getLength(); nCooSysIndex++ ) |
| { |
| Reference< chart2::XChartTypeContainer > xCTCnt( aCooSysSeq[ nCooSysIndex ], uno::UNO_QUERY_THROW ); |
| Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes()); |
| |
| sal_Int32 nChartTypeIndex = 0; |
| for( nChartTypeIndex=0; nChartTypeIndex<aChartTypes.getLength(); nChartTypeIndex++ ) |
| { |
| Reference< chart2::XDataSeriesContainer > xSeriesCnt( aChartTypes[nChartTypeIndex], uno::UNO_QUERY_THROW ); |
| Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xSeriesCnt->getDataSeries()); |
| |
| sal_Int32 nSeriesIndex = 0; |
| for( nSeriesIndex=0; nSeriesIndex<aSeriesSeq.getLength(); nSeriesIndex++ ) |
| { |
| if( xSeries==aSeriesSeq[nSeriesIndex] ) |
| { |
| xSeriesCnt->removeDataSeries(xSeries); |
| return; |
| } |
| } |
| } |
| } |
| } |
| catch( uno::Exception & ex ) |
| { |
| (void)ex; // avoid warning for pro build |
| OSL_ENSURE( false, OUStringToOString( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "Exception caught. Type: " )) + |
| OUString::createFromAscii( typeid( ex ).name()) + |
| OUString( RTL_CONSTASCII_USTRINGPARAM( ", Message: " )) + |
| ex.Message, RTL_TEXTENCODING_ASCII_US ).getStr()); |
| } |
| } |
| |
| // static |
| Reference< chart2::XDataSeries > SchXMLImportHelper::GetNewDataSeries( |
| const Reference< chart2::XChartDocument > & xDoc, |
| sal_Int32 nCoordinateSystemIndex, |
| const OUString & rChartTypeName, |
| bool bPushLastChartType /* = false */ ) |
| { |
| Reference< chart2::XDataSeries > xResult; |
| if(!xDoc.is()) |
| return xResult; |
| |
| try |
| { |
| Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( |
| xDoc->getFirstDiagram(), uno::UNO_QUERY_THROW ); |
| Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( |
| xCooSysCnt->getCoordinateSystems()); |
| Reference< uno::XComponentContext > xContext( lcl_getComponentContext()); |
| |
| if( nCoordinateSystemIndex < aCooSysSeq.getLength()) |
| { |
| Reference< chart2::XChartType > xCurrentType; |
| { |
| Reference< chart2::XChartTypeContainer > xCTCnt( aCooSysSeq[ nCoordinateSystemIndex ], uno::UNO_QUERY_THROW ); |
| Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes()); |
| // find matching chart type group |
| const Reference< chart2::XChartType > * pBegin = aChartTypes.getConstArray(); |
| const Reference< chart2::XChartType > * pEnd = pBegin + aChartTypes.getLength(); |
| const Reference< chart2::XChartType > * pIt = |
| ::std::find_if( pBegin, pEnd, lcl_MatchesChartType( rChartTypeName )); |
| if( pIt != pEnd ) |
| xCurrentType.set( *pIt ); |
| // if chart type is set at series and differs from current one, |
| // create a new chart type |
| if( !xCurrentType.is()) |
| { |
| xCurrentType.set( |
| xContext->getServiceManager()->createInstanceWithContext( rChartTypeName, xContext ), |
| uno::UNO_QUERY ); |
| if( xCurrentType.is()) |
| { |
| if( bPushLastChartType && aChartTypes.getLength()) |
| { |
| sal_Int32 nIndex( aChartTypes.getLength() - 1 ); |
| aChartTypes.realloc( aChartTypes.getLength() + 1 ); |
| aChartTypes[ nIndex + 1 ] = aChartTypes[ nIndex ]; |
| aChartTypes[ nIndex ] = xCurrentType; |
| xCTCnt->setChartTypes( aChartTypes ); |
| } |
| else |
| xCTCnt->addChartType( xCurrentType ); |
| } |
| } |
| } |
| |
| if( xCurrentType.is()) |
| { |
| Reference< chart2::XDataSeriesContainer > xSeriesCnt( xCurrentType, uno::UNO_QUERY_THROW ); |
| Sequence< Reference< chart2::XDataSeries > > aSeriesSeq( xSeriesCnt->getDataSeries()); |
| |
| if( xContext.is() ) |
| { |
| xResult.set( |
| xContext->getServiceManager()->createInstanceWithContext( |
| OUString::createFromAscii("com.sun.star.chart2.DataSeries"), |
| xContext ), uno::UNO_QUERY_THROW ); |
| } |
| if( xResult.is() ) |
| xSeriesCnt->addDataSeries( xResult ); |
| } |
| } |
| } |
| catch( uno::Exception & ex ) |
| { |
| (void)ex; // avoid warning for pro build |
| OSL_ENSURE( false, OUStringToOString( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "Exception caught. Type: " )) + |
| OUString::createFromAscii( typeid( ex ).name()) + |
| OUString( RTL_CONSTASCII_USTRINGPARAM( ", Message: " )) + |
| ex.Message, RTL_TEXTENCODING_ASCII_US ).getStr()); |
| } |
| return xResult; |
| } |
| |
| // static |
| Reference< chart2::data::XLabeledDataSequence > SchXMLImportHelper::GetNewLabeledDataSequence() |
| { |
| // @todo: remove this asap |
| OSL_ENSURE( false, "Do not call this method" ); |
| Reference< chart2::data::XLabeledDataSequence > xResult; |
| // DO NOT USED -- DEPRECATED. Use SchXMLTools::GetNewLabeledDataSequence() instead |
| return xResult; |
| } |
| |
| // ======================================== |
| |
| // #110680# |
| SchXMLImport::SchXMLImport( |
| const Reference< lang::XMultiServiceFactory >& xServiceFactory, |
| sal_uInt16 nImportFlags ) : |
| SvXMLImport( xServiceFactory, nImportFlags ) |
| { |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_CHART_EXT), GetXMLToken(XML_N_CHART_EXT), XML_NAMESPACE_CHART_EXT); |
| |
| mbIsGraphicLoadOnDemandSupported = false; |
| } |
| |
| // #110680# |
| SchXMLImport::SchXMLImport( |
| const Reference< lang::XMultiServiceFactory >& xServiceFactory, |
| Reference< frame::XModel > xModel, |
| Reference< document::XGraphicObjectResolver >& rGrfContainer, |
| sal_Bool /*bLoadDoc*/, sal_Bool bShowProgress ) |
| : SvXMLImport( xServiceFactory, xModel, rGrfContainer ) |
| { |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_CHART_EXT), GetXMLToken(XML_N_CHART_EXT), XML_NAMESPACE_CHART_EXT); |
| |
| // get status indicator (if requested) |
| if( bShowProgress ) |
| { |
| Reference< frame::XController > xController( xModel->getCurrentController()); |
| if( xController.is()) |
| { |
| Reference< frame::XFrame > xFrame( xController->getFrame()); |
| if( xFrame.is()) |
| { |
| Reference< task::XStatusIndicatorSupplier > xFactory( xFrame, uno::UNO_QUERY ); |
| if( xFactory.is()) |
| { |
| mxStatusIndicator = xFactory->getStatusIndicator(); |
| } |
| } |
| } |
| } |
| |
| // add progress view |
| if( mxStatusIndicator.is()) |
| { |
| const OUString aText( RTL_CONSTASCII_USTRINGPARAM( "XML Import" )); |
| mxStatusIndicator->start( aText, 100 ); // use percentage as values |
| } |
| } |
| |
| SchXMLImport::~SchXMLImport() throw () |
| { |
| // stop progress view |
| if( mxStatusIndicator.is()) |
| { |
| mxStatusIndicator->end(); |
| mxStatusIndicator->reset(); |
| } |
| |
| uno::Reference< chart2::XChartDocument > xChartDoc( GetModel(), uno::UNO_QUERY ); |
| if( xChartDoc.is() && xChartDoc->hasControllersLocked() ) |
| xChartDoc->unlockControllers(); |
| } |
| |
| // create the main context (subcontexts are created |
| // by the one created here) |
| SvXMLImportContext *SchXMLImport::CreateContext( sal_uInt16 nPrefix, const OUString& rLocalName, |
| const Reference< xml::sax::XAttributeList >& xAttrList ) |
| { |
| SvXMLImportContext* pContext = 0; |
| |
| // accept <office:document> |
| if( XML_NAMESPACE_OFFICE == nPrefix && |
| ( IsXMLToken( rLocalName, XML_DOCUMENT_STYLES) || |
| IsXMLToken( rLocalName, XML_DOCUMENT_CONTENT) )) |
| { |
| pContext = new SchXMLDocContext( maImportHelper, *this, nPrefix, rLocalName ); |
| } else if ( (XML_NAMESPACE_OFFICE == nPrefix) && |
| ( IsXMLToken(rLocalName, XML_DOCUMENT) || |
| (IsXMLToken(rLocalName, XML_DOCUMENT_META) |
| && (getImportFlags() & IMPORT_META) )) ) |
| { |
| uno::Reference<document::XDocumentPropertiesSupplier> xDPS( |
| GetModel(), uno::UNO_QUERY); |
| // mst@: right now, this seems to be not supported, so it is untested |
| if (xDPS.is()) { |
| uno::Reference<xml::sax::XDocumentHandler> xDocBuilder( |
| mxServiceFactory->createInstance( |
| ::rtl::OUString::createFromAscii( |
| "com.sun.star.xml.dom.SAXDocumentBuilder")), |
| uno::UNO_QUERY_THROW); |
| pContext = (IsXMLToken(rLocalName, XML_DOCUMENT_META)) |
| ? new SvXMLMetaDocumentContext(*this, |
| XML_NAMESPACE_OFFICE, rLocalName, |
| xDPS->getDocumentProperties(), xDocBuilder) |
| // flat OpenDocument file format |
| : new SchXMLFlatDocContext_Impl( |
| maImportHelper, *this, nPrefix, rLocalName, |
| xDPS->getDocumentProperties(), xDocBuilder); |
| } else { |
| pContext = (IsXMLToken(rLocalName, XML_DOCUMENT_META)) |
| ? SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList ) |
| : new SchXMLDocContext( maImportHelper, *this, |
| nPrefix, rLocalName ); |
| } |
| } else { |
| pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList ); |
| } |
| |
| return pContext; |
| } |
| |
| SvXMLImportContext* SchXMLImport::CreateStylesContext( |
| const OUString& rLocalName, |
| const Reference<xml::sax::XAttributeList>& xAttrList ) |
| { |
| //#i103287# make sure that the version information is set before importing all the properties (especially stroke-opacity!) |
| SchXMLTools::setBuildIDAtImportInfo( GetModel(), getImportInfo() ); |
| |
| SvXMLStylesContext* pStylesCtxt = |
| new SvXMLStylesContext( *(this), XML_NAMESPACE_OFFICE, rLocalName, xAttrList ); |
| |
| // set context at base class, so that all auto-style classes are imported |
| SetAutoStyles( pStylesCtxt ); |
| maImportHelper.SetAutoStylesContext( pStylesCtxt ); |
| |
| return pStylesCtxt; |
| } |
| |
| void SAL_CALL SchXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| uno::Reference< chart2::XChartDocument > xOldDoc( GetModel(), uno::UNO_QUERY ); |
| if( xOldDoc.is() && xOldDoc->hasControllersLocked() ) |
| xOldDoc->unlockControllers(); |
| |
| SvXMLImport::setTargetDocument( xDoc ); |
| |
| //set data provider and number formatter |
| // try to get an XDataProvider and set it |
| // @todo: if we have our own data, we must not use the parent as data provider |
| uno::Reference< chart2::XChartDocument > xChartDoc( GetModel(), uno::UNO_QUERY ); |
| |
| if( xChartDoc.is() ) |
| try |
| { |
| //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 ) |
| xChartDoc->lockControllers(); |
| |
| uno::Reference< container::XChild > xChild( xChartDoc, uno::UNO_QUERY ); |
| uno::Reference< chart2::data::XDataReceiver > xDataReceiver( xChartDoc, uno::UNO_QUERY ); |
| bool bHasOwnData = true; |
| if( xChild.is() && xDataReceiver.is()) |
| { |
| Reference< lang::XMultiServiceFactory > xFact( xChild->getParent(), uno::UNO_QUERY ); |
| if( xFact.is() ) |
| { |
| //if the parent has a number formatter we will use the numberformatter of the parent |
| Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( xFact, uno::UNO_QUERY ); |
| xDataReceiver->attachNumberFormatsSupplier( xNumberFormatsSupplier ); |
| |
| if ( !xChartDoc->getDataProvider().is() ) |
| { |
| const OUString aDataProviderServiceName( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.chart2.data.DataProvider")); |
| const uno::Sequence< OUString > aServiceNames( xFact->getAvailableServiceNames()); |
| const OUString * pBegin = aServiceNames.getConstArray(); |
| const OUString * pEnd = pBegin + aServiceNames.getLength(); |
| if( ::std::find( pBegin, pEnd, aDataProviderServiceName ) != pEnd ) |
| { |
| Reference< chart2::data::XDataProvider > xProvider( |
| xFact->createInstance( aDataProviderServiceName ), uno::UNO_QUERY ); |
| if( xProvider.is()) |
| { |
| xDataReceiver->attachDataProvider( xProvider ); |
| bHasOwnData = false; |
| } |
| } |
| } |
| else |
| bHasOwnData = false; |
| } |
| // else we have no parent => we have our own data |
| |
| if( bHasOwnData && ! xChartDoc->hasInternalDataProvider() ) |
| xChartDoc->createInternalDataProvider( sal_False ); |
| } |
| } |
| catch( uno::Exception & rEx ) |
| { |
| #ifdef DBG_UTIL |
| String aStr( rEx.Message ); |
| ByteString aBStr( aStr, RTL_TEXTENCODING_ASCII_US ); |
| DBG_ERROR1( "SchXMLChartContext::StartElement(): Exception caught: %s", aBStr.GetBuffer()); |
| #else |
| (void)rEx; // avoid warning for pro build |
| #endif |
| } |
| } |
| |
| // export components ======================================== |
| |
| // first version: everything comes from one storage |
| |
| Sequence< OUString > SAL_CALL SchXMLImport_getSupportedServiceNames() throw() |
| { |
| const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Chart.XMLOasisImporter" ) ); |
| const Sequence< OUString > aSeq( &aServiceName, 1 ); |
| return aSeq; |
| } |
| |
| OUString SAL_CALL SchXMLImport_getImplementationName() throw() |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( "SchXMLImport" ) ); |
| } |
| |
| Reference< uno::XInterface > SAL_CALL SchXMLImport_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception ) |
| { |
| // #110680# |
| // return (cppu::OWeakObject*)new SchXMLImport(); |
| return (cppu::OWeakObject*)new SchXMLImport(rSMgr); |
| } |
| |
| // ============================================================ |
| |
| // multiple storage version: one for content / styles / meta |
| |
| Sequence< OUString > SAL_CALL SchXMLImport_Styles_getSupportedServiceNames() throw() |
| { |
| const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Chart.XMLOasisStylesImporter" ) ); |
| const Sequence< OUString > aSeq( &aServiceName, 1 ); |
| return aSeq; |
| } |
| |
| OUString SAL_CALL SchXMLImport_Styles_getImplementationName() throw() |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( "SchXMLImport.Styles" ) ); |
| } |
| |
| Reference< uno::XInterface > SAL_CALL SchXMLImport_Styles_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception ) |
| { |
| // #110680# |
| // return (cppu::OWeakObject*)new SchXMLImport( IMPORT_STYLES ); |
| return (cppu::OWeakObject*)new SchXMLImport( rSMgr, IMPORT_STYLES ); |
| } |
| |
| // ------------------------------------------------------------ |
| |
| Sequence< OUString > SAL_CALL SchXMLImport_Content_getSupportedServiceNames() throw() |
| { |
| const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Chart.XMLOasisContentImporter" ) ); |
| const Sequence< OUString > aSeq( &aServiceName, 1 ); |
| return aSeq; |
| } |
| |
| OUString SAL_CALL SchXMLImport_Content_getImplementationName() throw() |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( "SchXMLImport.Content" ) ); |
| } |
| |
| Reference< uno::XInterface > SAL_CALL SchXMLImport_Content_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception ) |
| { |
| // #110680# |
| // return (cppu::OWeakObject*)new SchXMLImport( IMPORT_CONTENT | IMPORT_AUTOSTYLES | IMPORT_FONTDECLS ); |
| return (cppu::OWeakObject*)new SchXMLImport( rSMgr, IMPORT_CONTENT | IMPORT_AUTOSTYLES | IMPORT_FONTDECLS ); |
| } |
| |
| // ------------------------------------------------------------ |
| |
| Sequence< OUString > SAL_CALL SchXMLImport_Meta_getSupportedServiceNames() throw() |
| { |
| const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Chart.XMLOasisMetaImporter" ) ); |
| const Sequence< OUString > aSeq( &aServiceName, 1 ); |
| return aSeq; |
| } |
| |
| OUString SAL_CALL SchXMLImport_Meta_getImplementationName() throw() |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM( "SchXMLImport.Meta" ) ); |
| } |
| |
| Reference< uno::XInterface > SAL_CALL SchXMLImport_Meta_createInstance(const Reference< lang::XMultiServiceFactory > & rSMgr) throw( uno::Exception ) |
| { |
| // #110680# |
| // return (cppu::OWeakObject*)new SchXMLImport( IMPORT_META ); |
| return (cppu::OWeakObject*)new SchXMLImport( rSMgr, IMPORT_META ); |
| } |
| |
| // XServiceInfo |
| OUString SAL_CALL SchXMLImport::getImplementationName() throw( uno::RuntimeException ) |
| { |
| switch( getImportFlags()) |
| { |
| case IMPORT_ALL: |
| return SchXMLImport_getImplementationName(); |
| case IMPORT_STYLES: |
| return SchXMLImport_Styles_getImplementationName(); |
| case ( IMPORT_CONTENT | IMPORT_AUTOSTYLES | IMPORT_FONTDECLS ): |
| return SchXMLImport_Content_getImplementationName(); |
| case IMPORT_META: |
| return SchXMLImport_Meta_getImplementationName(); |
| |
| case IMPORT_SETTINGS: |
| // there is no settings component in chart |
| default: |
| return OUString::createFromAscii( "SchXMLImport" ); |
| } |
| } |
