| /************************************************************** | |
| * | |
| * 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 ); | |
| } | |
| if( aURLStr.getLength() ) | |
| { | |
| 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 | |
| { | |
| } |