chart2/source/tools/Scaling.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: Scaling.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 #include "Scaling.hxx"
  34 #include <rtl/math.hxx>
  35 #include "com/sun/star/uno/RuntimeException.hpp"
  36
  37 namespace
  38 {
  39
  40 static const ::rtl::OUString lcl_aServiceName_Logarithmic(
  41     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.LogarithmicScaling" ));
  42 static const ::rtl::OUString lcl_aServiceName_Exponential(
  43     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.ExponentialScaling" ));
  44 static const ::rtl::OUString lcl_aServiceName_Linear(
  45     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.LinearScaling" ));
  46 static const ::rtl::OUString lcl_aServiceName_Power(
  47     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.chart2.PowerScaling" ));
  48
  49 static const ::rtl::OUString lcl_aImplementationName_Logarithmic(
  50     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.chart2.LogarithmicScaling" ));
  51 static const ::rtl::OUString lcl_aImplementationName_Exponential(
  52     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.chart2.ExponentialScaling" ));
  53 static const ::rtl::OUString lcl_aImplementationName_Linear(
  54     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.chart2.LinearScaling" ));
  55 static const ::rtl::OUString lcl_aImplementationName_Power(
  56     RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.chart2.PowerScaling" ));
  57 }
  58
  59 //.............................................................................
  60 namespace chart
  61 {
  62 //.............................................................................
  63 using namespace ::com::sun::star;
  64 using namespace ::com::sun::star::chart2;
  65
  66 LogarithmicScaling::LogarithmicScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
  67         m_fBase( 10.0 ),
  68         m_fLogOfBase( log( 10.0 ) ),
  69         m_xContext( xContext )
  70 {
  71 }
  72
  73 LogarithmicScaling::LogarithmicScaling( double fBase ) :
  74         m_fBase( fBase ),
  75         m_fLogOfBase( log( fBase ) )
  76 {
  77 }
  78
  79 LogarithmicScaling::~LogarithmicScaling()
  80 {
  81 }
  82
  83     double SAL_CALL
  84 LogarithmicScaling::doScaling( double value )
  85     throw (uno::RuntimeException)
  86 {
  87     double fResult;
  88     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
  89         ::rtl::math::setNan( & fResult );
  90     else
  91         fResult = log( value ) / m_fLogOfBase;
  92     return fResult;
  93 }
  94
  95     uno::Reference< XScaling > SAL_CALL
  96 LogarithmicScaling::getInverseScaling()
  97     throw (uno::RuntimeException)
  98 {
  99     return new ExponentialScaling( m_fBase );
 100 }
 101
 102     ::rtl::OUString SAL_CALL
 103 LogarithmicScaling::getServiceName()
 104     throw (uno::RuntimeException)
 105 {
 106     return lcl_aServiceName_Logarithmic;
 107 }
 108
 109 uno::Sequence< ::rtl::OUString > LogarithmicScaling::getSupportedServiceNames_Static()
 110 {
 111     return uno::Sequence< ::rtl::OUString >( & lcl_aServiceName_Logarithmic, 1 );
 112 }
 113
 114 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 115 APPHELPER_XSERVICEINFO_IMPL( LogarithmicScaling, lcl_aServiceName_Logarithmic )
 116
 117 // ----------------------------------------
 118
 119 ExponentialScaling::ExponentialScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
 120         m_fBase( 10.0 ),
 121         m_xContext( xContext )
 122 {
 123 }
 124
 125 ExponentialScaling::ExponentialScaling( double fBase ) :
 126         m_fBase( fBase )
 127 {
 128 }
 129
 130 ExponentialScaling::~ExponentialScaling()
 131 {
 132 }
 133
 134     double SAL_CALL
 135 ExponentialScaling::doScaling( double value )
 136     throw (uno::RuntimeException)
 137 {
 138     double fResult;
 139     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
 140         ::rtl::math::setNan( & fResult );
 141     else
 142         fResult = pow( m_fBase, value );
 143     return fResult;
 144 }
 145
 146     uno::Reference< XScaling > SAL_CALL
 147 ExponentialScaling::getInverseScaling()
 148     throw (uno::RuntimeException)
 149 {
 150     return new LogarithmicScaling( m_fBase );
 151 }
 152
 153     ::rtl::OUString SAL_CALL
 154 ExponentialScaling::getServiceName()
 155     throw (uno::RuntimeException)
 156 {
 157     return lcl_aServiceName_Exponential;
 158 }
 159
 160 uno::Sequence< ::rtl::OUString > ExponentialScaling::getSupportedServiceNames_Static()
 161 {
 162     return uno::Sequence< ::rtl::OUString >( & lcl_aServiceName_Exponential, 1 );
 163 }
 164
 165 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 166 APPHELPER_XSERVICEINFO_IMPL( ExponentialScaling, lcl_aServiceName_Exponential )
 167
 168 // ----------------------------------------
 169
 170 LinearScaling::LinearScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
 171         m_fSlope( 1.0 ),
 172         m_fOffset( 0.0 ),
 173         m_xContext( xContext )
 174 {}
 175
 176 LinearScaling::LinearScaling( double fSlope, double fOffset ) :
 177         m_fSlope( fSlope ),
 178         m_fOffset( fOffset )
 179 {}
 180
 181 LinearScaling::~LinearScaling()
 182 {}
 183
 184 double SAL_CALL LinearScaling::doScaling( double value )
 185     throw (uno::RuntimeException)
 186 {
 187     double fResult;
 188     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
 189         ::rtl::math::setNan( & fResult );
 190     else
 191         fResult = m_fOffset + m_fSlope * value;
 192     return fResult;
 193 }
 194
 195 uno::Reference< XScaling > SAL_CALL
 196     LinearScaling::getInverseScaling()
 197     throw (uno::RuntimeException)
 198 {
 199     // ToDo: ApproxEqual ?
 200     if( m_fSlope == 0 )
 201         throw uno::RuntimeException();
 202
 203     return new LinearScaling( 1.0 / m_fSlope, m_fOffset / m_fSlope );
 204 }
 205
 206     ::rtl::OUString SAL_CALL
 207 LinearScaling::getServiceName()
 208     throw (uno::RuntimeException)
 209 {
 210     return lcl_aServiceName_Linear;
 211 }
 212
 213 uno::Sequence< ::rtl::OUString > LinearScaling::getSupportedServiceNames_Static()
 214 {
 215     return uno::Sequence< ::rtl::OUString >( & lcl_aServiceName_Linear, 1 );
 216 }
 217
 218 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 219 APPHELPER_XSERVICEINFO_IMPL( LinearScaling, lcl_aServiceName_Linear )
 220
 221 // ----------------------------------------
 222
 223 PowerScaling::PowerScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
 224         m_fExponent( 10.0 ),
 225         m_xContext( xContext )
 226 {}
 227
 228 PowerScaling::PowerScaling( double fExponent ) :
 229         m_fExponent( fExponent )
 230 {}
 231
 232 PowerScaling::~PowerScaling()
 233 {}
 234
 235 double SAL_CALL PowerScaling::doScaling( double value )
 236     throw (uno::RuntimeException)
 237 {
 238     double fResult;
 239     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
 240         ::rtl::math::setNan( & fResult );
 241     else
 242         fResult = pow( value, m_fExponent );
 243     return fResult;
 244 }
 245
 246 uno::Reference< XScaling > SAL_CALL
 247     PowerScaling::getInverseScaling()
 248     throw (uno::RuntimeException)
 249 {
 250     // ToDo: ApproxEqual ?
 251     if( m_fExponent == 0 )
 252         throw uno::RuntimeException();
 253
 254     return new PowerScaling( 1.0 / m_fExponent );
 255 }
 256
 257     ::rtl::OUString SAL_CALL
 258 PowerScaling::getServiceName()
 259     throw (uno::RuntimeException)
 260 {
 261     return lcl_aServiceName_Power;
 262 }
 263
 264 uno::Sequence< ::rtl::OUString > PowerScaling::getSupportedServiceNames_Static()
 265 {
 266     return uno::Sequence< ::rtl::OUString >( & lcl_aServiceName_Power, 1 );
 267 }
 268
 269 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 270 APPHELPER_XSERVICEINFO_IMPL( PowerScaling, lcl_aServiceName_Power )
 271
 272 //.............................................................................
 273 } //namespace chart
 274 //.............................................................................