chart2/source/controller/chartapiwrapper/WrappedScaleProperty.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: WrappedScaleProperty.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33
  34 #include "WrappedScaleProperty.hxx"
  35 #include "macros.hxx"
  36 #include "CommonConverters.hxx"
  37 #include "AxisHelper.hxx"
  38 #include <com/sun/star/chart2/XAxis.hpp>
  39 #include <com/sun/star/chart2/ExplicitIncrementData.hpp>
  40 #include <com/sun/star/chart2/ExplicitScaleData.hpp>
  41 #include <com/sun/star/chart2/AxisOrientation.hpp>
  42
  43 using namespace ::com::sun::star;
  44 using ::com::sun::star::uno::Any;
  45 using namespace ::com::sun::star::chart2;
  46 using ::com::sun::star::uno::Reference;
  47 using ::com::sun::star::uno::Sequence;
  48 using ::rtl::OUString;
  49
  50 //.............................................................................
  51 namespace chart
  52 {
  53 namespace wrapper
  54 {
  55
  56 WrappedScaleProperty::WrappedScaleProperty( tScaleProperty eScaleProperty
  57                 , ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
  58             : WrappedProperty(OUString(),OUString())
  59             , m_spChart2ModelContact( spChart2ModelContact )
  60             , m_eScaleProperty( eScaleProperty )
  61 {
  62     switch( m_eScaleProperty )
  63     {
  64         case SCALE_PROP_MAX:
  65             m_aOuterName = C2U("Max");
  66             break;
  67         case SCALE_PROP_MIN:
  68             m_aOuterName = C2U("Min");
  69             break;
  70         case SCALE_PROP_ORIGIN:
  71             m_aOuterName = C2U("Origin");
  72             break;
  73         case SCALE_PROP_STEPMAIN:
  74             m_aOuterName = C2U("StepMain");
  75             break;
  76         case SCALE_PROP_STEPHELP:
  77             m_aOuterName = C2U("StepHelp");
  78             break;
  79         case SCALE_PROP_STEPHELP_COUNT:
  80             m_aOuterName = C2U("StepHelpCount");
  81             break;
  82         case SCALE_PROP_AUTO_MAX:
  83             m_aOuterName = C2U("AutoMax");
  84             break;
  85         case SCALE_PROP_AUTO_MIN:
  86             m_aOuterName = C2U("AutoMin");
  87             break;
  88         case SCALE_PROP_AUTO_ORIGIN:
  89             m_aOuterName = C2U("AutoOrigin");
  90             break;
  91         case SCALE_PROP_AUTO_STEPMAIN:
  92             m_aOuterName = C2U("AutoStepMain");
  93             break;
  94         case SCALE_PROP_AUTO_STEPHELP:
  95             m_aOuterName = C2U("AutoStepHelp");
  96             break;
  97         case SCALE_PROP_LOGARITHMIC:
  98             m_aOuterName = C2U("Logarithmic");
  99             break;
 100         case SCALE_PROP_REVERSEDIRECTION:
 101             m_aOuterName = C2U("ReverseDirection");
 102             break;
 103         default:
 104             OSL_ENSURE(false,"unknown scale property");
 105             break;
 106     }
 107 }
 108
 109 WrappedScaleProperty::~WrappedScaleProperty()
 110 {
 111 }
 112
 113 //static
 114 void WrappedScaleProperty::addWrappedProperties( std::vector< WrappedProperty* >& rList
 115             , ::boost::shared_ptr< Chart2ModelContact > spChart2ModelContact )
 116 {
 117     rList.push_back( new WrappedScaleProperty( SCALE_PROP_MAX, spChart2ModelContact ) );
 118     rList.push_back( new WrappedScaleProperty( SCALE_PROP_MIN, spChart2ModelContact ) );
 119     rList.push_back( new WrappedScaleProperty( SCALE_PROP_ORIGIN, spChart2ModelContact ) );
 120     rList.push_back( new WrappedScaleProperty( SCALE_PROP_STEPMAIN, spChart2ModelContact ) );
 121     rList.push_back( new WrappedScaleProperty( SCALE_PROP_STEPHELP, spChart2ModelContact ) );
 122     rList.push_back( new WrappedScaleProperty( SCALE_PROP_STEPHELP_COUNT, spChart2ModelContact ) );
 123     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_MAX, spChart2ModelContact ) );
 124     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_MIN, spChart2ModelContact ) );
 125     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_ORIGIN, spChart2ModelContact ) );
 126     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_STEPMAIN, spChart2ModelContact ) );
 127     rList.push_back( new WrappedScaleProperty( SCALE_PROP_AUTO_STEPHELP, spChart2ModelContact ) );
 128     rList.push_back( new WrappedScaleProperty( SCALE_PROP_LOGARITHMIC, spChart2ModelContact ) );
 129     rList.push_back( new WrappedScaleProperty( SCALE_PROP_REVERSEDIRECTION, spChart2ModelContact ) );
 130 }
 131
 132 void WrappedScaleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 133                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 134 {
 135     setPropertyValue( m_eScaleProperty, rOuterValue, xInnerPropertySet );
 136 }
 137
 138 Any WrappedScaleProperty::getPropertyValue( const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 139                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 140 {
 141     return getPropertyValue( m_eScaleProperty, xInnerPropertySet );
 142 }
 143
 144 void WrappedScaleProperty::setPropertyValue( tScaleProperty eScaleProperty, const Any& rOuterValue, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 145                 throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 146 {
 147     m_aOuterValue = rOuterValue;
 148
 149     Reference< chart2::XAxis > xAxis( xInnerPropertySet, uno::UNO_QUERY );
 150     OSL_ENSURE(xAxis.is(),"need an XAxis");
 151     if(!xAxis.is())
 152         return;
 153
 154     bool bSetScaleData     = false;
 155
 156     chart2::ScaleData aScaleData( xAxis->getScaleData() );
 157
 158     sal_Bool bBool = false;
 159     switch( eScaleProperty )
 160     {
 161         case SCALE_PROP_MAX:
 162         {
 163             aScaleData.Maximum = rOuterValue;
 164             bSetScaleData = true;
 165             break;
 166         }
 167         case SCALE_PROP_MIN:
 168         {
 169             aScaleData.Minimum = rOuterValue;
 170             bSetScaleData = true;
 171             break;
 172         }
 173         case SCALE_PROP_STEPMAIN:
 174         {
 175             aScaleData.IncrementData.Distance = rOuterValue;
 176             bSetScaleData = true;
 177             break;
 178         }
 179         case SCALE_PROP_STEPHELP:
 180         {
 181             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 182             if( rSubIncrements.getLength() == 0 )
 183                 rSubIncrements.realloc( 1 );
 184
 185             double fStepMain = 0, fStepHelp = 0;
 186             if( (rOuterValue >>= fStepHelp) )
 187             {
 188                 if( AxisHelper::isLogarithmic(aScaleData.Scaling) )
 189                 {
 190                     sal_Int32 nIntervalCount = static_cast< sal_Int32 >(fStepHelp);
 191                     rSubIncrements[ 0 ].IntervalCount <<= nIntervalCount;
 192                 }
 193                 else if( (fStepHelp != 0.0) &&
 194                     (aScaleData.IncrementData.Distance >>= fStepMain) )
 195                 {
 196                     // approximate interval count
 197                     sal_Int32 nIntervalCount = static_cast< sal_Int32 >(fStepMain / fStepHelp);
 198                     rSubIncrements[ 0 ].IntervalCount <<= nIntervalCount;
 199                 }
 200             }
 201             bSetScaleData = true;
 202             break;
 203         }
 204         case SCALE_PROP_STEPHELP_COUNT:
 205         {
 206             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 207             if( rSubIncrements.getLength() == 0 )
 208                 rSubIncrements.realloc( 1 );
 209             sal_Int32 nIntervalCount=0;
 210             if( rOuterValue>>=nIntervalCount )
 211                 rSubIncrements[ 0 ].IntervalCount <<= nIntervalCount;
 212             else
 213                 rSubIncrements[ 0 ].IntervalCount  = Any();
 214             bSetScaleData = true;
 215             break;
 216         }
 217         case SCALE_PROP_AUTO_MAX:
 218         {
 219             if( (rOuterValue >>= bBool) && bBool )
 220                 aScaleData.Maximum = Any();
 221             else
 222                 aScaleData.Maximum = getPropertyValue( SCALE_PROP_MAX, xInnerPropertySet );
 223             bSetScaleData = true;
 224             break;
 225         }
 226         case SCALE_PROP_AUTO_MIN:
 227         {
 228             if( (rOuterValue >>= bBool) && bBool )
 229                 aScaleData.Minimum = Any();
 230             else
 231                 aScaleData.Minimum = getPropertyValue( SCALE_PROP_MIN, xInnerPropertySet );
 232             bSetScaleData = true;
 233             break;
 234         }
 235         case SCALE_PROP_AUTO_STEPMAIN:
 236         {
 237             if( (rOuterValue >>= bBool) && bBool )
 238                 aScaleData.IncrementData.Distance = Any();
 239             else
 240                 aScaleData.IncrementData.Distance = getPropertyValue( SCALE_PROP_STEPMAIN, xInnerPropertySet );
 241             bSetScaleData = true;
 242             break;
 243         }
 244         case SCALE_PROP_AUTO_STEPHELP:
 245         {
 246             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 247             if( rSubIncrements.getLength() == 0 )
 248                 rSubIncrements.realloc( 1 );
 249
 250             if( (rOuterValue >>= bBool) && bBool )
 251                 rSubIncrements[ 0 ].IntervalCount = Any();
 252             else
 253                 rSubIncrements[ 0 ].IntervalCount = getPropertyValue( SCALE_PROP_STEPHELP_COUNT, xInnerPropertySet );
 254             bSetScaleData = true;
 255             break;
 256         }
 257         case SCALE_PROP_ORIGIN:
 258         {
 259             aScaleData.Origin = rOuterValue;
 260             bSetScaleData = true;
 261             break;
 262         }
 263         case SCALE_PROP_AUTO_ORIGIN:
 264         {
 265             if( (rOuterValue >>= bBool) && bBool )
 266                 aScaleData.Origin = Any();
 267             else
 268                 aScaleData.Origin = getPropertyValue( SCALE_PROP_ORIGIN, xInnerPropertySet );
 269             bSetScaleData = true;
 270             break;
 271         }
 272         case SCALE_PROP_LOGARITHMIC:
 273         {
 274             if( rOuterValue >>= bBool )
 275             {
 276                 bool bWasLogarithm = AxisHelper::isLogarithmic( aScaleData.Scaling );
 277
 278                 // safe comparison between sal_Bool and bool
 279                 if( (!bBool) != (!bWasLogarithm) )
 280                 {
 281                     if( bBool )
 282                         aScaleData.Scaling = AxisHelper::createLogarithmicScaling( 10.0 );
 283                     else
 284                         aScaleData.Scaling = 0;
 285                     bSetScaleData = true;
 286                 }
 287             }
 288             break;
 289         }
 290         case SCALE_PROP_REVERSEDIRECTION:
 291         {
 292             if( rOuterValue >>= bBool )
 293             {
 294                 bool bWasReverse = ( AxisOrientation_REVERSE == aScaleData.Orientation );
 295                 if( (!bBool) != (!bWasReverse) ) // safe comparison between sal_Bool and bool
 296                 {
 297                     aScaleData.Orientation = bBool ? AxisOrientation_REVERSE : AxisOrientation_MATHEMATICAL;
 298                     bSetScaleData = true;
 299                 }
 300             }
 301             break;
 302         }
 303         default:
 304         {
 305             OSL_ENSURE(false,"unknown scale property");
 306             break;
 307         }
 308     }
 309
 310     if( bSetScaleData )
 311         xAxis->setScaleData( aScaleData );
 312 }
 313
 314 Any WrappedScaleProperty::getPropertyValue( tScaleProperty eScaleProperty, const Reference< beans::XPropertySet >& xInnerPropertySet ) const
 315                         throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 316 {
 317     Any aRet( m_aOuterValue );
 318
 319     Reference< chart2::XAxis > xAxis( xInnerPropertySet, uno::UNO_QUERY );
 320     OSL_ENSURE(xAxis.is(),"need an XAxis");
 321     if(!xAxis.is())
 322         return aRet;
 323
 324     chart2::ScaleData aScaleData( xAxis->getScaleData() );
 325
 326     chart2::ExplicitScaleData aExplicitScale;
 327     chart2::ExplicitIncrementData aExplicitIncrement;
 328
 329     switch( eScaleProperty )
 330     {
 331         case SCALE_PROP_MAX:
 332         {
 333             aRet = aScaleData.Maximum;
 334             if( !aRet.hasValue() )
 335             {
 336                 m_spChart2ModelContact->getExplicitValuesForAxis(
 337                     xAxis, aExplicitScale, aExplicitIncrement );
 338                 aRet <<= aExplicitScale.Maximum;
 339             }
 340             break;
 341         }
 342         case SCALE_PROP_MIN:
 343         {
 344             aRet = aScaleData.Minimum;
 345             if( !aRet.hasValue() )
 346             {
 347                 m_spChart2ModelContact->getExplicitValuesForAxis(
 348                     xAxis, aExplicitScale, aExplicitIncrement );
 349                 aRet <<= aExplicitScale.Minimum;
 350             }
 351             break;
 352         }
 353
 354         case SCALE_PROP_STEPMAIN:
 355         {
 356             aRet = aScaleData.IncrementData.Distance;
 357             if( !aRet.hasValue() )
 358             {
 359                 m_spChart2ModelContact->getExplicitValuesForAxis(
 360                     xAxis, aExplicitScale, aExplicitIncrement );
 361                 aRet <<= aExplicitIncrement.Distance;
 362             }
 363             break;
 364         }
 365         case SCALE_PROP_STEPHELP:
 366         {
 367             // todo: evaluate PostEquidistant
 368             bool bNeedToCalculateExplicitValues = true;
 369
 370             bool bLogarithmic( AxisHelper::isLogarithmic(aScaleData.Scaling) );
 371             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 372             if( bLogarithmic )
 373             {
 374                 if( rSubIncrements.getLength() > 0 )
 375                 {
 376                     sal_Int32 nIntervalCount = 0;
 377                     rSubIncrements[ 0 ].IntervalCount >>= nIntervalCount;
 378                     aRet = uno::makeAny( double(nIntervalCount) );
 379                     bNeedToCalculateExplicitValues = false;
 380                 }
 381             }
 382             else if( aScaleData.IncrementData.Distance.hasValue() )
 383             {
 384                 if( rSubIncrements.getLength() > 0 )
 385                 {
 386                     double fStepMain = 0;
 387                     sal_Int32 nIntervalCount = 0;
 388                     if( (aScaleData.IncrementData.Distance >>= fStepMain) &&
 389                         (rSubIncrements[ 0 ].IntervalCount >>= nIntervalCount) &&
 390                         nIntervalCount > 0 )
 391                     {
 392                         aRet <<= ( fStepMain / static_cast< double >( nIntervalCount ) );
 393                         bNeedToCalculateExplicitValues = false;
 394                     }
 395                 }
 396                 else
 397                 {
 398                     aRet = aScaleData.IncrementData.Distance;
 399                     bNeedToCalculateExplicitValues = false;
 400                 }
 401             }
 402
 403             if( bNeedToCalculateExplicitValues )
 404             {
 405                 m_spChart2ModelContact->getExplicitValuesForAxis(
 406                     xAxis, aExplicitScale, aExplicitIncrement );
 407                 if( aExplicitIncrement.SubIncrements.getLength() > 0 &&
 408                      aExplicitIncrement.SubIncrements[ 0 ].IntervalCount > 0 )
 409                 {
 410                     if( bLogarithmic )
 411                     {
 412                         if( rSubIncrements.getLength() > 0 )
 413                         {
 414                             sal_Int32 nIntervalCount = aExplicitIncrement.SubIncrements[ 0 ].IntervalCount;
 415                             aRet = uno::makeAny( double(nIntervalCount) );
 416                         }
 417                     }
 418                     else
 419                         aRet <<= ( aExplicitIncrement.Distance /
 420                                 static_cast< double >(
 421                                     aExplicitIncrement.SubIncrements[ 0 ].IntervalCount ));
 422                 }
 423                 else
 424                 {
 425                     if( bLogarithmic )
 426                         aRet <<= 5.0;
 427                     else
 428                         aRet <<= aExplicitIncrement.Distance;
 429                 }
 430             }
 431             break;
 432         }
 433         case SCALE_PROP_STEPHELP_COUNT:
 434         {
 435             sal_Int32 nIntervalCount = 0;
 436             bool bNeedToCalculateExplicitValues = true;
 437             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 438             if( rSubIncrements.getLength() > 0 )
 439             {
 440                 if( (rSubIncrements[ 0 ].IntervalCount >>= nIntervalCount) && (nIntervalCount > 0) )
 441                     bNeedToCalculateExplicitValues = false;
 442             }
 443             if( bNeedToCalculateExplicitValues )
 444             {
 445                 m_spChart2ModelContact->getExplicitValuesForAxis( xAxis, aExplicitScale, aExplicitIncrement );
 446                 if( aExplicitIncrement.SubIncrements.getLength() > 0 )
 447                     nIntervalCount = aExplicitIncrement.SubIncrements[ 0 ].IntervalCount;
 448             }
 449             aRet = uno::makeAny( nIntervalCount );
 450             break;
 451         }
 452         case SCALE_PROP_AUTO_MAX:
 453         {
 454             aRet <<= (sal_Bool)( !aScaleData.Maximum.hasValue() );
 455             break;
 456         }
 457         case SCALE_PROP_AUTO_MIN:
 458         {
 459             aRet <<= (sal_Bool)( !aScaleData.Minimum.hasValue() );
 460             break;
 461         }
 462         case SCALE_PROP_AUTO_STEPMAIN:
 463         {
 464             aRet <<= (sal_Bool)( !aScaleData.IncrementData.Distance.hasValue() );
 465             break;
 466         }
 467         case SCALE_PROP_AUTO_STEPHELP:
 468         {
 469             Sequence< chart2::SubIncrement >& rSubIncrements( aScaleData.IncrementData.SubIncrements );
 470             if( rSubIncrements.getLength() > 0 )
 471                 aRet <<= (sal_Bool)( !rSubIncrements[ 0 ].IntervalCount.hasValue() );
 472             else
 473                 aRet <<= sal_True;
 474             break;
 475         }
 476         case SCALE_PROP_ORIGIN:
 477         {
 478             aRet = aScaleData.Origin;
 479             if( !aRet.hasValue() )
 480             {
 481                 m_spChart2ModelContact->getExplicitValuesForAxis(
 482                     xAxis, aExplicitScale, aExplicitIncrement );
 483                 aRet <<= aExplicitScale.Origin;
 484             }
 485             break;
 486         }
 487         case SCALE_PROP_AUTO_ORIGIN:
 488         {
 489             aRet <<= !hasDoubleValue(aScaleData.Origin);
 490             break;
 491         }
 492         case SCALE_PROP_LOGARITHMIC:
 493         {
 494             aRet <<= static_cast< sal_Bool >( AxisHelper::isLogarithmic(aScaleData.Scaling) );
 495             break;
 496         }
 497         case SCALE_PROP_REVERSEDIRECTION:
 498         {
 499             aRet <<= static_cast< sal_Bool >( AxisOrientation_REVERSE == aScaleData.Orientation );
 500             break;
 501         }
 502         default:
 503         {
 504             OSL_ENSURE(false,"unknown scale property");
 505             break;
 506         }
 507     }
 508
 509     return aRet;
 510 }
 511
 512 } //  namespace wrapper
 513 } //namespace chart
 514 //.............................................................................