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