chart2/source/tools/Scaling.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 "Scaling.hxx"
  21 #include <rtl/math.hxx>
  22 #include "com/sun/star/uno/RuntimeException.hpp"
  23 #include <cppuhelper/supportsservice.hxx>
  24
  25 namespace
  26 {
  27
  28 static const char lcl_aServiceName_Logarithmic[] = "com.sun.star.chart2.LogarithmicScaling";
  29 static const char lcl_aServiceName_Exponential[] = "com.sun.star.chart2.ExponentialScaling";
  30 static const char lcl_aServiceName_Linear[] = "com.sun.star.chart2.LinearScaling";
  31 static const char lcl_aServiceName_Power[] = "com.sun.star.chart2.PowerScaling";
  32
  33 }
  34
  35 namespace chart
  36 {
  37 using namespace ::com::sun::star;
  38 using namespace ::com::sun::star::chart2;
  39
  40 LogarithmicScaling::LogarithmicScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
  41         m_fBase( 10.0 ),
  42         m_fLogOfBase( log( 10.0 ) ),
  43         m_xContext( xContext )
  44 {
  45 }
  46
  47 LogarithmicScaling::LogarithmicScaling( double fBase ) :
  48         m_fBase( fBase ),
  49         m_fLogOfBase( log( fBase ) )
  50 {
  51 }
  52
  53 LogarithmicScaling::~LogarithmicScaling()
  54 {
  55 }
  56
  57 double SAL_CALL LogarithmicScaling::doScaling( double value )
  58     throw (uno::RuntimeException, std::exception)
  59 {
  60     double fResult;
  61     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
  62         ::rtl::math::setNan( & fResult );
  63     else
  64         fResult = log( value ) / m_fLogOfBase;
  65     return fResult;
  66 }
  67
  68 uno::Reference< XScaling > SAL_CALL LogarithmicScaling::getInverseScaling()
  69     throw (uno::RuntimeException, std::exception)
  70 {
  71     return new ExponentialScaling( m_fBase );
  72 }
  73
  74 OUString SAL_CALL LogarithmicScaling::getServiceName()
  75     throw (uno::RuntimeException, std::exception)
  76 {
  77     return OUString(lcl_aServiceName_Logarithmic);
  78 }
  79
  80 uno::Sequence< OUString > LogarithmicScaling::getSupportedServiceNames_Static()
  81 {
  82     uno::Sequence< OUString > aSeq(1);
  83     aSeq.getArray()[0] = lcl_aServiceName_Logarithmic;
  84     return aSeq;
  85 }
  86
  87 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
  88 OUString SAL_CALL LogarithmicScaling::getImplementationName()
  89     throw( css::uno::RuntimeException, std::exception )
  90 {
  91     return getImplementationName_Static();
  92 }
  93
  94 OUString LogarithmicScaling::getImplementationName_Static()
  95 {
  96     return OUString(lcl_aServiceName_Logarithmic);
  97 }
  98
  99 sal_Bool SAL_CALL LogarithmicScaling::supportsService( const OUString& rServiceName )
 100     throw( css::uno::RuntimeException, std::exception )
 101 {
 102     return cppu::supportsService(this, rServiceName);
 103 }
 104
 105 css::uno::Sequence< OUString > SAL_CALL LogarithmicScaling::getSupportedServiceNames()
 106     throw( css::uno::RuntimeException, std::exception )
 107 {
 108     return getSupportedServiceNames_Static();
 109 }
 110
 111 ExponentialScaling::ExponentialScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
 112         m_fBase( 10.0 ),
 113         m_xContext( xContext )
 114 {
 115 }
 116
 117 ExponentialScaling::ExponentialScaling( double fBase ) :
 118         m_fBase( fBase )
 119 {
 120 }
 121
 122 ExponentialScaling::~ExponentialScaling()
 123 {
 124 }
 125
 126 double SAL_CALL ExponentialScaling::doScaling( double value )
 127     throw (uno::RuntimeException, std::exception)
 128 {
 129     double fResult;
 130     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
 131         ::rtl::math::setNan( & fResult );
 132     else
 133         fResult = pow( m_fBase, value );
 134     return fResult;
 135 }
 136
 137 uno::Reference< XScaling > SAL_CALL ExponentialScaling::getInverseScaling()
 138     throw (uno::RuntimeException, std::exception)
 139 {
 140     return new LogarithmicScaling( m_fBase );
 141 }
 142
 143 OUString SAL_CALL ExponentialScaling::getServiceName()
 144     throw (uno::RuntimeException, std::exception)
 145 {
 146     return OUString(lcl_aServiceName_Exponential);
 147 }
 148
 149 uno::Sequence< OUString > ExponentialScaling::getSupportedServiceNames_Static()
 150 {
 151     uno::Sequence< OUString > aSeq(1);
 152     aSeq.getArray()[0] = lcl_aServiceName_Exponential;
 153     return aSeq;
 154 }
 155
 156 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 157 OUString SAL_CALL ExponentialScaling::getImplementationName()
 158     throw( css::uno::RuntimeException, std::exception )
 159 {
 160     return getImplementationName_Static();
 161 }
 162
 163 OUString ExponentialScaling::getImplementationName_Static()
 164 {
 165     return OUString(lcl_aServiceName_Exponential);
 166 }
 167
 168 sal_Bool SAL_CALL ExponentialScaling::supportsService( const OUString& rServiceName )
 169     throw( css::uno::RuntimeException, std::exception )
 170 {
 171     return cppu::supportsService(this, rServiceName);
 172 }
 173
 174 css::uno::Sequence< OUString > SAL_CALL ExponentialScaling::getSupportedServiceNames()
 175     throw( css::uno::RuntimeException, std::exception )
 176 {
 177     return getSupportedServiceNames_Static();
 178 }
 179
 180 LinearScaling::LinearScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
 181         m_fSlope( 1.0 ),
 182         m_fOffset( 0.0 ),
 183         m_xContext( xContext )
 184 {}
 185
 186 LinearScaling::LinearScaling( double fSlope, double fOffset ) :
 187         m_fSlope( fSlope ),
 188         m_fOffset( fOffset )
 189 {}
 190
 191 LinearScaling::~LinearScaling()
 192 {}
 193
 194 double SAL_CALL LinearScaling::doScaling( double value )
 195     throw (uno::RuntimeException, std::exception)
 196 {
 197     double fResult;
 198     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
 199         ::rtl::math::setNan( & fResult );
 200     else
 201         fResult = m_fOffset + m_fSlope * value;
 202     return fResult;
 203 }
 204
 205 uno::Reference< XScaling > SAL_CALL
 206     LinearScaling::getInverseScaling()
 207     throw (uno::RuntimeException, std::exception)
 208 {
 209     // ToDo: ApproxEqual ?
 210     if( m_fSlope == 0 )
 211         throw uno::RuntimeException();
 212
 213     return new LinearScaling( 1.0 / m_fSlope, m_fOffset / m_fSlope );
 214 }
 215
 216 OUString SAL_CALL LinearScaling::getServiceName()
 217     throw (uno::RuntimeException, std::exception)
 218 {
 219     return OUString(lcl_aServiceName_Linear);
 220 }
 221
 222 uno::Sequence< OUString > LinearScaling::getSupportedServiceNames_Static()
 223 {
 224     uno::Sequence< OUString > aSeq(1);
 225     aSeq.getArray()[0] = lcl_aServiceName_Linear;
 226     return aSeq;
 227 }
 228
 229 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 230 OUString SAL_CALL LinearScaling::getImplementationName()
 231     throw( css::uno::RuntimeException, std::exception )
 232 {
 233     return getImplementationName_Static();
 234 }
 235
 236 OUString LinearScaling::getImplementationName_Static()
 237 {
 238     return OUString(lcl_aServiceName_Linear) ;
 239 }
 240
 241 sal_Bool SAL_CALL LinearScaling::supportsService( const OUString& rServiceName )
 242     throw( css::uno::RuntimeException, std::exception )
 243 {
 244     return cppu::supportsService(this, rServiceName);
 245 }
 246
 247 css::uno::Sequence< OUString > SAL_CALL LinearScaling::getSupportedServiceNames()
 248     throw( css::uno::RuntimeException, std::exception )
 249 {
 250     return getSupportedServiceNames_Static();
 251 }
 252
 253 PowerScaling::PowerScaling( const uno::Reference< uno::XComponentContext > & xContext ) :
 254         m_fExponent( 10.0 ),
 255         m_xContext( xContext )
 256 {}
 257
 258 PowerScaling::PowerScaling( double fExponent ) :
 259         m_fExponent( fExponent )
 260 {}
 261
 262 PowerScaling::~PowerScaling()
 263 {}
 264
 265 double SAL_CALL PowerScaling::doScaling( double value )
 266     throw (uno::RuntimeException, std::exception)
 267 {
 268     double fResult;
 269     if( ::rtl::math::isNan( value ) || ::rtl::math::isInf( value ) )
 270         ::rtl::math::setNan( & fResult );
 271     else
 272         fResult = pow( value, m_fExponent );
 273     return fResult;
 274 }
 275
 276 uno::Reference< XScaling > SAL_CALL
 277     PowerScaling::getInverseScaling()
 278     throw (uno::RuntimeException, std::exception)
 279 {
 280     // ToDo: ApproxEqual ?
 281     if( m_fExponent == 0 )
 282         throw uno::RuntimeException();
 283
 284     return new PowerScaling( 1.0 / m_fExponent );
 285 }
 286
 287     OUString SAL_CALL
 288 PowerScaling::getServiceName()
 289     throw (uno::RuntimeException, std::exception)
 290 {
 291     return OUString(lcl_aServiceName_Power);
 292 }
 293
 294 uno::Sequence< OUString > PowerScaling::getSupportedServiceNames_Static()
 295 {
 296     uno::Sequence< OUString > aSeq(1);
 297     aSeq.getArray()[0] = lcl_aServiceName_Power;
 298     return aSeq;
 299 }
 300
 301 // implement XServiceInfo methods basing upon getSupportedServiceNames_Static
 302 OUString SAL_CALL PowerScaling::getImplementationName()
 303     throw( css::uno::RuntimeException, std::exception )
 304 {
 305     return getImplementationName_Static();
 306 }
 307
 308 OUString PowerScaling::getImplementationName_Static()
 309 {
 310     return OUString(lcl_aServiceName_Power);
 311 }
 312
 313 sal_Bool SAL_CALL PowerScaling::supportsService( const OUString& rServiceName )
 314     throw( css::uno::RuntimeException, std::exception )
 315 {
 316     return cppu::supportsService(this, rServiceName);
 317 }
 318
 319 css::uno::Sequence< OUString > SAL_CALL PowerScaling::getSupportedServiceNames()
 320     throw( css::uno::RuntimeException, std::exception )
 321 {
 322     return getSupportedServiceNames_Static();
 323 }
 324
 325 } //namespace chart
 326
 327 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
 328 com_sun_star_chart2_LinearScaling_get_implementation(css::uno::XComponentContext *context,
 329         css::uno::Sequence<css::uno::Any> const &)
 330 {
 331     return cppu::acquire(new chart::LinearScaling(context));
 332 }
 333
 334 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
 335 com_sun_star_chart2_ExponentialScaling_get_implementation(css::uno::XComponentContext *context,
 336         css::uno::Sequence<css::uno::Any> const &)
 337 {
 338     return cppu::acquire(new chart::ExponentialScaling(context));
 339 }
 340
 341 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
 342 com_sun_star_chart2_LogarithmicScaling_get_implementation(css::uno::XComponentContext *context,
 343         css::uno::Sequence<css::uno::Any> const &)
 344 {
 345     return cppu::acquire(new chart::LogarithmicScaling(context));
 346 }
 347
 348 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
 349 com_sun_star_chart2_PowerScaling_get_implementation(css::uno::XComponentContext *context,
 350         css::uno::Sequence<css::uno::Any> const &)
 351 {
 352     return cppu::acquire(new chart::PowerScaling(context));
 353 }
 354
 355 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */