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