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