chart2/source/controller/chartapiwrapper/WrappedScaleProperty.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 "WrappedScaleProperty.hxx"
  21 #include "macros.hxx"
  22 #include "CommonConverters.hxx"
  23 #include "AxisHelper.hxx"
  24 #include <com/sun/star/chart2/XAxis.hpp>
  25 #include <com/sun/star/chart/ChartAxisType.hpp>
  26 #include <chartview/ExplicitScaleValues.hxx>
  27
  28 using namespace ::com::sun::star;
  29 using ::com::sun::star::uno::Any;
  30 using namespace ::com::sun::star::chart2;
  31 using ::com::sun::star::uno::Reference;
  32 using ::com::sun::star::uno::Sequence;
  33 using ::com::sun::star::chart::TimeIncrement;
  34
  35 namespace chart
  36 {
  37 namespace wrapper
  38 {
  39
  40 WrappedScaleProperty::WrappedScaleProperty( tScaleProperty eScaleProperty
  41                 , ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
  42             : WrappedProperty(OUString(),OUString())
  43             , m_spChart2ModelContact( spChart2ModelContact )
  44             , m_eScaleProperty( eScaleProperty )
  45 {
  46     switch( m_eScaleProperty )
  47     {
  48         case SCALE_PROP_MAX:
  49             m_aOuterName = "Max";
  50             break;
  51         case SCALE_PROP_MIN:
  52             m_aOuterName = "Min";
  53             break;
  54         case SCALE_PROP_ORIGIN:
  55             m_aOuterName = "Origin";
  56             break;
  57         case SCALE_PROP_STEPMAIN:
  58             m_aOuterName = "StepMain";
  59             break;
  60         case SCALE_PROP_STEPHELP:
  61             m_aOuterName = "StepHelp";
  62             break;
  63         case SCALE_PROP_STEPHELP_COUNT:
  64             m_aOuterName = "StepHelpCount";
  65             break;
  66         case SCALE_PROP_AUTO_MAX:
  67             m_aOuterName = "AutoMax";
  68             break;
  69         case SCALE_PROP_AUTO_MIN:
  70             m_aOuterName = "AutoMin";
  71             break;
  72         case SCALE_PROP_AUTO_ORIGIN:
  73             m_aOuterName = "AutoOrigin";
  74             break;
  75         case SCALE_PROP_AUTO_STEPMAIN:
  76             m_aOuterName = "AutoStepMain";
  77             break;
  78         case SCALE_PROP_AUTO_STEPHELP:
  79             m_aOuterName = "AutoStepHelp";
  80             break;
  81         case SCALE_PROP_AXIS_TYPE:
  82             m_aOuterName = "AxisType";
  83             break;
  84         case SCALE_PROP_DATE_INCREMENT:
  85             m_aOuterName = "TimeIncrement";
  86             break;
  87         case SCALE_PROP_EXPLICIT_DATE_INCREMENT:
  88             m_aOuterName = "ExplicitTimeIncrement";
  89             break;
  90         case SCALE_PROP_LOGARITHMIC:
  91             m_aOuterName = "Logarithmic";
  92             break;
  93         case SCALE_PROP_REVERSEDIRECTION:
  94             m_aOuterName = "ReverseDirection";
  95             break;
  96         default:
  97             OSL_FAIL("unknown scale property");
  98             break;
  99     }
 100 }
 101
 102 WrappedScaleProperty::~WrappedScaleProperty()
 103 {
 104 }
 105
 106 void WrappedScaleProperty::addWrappedProperties( std::vector< WrappedProperty* >& rList
 107             , ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 108 {
 109     rList.push_back( new WrappedScaleProperty( SCALE_PROP_MAX, spChart2ModelContact ) );
 110     rList.push_back( new WrappedScaleProperty( SCALE_PROP_MIN, spChart2ModelContact ) );
 111     rList.push_back( new WrappedScaleProperty( SCALE_PROP_ORIGIN, spChart2ModelContact ) );
 112     rList.push_back( new WrappedScaleProperty( SCALE_PROP_STEPMAIN, spChart2ModelContact ) );
 113     rList.push_back( new WrappedScaleProperty( SCALE_PROP_STEPHELP, spChart2ModelContact ) );
 114     rList.push_back( new WrappedScaleProperty( SCALE_PROP_STEPHELP_COUNT, spChart2ModelContact ) );
 115     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_MAX, spChart2ModelContact ) );
 116     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_MIN, spChart2ModelContact ) );
 117     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_ORIGIN, spChart2ModelContact ) );
 118     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_STEPMAIN, spChart2ModelContact ) );
 119     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_STEPHELP, spChart2ModelContact ) );
 120     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AXIS_TYPE, spChart2ModelContact ) );
 121     rList.push_back( new WrappedScaleProperty( SCALE_PROP_DATE_INCREMENT, spChart2ModelContact ) );
 122     rList.push_back( new WrappedScaleProperty( SCALE_PROP_EXPLICIT_DATE_INCREMENT, spChart2ModelContact ) );
 123     rList.push_back( new WrappedScaleProperty( SCALE_PROP_LOGARITHMIC, spChart2ModelContact ) );
 124     rList.push_back( new WrappedScaleProperty( SCALE_PROP_REVERSEDIRECTION, spChart2ModelContact ) );
 125 }
 126
 127 void WrappedScaleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 128                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 129 {
 130     setPropertyValue( m_eScaleProperty, rOuterValue, xInnerPropertySet );
 131 }
 132
 133 Any WrappedScaleProperty::getPropertyValue( const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 134                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 135 {
 136     return getPropertyValue( m_eScaleProperty, xInnerPropertySet );
 137 }
 138
 139 void WrappedScaleProperty::setPropertyValue( tScaleProperty eScaleProperty, const Any& rOuterValue, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 140                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 141 {
 142     m_aOuterValue = rOuterValue;
 143
 144     Reference< chart2::XAxis > xAxis( xInnerPropertySet, uno::UNO_QUERY );
 145     OSL_ENSURE(xAxis.is(),"need an XAxis");
 146     if(!xAxis.is())
 147         return;
 148
 149     bool bSetScaleData     = false;
 150
 151     chart2::ScaleData aScaleData( xAxis->getScaleData() );
 152
 153     bool bBool = false;
 154     switch( eScaleProperty )
 155     {
 156         case SCALE_PROP_MAX:
 157         {
 158             aScaleData.Maximum = rOuterValue;
 159             bSetScaleData = true;
 160             break;
 161         }
 162         case SCALE_PROP_MIN:
 163         {
 164             aScaleData.Minimum = rOuterValue;
 165             bSetScaleData = true;
 166             break;
 167         }
 168         case SCALE_PROP_STEPMAIN:
 169         {
 170             aScaleData.IncrementData.Distance = rOuterValue;
 171             bSetScaleData = true;
 172             break;
 173         }
 174         case SCALE_PROP_STEPHELP:
 175         {
 176             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 177             if( rSubIncrements.getLength() == 0 )
 178                 rSubIncrements.realloc( 1 );
 179
 180             double fStepHelp = 0;
 181             if( (rOuterValue >>= fStepHelp) )
 182             {
 183                 double fStepMain = 0;
 184                 if( AxisHelper::isLogarithmic(aScaleData.Scaling) )
 185                 {
 186                     sal_Int32 nIntervalCount = static_cast< sal_Int32 >(fStepHelp);
 187                     rSubIncrements[ 0 ].IntervalCount <<= nIntervalCount;
 188                 }
 189                 else if( (fStepHelp != 0.0) &&
 190                     (aScaleData.IncrementData.Distance >>= fStepMain) )
 191                 {
 192                     // approximate interval count
 193                     sal_Int32 nIntervalCount = static_cast< sal_Int32 >(fStepMain / fStepHelp);//cppcheck-suppress zerodiv
 194                     rSubIncrements[ 0 ].IntervalCount <<= nIntervalCount;
 195                 }
 196             }
 197             bSetScaleData = true;
 198             break;
 199         }
 200         case SCALE_PROP_STEPHELP_COUNT:
 201         {
 202             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 203             if( rSubIncrements.getLength() == 0 )
 204                 rSubIncrements.realloc( 1 );
 205             sal_Int32 nIntervalCount=0;
 206             if( rOuterValue>>=nIntervalCount )
 207                 rSubIncrements[ 0 ].IntervalCount <<= nIntervalCount;
 208             else
 209                 rSubIncrements[ 0 ].IntervalCount  = Any();
 210             bSetScaleData = true;
 211             break;
 212         }
 213         case SCALE_PROP_AUTO_MAX:
 214         {
 215             if( (rOuterValue >>= bBool) && bBool )
 216                 aScaleData.Maximum = Any();
 217             else
 218                 aScaleData.Maximum = getPropertyValue( SCALE_PROP_MAX, xInnerPropertySet );
 219             bSetScaleData = true;
 220             break;
 221         }
 222         case SCALE_PROP_AUTO_MIN:
 223         {
 224             if( (rOuterValue >>= bBool) && bBool )
 225                 aScaleData.Minimum = Any();
 226             else
 227                 aScaleData.Minimum = getPropertyValue( SCALE_PROP_MIN, xInnerPropertySet );
 228             bSetScaleData = true;
 229             break;
 230         }
 231         case SCALE_PROP_AUTO_STEPMAIN:
 232         {
 233             if( (rOuterValue >>= bBool) && bBool )
 234                 aScaleData.IncrementData.Distance = Any();
 235             else
 236                 aScaleData.IncrementData.Distance = getPropertyValue( SCALE_PROP_STEPMAIN, xInnerPropertySet );
 237             bSetScaleData = true;
 238             break;
 239         }
 240         case SCALE_PROP_AUTO_STEPHELP:
 241         {
 242             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 243             if( rSubIncrements.getLength() == 0 )
 244                 rSubIncrements.realloc( 1 );
 245
 246             if( (rOuterValue >>= bBool) && bBool )
 247                 rSubIncrements[ 0 ].IntervalCount = Any();
 248             else
 249                 rSubIncrements[ 0 ].IntervalCount = getPropertyValue( SCALE_PROP_STEPHELP_COUNT, xInnerPropertySet );
 250             bSetScaleData = true;
 251             break;
 252         }
 253         case SCALE_PROP_ORIGIN:
 254         {
 255             aScaleData.Origin = rOuterValue;
 256             bSetScaleData = true;
 257             break;
 258         }
 259         case SCALE_PROP_AUTO_ORIGIN:
 260         {
 261             if( (rOuterValue >>= bBool) && bBool )
 262                 aScaleData.Origin = Any();
 263             else
 264                 aScaleData.Origin = getPropertyValue( SCALE_PROP_ORIGIN, xInnerPropertySet );
 265             bSetScaleData = true;
 266             break;
 267         }
 268         case SCALE_PROP_AXIS_TYPE:
 269         {
 270             sal_Int32 nType = 0;
 271             if( (rOuterValue >>= nType) )
 272             {
 273                 if( ::com::sun::star::chart::ChartAxisType::AUTOMATIC == nType )
 274                 {
 275                     aScaleData.AutoDateAxis = true;
 276                     if( aScaleData.AxisType == AxisType::DATE )
 277                         aScaleData.AxisType = AxisType::CATEGORY;
 278                 }
 279                 else if( ::com::sun::star::chart::ChartAxisType::CATEGORY == nType )
 280                 {
 281                     aScaleData.AutoDateAxis = false;
 282                     if( aScaleData.AxisType == AxisType::DATE )
 283                         aScaleData.AxisType = AxisType::CATEGORY;
 284                 }
 285                 else if( ::com::sun::star::chart::ChartAxisType::DATE == nType )
 286                 {
 287                     if( aScaleData.AxisType == AxisType::CATEGORY )
 288                         aScaleData.AxisType = AxisType::DATE;
 289                 }
 290                 bSetScaleData = true;
 291             }
 292             break;
 293         }
 294         case SCALE_PROP_DATE_INCREMENT:
 295         {
 296             TimeIncrement aTimeIncrement;
 297             rOuterValue >>= aTimeIncrement;
 298             aScaleData.TimeIncrement = aTimeIncrement;
 299             bSetScaleData = true;
 300             break;
 301         }
 302         case SCALE_PROP_EXPLICIT_DATE_INCREMENT:
 303             //read only property
 304             break;
 305         case SCALE_PROP_LOGARITHMIC:
 306         {
 307             if( rOuterValue >>= bBool )
 308             {
 309                 bool bWasLogarithm = AxisHelper::isLogarithmic( aScaleData.Scaling );
 310
 311                 // safe comparison between sal_Bool and bool
 312                 if( (!bBool) != (!bWasLogarithm) )
 313                 {
 314                     if( bBool )
 315                         aScaleData.Scaling = AxisHelper::createLogarithmicScaling( 10.0 );
 316                     else
 317                         aScaleData.Scaling = 0;
 318                     bSetScaleData = true;
 319                 }
 320             }
 321             break;
 322         }
 323         case SCALE_PROP_REVERSEDIRECTION:
 324         {
 325             if( rOuterValue >>= bBool )
 326             {
 327                 bool bWasReverse = ( AxisOrientation_REVERSE == aScaleData.Orientation );
 328                 if( (!bBool) != (!bWasReverse) ) // safe comparison between sal_Bool and bool
 329                 {
 330                     aScaleData.Orientation = bBool ? AxisOrientation_REVERSE : AxisOrientation_MATHEMATICAL;
 331                     bSetScaleData = true;
 332                 }
 333             }
 334             break;
 335         }
 336         default:
 337         {
 338             OSL_FAIL("unknown scale property");
 339             break;
 340         }
 341     }
 342
 343     if( bSetScaleData )
 344         xAxis->setScaleData( aScaleData );
 345 }
 346
 347 Any WrappedScaleProperty::getPropertyValue( tScaleProperty eScaleProperty, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 348                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 349 {
 350     Any aRet( m_aOuterValue );
 351
 352     Reference< chart2::XAxis > xAxis( xInnerPropertySet, uno::UNO_QUERY );
 353     OSL_ENSURE(xAxis.is(),"need an XAxis");
 354     if(!xAxis.is())
 355         return aRet;
 356
 357     chart2::ScaleData aScaleData( xAxis->getScaleData() );
 358
 359     ExplicitScaleData aExplicitScale;
 360     ExplicitIncrementData aExplicitIncrement;
 361
 362     switch( eScaleProperty )
 363     {
 364         case SCALE_PROP_MAX:
 365         {
 366             aRet = aScaleData.Maximum;
 367             if( !aRet.hasValue() )
 368             {
 369                 m_spChart2ModelContact->getExplicitValuesForAxis(
 370                     xAxis, aExplicitScale, aExplicitIncrement );
 371                 aRet <<= aExplicitScale.Maximum;
 372             }
 373             break;
 374         }
 375         case SCALE_PROP_MIN:
 376         {
 377             aRet = aScaleData.Minimum;
 378             if( !aRet.hasValue() )
 379             {
 380                 m_spChart2ModelContact->getExplicitValuesForAxis(
 381                     xAxis, aExplicitScale, aExplicitIncrement );
 382                 aRet <<= aExplicitScale.Minimum;
 383             }
 384             break;
 385         }
 386
 387         case SCALE_PROP_STEPMAIN:
 388         {
 389             aRet = aScaleData.IncrementData.Distance;
 390             if( !aRet.hasValue() )
 391             {
 392                 m_spChart2ModelContact->getExplicitValuesForAxis(
 393                     xAxis, aExplicitScale, aExplicitIncrement );
 394                 aRet <<= aExplicitIncrement.Distance;
 395             }
 396             break;
 397         }
 398         case SCALE_PROP_STEPHELP:
 399         {
 400             // todo: evaluate PostEquidistant
 401             bool bNeedToCalculateExplicitValues = true;
 402
 403             bool bLogarithmic( AxisHelper::isLogarithmic(aScaleData.Scaling) );
 404             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 405             if( bLogarithmic )
 406             {
 407                 if( rSubIncrements.getLength() > 0 )
 408                 {
 409                     sal_Int32 nIntervalCount = 0;
 410                     rSubIncrements[ 0 ].IntervalCount >>= nIntervalCount;
 411                     aRet = uno::makeAny( double(nIntervalCount) );
 412                     bNeedToCalculateExplicitValues = false;
 413                 }
 414             }
 415             else if( aScaleData.IncrementData.Distance.hasValue() )
 416             {
 417                 if( rSubIncrements.getLength() > 0 )
 418                 {
 419                     double fStepMain = 0;
 420                     sal_Int32 nIntervalCount = 0;
 421                     if( (aScaleData.IncrementData.Distance >>= fStepMain) &&
 422                         (rSubIncrements[ 0 ].IntervalCount >>= nIntervalCount) &&
 423                         nIntervalCount > 0 )
 424                     {
 425                         aRet <<= ( fStepMain / static_cast< double >( nIntervalCount ) );
 426                         bNeedToCalculateExplicitValues = false;
 427                     }
 428                 }
 429                 else
 430                 {
 431                     aRet = aScaleData.IncrementData.Distance;
 432                     bNeedToCalculateExplicitValues = false;
 433                 }
 434             }
 435
 436             if( bNeedToCalculateExplicitValues )
 437             {
 438                 m_spChart2ModelContact->getExplicitValuesForAxis(
 439                     xAxis, aExplicitScale, aExplicitIncrement );
 440
 441                 if( !aExplicitIncrement.SubIncrements.empty() &&
 442                      aExplicitIncrement.SubIncrements[ 0 ].IntervalCount > 0 )
 443                 {
 444                     if( bLogarithmic )
 445                     {
 446                         if( rSubIncrements.getLength() > 0 )
 447                         {
 448                             sal_Int32 nIntervalCount = aExplicitIncrement.SubIncrements[ 0 ].IntervalCount;
 449                             aRet = uno::makeAny( double(nIntervalCount) );
 450                         }
 451                     }
 452                     else
 453                         aRet <<= ( aExplicitIncrement.Distance /
 454                                 static_cast< double >(
 455                                     aExplicitIncrement.SubIncrements[ 0 ].IntervalCount ));
 456                 }
 457                 else
 458                 {
 459                     if( bLogarithmic )
 460                         aRet <<= 5.0;
 461                     else
 462                         aRet <<= aExplicitIncrement.Distance;
 463                 }
 464             }
 465             break;
 466         }
 467         case SCALE_PROP_STEPHELP_COUNT:
 468         {
 469             sal_Int32 nIntervalCount = 0;
 470             bool bNeedToCalculateExplicitValues = true;
 471             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 472             if( rSubIncrements.getLength() > 0 )
 473             {
 474                 if( (rSubIncrements[ 0 ].IntervalCount >>= nIntervalCount) && (nIntervalCount > 0) )
 475                     bNeedToCalculateExplicitValues = false;
 476             }
 477             if( bNeedToCalculateExplicitValues )
 478             {
 479                 m_spChart2ModelContact->getExplicitValuesForAxis( xAxis, aExplicitScale, aExplicitIncrement );
 480                 if( !aExplicitIncrement.SubIncrements.empty() )
 481                     nIntervalCount = aExplicitIncrement.SubIncrements[ 0 ].IntervalCount;
 482             }
 483             aRet = uno::makeAny( nIntervalCount );
 484             break;
 485         }
 486         case SCALE_PROP_AUTO_MAX:
 487         {
 488             aRet <<= !aScaleData.Maximum.hasValue();
 489             break;
 490         }
 491         case SCALE_PROP_AUTO_MIN:
 492         {
 493             aRet <<= !aScaleData.Minimum.hasValue();
 494             break;
 495         }
 496         case SCALE_PROP_AUTO_STEPMAIN:
 497         {
 498             aRet <<= !aScaleData.IncrementData.Distance.hasValue();
 499             break;
 500         }
 501         case SCALE_PROP_AUTO_STEPHELP:
 502         {
 503             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 504             if( rSubIncrements.getLength() > 0 )
 505                 aRet <<= !rSubIncrements[ 0 ].IntervalCount.hasValue();
 506             else
 507                 aRet <<= true;
 508             break;
 509         }
 510         case SCALE_PROP_ORIGIN:
 511         {
 512             aRet = aScaleData.Origin;
 513             if( !aRet.hasValue() )
 514             {
 515                 m_spChart2ModelContact->getExplicitValuesForAxis(
 516                     xAxis, aExplicitScale, aExplicitIncrement );
 517                 aRet <<= aExplicitScale.Origin;
 518             }
 519             break;
 520         }
 521         case SCALE_PROP_AUTO_ORIGIN:
 522         {
 523             aRet <<= !hasDoubleValue(aScaleData.Origin);
 524             break;
 525         }
 526         case SCALE_PROP_AXIS_TYPE:
 527         {
 528             sal_Int32 nType = ::com::sun::star::chart::ChartAxisType::AUTOMATIC;
 529             if( aScaleData.AxisType == AxisType::DATE )
 530             {
 531                 nType = ::com::sun::star::chart::ChartAxisType::DATE;
 532             }
 533             else if( aScaleData.AxisType == AxisType::CATEGORY )
 534             {
 535                 if( !aScaleData.AutoDateAxis )
 536                     nType = ::com::sun::star::chart::ChartAxisType::CATEGORY;
 537             }
 538             aRet = uno::makeAny( nType );
 539             break;
 540         }
 541         case SCALE_PROP_DATE_INCREMENT:
 542         {
 543             if( aScaleData.AxisType == AxisType::DATE || aScaleData.AutoDateAxis )
 544                 aRet = uno::makeAny( aScaleData.TimeIncrement );
 545             break;
 546         }
 547         case SCALE_PROP_EXPLICIT_DATE_INCREMENT:
 548         {
 549             if( aScaleData.AxisType == AxisType::DATE || aScaleData.AutoDateAxis )
 550             {
 551                 m_spChart2ModelContact->getExplicitValuesForAxis( xAxis, aExplicitScale, aExplicitIncrement );
 552                 if( aExplicitScale.AxisType == AxisType::DATE )
 553                 {
 554                     TimeIncrement aTimeIncrement;
 555                     aTimeIncrement.MajorTimeInterval = uno::makeAny( aExplicitIncrement.MajorTimeInterval );
 556                     aTimeIncrement.MinorTimeInterval = uno::makeAny( aExplicitIncrement.MinorTimeInterval );
 557                     aTimeIncrement.TimeResolution = uno::makeAny( aExplicitScale.TimeResolution );
 558                     aRet = uno::makeAny(aTimeIncrement);
 559                 }
 560             }
 561
 562             if( aScaleData.AxisType == AxisType::DATE || aScaleData.AutoDateAxis )
 563                 aRet = uno::makeAny( aScaleData.TimeIncrement );
 564             break;
 565         }
 566         case SCALE_PROP_LOGARITHMIC:
 567         {
 568             aRet <<= AxisHelper::isLogarithmic(aScaleData.Scaling);
 569             break;
 570         }
 571         case SCALE_PROP_REVERSEDIRECTION:
 572         {
 573             aRet <<= AxisOrientation_REVERSE == aScaleData.Orientation;
 574             break;
 575         }
 576         default:
 577         {
 578             OSL_FAIL("unknown scale property");
 579             break;
 580         }
 581     }
 582
 583     return aRet;
 584 }
 585
 586 } //  namespace wrapper
 587 } //  namespace chart
 588
 589 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */