slideshow/source/engine/expressionnodefactory.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
  21 #include <expressionnodefactory.hxx>
  22
  23 #include <basegfx/matrix/b2dhommatrix.hxx>
  24 #include <basegfx/point/b2dpoint.hxx>
  25
  26 #include <functional>
  27 #include <algorithm>
  28
  29
  30 /* Implementation of ExpressionNodeFactory class */
  31
  32 namespace slideshow
  33 {
  34     namespace internal
  35     {
  36         namespace
  37         {
  38             class ConstantValueExpression : public ExpressionNode
  39             {
  40             public:
  41                 explicit ConstantValueExpression( double rValue ) :
  42                     maValue( rValue )
  43                 {
  44                 }
  45
  46                 virtual double operator()( double /*t*/ ) const override
  47                 {
  48                     return maValue;
  49                 }
  50
  51                 virtual bool isConstant() const override
  52                 {
  53                     return true;
  54                 }
  55
  56             private:
  57                 double  maValue;
  58             };
  59
  60             class TValueExpression : public ExpressionNode
  61             {
  62             public:
  63                 TValueExpression()
  64                 {
  65                 }
  66
  67                 virtual double operator()( double t ) const override
  68                 {
  69                     return t;
  70                 }
  71
  72                 virtual bool isConstant() const override
  73                 {
  74                     return false;
  75                 }
  76             };
  77
  78             /** Base class for following binary functions (*+-/)
  79
  80                 Does not pay off to have all this as a template, since
  81                 we'd have to hold the functor as a member (+33% object
  82                 size).
  83              */
  84             class BinaryExpressionBase : public ExpressionNode
  85             {
  86             public:
  87                 BinaryExpressionBase( const std::shared_ptr<ExpressionNode>&    rFirstArg,
  88                                       const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
  89                     mpFirstArg( rFirstArg ),
  90                     mpSecondArg( rSecondArg )
  91                 {
  92                 }
  93
  94                 virtual bool isConstant() const override
  95                 {
  96                     return
  97                         mpFirstArg->isConstant() &&
  98                         mpSecondArg->isConstant();
  99                 }
 100
 101             protected:
 102                 std::shared_ptr<ExpressionNode> mpFirstArg;
 103                 std::shared_ptr<ExpressionNode> mpSecondArg;
 104             };
 105
 106             class PlusExpression : public BinaryExpressionBase
 107             {
 108             public:
 109                 PlusExpression( const std::shared_ptr<ExpressionNode>&  rFirstArg,
 110                                 const std::shared_ptr<ExpressionNode>&  rSecondArg ) :
 111                     BinaryExpressionBase( rFirstArg, rSecondArg )
 112                 {
 113                 }
 114
 115                 virtual double operator()( double t ) const override
 116                 {
 117                     return (*mpFirstArg)(t) + (*mpSecondArg)(t);
 118                 }
 119             };
 120
 121             class MinusExpression : public BinaryExpressionBase
 122             {
 123             public:
 124                 MinusExpression( const std::shared_ptr<ExpressionNode>& rFirstArg,
 125                                  const std::shared_ptr<ExpressionNode>& rSecondArg ) :
 126                     BinaryExpressionBase( rFirstArg, rSecondArg )
 127                 {
 128                 }
 129
 130                 virtual double operator()( double t ) const override
 131                 {
 132                     return (*mpFirstArg)(t) - (*mpSecondArg)(t);
 133                 }
 134             };
 135
 136             class MultipliesExpression : public BinaryExpressionBase
 137             {
 138             public:
 139                 MultipliesExpression( const std::shared_ptr<ExpressionNode>&    rFirstArg,
 140                                       const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
 141                     BinaryExpressionBase( rFirstArg, rSecondArg )
 142                 {
 143                 }
 144
 145                 virtual double operator()( double t ) const override
 146                 {
 147                     return (*mpFirstArg)(t) * (*mpSecondArg)(t);
 148                 }
 149             };
 150
 151             class DividesExpression : public BinaryExpressionBase
 152             {
 153             public:
 154                 DividesExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 155                                    const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 156                     BinaryExpressionBase( rFirstArg, rSecondArg )
 157                 {
 158                 }
 159
 160                 virtual double operator()( double t ) const override
 161                 {
 162                     return (*mpFirstArg)(t) / (*mpSecondArg)(t);
 163                 }
 164             };
 165
 166             class MinExpression : public BinaryExpressionBase
 167             {
 168             public:
 169                 MinExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 170                                const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 171                     BinaryExpressionBase( rFirstArg, rSecondArg )
 172                 {
 173                 }
 174
 175                 virtual double operator()( double t ) const override
 176                 {
 177                     return ::std::min( (*mpFirstArg)(t), (*mpSecondArg)(t) );
 178                 }
 179             };
 180
 181             class MaxExpression : public BinaryExpressionBase
 182             {
 183             public:
 184                 MaxExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
 185                                const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
 186                     BinaryExpressionBase( rFirstArg, rSecondArg )
 187                 {
 188                 }
 189
 190                 virtual double operator()( double t ) const override
 191                 {
 192                     return ::std::max( (*mpFirstArg)(t), (*mpSecondArg)(t) );
 193                 }
 194             };
 195         }
 196
 197         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createConstantValueExpression( double rConstantValue )
 198         {
 199             return std::shared_ptr<ExpressionNode>( new ConstantValueExpression(rConstantValue) );
 200         }
 201
 202         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createValueTExpression()
 203         {
 204             return std::shared_ptr<ExpressionNode>( new TValueExpression() );
 205         }
 206
 207         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createPlusExpression( const std::shared_ptr<ExpressionNode>& rLHS,
 208                                                                              const std::shared_ptr<ExpressionNode>& rRHS )
 209         {
 210             return std::shared_ptr<ExpressionNode>( new PlusExpression(rLHS, rRHS) );
 211         }
 212
 213         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinusExpression( const std::shared_ptr<ExpressionNode>&    rLHS,
 214                                                                               const std::shared_ptr<ExpressionNode>&    rRHS )
 215         {
 216             return std::shared_ptr<ExpressionNode>( new MinusExpression(rLHS, rRHS) );
 217         }
 218
 219         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMultipliesExpression( const std::shared_ptr<ExpressionNode>&   rLHS,
 220                                                                                    const std::shared_ptr<ExpressionNode>&   rRHS )
 221         {
 222             return std::shared_ptr<ExpressionNode>( new MultipliesExpression(rLHS, rRHS) );
 223         }
 224
 225         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createDividesExpression( const std::shared_ptr<ExpressionNode>&  rLHS,
 226                                                                                 const std::shared_ptr<ExpressionNode>&  rRHS )
 227         {
 228             return std::shared_ptr<ExpressionNode>( new DividesExpression(rLHS, rRHS) );
 229         }
 230
 231         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
 232                                                                                const std::shared_ptr<ExpressionNode>&   rInnerFunction )
 233         {
 234             return std::shared_ptr<ExpressionNode>( new MinExpression(rOuterFunction, rInnerFunction) );
 235         }
 236
 237         std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMaxExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
 238                                                                                const std::shared_ptr<ExpressionNode>&   rInnerFunction )
 239         {
 240             return std::shared_ptr<ExpressionNode>( new MaxExpression(rOuterFunction, rInnerFunction) );
 241         }
 242
 243     }
 244 }
 245
 246 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */