| /************************************************************** |
| * |
| * 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 PropertyMap.hxx with this define |
| // to create the maps |
| #ifndef _PROPERTYMAP_HXX_ |
| #define XML_SCH_CREATE_GLOBAL_MAPS |
| #include "PropertyMap.hxx" |
| #undef XML_SCH_CREATE_GLOBAL_MAPS |
| #endif |
| |
| #include "XMLChartPropertySetMapper.hxx" |
| #include "SchXMLTools.hxx" |
| #include <xmloff/EnumPropertyHdl.hxx> |
| #include <xmloff/XMLConstantsPropertyHandler.hxx> |
| #include <xmloff/attrlist.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include <xmloff/shapeimport.hxx> |
| #include <xmloff/NamedBoolPropertyHdl.hxx> |
| #include <xmloff/xmlexp.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include "XMLErrorIndicatorPropertyHdl.hxx" |
| #include "XMLErrorBarStylePropertyHdl.hxx" |
| #include "XMLTextOrientationHdl.hxx" |
| #include "XMLSymbolTypePropertyHdl.hxx" |
| #include "XMLAxisPositionPropertyHdl.hxx" |
| #include <com/sun/star/chart/ChartAxisMarks.hpp> |
| #include <com/sun/star/chart/ChartDataCaption.hpp> |
| #include <com/sun/star/chart/ChartSymbolType.hpp> |
| #include <com/sun/star/drawing/LineStyle.hpp> |
| #include <com/sun/star/drawing/FillStyle.hpp> |
| #include <com/sun/star/drawing/LineJoint.hpp> |
| #include <com/sun/star/chart/ChartDataRowSource.hpp> |
| #include <com/sun/star/chart/ChartAxisPosition.hpp> |
| |
| // header for any2enum |
| #include <comphelper/extract.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/math.hxx> |
| |
| #define SCH_XML_SETFLAG( status, flag ) (status)|= (flag) |
| #define SCH_XML_UNSETFLAG( status, flag ) (status) = ((status) | (flag)) - (flag) |
| |
| using namespace com::sun::star; |
| using namespace ::xmloff::token; |
| |
| // the following class implementations are in this file: |
| // |
| // * XMLChartPropHdlFactory |
| // * XMLChartPropertySetMapper |
| // * XMLChartExportPropertyMapper |
| // * XMLChartImportPropertyMapper |
| // * SchXMLStyleExport |
| |
| // ---------------------------------------- |
| |
| XMLChartPropHdlFactory::~XMLChartPropHdlFactory() |
| { |
| } |
| |
| const XMLPropertyHandler* XMLChartPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const |
| { |
| const XMLPropertyHandler* pHdl = XMLPropertyHandlerFactory::GetPropertyHandler( nType ); |
| if( ! pHdl ) |
| { |
| switch( nType ) |
| { |
| case XML_SCH_TYPE_AXIS_POSITION: |
| pHdl = new XMLAxisPositionPropertyHdl( false ); |
| break; |
| case XML_SCH_TYPE_AXIS_POSITION_VALUE: |
| pHdl = new XMLAxisPositionPropertyHdl( true ); |
| break; |
| |
| case XML_SCH_TYPE_AXIS_LABEL_POSITION: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartAxisLabelPositionEnumMap, |
| ::getCppuType((const chart::ChartAxisLabelPosition*)0) ); |
| break; |
| |
| case XML_SCH_TYPE_TICK_MARK_POSITION: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartAxisMarkPositionEnumMap, |
| ::getCppuType((const chart::ChartAxisMarkPosition*)0) ); |
| break; |
| |
| case XML_SCH_TYPE_AXIS_ARRANGEMENT: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartAxisArrangementEnumMap, |
| ::getCppuType((const chart::ChartAxisArrangeOrderType*)0) ); |
| break; |
| |
| case XML_SCH_TYPE_ERROR_BAR_STYLE: |
| // here we have a constant rather than an enum |
| pHdl = new XMLErrorBarStylePropertyHdl( aXMLChartErrorBarStyleEnumMap, |
| ::getCppuType((const sal_Int32*)0) ); |
| break; |
| |
| case XML_SCH_TYPE_REGRESSION_TYPE: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartRegressionCurveTypeEnumMap, |
| ::getCppuType((const chart::ChartRegressionCurveType*)0) ); |
| break; |
| |
| case XML_SCH_TYPE_ERROR_INDICATOR_LOWER: |
| pHdl = new XMLErrorIndicatorPropertyHdl( sal_False ); |
| break; |
| case XML_SCH_TYPE_ERROR_INDICATOR_UPPER: |
| pHdl = new XMLErrorIndicatorPropertyHdl( sal_True ); |
| break; |
| |
| case XML_SCH_TYPE_SOLID_TYPE: |
| // here we have a constant rather than an enum |
| pHdl = new XMLEnumPropertyHdl( aXMLChartSolidTypeEnumMap, |
| ::getCppuType((const sal_Int32*)0) ); |
| break; |
| case XML_SCH_TYPE_LABEL_PLACEMENT_TYPE: |
| // here we have a constant rather than an enum |
| pHdl = new XMLEnumPropertyHdl( aXMLChartDataLabelPlacementEnumMap, |
| ::getCppuType((const sal_Int32*)0) ); |
| break; |
| case XML_SCH_TYPE_DATAROWSOURCE: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartDataRowSourceTypeEnumMap, |
| ::getCppuType((const chart::ChartDataRowSource*)0) ); |
| break; |
| case XML_SCH_TYPE_TEXT_ORIENTATION: |
| pHdl = new XMLTextOrientationHdl(); |
| break; |
| |
| case XML_SCH_TYPE_INTERPOLATION: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartInterpolationTypeEnumMap, |
| ::getCppuType((const sal_Int32*)0) ); |
| break; |
| case XML_SCH_TYPE_SYMBOL_TYPE: |
| pHdl = new XMLSymbolTypePropertyHdl( false ); |
| break; |
| |
| case XML_SCH_TYPE_NAMED_SYMBOL: |
| pHdl = new XMLSymbolTypePropertyHdl( true ); |
| break; |
| |
| case XML_SCH_TYPE_MISSING_VALUE_TREATMENT: |
| pHdl = new XMLEnumPropertyHdl( aXMLChartMissingValueTreatmentEnumMap, |
| ::getCppuType((const sal_Int32*)0) ); |
| break; |
| } |
| if( pHdl ) |
| PutHdlCache( nType, pHdl ); |
| } |
| |
| return pHdl; |
| } |
| |
| // ---------------------------------------- |
| |
| XMLChartPropertySetMapper::XMLChartPropertySetMapper() : |
| XMLPropertySetMapper( aXMLChartPropMap, new XMLChartPropHdlFactory ) |
| { |
| } |
| |
| XMLChartPropertySetMapper::~XMLChartPropertySetMapper() |
| { |
| } |
| |
| // ---------------------------------------- |
| |
| XMLChartExportPropertyMapper::XMLChartExportPropertyMapper( const UniReference< XMLPropertySetMapper >& rMapper, |
| SvXMLExport& rExport) : |
| SvXMLExportPropertyMapper( rMapper ), |
| msTrue( GetXMLToken( XML_TRUE )), |
| msFalse( GetXMLToken( XML_FALSE )), |
| mrExport( rExport ) |
| { |
| // chain draw properties |
| ChainExportMapper( XMLShapeExport::CreateShapePropMapper( rExport )); |
| |
| // chain text properties |
| ChainExportMapper( XMLTextParagraphExport::CreateParaExtPropMapper( rExport )); |
| } |
| |
| XMLChartExportPropertyMapper::~XMLChartExportPropertyMapper() |
| { |
| } |
| |
| void XMLChartExportPropertyMapper::ContextFilter( |
| std::vector< XMLPropertyState >& rProperties, |
| uno::Reference< beans::XPropertySet > rPropSet ) const |
| { |
| ::rtl::OUString aAutoPropName; |
| sal_Bool bCheckAuto = sal_False; |
| |
| // filter properties |
| for( std::vector< XMLPropertyState >::iterator property = rProperties.begin(); |
| property != rProperties.end(); |
| property++ ) |
| { |
| // find properties with context |
| // to prevent writing this property set mnIndex member to -1 |
| switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex )) |
| { |
| // if Auto... is set the corresponding properties mustn't be exported |
| case XML_SCH_CONTEXT_MIN: |
| bCheckAuto = sal_True; |
| aAutoPropName = ::rtl::OUString::createFromAscii( "AutoMin" ); |
| break; |
| case XML_SCH_CONTEXT_MAX: |
| bCheckAuto = sal_True; |
| aAutoPropName = ::rtl::OUString::createFromAscii( "AutoMax" ); |
| break; |
| case XML_SCH_CONTEXT_STEP_MAIN: |
| bCheckAuto = sal_True; |
| aAutoPropName = ::rtl::OUString::createFromAscii( "AutoStepMain" ); |
| break; |
| case XML_SCH_CONTEXT_STEP_HELP_COUNT: |
| bCheckAuto = sal_True; |
| aAutoPropName = ::rtl::OUString::createFromAscii( "AutoStepHelp" ); |
| break; |
| |
| case XML_SCH_CONTEXT_ORIGIN: |
| bCheckAuto = sal_True; |
| aAutoPropName = ::rtl::OUString::createFromAscii( "AutoOrigin" ); |
| break; |
| |
| // the following property is deprecated |
| // elemet-item symbol-image is used now |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_IMAGE_NAME: |
| property->mnIndex = -1; |
| break; |
| |
| case XML_SCH_CONTEXT_STOCK_WITH_VOLUME: |
| case XML_SCH_CONTEXT_LINES_USED: |
| // note this avoids export of the properties in OASIS format, |
| // but also for the OOo XML Flat format (used by binfilter), |
| // because there, the transformation to OOo is done after the |
| // complete export of the chart in OASIS format. |
| if( mrExport.getExportFlags() & EXPORT_OASIS ) |
| property->mnIndex = -1; |
| break; |
| } |
| |
| if( bCheckAuto ) |
| { |
| if( rPropSet.is()) |
| { |
| try |
| { |
| sal_Bool bAuto = false; |
| uno::Any aAny = rPropSet->getPropertyValue( aAutoPropName ); |
| aAny >>= bAuto; |
| if( bAuto ) |
| property->mnIndex = -1; |
| } |
| catch( beans::UnknownPropertyException ) |
| { |
| } |
| } |
| bCheckAuto = sal_False; |
| } |
| } |
| |
| SvXMLExportPropertyMapper::ContextFilter(rProperties, rPropSet); |
| } |
| |
| void XMLChartExportPropertyMapper::handleElementItem( |
| SvXMLExport& rExport, |
| const XMLPropertyState& rProperty, sal_uInt16 nFlags, |
| const ::std::vector< XMLPropertyState > *pProperties, |
| sal_uInt32 nIdx ) const |
| { |
| switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex )) |
| { |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_IMAGE: |
| { |
| ::rtl::OUString aURLStr; |
| rProperty.maValue >>= aURLStr; |
| |
| // export as XLink reference into the package |
| // if embedding is off |
| ::rtl::OUString sTempURL( mrExport.AddEmbeddedGraphicObject( aURLStr )); |
| if( sTempURL.getLength() ) |
| { |
| mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sTempURL ); |
| mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, |
| XML_SIMPLE ); |
| mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, |
| XML_ONLOAD ); |
| } |
| |
| { |
| sal_uInt32 nPropIndex = rProperty.mnIndex; |
| // this is the element that has to live until the next statement |
| SvXMLElementExport aElem( mrExport, |
| getPropertySetMapper()->GetEntryNameSpace( nPropIndex ), |
| getPropertySetMapper()->GetEntryXMLName( nPropIndex ), |
| sal_True, sal_True ); |
| |
| // export as Base64 embedded graphic |
| // if embedding is on |
| if( aURLStr.getLength()) |
| mrExport.AddEmbeddedGraphicObjectAsBase64( aURLStr ); |
| } |
| } |
| break; |
| |
| case XML_SCH_CONTEXT_SPECIAL_LABEL_SEPARATOR: |
| { |
| ::rtl::OUString aSeparator; |
| rProperty.maValue >>= aSeparator; |
| |
| if( aSeparator.getLength() ) |
| { |
| sal_uInt32 nPropIndex = rProperty.mnIndex; |
| SvXMLElementExport aElem( mrExport, |
| getPropertySetMapper()->GetEntryNameSpace( nPropIndex ), |
| getPropertySetMapper()->GetEntryXMLName( nPropIndex ), |
| sal_True, sal_True ); |
| |
| SchXMLTools::exportText( mrExport, aSeparator, true ); |
| } |
| } |
| break; |
| |
| default: |
| // call parent |
| SvXMLExportPropertyMapper::handleElementItem( rExport, rProperty, |
| nFlags, pProperties, nIdx ); |
| break; |
| } |
| } |
| |
| void XMLChartExportPropertyMapper::handleSpecialItem( |
| SvXMLAttributeList& rAttrList, const XMLPropertyState& rProperty, |
| const SvXMLUnitConverter& rUnitConverter, |
| const SvXMLNamespaceMap& rNamespaceMap, |
| const ::std::vector< XMLPropertyState > *pProperties, |
| sal_uInt32 nIdx ) const |
| { |
| sal_Bool bHandled = sal_False; |
| |
| sal_Int32 nContextId = maPropMapper->GetEntryContextId( rProperty.mnIndex ); |
| |
| if( nContextId ) |
| { |
| bHandled = sal_True; |
| |
| rtl::OUString sAttrName = maPropMapper->GetEntryXMLName( rProperty.mnIndex ); |
| sal_uInt16 nNameSpace = maPropMapper->GetEntryNameSpace( rProperty.mnIndex ); |
| rtl::OUStringBuffer sValueBuffer; |
| rtl::OUString sValue; |
| |
| sal_Int32 nValue = 0; |
| sal_Bool bValue = sal_False; |
| |
| switch( nContextId ) |
| { |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_INNER: |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_INNER: |
| rProperty.maValue >>= nValue; |
| bValue = (( nValue & chart::ChartAxisMarks::INNER ) == chart::ChartAxisMarks::INNER ); |
| SvXMLUnitConverter::convertBool( sValueBuffer, bValue ); |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_OUTER: |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_OUTER: |
| rProperty.maValue >>= nValue; |
| bValue = (( nValue & chart::ChartAxisMarks::OUTER ) == chart::ChartAxisMarks::OUTER ); |
| SvXMLUnitConverter::convertBool( sValueBuffer, bValue ); |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_TEXT_ROTATION: |
| { |
| // convert from 100th degrees to degrees (double) |
| rProperty.maValue >>= nValue; |
| double fVal = (double)(nValue) / 100.0; |
| SvXMLUnitConverter::convertDouble( sValueBuffer, fVal ); |
| } |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_NUMBER: |
| { |
| rProperty.maValue >>= nValue; |
| if((( nValue & chart::ChartDataCaption::VALUE ) == chart::ChartDataCaption::VALUE )) |
| { |
| if( ( nValue & chart::ChartDataCaption::PERCENT ) == chart::ChartDataCaption::PERCENT ) |
| { |
| const SvtSaveOptions::ODFDefaultVersion nCurrentVersion( SvtSaveOptions().GetODFDefaultVersion() ); |
| if( nCurrentVersion < SvtSaveOptions::ODFVER_012 ) |
| sValueBuffer.append( GetXMLToken( XML_PERCENTAGE )); |
| else |
| sValueBuffer.append( GetXMLToken( XML_VALUE_AND_PERCENTAGE )); |
| } |
| else |
| sValueBuffer.append( GetXMLToken( XML_VALUE )); |
| } |
| else if(( nValue & chart::ChartDataCaption::PERCENT ) == chart::ChartDataCaption::PERCENT ) |
| sValueBuffer.append( GetXMLToken( XML_PERCENTAGE )); |
| else |
| sValueBuffer.append( GetXMLToken( XML_NONE )); |
| } |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_TEXT: |
| rProperty.maValue >>= nValue; |
| bValue = (( nValue & chart::ChartDataCaption::TEXT ) == chart::ChartDataCaption::TEXT ); |
| SvXMLUnitConverter::convertBool( sValueBuffer, bValue ); |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_SYMBOL: |
| rProperty.maValue >>= nValue; |
| bValue = (( nValue & chart::ChartDataCaption::SYMBOL ) == chart::ChartDataCaption::SYMBOL ); |
| SvXMLUnitConverter::convertBool( sValueBuffer, bValue ); |
| break; |
| |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH: |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_HEIGHT: |
| { |
| awt::Size aSize; |
| rProperty.maValue >>= aSize; |
| rUnitConverter.convertMeasure( sValueBuffer, |
| nContextId == XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH |
| ? aSize.Width |
| : aSize.Height ); |
| } |
| break; |
| |
| case XML_SCH_CONTEXT_SPECIAL_NUMBER_FORMAT: |
| { |
| // just for import |
| break; |
| } |
| |
| default: |
| bHandled = sal_False; |
| break; |
| } |
| |
| if( sValueBuffer.getLength()) |
| { |
| sValue = sValueBuffer.makeStringAndClear(); |
| sAttrName = rNamespaceMap.GetQNameByKey( nNameSpace, sAttrName ); |
| rAttrList.AddAttribute( sAttrName, sValue ); |
| } |
| } |
| |
| if( !bHandled ) |
| { |
| // call parent |
| SvXMLExportPropertyMapper::handleSpecialItem( rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx ); |
| } |
| } |
| |
| // ---------------------------------------- |
| |
| XMLChartImportPropertyMapper::XMLChartImportPropertyMapper( const UniReference< XMLPropertySetMapper >& rMapper, |
| const SvXMLImport& _rImport ) : |
| SvXMLImportPropertyMapper( rMapper, const_cast< SvXMLImport & >( _rImport )), |
| mrImport( const_cast< SvXMLImport & > ( _rImport )) |
| { |
| // chain shape mapper for drawing properties |
| |
| // give an empty model. It is only used for numbering rules that don't exist in chart |
| uno::Reference< frame::XModel > xEmptyModel; |
| ChainImportMapper( XMLShapeImportHelper::CreateShapePropMapper( xEmptyModel, mrImport )); |
| |
| //#i14365# save and load writing-mode for chart elements |
| //The property TextWritingMode is mapped wrongly in the underlying draw mapper, but for draw it is necessary |
| //We remove that property here only for chart thus the chart can use the correct mapping from the writer paragraph settings (attribute 'writing-mode' <-> property 'WritingMode') |
| sal_Int32 nUnwantedWrongEntry = maPropMapper->FindEntryIndex( "TextWritingMode", XML_NAMESPACE_STYLE, GetXMLToken(XML_WRITING_MODE) ); |
| maPropMapper->RemoveEntry(nUnwantedWrongEntry); |
| |
| // do not chain text properties: on import this is done by shape mapper |
| // to import old documents |
| // ChainImportMapper( XMLTextImportHelper::CreateParaExtPropMapper()); |
| } |
| |
| XMLChartImportPropertyMapper::~XMLChartImportPropertyMapper() |
| { |
| } |
| |
| sal_Bool XMLChartImportPropertyMapper::handleSpecialItem( |
| XMLPropertyState& rProperty, |
| ::std::vector< XMLPropertyState >& rProperties, |
| const ::rtl::OUString& rValue, |
| const SvXMLUnitConverter& rUnitConverter, |
| const SvXMLNamespaceMap& rNamespaceMap ) const |
| { |
| static const ::rtl::OUString sPackageProtocol( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package:" ) ); |
| sal_Int32 nContextId = maPropMapper->GetEntryContextId( rProperty.mnIndex ); |
| sal_Bool bRet = (nContextId != 0); |
| |
| if( nContextId ) |
| { |
| sal_Int32 nValue = 0; |
| sal_Bool bValue = sal_False; |
| |
| switch( nContextId ) |
| { |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_INNER: |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_INNER: |
| SvXMLUnitConverter::convertBool( bValue, rValue ); |
| // modify old value |
| rProperty.maValue >>= nValue; |
| if( bValue ) |
| SCH_XML_SETFLAG( nValue, chart::ChartAxisMarks::INNER ); |
| else |
| SCH_XML_UNSETFLAG( nValue, chart::ChartAxisMarks::INNER ); |
| rProperty.maValue <<= nValue; |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_OUTER: |
| case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_OUTER: |
| SvXMLUnitConverter::convertBool( bValue, rValue ); |
| // modify old value |
| rProperty.maValue >>= nValue; |
| if( bValue ) |
| SCH_XML_SETFLAG( nValue, chart::ChartAxisMarks::OUTER ); |
| else |
| SCH_XML_UNSETFLAG( nValue, chart::ChartAxisMarks::OUTER ); |
| rProperty.maValue <<= nValue; |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_TEXT_ROTATION: |
| { |
| // convert from degrees (double) to 100th degrees (integer) |
| double fVal; |
| SvXMLUnitConverter::convertDouble( fVal, rValue ); |
| nValue = (sal_Int32)( fVal * 100.0 ); |
| rProperty.maValue <<= nValue; |
| } |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_NUMBER: |
| { |
| // modify old value |
| rProperty.maValue >>= nValue; |
| if( IsXMLToken( rValue, XML_NONE )) |
| SCH_XML_UNSETFLAG( nValue, chart::ChartDataCaption::VALUE | chart::ChartDataCaption::PERCENT ); |
| else if( IsXMLToken( rValue, XML_VALUE_AND_PERCENTAGE ) ) |
| SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::VALUE | chart::ChartDataCaption::PERCENT ); |
| else if( IsXMLToken( rValue, XML_VALUE ) ) |
| SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::VALUE ); |
| else // must be XML_PERCENTAGE |
| SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::PERCENT ); |
| rProperty.maValue <<= nValue; |
| } |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_TEXT: |
| rProperty.maValue >>= nValue; |
| SvXMLUnitConverter::convertBool( bValue, rValue ); |
| if( bValue ) |
| SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::TEXT ); |
| else |
| SCH_XML_UNSETFLAG( nValue, chart::ChartDataCaption::TEXT ); |
| rProperty.maValue <<= nValue; |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_SYMBOL: |
| rProperty.maValue >>= nValue; |
| SvXMLUnitConverter::convertBool( bValue, rValue ); |
| if( bValue ) |
| SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::SYMBOL ); |
| else |
| SCH_XML_UNSETFLAG( nValue, chart::ChartDataCaption::SYMBOL ); |
| rProperty.maValue <<= nValue; |
| break; |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH: |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_HEIGHT: |
| { |
| awt::Size aSize; |
| rProperty.maValue >>= aSize; |
| rUnitConverter.convertMeasure( nContextId == XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH |
| ? aSize.Width |
| : aSize.Height, |
| rValue ); |
| rProperty.maValue <<= aSize; |
| } |
| break; |
| |
| // deprecated from 6.0 beta on |
| case XML_SCH_CONTEXT_SPECIAL_SYMBOL_IMAGE_NAME: |
| rProperty.maValue <<= mrImport.ResolveGraphicObjectURL( rValue, sal_False ); |
| break; |
| |
| default: |
| bRet = sal_False; |
| break; |
| } |
| } |
| |
| |
| // if we didn't handle it, the parent should |
| if( !bRet ) |
| { |
| // call parent |
| bRet = SvXMLImportPropertyMapper::handleSpecialItem( rProperty, rProperties, rValue, rUnitConverter, rNamespaceMap ); |
| } |
| |
| return bRet; |
| } |
| |
| void XMLChartImportPropertyMapper::finished( ::std::vector< XMLPropertyState >& /*rProperties*/, sal_Int32 /*nStartIndex*/, sal_Int32 /*nEndIndex*/ ) const |
| { |
| } |
