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 <com/sun/star/uno/RuntimeException.hpp>
  22 #include <cppuhelper/supportsservice.hxx>
  23
  24 #include <cmath>
  25 #include <limits>
  26
  27 namespace com::sun::star::uno { class XComponentContext; }
  28
  29 namespace
  30 {
  31
  32 constexpr OUString lcl_aServiceName_Logarithmic = u"com.sun.star.chart2.LogarithmicScaling"_ustr;
  33 constexpr OUString lcl_aServiceName_Exponential = u"com.sun.star.chart2.ExponentialScaling"_ustr;
  34 constexpr OUString lcl_aServiceName_Linear = u"com.sun.star.chart2.LinearScaling"_ustr;
  35 constexpr OUString lcl_aServiceName_Power = u"com.sun.star.chart2.PowerScaling"_ustr;
  36
  37 }
  38
  39 namespace chart
  40 {
  41 using namespace ::com::sun::star;
  42 using namespace ::com::sun::star::chart2;
  43
  44 LogarithmicScaling::LogarithmicScaling() :
  45         m_fBase( 10.0 ),
  46         m_fLogOfBase( log( 10.0 ) )
  47 {
  48 }
  49
  50 LogarithmicScaling::LogarithmicScaling( double fBase ) :
  51         m_fBase( fBase ),
  52         m_fLogOfBase( log( fBase ) )
  53 {
  54 }
  55
  56 LogarithmicScaling::~LogarithmicScaling()
  57 {
  58 }
  59
  60 double SAL_CALL LogarithmicScaling::doScaling( double value )
  61 {
  62     if( std::isnan( value ) || std::isinf( value ) )
  63         return std::numeric_limits<double>::quiet_NaN();
  64     return std::log( value ) / m_fLogOfBase;
  65 }
  66
  67 uno::Reference< XScaling > SAL_CALL LogarithmicScaling::getInverseScaling()
  68 {
  69     return new ExponentialScaling( m_fBase );
  70 }
  71
  72 OUString SAL_CALL LogarithmicScaling::getServiceName()
  73 {
  74     return lcl_aServiceName_Logarithmic;
  75 }
  76
  77 OUString SAL_CALL LogarithmicScaling::getImplementationName()
  78 {
  79     return lcl_aServiceName_Logarithmic;
  80 }
  81
  82 sal_Bool SAL_CALL LogarithmicScaling::supportsService( const OUString& rServiceName )
  83 {
  84     return cppu::supportsService(this, rServiceName);
  85 }
  86
  87 css::uno::Sequence< OUString > SAL_CALL LogarithmicScaling::getSupportedServiceNames()
  88 {
  89     return { lcl_aServiceName_Logarithmic };
  90 }
  91
  92 ExponentialScaling::ExponentialScaling() :
  93         m_fBase( 10.0 )
  94 {
  95 }
  96
  97 ExponentialScaling::ExponentialScaling( double fBase ) :
  98         m_fBase( fBase )
  99 {
 100 }
 101
 102 ExponentialScaling::~ExponentialScaling()
 103 {
 104 }
 105
 106 double SAL_CALL ExponentialScaling::doScaling( double value )
 107 {
 108     if( std::isnan( value ) || std::isinf( value ) )
 109         return std::numeric_limits<double>::quiet_NaN();
 110     return std::pow( m_fBase, value );
 111 }
 112
 113 uno::Reference< XScaling > SAL_CALL ExponentialScaling::getInverseScaling()
 114 {
 115     return new LogarithmicScaling( m_fBase );
 116 }
 117
 118 OUString SAL_CALL ExponentialScaling::getServiceName()
 119 {
 120     return lcl_aServiceName_Exponential;
 121 }
 122
 123 OUString SAL_CALL ExponentialScaling::getImplementationName()
 124 {
 125     return lcl_aServiceName_Exponential;
 126 }
 127
 128 sal_Bool SAL_CALL ExponentialScaling::supportsService( const OUString& rServiceName )
 129 {
 130     return cppu::supportsService(this, rServiceName);
 131 }
 132
 133 css::uno::Sequence< OUString > SAL_CALL ExponentialScaling::getSupportedServiceNames()
 134 {
 135     return { lcl_aServiceName_Exponential };
 136 }
 137
 138 LinearScaling::LinearScaling() :
 139         m_fSlope( 1.0 ),
 140         m_fOffset( 0.0 )
 141 {}
 142
 143 LinearScaling::LinearScaling( double fSlope, double fOffset ) :
 144         m_fSlope( fSlope ),
 145         m_fOffset( fOffset )
 146 {}
 147
 148 LinearScaling::~LinearScaling()
 149 {}
 150
 151 double SAL_CALL LinearScaling::doScaling( double value )
 152 {
 153     if( std::isnan( value ) || std::isinf( value ) )
 154         return std::numeric_limits<double>::quiet_NaN();
 155     return m_fOffset + m_fSlope * value;
 156 }
 157
 158 uno::Reference< XScaling > SAL_CALL
 159     LinearScaling::getInverseScaling()
 160 {
 161     // ToDo: ApproxEqual ?
 162     if( m_fSlope == 0 )
 163         throw uno::RuntimeException(u"Divide by zero exception"_ustr);
 164
 165     return new LinearScaling( 1.0 / m_fSlope, m_fOffset / m_fSlope );
 166 }
 167
 168 OUString SAL_CALL LinearScaling::getServiceName()
 169 {
 170     return lcl_aServiceName_Linear;
 171 }
 172
 173 OUString SAL_CALL LinearScaling::getImplementationName()
 174 {
 175     return lcl_aServiceName_Linear ;
 176 }
 177
 178 sal_Bool SAL_CALL LinearScaling::supportsService( const OUString& rServiceName )
 179 {
 180     return cppu::supportsService(this, rServiceName);
 181 }
 182
 183 css::uno::Sequence< OUString > SAL_CALL LinearScaling::getSupportedServiceNames()
 184 {
 185     return { lcl_aServiceName_Linear };
 186 }
 187
 188 PowerScaling::PowerScaling() :
 189         m_fExponent( 10.0 )
 190 {}
 191
 192 PowerScaling::PowerScaling( double fExponent ) :
 193         m_fExponent( fExponent )
 194 {}
 195
 196 PowerScaling::~PowerScaling()
 197 {}
 198
 199 double SAL_CALL PowerScaling::doScaling( double value )
 200 {
 201     if( std::isnan( value ) || std::isinf( value ) )
 202         return std::numeric_limits<double>::quiet_NaN();
 203     return std::pow( value, m_fExponent );
 204 }
 205
 206 uno::Reference< XScaling > SAL_CALL
 207     PowerScaling::getInverseScaling()
 208 {
 209     // ToDo: ApproxEqual ?
 210     if( m_fExponent == 0 )
 211         throw uno::RuntimeException(u"Divide by zero exception"_ustr);
 212
 213     return new PowerScaling( 1.0 / m_fExponent );
 214 }
 215
 216     OUString SAL_CALL
 217 PowerScaling::getServiceName()
 218 {
 219     return lcl_aServiceName_Power;
 220 }
 221
 222 OUString SAL_CALL PowerScaling::getImplementationName()
 223 {
 224     return lcl_aServiceName_Power;
 225 }
 226
 227 sal_Bool SAL_CALL PowerScaling::supportsService( const OUString& rServiceName )
 228 {
 229     return cppu::supportsService(this, rServiceName);
 230 }
 231
 232 css::uno::Sequence< OUString > SAL_CALL PowerScaling::getSupportedServiceNames()
 233 {
 234     return { lcl_aServiceName_Power };
 235 }
 236
 237 } //namespace chart
 238
 239 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 240 com_sun_star_chart2_LinearScaling_get_implementation(css::uno::XComponentContext *,
 241         css::uno::Sequence<css::uno::Any> const &)
 242 {
 243     return cppu::acquire(new chart::LinearScaling );
 244 }
 245
 246 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 247 com_sun_star_chart2_ExponentialScaling_get_implementation(css::uno::XComponentContext *,
 248         css::uno::Sequence<css::uno::Any> const &)
 249 {
 250     return cppu::acquire(new chart::ExponentialScaling );
 251 }
 252
 253 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 254 com_sun_star_chart2_LogarithmicScaling_get_implementation(css::uno::XComponentContext *,
 255         css::uno::Sequence<css::uno::Any> const &)
 256 {
 257     return cppu::acquire(new chart::LogarithmicScaling );
 258 }
 259
 260 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 261 com_sun_star_chart2_PowerScaling_get_implementation(css::uno::XComponentContext *,
 262         css::uno::Sequence<css::uno::Any> const &)
 263 {
 264     return cppu::acquire(new chart::PowerScaling );
 265 }
 266
 267 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */