xmloff/source/chart/SchXMLAxisContext.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sax/tools/converter.hxx>
  21
  22 #include "SchXMLAxisContext.hxx"
  23 #include "SchXMLChartContext.hxx"
  24 #include "SchXMLTools.hxx"
  25 #include <xmloff/xmlnmspe.hxx>
  26 #include <xmloff/xmlement.hxx>
  27 #include <xmloff/xmlstyle.hxx>
  28 #include <xmloff/prstylei.hxx>
  29 #include <xmloff/nmspmap.hxx>
  30 #include <xmloff/xmluconv.hxx>
  31
  32 #include <tools/color.hxx>
  33
  34 #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
  35 #include <com/sun/star/chart/ChartAxisMarkPosition.hpp>
  36 #include <com/sun/star/chart/ChartAxisPosition.hpp>
  37 #include <com/sun/star/chart/ChartAxisType.hpp>
  38 #include <com/sun/star/chart/TimeIncrement.hpp>
  39 #include <com/sun/star/chart/TimeInterval.hpp>
  40 #include <com/sun/star/chart/TimeUnit.hpp>
  41 #include <com/sun/star/chart/XAxis.hpp>
  42 #include <com/sun/star/chart/XAxisSupplier.hpp>
  43 #include <com/sun/star/chart2/AxisType.hpp>
  44 #include <com/sun/star/chart2/XChartDocument.hpp>
  45 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  46
  47 #include <com/sun/star/drawing/LineStyle.hpp>
  48
  49 using namespace ::xmloff::token;
  50 using namespace com::sun::star;
  51
  52 using com::sun::star::uno::Reference;
  53
  54 static const SvXMLEnumMapEntry aXMLAxisDimensionMap[] =
  55 {
  56     { XML_X,  SCH_XML_AXIS_X  },
  57     { XML_Y,  SCH_XML_AXIS_Y  },
  58     { XML_Z,  SCH_XML_AXIS_Z  },
  59     { XML_TOKEN_INVALID, 0 }
  60 };
  61
  62 static const SvXMLEnumMapEntry aXMLAxisTypeMap[] =
  63 {
  64     { XML_AUTO,  ::com::sun::star::chart::ChartAxisType::AUTOMATIC },
  65     { XML_TEXT,  ::com::sun::star::chart::ChartAxisType::CATEGORY },
  66     { XML_DATE,  ::com::sun::star::chart::ChartAxisType::DATE },
  67     { XML_TOKEN_INVALID, 0 }
  68 };
  69
  70 class SchXMLCategoriesContext : public SvXMLImportContext
  71 {
  72 private:
  73     OUString& mrAddress;
  74
  75 public:
  76     SchXMLCategoriesContext( SvXMLImport& rImport,
  77                                    sal_uInt16 nPrefix,
  78                                    const OUString& rLocalName,
  79                                    OUString& rAddress );
  80     virtual ~SchXMLCategoriesContext();
  81     virtual void StartElement( const Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList ) SAL_OVERRIDE;
  82 };
  83
  84 class DateScaleContext : public SvXMLImportContext
  85 {
  86 public:
  87     DateScaleContext( SvXMLImport& rImport,
  88                         sal_uInt16 nPrefix, const OUString& rLocalName,
  89                         const Reference< beans::XPropertySet >& rAxisProps );
  90
  91     virtual ~DateScaleContext();
  92     virtual void StartElement( const Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList ) SAL_OVERRIDE;
  93
  94 private:
  95     Reference< beans::XPropertySet > m_xAxisProps;
  96 };
  97
  98 SchXMLAxisContext::SchXMLAxisContext( SchXMLImportHelper& rImpHelper,
  99                                       SvXMLImport& rImport, const OUString& rLocalName,
 100                                       Reference< chart::XDiagram > xDiagram,
 101                                       std::vector< SchXMLAxis >& rAxes,
 102                                       OUString & rCategoriesAddress,
 103                                       bool bAddMissingXAxisForNetCharts,
 104                                       bool bAdaptWrongPercentScaleValues,
 105                                       bool bAdaptXAxisOrientationForOld2DBarCharts,
 106                                       bool& rbAxisPositionAttributeImported ) :
 107         SvXMLImportContext( rImport, XML_NAMESPACE_CHART, rLocalName ),
 108         m_rImportHelper( rImpHelper ),
 109         m_xDiagram( xDiagram ),
 110         m_rAxes( rAxes ),
 111         m_rCategoriesAddress( rCategoriesAddress ),
 112         m_nAxisType(chart::ChartAxisType::AUTOMATIC),
 113         m_bAxisTypeImported(false),
 114         m_bDateScaleImported(false),
 115         m_bAddMissingXAxisForNetCharts( bAddMissingXAxisForNetCharts ),
 116         m_bAdaptWrongPercentScaleValues( bAdaptWrongPercentScaleValues ),
 117         m_bAdaptXAxisOrientationForOld2DBarCharts( bAdaptXAxisOrientationForOld2DBarCharts ),
 118         m_rbAxisPositionAttributeImported( rbAxisPositionAttributeImported )
 119 {
 120 }
 121
 122 SchXMLAxisContext::~SchXMLAxisContext()
 123 {}
 124
 125 static Reference< chart::XAxis > lcl_getChartAxis(const SchXMLAxis& rCurrentAxis, const Reference< chart::XDiagram >& rDiagram )
 126 {
 127     Reference< chart::XAxis > xAxis;
 128     Reference< chart::XAxisSupplier > xAxisSuppl( rDiagram, uno::UNO_QUERY );
 129     if( !xAxisSuppl.is() )
 130         return xAxis;
 131     if( rCurrentAxis.nAxisIndex == 0 )
 132         xAxis = xAxisSuppl->getAxis(rCurrentAxis.eDimension);
 133     else
 134         xAxis = xAxisSuppl->getSecondaryAxis(rCurrentAxis.eDimension);
 135     return xAxis;
 136 }
 137
 138 /* returns a shape for the current axis's title. The property
 139    "Has...AxisTitle" is set to "True" to get the shape
 140  */
 141 Reference< drawing::XShape > SchXMLAxisContext::getTitleShape()
 142 {
 143     Reference< drawing::XShape > xResult;
 144     Reference< beans::XPropertySet > xDiaProp( m_rImportHelper.GetChartDocument()->getDiagram(), uno::UNO_QUERY );
 145     Reference< chart::XAxis > xAxis( lcl_getChartAxis( m_aCurrentAxis, m_xDiagram ) );
 146     if( !xDiaProp.is() || !xAxis.is() )
 147         return xResult;
 148
 149     OUString aPropName;
 150     switch( m_aCurrentAxis.eDimension )
 151     {
 152         case SCH_XML_AXIS_X:
 153             if( m_aCurrentAxis.nAxisIndex == 0 )
 154                 aPropName = "HasXAxisTitle";
 155             else
 156                 aPropName = "HasSecondaryXAxisTitle";
 157             break;
 158         case SCH_XML_AXIS_Y:
 159             if( m_aCurrentAxis.nAxisIndex == 0 )
 160                 aPropName = "HasYAxisTitle";
 161             else
 162                 aPropName = "HasSecondaryYAxisTitle";
 163             break;
 164         case SCH_XML_AXIS_Z:
 165             aPropName = "HasZAxisTitle";
 166             break;
 167         case SCH_XML_AXIS_UNDEF:
 168             SAL_INFO("xmloff.chart", "Invalid axis" );
 169             break;
 170     }
 171     xDiaProp->setPropertyValue( aPropName, uno::makeAny(sal_True) );
 172     xResult = Reference< drawing::XShape >( xAxis->getAxisTitle(), uno::UNO_QUERY );
 173     return xResult;
 174 }
 175
 176 void SchXMLAxisContext::CreateGrid( const OUString& sAutoStyleName, bool bIsMajor )
 177 {
 178     Reference< beans::XPropertySet > xDiaProp( m_rImportHelper.GetChartDocument()->getDiagram(), uno::UNO_QUERY );
 179     Reference< chart::XAxis > xAxis( lcl_getChartAxis( m_aCurrentAxis, m_xDiagram ) );
 180     if( !xDiaProp.is() || !xAxis.is() )
 181         return;
 182
 183     OUString aPropName;
 184     switch( m_aCurrentAxis.eDimension )
 185     {
 186         case SCH_XML_AXIS_X:
 187             if( bIsMajor )
 188                 aPropName = "HasXAxisGrid";
 189             else
 190                 aPropName = "HasXAxisHelpGrid";
 191             break;
 192         case SCH_XML_AXIS_Y:
 193             if( bIsMajor )
 194                 aPropName = "HasYAxisGrid";
 195             else
 196                 aPropName = "HasYAxisHelpGrid";
 197             break;
 198         case SCH_XML_AXIS_Z:
 199             if( bIsMajor )
 200                 aPropName = "HasZAxisGrid";
 201             else
 202                 aPropName = "HasZAxisHelpGrid";
 203             break;
 204         case SCH_XML_AXIS_UNDEF:
 205             SAL_INFO("xmloff.chart", "Invalid axis" );
 206             break;
 207     }
 208     xDiaProp->setPropertyValue( aPropName, uno::makeAny(sal_True) );
 209
 210     Reference< beans::XPropertySet > xGridProp;
 211     if( bIsMajor )
 212         xGridProp = xAxis->getMajorGrid();
 213     else
 214         xGridProp = xAxis->getMinorGrid();
 215
 216     // set properties
 217     if( xGridProp.is())
 218     {
 219         // the line color is black as default, in the model it is a light gray
 220         xGridProp->setPropertyValue("LineColor",
 221                                      uno::makeAny( COL_BLACK ));
 222         if( !sAutoStyleName.isEmpty())
 223         {
 224             const SvXMLStylesContext* pStylesCtxt = m_rImportHelper.GetAutoStylesContext();
 225             if( pStylesCtxt )
 226             {
 227                 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
 228                     SchXMLImportHelper::GetChartFamilyID(), sAutoStyleName );
 229
 230                 if( pStyle && pStyle->ISA( XMLPropStyleContext ))
 231                     const_cast<XMLPropStyleContext*>( static_cast< const XMLPropStyleContext* >( pStyle ))->FillPropertySet( xGridProp );
 232             }
 233         }
 234     }
 235 }
 236
 237 namespace
 238 {
 239 enum AxisAttributeTokens
 240 {
 241     XML_TOK_AXIS_DIMENSION,
 242     XML_TOK_AXIS_NAME,
 243     XML_TOK_AXIS_STYLE_NAME,
 244     XML_TOK_AXIS_TYPE,
 245     XML_TOK_AXIS_TYPE_EXT
 246 };
 247
 248 const SvXMLTokenMapEntry aAxisAttributeTokenMap[] =
 249 {
 250     { XML_NAMESPACE_CHART,      XML_DIMENSION,  XML_TOK_AXIS_DIMENSION      },
 251     { XML_NAMESPACE_CHART,      XML_NAME,       XML_TOK_AXIS_NAME           },
 252     { XML_NAMESPACE_CHART,      XML_STYLE_NAME, XML_TOK_AXIS_STYLE_NAME     },
 253     { XML_NAMESPACE_CHART,      XML_AXIS_TYPE,  XML_TOK_AXIS_TYPE           },
 254     { XML_NAMESPACE_CHART_EXT,  XML_AXIS_TYPE,  XML_TOK_AXIS_TYPE_EXT       },
 255     XML_TOKEN_MAP_END
 256 };
 257
 258 class AxisAttributeTokenMap : public SvXMLTokenMap
 259 {
 260 public:
 261     AxisAttributeTokenMap(): SvXMLTokenMap( aAxisAttributeTokenMap ) {}
 262     virtual ~AxisAttributeTokenMap() {}
 263 };
 264
 265 //a AxisAttributeTokenMap Singleton
 266 struct theAxisAttributeTokenMap : public rtl::Static< AxisAttributeTokenMap, theAxisAttributeTokenMap > {};
 267 }
 268
 269 void SchXMLAxisContext::StartElement( const Reference< xml::sax::XAttributeList >& xAttrList )
 270 {
 271     // parse attributes
 272     sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
 273     const SvXMLTokenMap& rAttrTokenMap = theAxisAttributeTokenMap::get();
 274
 275     for( sal_Int16 i = 0; i < nAttrCount; i++ )
 276     {
 277         OUString sAttrName = xAttrList->getNameByIndex( i );
 278         OUString aLocalName;
 279         OUString aValue = xAttrList->getValueByIndex( i );
 280         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
 281
 282         switch( rAttrTokenMap.Get( nPrefix, aLocalName ))
 283         {
 284             case XML_TOK_AXIS_DIMENSION:
 285                 {
 286                     sal_uInt16 nEnumVal;
 287                     if( SvXMLUnitConverter::convertEnum( nEnumVal, aValue, aXMLAxisDimensionMap ))
 288                         m_aCurrentAxis.eDimension = ( SchXMLAxisDimension )nEnumVal;
 289                 }
 290                 break;
 291             case XML_TOK_AXIS_NAME:
 292                 m_aCurrentAxis.aName = aValue;
 293                 break;
 294             case XML_TOK_AXIS_TYPE:
 295             case XML_TOK_AXIS_TYPE_EXT:
 296                 sal_uInt16 nEnumVal;
 297                 if( SvXMLUnitConverter::convertEnum( nEnumVal, aValue, aXMLAxisTypeMap ))
 298                 {
 299                     m_nAxisType = nEnumVal;
 300                     m_bAxisTypeImported = true;
 301                 }
 302                 break;
 303             case XML_TOK_AXIS_STYLE_NAME:
 304                 m_aAutoStyleName = aValue;
 305                 break;
 306         }
 307     }
 308
 309     // check for number of axes with same dimension
 310     m_aCurrentAxis.nAxisIndex = 0;
 311     sal_Int32 nNumOfAxes = m_rAxes.size();
 312     for( sal_Int32 nCurrent = 0; nCurrent < nNumOfAxes; nCurrent++ )
 313     {
 314         if( m_rAxes[ nCurrent ].eDimension == m_aCurrentAxis.eDimension )
 315             m_aCurrentAxis.nAxisIndex++;
 316     }
 317     CreateAxis();
 318 }
 319 namespace
 320 {
 321
 322 Reference< chart2::XAxis > lcl_getAxis( const Reference< frame::XModel >& xChartModel,
 323                                             sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
 324 {
 325     Reference< chart2::XAxis > xAxis;
 326
 327     try
 328     {
 329         Reference< chart2::XChartDocument > xChart2Document( xChartModel, uno::UNO_QUERY );
 330         if( xChart2Document.is() )
 331         {
 332             Reference< chart2::XDiagram > xDiagram( xChart2Document->getFirstDiagram());
 333             Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xDiagram, uno::UNO_QUERY_THROW );
 334             uno::Sequence< Reference< chart2::XCoordinateSystem > >
 335                 aCooSysSeq( xCooSysCnt->getCoordinateSystems());
 336             sal_Int32 nCooSysIndex = 0;
 337             if( nCooSysIndex < aCooSysSeq.getLength() )
 338             {
 339                 Reference< chart2::XCoordinateSystem > xCooSys( aCooSysSeq[nCooSysIndex] );
 340                 if( xCooSys.is() && nDimensionIndex < xCooSys->getDimension() )
 341                 {
 342                     const sal_Int32 nMaxAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
 343                     if( nAxisIndex <= nMaxAxisIndex )
 344                         xAxis = xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex );
 345                 }
 346             }
 347         }
 348     }
 349     catch( uno::Exception & )
 350     {
 351         SAL_INFO("xmloff.chart", "Couldn't get axis" );
 352     }
 353
 354     return xAxis;
 355 }
 356
 357 bool lcl_divideBy100( uno::Any& rDoubleAny )
 358 {
 359     bool bChanged = false;
 360     double fValue=0.0;
 361     if( (rDoubleAny>>=fValue) && (fValue!=0.0) )
 362     {
 363         fValue/=100.0;
 364         rDoubleAny = uno::makeAny(fValue);
 365         bChanged = true;
 366     }
 367     return bChanged;
 368 }
 369
 370 bool lcl_AdaptWrongPercentScaleValues(chart2::ScaleData& rScaleData)
 371 {
 372     bool bChanged = lcl_divideBy100( rScaleData.Minimum );
 373     bChanged = lcl_divideBy100( rScaleData.Maximum ) || bChanged;
 374     bChanged = lcl_divideBy100( rScaleData.Origin ) || bChanged;
 375     bChanged = lcl_divideBy100( rScaleData.IncrementData.Distance ) || bChanged;
 376     return bChanged;
 377 }
 378
 379 }//end anonymous namespace
 380
 381 void SchXMLAxisContext::CreateAxis()
 382 {
 383     m_rAxes.push_back( m_aCurrentAxis );
 384
 385     Reference< beans::XPropertySet > xDiaProp( m_rImportHelper.GetChartDocument()->getDiagram(), uno::UNO_QUERY );
 386     if( !xDiaProp.is() )
 387         return;
 388     OUString aPropName;
 389     switch( m_aCurrentAxis.eDimension )
 390     {
 391         case SCH_XML_AXIS_X:
 392             if( m_aCurrentAxis.nAxisIndex == 0 )
 393                 aPropName = "HasXAxis";
 394             else
 395                 aPropName = "HasSecondaryXAxis";
 396             break;
 397         case SCH_XML_AXIS_Y:
 398             if( m_aCurrentAxis.nAxisIndex == 0 )
 399                 aPropName = "HasYAxis";
 400             else
 401                 aPropName = "HasSecondaryYAxis";
 402             break;
 403         case SCH_XML_AXIS_Z:
 404             if( m_aCurrentAxis.nAxisIndex == 0 )
 405                 aPropName = "HasXAxis";
 406             else
 407                 aPropName = "HasSecondaryXAxis";
 408             break;
 409         case SCH_XML_AXIS_UNDEF:
 410             SAL_INFO("xmloff.chart", "Invalid axis" );
 411             break;
 412     }
 413     try
 414     {
 415         xDiaProp->setPropertyValue( aPropName, uno::makeAny(sal_True) );
 416     }
 417     catch( beans::UnknownPropertyException & )
 418     {
 419         SAL_INFO("xmloff.chart", "Couldn't turn on axis" );
 420     }
 421     if( m_aCurrentAxis.eDimension==SCH_XML_AXIS_Z )
 422     {
 423         bool bSettingZAxisSuccedded = false;
 424         try
 425         {
 426             xDiaProp->getPropertyValue( aPropName ) >>= bSettingZAxisSuccedded;
 427         }
 428         catch( beans::UnknownPropertyException & )
 429         {
 430             SAL_INFO("xmloff.chart", "Couldn't turn on z axis" );
 431         }
 432         if( !bSettingZAxisSuccedded )
 433             return;
 434     }
 435
 436     m_xAxisProps = Reference<beans::XPropertySet>( lcl_getChartAxis( m_aCurrentAxis, m_xDiagram ), uno::UNO_QUERY );
 437
 438     if( m_bAddMissingXAxisForNetCharts && m_aCurrentAxis.eDimension==SCH_XML_AXIS_Y && m_aCurrentAxis.nAxisIndex==0 )
 439     {
 440         try
 441         {
 442             xDiaProp->setPropertyValue("HasXAxis", uno::makeAny(sal_True) );
 443         }
 444         catch( beans::UnknownPropertyException & )
 445         {
 446             SAL_INFO("xmloff.chart", "Couldn't turn on x axis" );
 447         }
 448     }
 449
 450     // set properties
 451     if( m_xAxisProps.is())
 452     {
 453         uno::Any aTrueBool( uno::makeAny( sal_True ));
 454         uno::Any aFalseBool( uno::makeAny( sal_False ));
 455
 456         // #i109879# the line color is black as default, in the model it is a light gray
 457         m_xAxisProps->setPropertyValue("LineColor",
 458                                      uno::makeAny( COL_BLACK ));
 459
 460         m_xAxisProps->setPropertyValue("DisplayLabels", aFalseBool );
 461
 462         // #88077# AutoOrigin 'on' is default
 463         m_xAxisProps->setPropertyValue("AutoOrigin", aTrueBool );
 464
 465         if( m_bAxisTypeImported )
 466             m_xAxisProps->setPropertyValue("AxisType", uno::makeAny(m_nAxisType) );
 467
 468         if( !m_aAutoStyleName.isEmpty())
 469         {
 470             const SvXMLStylesContext* pStylesCtxt = m_rImportHelper.GetAutoStylesContext();
 471             if( pStylesCtxt )
 472             {
 473                 const SvXMLStyleContext* pStyle = pStylesCtxt->FindStyleChildContext(
 474                     SchXMLImportHelper::GetChartFamilyID(), m_aAutoStyleName );
 475
 476                 if( pStyle && pStyle->ISA( XMLPropStyleContext ))
 477                 {
 478                     // note: SvXMLStyleContext::FillPropertySet is not const
 479                     XMLPropStyleContext * pPropStyleContext = const_cast< XMLPropStyleContext * >( dynamic_cast< const XMLPropStyleContext * >( pStyle ));
 480                     if( pPropStyleContext )
 481                         pPropStyleContext->FillPropertySet( m_xAxisProps );
 482
 483                     if( m_bAdaptWrongPercentScaleValues && m_aCurrentAxis.eDimension==SCH_XML_AXIS_Y )
 484                     {
 485                         //set scale data of added x axis back to default
 486                         Reference< chart2::XAxis > xAxis( lcl_getAxis( GetImport().GetModel(),
 487                                             m_aCurrentAxis.eDimension, m_aCurrentAxis.nAxisIndex ) );
 488                         if( xAxis.is() )
 489                         {
 490                             chart2::ScaleData aScaleData( xAxis->getScaleData());
 491                             if( lcl_AdaptWrongPercentScaleValues(aScaleData) )
 492                                 xAxis->setScaleData( aScaleData );
 493                         }
 494                     }
 495
 496                     if( m_bAddMissingXAxisForNetCharts )
 497                     {
 498                         //copy style from y axis to added x axis:
 499
 500                         Reference< chart::XAxisSupplier > xAxisSuppl( xDiaProp, uno::UNO_QUERY );
 501                         if( xAxisSuppl.is() )
 502                         {
 503                             Reference< beans::XPropertySet > xXAxisProp( xAxisSuppl->getAxis(0), uno::UNO_QUERY );
 504                             const_cast<XMLPropStyleContext*>( static_cast< const XMLPropStyleContext* >( pStyle ))->FillPropertySet( xXAxisProp );
 505                         }
 506
 507                         //set scale data of added x axis back to default
 508                         Reference< chart2::XAxis > xAxis( lcl_getAxis( GetImport().GetModel(),
 509                                             0 /*nDimensionIndex*/, 0 /*nAxisIndex*/ ) );
 510                         if( xAxis.is() )
 511                         {
 512                             chart2::ScaleData aScaleData;
 513                             aScaleData.AxisType = chart2::AxisType::CATEGORY;
 514                             aScaleData.Orientation = chart2::AxisOrientation_MATHEMATICAL;
 515                             xAxis->setScaleData( aScaleData );
 516                         }
 517
 518                         //set line style of added x axis to invisible
 519                         Reference< beans::XPropertySet > xNewAxisProp( xAxis, uno::UNO_QUERY );
 520                         if( xNewAxisProp.is() )
 521                         {
 522                             xNewAxisProp->setPropertyValue("LineStyle"
 523                                 , uno::makeAny(drawing::LineStyle_NONE));
 524                         }
 525                     }
 526
 527                     if( m_bAdaptXAxisOrientationForOld2DBarCharts && m_aCurrentAxis.eDimension == SCH_XML_AXIS_X )
 528                     {
 529                         bool bIs3DChart = false;
 530                         if( xDiaProp.is() && ( xDiaProp->getPropertyValue("Dim3D") >>= bIs3DChart )
 531                             && !bIs3DChart )
 532                         {
 533                             Reference< chart2::XChartDocument > xChart2Document( GetImport().GetModel(), uno::UNO_QUERY );
 534                             if( xChart2Document.is() )
 535                             {
 536                                 Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xChart2Document->getFirstDiagram(), uno::UNO_QUERY );
 537                                 if( xCooSysCnt.is() )
 538                                 {
 539                                     uno::Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems() );
 540                                     if( aCooSysSeq.getLength() )
 541                                     {
 542                                         bool bSwapXandYAxis = false;
 543                                         Reference< chart2::XCoordinateSystem > xCooSys( aCooSysSeq[0] );
 544                                         Reference< beans::XPropertySet > xCooSysProp( xCooSys, uno::UNO_QUERY );
 545                                         if( xCooSysProp.is() && ( xCooSysProp->getPropertyValue("SwapXAndYAxis") >>= bSwapXandYAxis )
 546                                             && bSwapXandYAxis )
 547                                         {
 548                                             Reference< chart2::XAxis > xAxis = xCooSys->getAxisByDimension( 0, m_aCurrentAxis.nAxisIndex );
 549                                             if( xAxis.is() )
 550                                             {
 551                                                 chart2::ScaleData aScaleData = xAxis->getScaleData();
 552                                                 aScaleData.Orientation = chart2::AxisOrientation_REVERSE;
 553                                                 xAxis->setScaleData( aScaleData );
 554                                             }
 555                                         }
 556                                     }
 557                                 }
 558                             }
 559                         }
 560                     }
 561
 562                     m_rbAxisPositionAttributeImported = m_rbAxisPositionAttributeImported || SchXMLTools::getPropertyFromContext(
 563                         OUString("CrossoverPosition"), pPropStyleContext, pStylesCtxt ).hasValue();
 564                 }
 565             }
 566         }
 567     }
 568 }
 569
 570 void SchXMLAxisContext::SetAxisTitle()
 571 {
 572     if( m_aCurrentAxis.aTitle.isEmpty() )
 573         return;
 574
 575     Reference< chart::XAxis > xAxis( lcl_getChartAxis( m_aCurrentAxis, m_xDiagram ) );
 576     if( !xAxis.is() )
 577         return;
 578
 579     Reference< beans::XPropertySet > xTitleProp( xAxis->getAxisTitle() );
 580     if( xTitleProp.is() )
 581     {
 582         try
 583         {
 584             xTitleProp->setPropertyValue("String", uno::makeAny(m_aCurrentAxis.aTitle) );
 585         }
 586         catch( beans::UnknownPropertyException & )
 587         {
 588             SAL_INFO("xmloff.chart", "Property String for Title not available" );
 589         }
 590     }
 591 }
 592
 593 namespace
 594 {
 595 enum AxisChildTokens
 596 {
 597     XML_TOK_AXIS_TITLE,
 598     XML_TOK_AXIS_CATEGORIES,
 599     XML_TOK_AXIS_GRID,
 600     XML_TOK_AXIS_DATE_SCALE,
 601     XML_TOK_AXIS_DATE_SCALE_EXT
 602 };
 603
 604 const SvXMLTokenMapEntry aAxisChildTokenMap[] =
 605 {
 606     { XML_NAMESPACE_CHART,      XML_TITLE,              XML_TOK_AXIS_TITLE          },
 607     { XML_NAMESPACE_CHART,      XML_CATEGORIES,         XML_TOK_AXIS_CATEGORIES     },
 608     { XML_NAMESPACE_CHART,      XML_GRID,               XML_TOK_AXIS_GRID           },
 609     { XML_NAMESPACE_CHART,      XML_DATE_SCALE,         XML_TOK_AXIS_DATE_SCALE     },
 610     { XML_NAMESPACE_CHART_EXT,  XML_DATE_SCALE,         XML_TOK_AXIS_DATE_SCALE_EXT },
 611     XML_TOKEN_MAP_END
 612 };
 613
 614 class AxisChildTokenMap : public SvXMLTokenMap
 615 {
 616 public:
 617     AxisChildTokenMap(): SvXMLTokenMap( aAxisChildTokenMap ) {}
 618     virtual ~AxisChildTokenMap() {}
 619 };
 620
 621 //a AxisChildTokenMap Singleton
 622 struct theAxisChildTokenMap : public rtl::Static< AxisChildTokenMap, theAxisChildTokenMap > {};
 623 }
 624
 625 SvXMLImportContext* SchXMLAxisContext::CreateChildContext(
 626     sal_uInt16 p_nPrefix,
 627     const OUString& rLocalName,
 628     const Reference< xml::sax::XAttributeList >& xAttrList )
 629 {
 630     SvXMLImportContext* pContext = 0;
 631     const SvXMLTokenMap& rTokenMap = theAxisChildTokenMap::get();
 632
 633     switch( rTokenMap.Get( p_nPrefix, rLocalName ))
 634     {
 635         case XML_TOK_AXIS_TITLE:
 636         {
 637             Reference< drawing::XShape > xTitleShape = getTitleShape();
 638             pContext = new SchXMLTitleContext( m_rImportHelper, GetImport(), rLocalName,
 639                                                m_aCurrentAxis.aTitle,
 640                                                xTitleShape );
 641         }
 642         break;
 643
 644         case XML_TOK_AXIS_CATEGORIES:
 645             pContext = new SchXMLCategoriesContext( GetImport(),
 646                                                           p_nPrefix, rLocalName,
 647                                                           m_rCategoriesAddress );
 648             m_aCurrentAxis.bHasCategories = true;
 649             break;
 650
 651         case XML_TOK_AXIS_DATE_SCALE:
 652         case XML_TOK_AXIS_DATE_SCALE_EXT:
 653             pContext = new DateScaleContext( GetImport(),
 654                             p_nPrefix, rLocalName, m_xAxisProps );
 655             m_bDateScaleImported = true;
 656             break;
 657
 658         case XML_TOK_AXIS_GRID:
 659         {
 660             sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
 661             bool bIsMajor = true;       // default value for class is "major"
 662             OUString sAutoStyleName;
 663
 664             for( sal_Int16 i = 0; i < nAttrCount; i++ )
 665             {
 666                 OUString sAttrName = xAttrList->getNameByIndex( i );
 667                 OUString aLocalName;
 668                 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
 669
 670                 if( nPrefix == XML_NAMESPACE_CHART )
 671                 {
 672                     if( IsXMLToken( aLocalName, XML_CLASS ) )
 673                     {
 674                         if( IsXMLToken( xAttrList->getValueByIndex( i ), XML_MINOR ) )
 675                             bIsMajor = false;
 676                     }
 677                     else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
 678                         sAutoStyleName = xAttrList->getValueByIndex( i );
 679                 }
 680             }
 681
 682             CreateGrid( sAutoStyleName, bIsMajor );
 683
 684             // don't create a context => use default context. grid elements are empty
 685             pContext = new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
 686         }
 687         break;
 688
 689         default:
 690             pContext = new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
 691             break;
 692     }
 693
 694     return pContext;
 695 }
 696
 697 void SchXMLAxisContext::EndElement()
 698 {
 699     if( !m_bDateScaleImported && m_nAxisType==chart::ChartAxisType::AUTOMATIC )
 700     {
 701         Reference< chart2::XAxis > xAxis( lcl_getAxis( GetImport().GetModel(), m_aCurrentAxis.eDimension, m_aCurrentAxis.nAxisIndex ) );
 702         if( xAxis.is() )
 703         {
 704             chart2::ScaleData aScaleData( xAxis->getScaleData());
 705             aScaleData.AutoDateAxis = false;//different default for older documents
 706             xAxis->setScaleData( aScaleData );
 707         }
 708     }
 709
 710     SetAxisTitle();
 711 }
 712
 713 namespace
 714 {
 715
 716 Reference< chart2::XAxis > lcl_getAxis( const Reference< chart2::XCoordinateSystem >& rCooSys, sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex )
 717 {
 718     Reference< chart2::XAxis > xAxis;
 719     try
 720     {
 721         xAxis = rCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex );
 722     }
 723     catch( uno::Exception & )
 724     {
 725     }
 726     return xAxis;
 727 }
 728
 729 } // anonymous namespace
 730
 731 void SchXMLAxisContext::CorrectAxisPositions( const Reference< chart2::XChartDocument >& xNewDoc,
 732                           const OUString& rChartTypeServiceName,
 733                           const OUString& rODFVersionOfFile,
 734                           bool bAxisPositionAttributeImported )
 735 {
 736     if( ( rODFVersionOfFile.isEmpty() || rODFVersionOfFile == "1.0" || rODFVersionOfFile == "1.1"
 737         || ( rODFVersionOfFile == "1.2" && !bAxisPositionAttributeImported ) ) )
 738     {
 739         try
 740         {
 741             Reference< chart2::XCoordinateSystemContainer > xCooSysCnt( xNewDoc->getFirstDiagram(), uno::UNO_QUERY_THROW );
 742             uno::Sequence< Reference< chart2::XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems());
 743             if( aCooSysSeq.getLength() )
 744             {
 745                 Reference< chart2::XCoordinateSystem > xCooSys( aCooSysSeq[0] );
 746                 if( xCooSys.is() )
 747                 {
 748                     Reference< chart2::XAxis > xMainXAxis = lcl_getAxis( xCooSys, 0, 0 );
 749                     Reference< chart2::XAxis > xMainYAxis = lcl_getAxis( xCooSys, 1, 0 );
 750                     //Reference< chart2::XAxis > xMajorZAxis = lcl_getAxis( xCooSys, 2, 0 );
 751                     Reference< chart2::XAxis > xSecondaryXAxis = lcl_getAxis( xCooSys, 0, 1 );
 752                     Reference< chart2::XAxis > xSecondaryYAxis = lcl_getAxis( xCooSys, 1, 1 );
 753
 754                     Reference< beans::XPropertySet > xMainXAxisProp( xMainXAxis, uno::UNO_QUERY );
 755                     Reference< beans::XPropertySet > xMainYAxisProp( xMainYAxis, uno::UNO_QUERY );
 756                     Reference< beans::XPropertySet > xSecondaryXAxisProp( xSecondaryXAxis, uno::UNO_QUERY );
 757                     Reference< beans::XPropertySet > xSecondaryYAxisProp( xSecondaryYAxis, uno::UNO_QUERY );
 758
 759                     if( xMainXAxisProp.is() && xMainYAxisProp.is() )
 760                     {
 761                         chart2::ScaleData aMainXScale = xMainXAxis->getScaleData();
 762                         if( rChartTypeServiceName == "com.sun.star.chart2.ScatterChartType" )
 763                         {
 764                             xMainYAxisProp->setPropertyValue("CrossoverPosition"
 765                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE) );
 766                             double fCrossoverValue = 0.0;
 767                             aMainXScale.Origin >>= fCrossoverValue;
 768                             xMainYAxisProp->setPropertyValue("CrossoverValue"
 769                                     , uno::makeAny( fCrossoverValue ) );
 770
 771                             if( aMainXScale.Orientation == chart2::AxisOrientation_REVERSE )
 772                             {
 773                                 xMainYAxisProp->setPropertyValue("LabelPosition"
 774                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END) );
 775                                 xMainYAxisProp->setPropertyValue("MarkPosition"
 776                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
 777                                 if( xSecondaryYAxisProp.is() )
 778                                     xSecondaryYAxisProp->setPropertyValue("CrossoverPosition"
 779                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
 780                             }
 781                             else
 782                             {
 783                                 xMainYAxisProp->setPropertyValue("LabelPosition"
 784                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START) );
 785                                 xMainYAxisProp->setPropertyValue("MarkPosition"
 786                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
 787                                 if( xSecondaryYAxisProp.is() )
 788                                     xSecondaryYAxisProp->setPropertyValue("CrossoverPosition"
 789                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
 790                             }
 791                         }
 792                         else
 793                         {
 794                             if( aMainXScale.Orientation == chart2::AxisOrientation_REVERSE )
 795                             {
 796                                 xMainYAxisProp->setPropertyValue("CrossoverPosition"
 797                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
 798                                 if( xSecondaryYAxisProp.is() )
 799                                     xSecondaryYAxisProp->setPropertyValue("CrossoverPosition"
 800                                         , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
 801                             }
 802                             else
 803                             {
 804                                 xMainYAxisProp->setPropertyValue("CrossoverPosition"
 805                                     , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
 806                                 if( xSecondaryYAxisProp.is() )
 807                                     xSecondaryYAxisProp->setPropertyValue("CrossoverPosition"
 808                                         , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
 809                             }
 810                         }
 811
 812                         chart2::ScaleData aMainYScale = xMainYAxis->getScaleData();
 813                         xMainXAxisProp->setPropertyValue("CrossoverPosition"
 814                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE) );
 815                         double fCrossoverValue = 0.0;
 816                         aMainYScale.Origin >>= fCrossoverValue;
 817                         xMainXAxisProp->setPropertyValue("CrossoverValue"
 818                                 , uno::makeAny( fCrossoverValue ) );
 819
 820                         if( aMainYScale.Orientation == chart2::AxisOrientation_REVERSE )
 821                         {
 822                             xMainXAxisProp->setPropertyValue("LabelPosition"
 823                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END) );
 824                             xMainXAxisProp->setPropertyValue("MarkPosition"
 825                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
 826                             if( xSecondaryXAxisProp.is() )
 827                                 xSecondaryXAxisProp->setPropertyValue("CrossoverPosition"
 828                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START) );
 829                         }
 830                         else
 831                         {
 832                             xMainXAxisProp->setPropertyValue("LabelPosition"
 833                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START) );
 834                             xMainXAxisProp->setPropertyValue("MarkPosition"
 835                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS) );
 836                             if( xSecondaryXAxisProp.is() )
 837                                 xSecondaryXAxisProp->setPropertyValue("CrossoverPosition"
 838                                 , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_END) );
 839                         }
 840                     }
 841                 }
 842             }
 843         }
 844         catch( uno::Exception & )
 845         {
 846         }
 847     }
 848 }
 849
 850 SchXMLCategoriesContext::SchXMLCategoriesContext(
 851     SvXMLImport& rImport,
 852     sal_uInt16 nPrefix,
 853     const OUString& rLocalName,
 854     OUString& rAddress ) :
 855         SvXMLImportContext( rImport, nPrefix, rLocalName ),
 856         mrAddress( rAddress )
 857 {
 858 }
 859
 860 SchXMLCategoriesContext::~SchXMLCategoriesContext()
 861 {
 862 }
 863
 864 void SchXMLCategoriesContext::StartElement( const Reference< xml::sax::XAttributeList >& xAttrList )
 865 {
 866     sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
 867
 868     for( sal_Int16 i = 0; i < nAttrCount; i++ )
 869     {
 870         OUString sAttrName = xAttrList->getNameByIndex( i );
 871         OUString aLocalName;
 872         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
 873
 874         if( nPrefix == XML_NAMESPACE_TABLE &&
 875             IsXMLToken( aLocalName, XML_CELL_RANGE_ADDRESS ) )
 876         {
 877             Reference< chart2::XChartDocument > xNewDoc( GetImport().GetModel(), uno::UNO_QUERY );
 878             mrAddress = xAttrList->getValueByIndex( i );
 879         }
 880     }
 881 }
 882
 883 DateScaleContext::DateScaleContext(
 884     SvXMLImport& rImport,
 885     sal_uInt16 nPrefix,
 886     const OUString& rLocalName,
 887     const Reference< beans::XPropertySet >& rAxisProps ) :
 888         SvXMLImportContext( rImport, nPrefix, rLocalName ),
 889         m_xAxisProps( rAxisProps )
 890 {
 891 }
 892
 893 DateScaleContext::~DateScaleContext()
 894 {
 895 }
 896
 897 namespace
 898 {
 899 enum DateScaleAttributeTokens
 900 {
 901     XML_TOK_DATESCALE_BASE_TIME_UNIT,
 902     XML_TOK_DATESCALE_MAJOR_INTERVAL_VALUE,
 903     XML_TOK_DATESCALE_MAJOR_INTERVAL_UNIT,
 904     XML_TOK_DATESCALE_MINOR_INTERVAL_VALUE,
 905     XML_TOK_DATESCALE_MINOR_INTERVAL_UNIT
 906 };
 907
 908 const SvXMLTokenMapEntry aDateScaleAttributeTokenMap[] =
 909 {
 910     { XML_NAMESPACE_CHART,  XML_BASE_TIME_UNIT,         XML_TOK_DATESCALE_BASE_TIME_UNIT  },
 911     { XML_NAMESPACE_CHART,  XML_MAJOR_INTERVAL_VALUE,   XML_TOK_DATESCALE_MAJOR_INTERVAL_VALUE  },
 912     { XML_NAMESPACE_CHART,  XML_MAJOR_INTERVAL_UNIT,    XML_TOK_DATESCALE_MAJOR_INTERVAL_UNIT  },
 913     { XML_NAMESPACE_CHART,  XML_MINOR_INTERVAL_VALUE,   XML_TOK_DATESCALE_MINOR_INTERVAL_VALUE  },
 914     { XML_NAMESPACE_CHART,  XML_MINOR_INTERVAL_UNIT,    XML_TOK_DATESCALE_MINOR_INTERVAL_UNIT  },
 915     XML_TOKEN_MAP_END
 916 };
 917
 918 class DateScaleAttributeTokenMap : public SvXMLTokenMap
 919 {
 920 public:
 921     DateScaleAttributeTokenMap(): SvXMLTokenMap( aDateScaleAttributeTokenMap ) {}
 922     virtual ~DateScaleAttributeTokenMap() {}
 923 };
 924
 925 struct theDateScaleAttributeTokenMap : public rtl::Static< DateScaleAttributeTokenMap, theDateScaleAttributeTokenMap > {};
 926
 927 sal_Int32 lcl_getTimeUnit( const OUString& rValue )
 928 {
 929     sal_Int32 nTimeUnit = ::com::sun::star::chart::TimeUnit::DAY;
 930     if( IsXMLToken( rValue, XML_DAYS ) )
 931         nTimeUnit = ::com::sun::star::chart::TimeUnit::DAY;
 932     else if( IsXMLToken( rValue, XML_MONTHS ) )
 933         nTimeUnit = ::com::sun::star::chart::TimeUnit::MONTH;
 934     else if( IsXMLToken( rValue, XML_YEARS ) )
 935         nTimeUnit = ::com::sun::star::chart::TimeUnit::YEAR;
 936     return nTimeUnit;
 937 }
 938
 939 }
 940
 941 void DateScaleContext::StartElement( const Reference< xml::sax::XAttributeList >& xAttrList )
 942 {
 943     if( !m_xAxisProps.is() )
 944         return;
 945
 946     // parse attributes
 947     sal_Int16 nAttrCount = xAttrList.is()? xAttrList->getLength(): 0;
 948     const SvXMLTokenMap& rAttrTokenMap = theDateScaleAttributeTokenMap::get();
 949
 950     bool bSetNewIncrement=false;
 951     chart::TimeIncrement aIncrement;
 952     m_xAxisProps->getPropertyValue("TimeIncrement") >>= aIncrement;
 953
 954     for( sal_Int16 i = 0; i < nAttrCount; i++ )
 955     {
 956         OUString sAttrName = xAttrList->getNameByIndex( i );
 957         OUString aLocalName;
 958         OUString aValue = xAttrList->getValueByIndex( i );
 959         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
 960
 961         switch( rAttrTokenMap.Get( nPrefix, aLocalName ))
 962         {
 963             case XML_TOK_DATESCALE_BASE_TIME_UNIT:
 964                 {
 965                     aIncrement.TimeResolution = uno::makeAny( lcl_getTimeUnit(aValue) );
 966                     bSetNewIncrement = true;
 967                 }
 968                 break;
 969             case XML_TOK_DATESCALE_MAJOR_INTERVAL_VALUE:
 970                 {
 971                     chart::TimeInterval aInterval(1,0);
 972                     aIncrement.MajorTimeInterval >>= aInterval;
 973                     ::sax::Converter::convertNumber( aInterval.Number, aValue );
 974                     aIncrement.MajorTimeInterval = uno::makeAny(aInterval);
 975                     bSetNewIncrement = true;
 976                 }
 977                 break;
 978             case XML_TOK_DATESCALE_MAJOR_INTERVAL_UNIT:
 979                 {
 980                     chart::TimeInterval aInterval(1,0);
 981                     aIncrement.MajorTimeInterval >>= aInterval;
 982                     aInterval.TimeUnit = lcl_getTimeUnit(aValue);
 983                     aIncrement.MajorTimeInterval = uno::makeAny(aInterval);
 984                     bSetNewIncrement = true;
 985                 }
 986                 break;
 987             case XML_TOK_DATESCALE_MINOR_INTERVAL_VALUE:
 988                 {
 989                     chart::TimeInterval aInterval(1,0);
 990                     aIncrement.MinorTimeInterval >>= aInterval;
 991                     ::sax::Converter::convertNumber( aInterval.Number, aValue );
 992                     aIncrement.MinorTimeInterval = uno::makeAny(aInterval);
 993                     bSetNewIncrement = true;
 994                 }
 995                 break;
 996             case XML_TOK_DATESCALE_MINOR_INTERVAL_UNIT:
 997                 {
 998                     chart::TimeInterval aInterval(1,0);
 999                     aIncrement.MinorTimeInterval >>= aInterval;
1000                     aInterval.TimeUnit = lcl_getTimeUnit(aValue);
1001                     aIncrement.MinorTimeInterval = uno::makeAny(aInterval);
1002                     bSetNewIncrement = true;
1003                 }
1004                 break;
1005         }
1006     }
1007
1008     if( bSetNewIncrement )
1009         m_xAxisProps->setPropertyValue("TimeIncrement", uno::makeAny( aIncrement ) );
1010 }
1011
1012 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */