xmloff/source/chart/PropertyMaps.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PropertyMaps.cxx,v $
  10  * $Revision: 1.56.40.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33
  34 // include PropertyMap.hxx with this define
  35 // to create the maps
  36 #ifndef _PROPERTYMAP_HXX_
  37 #define XML_SCH_CREATE_GLOBAL_MAPS
  38 #include "PropertyMap.hxx"
  39 #undef XML_SCH_CREATE_GLOBAL_MAPS
  40 #endif
  41
  42 #include "XMLChartPropertySetMapper.hxx"
  43 #include "SchXMLTools.hxx"
  44 #include <xmloff/EnumPropertyHdl.hxx>
  45 #include <xmloff/XMLConstantsPropertyHandler.hxx>
  46 #include <xmloff/attrlist.hxx>
  47 #include <xmloff/nmspmap.hxx>
  48 #include <xmloff/xmluconv.hxx>
  49 #include <xmloff/shapeimport.hxx>
  50 #include <xmloff/NamedBoolPropertyHdl.hxx>
  51 #include <xmloff/xmlexp.hxx>
  52 #include <xmloff/xmltoken.hxx>
  53 #include "XMLErrorIndicatorPropertyHdl.hxx"
  54 #include "XMLErrorBarStylePropertyHdl.hxx"
  55 #include "XMLTextOrientationHdl.hxx"
  56 #include "XMLSymbolTypePropertyHdl.hxx"
  57 #include "XMLAxisPositionPropertyHdl.hxx"
  58 #include <com/sun/star/chart/ChartAxisMarks.hpp>
  59 #include <com/sun/star/chart/ChartDataCaption.hpp>
  60 #include <com/sun/star/chart/ChartSymbolType.hpp>
  61 #include <com/sun/star/drawing/LineStyle.hpp>
  62 #include <com/sun/star/drawing/FillStyle.hpp>
  63 #include <com/sun/star/drawing/LineJoint.hpp>
  64 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  65 #include <com/sun/star/chart/ChartAxisPosition.hpp>
  66
  67 // header for any2enum
  68 #include <comphelper/extract.hxx>
  69 #include <rtl/ustrbuf.hxx>
  70 #include <rtl/math.hxx>
  71
  72 #define SCH_XML_SETFLAG( status, flag )         (status)|= (flag)
  73 #define SCH_XML_UNSETFLAG( status, flag )   (status) = ((status) | (flag)) - (flag)
  74
  75 using namespace com::sun::star;
  76 using namespace ::xmloff::token;
  77
  78 // the following class implementations are in this file:
  79 //
  80 // * XMLChartPropHdlFactory
  81 // * XMLChartPropertySetMapper
  82 // * XMLChartExportPropertyMapper
  83 // * XMLChartImportPropertyMapper
  84 // * SchXMLStyleExport
  85
  86 // ----------------------------------------
  87
  88 XMLChartPropHdlFactory::~XMLChartPropHdlFactory()
  89 {
  90 }
  91
  92 const XMLPropertyHandler* XMLChartPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const
  93 {
  94     const XMLPropertyHandler* pHdl = XMLPropertyHandlerFactory::GetPropertyHandler( nType );
  95     if( ! pHdl )
  96     {
  97         switch( nType )
  98         {
  99             case XML_SCH_TYPE_AXIS_POSITION:
 100                 pHdl = new XMLAxisPositionPropertyHdl( false );
 101                 break;
 102             case XML_SCH_TYPE_AXIS_POSITION_VALUE:
 103                 pHdl = new XMLAxisPositionPropertyHdl( true );
 104                 break;
 105
 106             case XML_SCH_TYPE_AXIS_LABEL_POSITION:
 107                 pHdl = new XMLEnumPropertyHdl( aXMLChartAxisLabelPositionEnumMap,
 108                                                ::getCppuType((const chart::ChartAxisLabelPosition*)0) );
 109                 break;
 110
 111             case XML_SCH_TYPE_TICK_MARK_POSITION:
 112                 pHdl = new XMLEnumPropertyHdl( aXMLChartAxisMarkPositionEnumMap,
 113                                                ::getCppuType((const chart::ChartAxisMarkPosition*)0) );
 114                 break;
 115
 116             case XML_SCH_TYPE_AXIS_ARRANGEMENT:
 117                 pHdl = new XMLEnumPropertyHdl( aXMLChartAxisArrangementEnumMap,
 118                                                ::getCppuType((const chart::ChartAxisArrangeOrderType*)0) );
 119                 break;
 120
 121             case XML_SCH_TYPE_ERROR_BAR_STYLE:
 122                 // here we have a constant rather than an enum
 123                 pHdl = new XMLErrorBarStylePropertyHdl( aXMLChartErrorBarStyleEnumMap,
 124                                                ::getCppuType((const sal_Int32*)0) );
 125                 break;
 126
 127             case XML_SCH_TYPE_REGRESSION_TYPE:
 128                 pHdl = new XMLEnumPropertyHdl( aXMLChartRegressionCurveTypeEnumMap,
 129                                                ::getCppuType((const chart::ChartRegressionCurveType*)0) );
 130                 break;
 131
 132             case XML_SCH_TYPE_ERROR_INDICATOR_LOWER:
 133                 pHdl = new XMLErrorIndicatorPropertyHdl( sal_False );
 134                 break;
 135             case XML_SCH_TYPE_ERROR_INDICATOR_UPPER:
 136                 pHdl = new XMLErrorIndicatorPropertyHdl( sal_True );
 137                 break;
 138
 139             case XML_SCH_TYPE_SOLID_TYPE:
 140                 // here we have a constant rather than an enum
 141                 pHdl = new XMLEnumPropertyHdl( aXMLChartSolidTypeEnumMap,
 142                                                ::getCppuType((const sal_Int32*)0) );
 143                 break;
 144             case XML_SCH_TYPE_LABEL_PLACEMENT_TYPE:
 145                 // here we have a constant rather than an enum
 146                 pHdl = new XMLEnumPropertyHdl( aXMLChartDataLabelPlacementEnumMap,
 147                                                 ::getCppuType((const sal_Int32*)0) );
 148                 break;
 149             case XML_SCH_TYPE_DATAROWSOURCE:
 150                 pHdl = new XMLEnumPropertyHdl( aXMLChartDataRowSourceTypeEnumMap,
 151                                                ::getCppuType((const chart::ChartDataRowSource*)0) );
 152                 break;
 153             case XML_SCH_TYPE_TEXT_ORIENTATION:
 154                 pHdl = new XMLTextOrientationHdl();
 155                 break;
 156
 157             case XML_SCH_TYPE_INTERPOLATION:
 158                 pHdl = new XMLEnumPropertyHdl( aXMLChartInterpolationTypeEnumMap,
 159                                                ::getCppuType((const sal_Int32*)0) );
 160                 break;
 161             case XML_SCH_TYPE_SYMBOL_TYPE:
 162                 pHdl = new XMLSymbolTypePropertyHdl( false );
 163                 break;
 164
 165             case XML_SCH_TYPE_NAMED_SYMBOL:
 166                 pHdl = new XMLSymbolTypePropertyHdl( true );
 167                 break;
 168
 169             case XML_SCH_TYPE_MISSING_VALUE_TREATMENT:
 170                 pHdl = new XMLEnumPropertyHdl( aXMLChartMissingValueTreatmentEnumMap,
 171                                                ::getCppuType((const sal_Int32*)0) );
 172                 break;
 173         }
 174         if( pHdl )
 175             PutHdlCache( nType, pHdl );
 176     }
 177
 178     return pHdl;
 179 }
 180
 181 // ----------------------------------------
 182
 183 XMLChartPropertySetMapper::XMLChartPropertySetMapper() :
 184         XMLPropertySetMapper( aXMLChartPropMap, new XMLChartPropHdlFactory )
 185 {
 186 }
 187
 188 XMLChartPropertySetMapper::~XMLChartPropertySetMapper()
 189 {
 190 }
 191
 192 // ----------------------------------------
 193
 194 XMLChartExportPropertyMapper::XMLChartExportPropertyMapper( const UniReference< XMLPropertySetMapper >& rMapper,
 195                                                             SvXMLExport& rExport) :
 196         SvXMLExportPropertyMapper( rMapper ),
 197         msTrue( GetXMLToken( XML_TRUE )),
 198         msFalse( GetXMLToken( XML_FALSE )),
 199         mrExport( rExport )
 200 {
 201     // chain draw properties
 202     ChainExportMapper( XMLShapeExport::CreateShapePropMapper( rExport ));
 203
 204     // chain text properties
 205     ChainExportMapper( XMLTextParagraphExport::CreateParaExtPropMapper( rExport ));
 206 }
 207
 208 XMLChartExportPropertyMapper::~XMLChartExportPropertyMapper()
 209 {
 210 }
 211
 212 void XMLChartExportPropertyMapper::ContextFilter(
 213     std::vector< XMLPropertyState >& rProperties,
 214     uno::Reference< beans::XPropertySet > rPropSet ) const
 215 {
 216     ::rtl::OUString aAutoPropName;
 217     sal_Bool bCheckAuto = sal_False;
 218
 219     // filter properties
 220     for( std::vector< XMLPropertyState >::iterator property = rProperties.begin();
 221          property != rProperties.end();
 222          property++ )
 223     {
 224         // find properties with context
 225         // to prevent writing this property set mnIndex member to -1
 226         switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex ))
 227         {
 228             // if Auto... is set the corresponding properties mustn't be exported
 229             case XML_SCH_CONTEXT_MIN:
 230                 bCheckAuto = sal_True;
 231                 aAutoPropName = ::rtl::OUString::createFromAscii( "AutoMin" );
 232                 break;
 233             case XML_SCH_CONTEXT_MAX:
 234                 bCheckAuto = sal_True;
 235                 aAutoPropName = ::rtl::OUString::createFromAscii( "AutoMax" );
 236                 break;
 237             case XML_SCH_CONTEXT_STEP_MAIN:
 238                 bCheckAuto = sal_True;
 239                 aAutoPropName = ::rtl::OUString::createFromAscii( "AutoStepMain" );
 240                 break;
 241             case XML_SCH_CONTEXT_STEP_HELP_COUNT:
 242                 bCheckAuto = sal_True;
 243                 aAutoPropName = ::rtl::OUString::createFromAscii( "AutoStepHelp" );
 244                 break;
 245
 246             case XML_SCH_CONTEXT_ORIGIN:
 247                 bCheckAuto = sal_True;
 248                 aAutoPropName = ::rtl::OUString::createFromAscii( "AutoOrigin" );
 249                 break;
 250
 251             // the following property is deprecated
 252             // elemet-item symbol-image is used now
 253             case XML_SCH_CONTEXT_SPECIAL_SYMBOL_IMAGE_NAME:
 254                 property->mnIndex = -1;
 255                 break;
 256
 257             case XML_SCH_CONTEXT_STOCK_WITH_VOLUME:
 258             case XML_SCH_CONTEXT_LINES_USED:
 259                 // note this avoids export of the properties in OASIS format,
 260                 // but also for the OOo XML Flat format (used by binfilter),
 261                 // because there, the transformation to OOo is done after the
 262                 // complete export of the chart in OASIS format.
 263                 if( mrExport.getExportFlags() & EXPORT_OASIS )
 264                     property->mnIndex = -1;
 265                 break;
 266         }
 267
 268         if( bCheckAuto )
 269         {
 270             if( rPropSet.is())
 271             {
 272                 try
 273                 {
 274                     sal_Bool bAuto = false;
 275                     uno::Any aAny = rPropSet->getPropertyValue( aAutoPropName );
 276                     aAny >>= bAuto;
 277                     if( bAuto )
 278                         property->mnIndex = -1;
 279                 }
 280                 catch( beans::UnknownPropertyException )
 281                 {
 282                 }
 283             }
 284             bCheckAuto = sal_False;
 285         }
 286     }
 287
 288     SvXMLExportPropertyMapper::ContextFilter(rProperties, rPropSet);
 289 }
 290
 291 void XMLChartExportPropertyMapper::handleElementItem(
 292     SvXMLExport& rExport,
 293     const XMLPropertyState& rProperty, sal_uInt16 nFlags,
 294     const ::std::vector< XMLPropertyState > *pProperties,
 295     sal_uInt32 nIdx ) const
 296 {
 297     switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ))
 298     {
 299         case XML_SCH_CONTEXT_SPECIAL_SYMBOL_IMAGE:
 300             {
 301                 ::rtl::OUString aURLStr;
 302                 rProperty.maValue >>= aURLStr;
 303
 304                 // export as XLink reference into the package
 305                 // if embedding is off
 306                 ::rtl::OUString sTempURL( mrExport.AddEmbeddedGraphicObject( aURLStr ));
 307                 if( sTempURL.getLength() )
 308                 {
 309                     mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sTempURL );
 310                     mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE,
 311                                               XML_SIMPLE );
 312                     mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE,
 313                                               XML_ONLOAD );
 314                 }
 315
 316                 {
 317                     sal_uInt32 nPropIndex = rProperty.mnIndex;
 318                     // this is the element that has to live until the next statement
 319                     SvXMLElementExport aElem( mrExport,
 320                                               getPropertySetMapper()->GetEntryNameSpace( nPropIndex ),
 321                                               getPropertySetMapper()->GetEntryXMLName( nPropIndex ),
 322                                               sal_True, sal_True );
 323
 324                     // export as Base64 embedded graphic
 325                     // if embedding is on
 326                     if( aURLStr.getLength())
 327                         mrExport.AddEmbeddedGraphicObjectAsBase64( aURLStr );
 328                 }
 329             }
 330             break;
 331
 332         case XML_SCH_CONTEXT_SPECIAL_LABEL_SEPARATOR:
 333             {
 334                 ::rtl::OUString aSeparator;
 335                 rProperty.maValue >>= aSeparator;
 336
 337                 if( aSeparator.getLength() )
 338                 {
 339                     sal_uInt32 nPropIndex = rProperty.mnIndex;
 340                     SvXMLElementExport aElem( mrExport,
 341                                               getPropertySetMapper()->GetEntryNameSpace( nPropIndex ),
 342                                               getPropertySetMapper()->GetEntryXMLName( nPropIndex ),
 343                                               sal_True, sal_True );
 344
 345                     SchXMLTools::exportText( mrExport, aSeparator, true );
 346                 }
 347             }
 348             break;
 349
 350         default:
 351             // call parent
 352             SvXMLExportPropertyMapper::handleElementItem( rExport, rProperty,
 353                                                           nFlags, pProperties, nIdx );
 354             break;
 355     }
 356 }
 357
 358 void XMLChartExportPropertyMapper::handleSpecialItem(
 359     SvXMLAttributeList& rAttrList, const XMLPropertyState& rProperty,
 360     const SvXMLUnitConverter& rUnitConverter,
 361     const SvXMLNamespaceMap& rNamespaceMap,
 362     const ::std::vector< XMLPropertyState > *pProperties,
 363     sal_uInt32 nIdx ) const
 364 {
 365     sal_Bool bHandled = sal_False;
 366
 367     sal_Int32 nContextId = maPropMapper->GetEntryContextId( rProperty.mnIndex );
 368
 369     if( nContextId )
 370     {
 371         bHandled = sal_True;
 372
 373         rtl::OUString sAttrName = maPropMapper->GetEntryXMLName( rProperty.mnIndex );
 374         sal_uInt16 nNameSpace = maPropMapper->GetEntryNameSpace( rProperty.mnIndex );
 375         rtl::OUStringBuffer sValueBuffer;
 376         rtl::OUString sValue;
 377
 378         sal_Int32 nValue = 0;
 379         sal_Bool bValue = sal_False;
 380
 381         switch( nContextId )
 382         {
 383             case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_INNER:
 384             case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_INNER:
 385                 rProperty.maValue >>= nValue;
 386                 bValue = (( nValue & chart::ChartAxisMarks::INNER ) == chart::ChartAxisMarks::INNER );
 387                 SvXMLUnitConverter::convertBool( sValueBuffer, bValue );
 388                 break;
 389             case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_OUTER:
 390             case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_OUTER:
 391                 rProperty.maValue >>= nValue;
 392                 bValue = (( nValue & chart::ChartAxisMarks::OUTER ) == chart::ChartAxisMarks::OUTER );
 393                 SvXMLUnitConverter::convertBool( sValueBuffer, bValue );
 394                 break;
 395             case XML_SCH_CONTEXT_SPECIAL_TEXT_ROTATION:
 396                 {
 397                     // convert from 100th degrees to degrees (double)
 398                     rProperty.maValue >>= nValue;
 399                     double fVal = (double)(nValue) / 100.0;
 400                     SvXMLUnitConverter::convertDouble( sValueBuffer, fVal );
 401                 }
 402                 break;
 403             case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_NUMBER:
 404                 {
 405                     rProperty.maValue >>= nValue;
 406                     if((( nValue & chart::ChartDataCaption::VALUE ) == chart::ChartDataCaption::VALUE ))
 407                     {
 408                         if( ( nValue & chart::ChartDataCaption::PERCENT ) == chart::ChartDataCaption::PERCENT )
 409                         {
 410                             const SvtSaveOptions::ODFDefaultVersion nCurrentVersion( SvtSaveOptions().GetODFDefaultVersion() );
 411                             if( nCurrentVersion < SvtSaveOptions::ODFVER_012 )
 412                                 sValueBuffer.append( GetXMLToken( XML_PERCENTAGE ));
 413                             else
 414                                 sValueBuffer.append( GetXMLToken( XML_VALUE_AND_PERCENTAGE ));
 415                         }
 416                         else
 417                             sValueBuffer.append( GetXMLToken( XML_VALUE ));
 418                     }
 419                     else if(( nValue & chart::ChartDataCaption::PERCENT ) == chart::ChartDataCaption::PERCENT )
 420                         sValueBuffer.append( GetXMLToken( XML_PERCENTAGE ));
 421                     else
 422                         sValueBuffer.append( GetXMLToken( XML_NONE ));
 423                 }
 424                 break;
 425             case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_TEXT:
 426                 rProperty.maValue >>= nValue;
 427                 bValue = (( nValue & chart::ChartDataCaption::TEXT ) == chart::ChartDataCaption::TEXT );
 428                 SvXMLUnitConverter::convertBool( sValueBuffer, bValue );
 429                 break;
 430             case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_SYMBOL:
 431                 rProperty.maValue >>= nValue;
 432                 bValue = (( nValue & chart::ChartDataCaption::SYMBOL ) == chart::ChartDataCaption::SYMBOL );
 433                 SvXMLUnitConverter::convertBool( sValueBuffer, bValue );
 434                 break;
 435
 436             case XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH:
 437             case XML_SCH_CONTEXT_SPECIAL_SYMBOL_HEIGHT:
 438                 {
 439                     awt::Size aSize;
 440                     rProperty.maValue >>= aSize;
 441                     rUnitConverter.convertMeasure( sValueBuffer,
 442                                                    nContextId == XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH
 443                                                    ? aSize.Width
 444                                                    : aSize.Height );
 445                 }
 446                 break;
 447
 448             case XML_SCH_CONTEXT_SPECIAL_NUMBER_FORMAT:
 449                 {
 450                     // just for import
 451                     break;
 452                 }
 453
 454             default:
 455                 bHandled = sal_False;
 456                 break;
 457         }
 458
 459         if( sValueBuffer.getLength())
 460         {
 461             sValue = sValueBuffer.makeStringAndClear();
 462             sAttrName = rNamespaceMap.GetQNameByKey( nNameSpace, sAttrName );
 463             rAttrList.AddAttribute( sAttrName, sValue );
 464         }
 465     }
 466
 467     if( !bHandled )
 468     {
 469         // call parent
 470         SvXMLExportPropertyMapper::handleSpecialItem( rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx );
 471     }
 472 }
 473
 474 // ----------------------------------------
 475
 476 XMLChartImportPropertyMapper::XMLChartImportPropertyMapper( const UniReference< XMLPropertySetMapper >& rMapper,
 477                                                             const SvXMLImport& _rImport ) :
 478         SvXMLImportPropertyMapper( rMapper, const_cast< SvXMLImport & >( _rImport )),
 479         mrImport( const_cast< SvXMLImport & > ( _rImport ))
 480 {
 481     // chain shape mapper for drawing properties
 482
 483     // give an empty model. It is only used for numbering rules that don't exist in chart
 484     uno::Reference< frame::XModel > xEmptyModel;
 485     ChainImportMapper( XMLShapeImportHelper::CreateShapePropMapper( xEmptyModel, mrImport ));
 486
 487     //#i14365# save and load writing-mode for chart elements
 488     //The property TextWritingMode is mapped wrongly in the underlying draw mapper, but for draw it is necessary
 489     //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')
 490     sal_Int32 nUnwantedWrongEntry = maPropMapper->FindEntryIndex( "TextWritingMode", XML_NAMESPACE_STYLE, GetXMLToken(XML_WRITING_MODE) );
 491     maPropMapper->RemoveEntry(nUnwantedWrongEntry);
 492
 493     // do not chain text properties: on import this is done by shape mapper
 494     // to import old documents
 495 //      ChainImportMapper( XMLTextImportHelper::CreateParaExtPropMapper());
 496 }
 497
 498 XMLChartImportPropertyMapper::~XMLChartImportPropertyMapper()
 499 {
 500 }
 501
 502 sal_Bool XMLChartImportPropertyMapper::handleSpecialItem(
 503     XMLPropertyState& rProperty,
 504     ::std::vector< XMLPropertyState >& rProperties,
 505     const ::rtl::OUString& rValue,
 506     const SvXMLUnitConverter& rUnitConverter,
 507     const SvXMLNamespaceMap& rNamespaceMap ) const
 508 {
 509     static const ::rtl::OUString sPackageProtocol( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package:" ) );
 510     sal_Int32 nContextId = maPropMapper->GetEntryContextId( rProperty.mnIndex );
 511     sal_Bool bRet = (nContextId != 0);
 512
 513     if( nContextId )
 514     {
 515         sal_Int32 nValue = 0;
 516         sal_Bool bValue = sal_False;
 517
 518         switch( nContextId )
 519         {
 520             case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_INNER:
 521             case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_INNER:
 522                 SvXMLUnitConverter::convertBool( bValue, rValue );
 523                 // modify old value
 524                 rProperty.maValue >>= nValue;
 525                 if( bValue )
 526                     SCH_XML_SETFLAG( nValue, chart::ChartAxisMarks::INNER );
 527                 else
 528                     SCH_XML_UNSETFLAG( nValue, chart::ChartAxisMarks::INNER );
 529                 rProperty.maValue <<= nValue;
 530                 break;
 531             case XML_SCH_CONTEXT_SPECIAL_TICKS_MAJ_OUTER:
 532             case XML_SCH_CONTEXT_SPECIAL_TICKS_MIN_OUTER:
 533                 SvXMLUnitConverter::convertBool( bValue, rValue );
 534                 // modify old value
 535                 rProperty.maValue >>= nValue;
 536                 if( bValue )
 537                     SCH_XML_SETFLAG( nValue, chart::ChartAxisMarks::OUTER );
 538                 else
 539                     SCH_XML_UNSETFLAG( nValue, chart::ChartAxisMarks::OUTER );
 540                 rProperty.maValue <<= nValue;
 541                 break;
 542             case XML_SCH_CONTEXT_SPECIAL_TEXT_ROTATION:
 543                 {
 544                     // convert from degrees (double) to 100th degrees (integer)
 545                     double fVal;
 546                     SvXMLUnitConverter::convertDouble( fVal, rValue );
 547                     nValue = (sal_Int32)( fVal * 100.0 );
 548                     rProperty.maValue <<= nValue;
 549                 }
 550                 break;
 551             case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_NUMBER:
 552                 {
 553                     // modify old value
 554                     rProperty.maValue >>= nValue;
 555                     if( IsXMLToken( rValue, XML_NONE ))
 556                         SCH_XML_UNSETFLAG( nValue, chart::ChartDataCaption::VALUE | chart::ChartDataCaption::PERCENT );
 557                     else if( IsXMLToken( rValue, XML_VALUE_AND_PERCENTAGE ) )
 558                         SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::VALUE | chart::ChartDataCaption::PERCENT );
 559                     else if( IsXMLToken( rValue, XML_VALUE ) )
 560                         SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::VALUE );
 561                     else // must be XML_PERCENTAGE
 562                         SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::PERCENT );
 563                     rProperty.maValue <<= nValue;
 564                 }
 565                 break;
 566             case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_TEXT:
 567                 rProperty.maValue >>= nValue;
 568                 SvXMLUnitConverter::convertBool( bValue, rValue );
 569                 if( bValue )
 570                     SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::TEXT );
 571                 else
 572                     SCH_XML_UNSETFLAG( nValue, chart::ChartDataCaption::TEXT );
 573                 rProperty.maValue <<= nValue;
 574                 break;
 575             case XML_SCH_CONTEXT_SPECIAL_DATA_LABEL_SYMBOL:
 576                 rProperty.maValue >>= nValue;
 577                 SvXMLUnitConverter::convertBool( bValue, rValue );
 578                 if( bValue )
 579                     SCH_XML_SETFLAG( nValue, chart::ChartDataCaption::SYMBOL );
 580                 else
 581                     SCH_XML_UNSETFLAG( nValue, chart::ChartDataCaption::SYMBOL );
 582                 rProperty.maValue <<= nValue;
 583                 break;
 584             case XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH:
 585             case XML_SCH_CONTEXT_SPECIAL_SYMBOL_HEIGHT:
 586                 {
 587                     awt::Size aSize;
 588                     rProperty.maValue >>= aSize;
 589                     rUnitConverter.convertMeasure( nContextId == XML_SCH_CONTEXT_SPECIAL_SYMBOL_WIDTH
 590                                                    ? aSize.Width
 591                                                    : aSize.Height,
 592                                                    rValue );
 593                     rProperty.maValue <<= aSize;
 594                 }
 595                 break;
 596
 597             // deprecated from 6.0 beta on
 598             case XML_SCH_CONTEXT_SPECIAL_SYMBOL_IMAGE_NAME:
 599                 rProperty.maValue <<= mrImport.ResolveGraphicObjectURL( rValue, sal_False );
 600                 break;
 601
 602             default:
 603                 bRet = sal_False;
 604                 break;
 605         }
 606     }
 607
 608
 609     // if we didn't handle it, the parent should
 610     if( !bRet )
 611     {
 612         // call parent
 613         bRet = SvXMLImportPropertyMapper::handleSpecialItem( rProperty, rProperties, rValue, rUnitConverter, rNamespaceMap );
 614     }
 615
 616     return bRet;
 617 }
 618
 619 void XMLChartImportPropertyMapper::finished( ::std::vector< XMLPropertyState >& /*rProperties*/, sal_Int32 /*nStartIndex*/, sal_Int32 /*nEndIndex*/ ) const
 620 {
 621 }