plugins/dali-script-v8/src/animation/constrainer-api.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "constrainer-api.h"
  20
  21 //EXTERNAL INCLUDES
  22 #include <cfloat> //For FLT_MAX
  23
  24 // INTERNAL INCLUDES
  25 #include <animation/linear-constrainer-wrapper.h>
  26 #include <animation/path-constrainer-wrapper.h>
  27 #include <object/property-value-wrapper.h>
  28 #include <v8-utils.h>
  29
  30 namespace Dali
  31 {
  32
  33 namespace V8Plugin
  34 {
  35
  36 namespace // un named namespace
  37 {
  38
  39 PathConstrainer GetPathConstrainer( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
  40 {
  41   v8::HandleScope handleScope( isolate );
  42
  43   v8::Local<v8::Object> object = args.This();
  44   v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField( 0 ) );
  45   void* ptr = field->Value();
  46
  47   PathConstrainerWrapper* wrapper = static_cast<PathConstrainerWrapper *>( ptr );
  48   return wrapper->GetPathConstrainer();
  49 }
  50
  51 LinearConstrainer GetLinearConstrainer( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
  52 {
  53   v8::HandleScope handleScope( isolate );
  54
  55   v8::Local<v8::Object> object = args.This();
  56   v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField( 0 ) );
  57   void* ptr = field->Value();
  58
  59   LinearConstrainerWrapper* wrapper = static_cast<LinearConstrainerWrapper *>( ptr );
  60   return wrapper->GetLinearConstrainer();
  61 }
  62
  63 bool GetApplyParameters( const v8::FunctionCallbackInfo< v8::Value >& args, Actor& targetActor, Property::Index& targetPropertyIndex,
  64                          Actor& sourceActor, Property::Index& sourcePropertyIndex, Vector2& range, Vector2& wrap )
  65 {
  66   v8::Isolate* isolate = args.GetIsolate();
  67   v8::HandleScope handleScope( isolate );
  68
  69   if( args[0]->IsObject() )
  70   {
  71     bool found(false);
  72
  73     v8::Local<v8::Object> obj = args[0]->ToObject();
  74     v8::Local<v8::Value> member = obj->Get( v8::String::NewFromUtf8( isolate, "target" ) );
  75
  76     //Get target actor
  77     if( member->IsObject() )
  78     {
  79       v8::Local<v8::Object> targetActorObject = member->ToObject();
  80       targetActor = V8Utils::GetActorFromObject( isolate, found, targetActorObject );
  81       if( !targetActor )
  82       {
  83         DALI_SCRIPT_EXCEPTION( isolate, "Target actor not found" );
  84         return false;
  85       }
  86     }
  87     else
  88     {
  89       DALI_SCRIPT_EXCEPTION( isolate, "Target actor not specified" );
  90       return false;
  91     }
  92
  93     //Get source actor
  94     member = obj->Get( v8::String::NewFromUtf8( isolate, "source" ) );
  95     if( member->IsObject() )
  96     {
  97       v8::Local<v8::Object> sourceActorObject = member->ToObject();
  98       sourceActor = V8Utils::GetActorFromObject( isolate, found, sourceActorObject );
  99       if( !sourceActor )
 100       {
 101         DALI_SCRIPT_EXCEPTION( isolate, "Source actor not found" );
 102         return false;
 103       }
 104     }
 105     else
 106     {
 107       DALI_SCRIPT_EXCEPTION( isolate, "Source actor not specified" );
 108       return false;
 109     }
 110
 111     //Get target property
 112     member = obj->Get( v8::String::NewFromUtf8( isolate, "targetProperty" ) );
 113     if( member->IsString() )
 114     {
 115       std::string propertyName = V8Utils::v8StringToStdString( member );
 116       targetPropertyIndex = targetActor.GetPropertyIndex( propertyName );
 117       if( targetPropertyIndex == Property::INVALID_INDEX )
 118       {
 119         DALI_SCRIPT_EXCEPTION( isolate, "Target property not found" );
 120         return false;
 121       }
 122     }
 123     else
 124     {
 125       DALI_SCRIPT_EXCEPTION( isolate, "Target property not specified" );
 126       return false;
 127     }
 128
 129     //Get source property
 130     member = obj->Get( v8::String::NewFromUtf8( isolate, "sourceProperty" ) );
 131     if( member->IsString() )
 132     {
 133       std::string propertyName = V8Utils::v8StringToStdString( member );
 134       sourcePropertyIndex = targetActor.GetPropertyIndex( propertyName );
 135       if( sourcePropertyIndex == Property::INVALID_INDEX )
 136       {
 137         DALI_SCRIPT_EXCEPTION( isolate, "Source property not found" );
 138         return false;
 139         }
 140     }
 141     else
 142     {
 143       DALI_SCRIPT_EXCEPTION( isolate, "Source property not specified" );
 144       return false;
 145     }
 146
 147     //Get range
 148     member = obj->Get( v8::String::NewFromUtf8( isolate, "range" ) );
 149     if( member->IsObject() )
 150     {
 151       v8::Local<v8::Object> rangeObject = member->ToObject();
 152       Property::Value value = V8Utils::GetPropertyValueFromObject( found, isolate, rangeObject );
 153       value.Get( range );
 154     }
 155     else
 156     {
 157       DALI_SCRIPT_EXCEPTION( isolate, "Range not specified" );
 158       return false;
 159     }
 160
 161     //Get wrap range
 162     member = obj->Get( v8::String::NewFromUtf8( isolate, "wrap" ) );
 163     if( member->IsObject() )
 164     {
 165       v8::Local<v8::Object> wrapObject = member->ToObject();
 166       Property::Value value = V8Utils::GetPropertyValueFromObject( found, isolate, wrapObject );
 167       value.Get( wrap );
 168     }
 169     else
 170     {
 171       wrap =  Vector2(-FLT_MAX, FLT_MAX);
 172     }
 173
 174     return true;
 175   }
 176   else
 177   {
 178     DALI_SCRIPT_EXCEPTION( isolate, "Bad parameter (Object)" );
 179     return false;
 180   }
 181 }
 182
 183 } // un-named namespace
 184
 185 /**
 186  * Apply the constraint
 187  * @method applyConstraint
 188  * @for PathConstrainer and LinearConstrainer
 189  * @param {Object}  Constraint
 190  * @param {Object}  Constraint.targetActor
 191  * @param {String}  Constraint.targetProperty
 192  * @param {String}  Constraint.sourceProperty
 193  * @param {Vector2} Constraint.range
 194  * @param {Vector2} Constraint.wrap
 195  *
 196  * @example
 197  *
 198  *        var constraintPosition = {  "target":targetActor,
 199  *                                    "targetProperty":"position",
 200  *                                    "source":sourceActor,
 201  *                                    "sourceProperty":"colorAlpha",
 202  *                                    "range":range
 203  *                                    "wrap":wrap
 204  *                                 };
 205  *        pathConstrainer.applyConstraint( constraintPosition );
 206  */
 207 void ConstrainerApi::Apply( const v8::FunctionCallbackInfo< v8::Value >& args )
 208 {
 209   v8::Isolate* isolate = args.GetIsolate();
 210   v8::HandleScope handleScope( isolate );
 211
 212   Actor target, source;
 213   Property::Index targetPropertyIndex = Property::INVALID_INDEX;
 214   Property::Index sourcePropertyIndex = Property::INVALID_INDEX;
 215
 216   Vector2 range, wrap;
 217   if( GetApplyParameters(args, target, targetPropertyIndex, source,  sourcePropertyIndex, range, wrap ) )
 218   {
 219
 220     PathConstrainer pathConstrainer = GetPathConstrainer( isolate, args );
 221     if( pathConstrainer )
 222     {
 223       pathConstrainer.Apply( Property(target, targetPropertyIndex),
 224                              Property(source, sourcePropertyIndex),
 225                              range, wrap );
 226     }
 227     else
 228     {
 229       LinearConstrainer linearConstrainer = GetLinearConstrainer( isolate, args );
 230       if( linearConstrainer )
 231       {
 232         linearConstrainer.Apply( Property(target, targetPropertyIndex),
 233                                  Property(source, sourcePropertyIndex),
 234                                  range, wrap );
 235       }
 236     }
 237   }
 238 }
 239
 240 /**
 241  * Remove the constraint
 242  * @method remove
 243  * @for PathConstrainer
 244  * @param {Object} Actor
 245  * @example
 246  *        pathConstrainer.remove( targetActor );
 247  */
 248 void ConstrainerApi::Remove( const v8::FunctionCallbackInfo< v8::Value >& args )
 249 {
 250   v8::Isolate* isolate = args.GetIsolate();
 251   v8::HandleScope handleScope( isolate );
 252
 253   //Get target actor
 254   bool found( false );
 255   Actor targetActor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
 256   if( !found )
 257   {
 258     DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 (Actor)" );
 259     return;
 260   }
 261
 262
 263   PathConstrainer pathConstrainer = GetPathConstrainer( isolate, args );
 264   if( pathConstrainer )
 265   {
 266     pathConstrainer.Remove(targetActor);
 267   }
 268   else
 269   {
 270     LinearConstrainer linearConstrainer = GetLinearConstrainer( isolate, args );
 271     if( linearConstrainer )
 272     {
 273       linearConstrainer.Remove(targetActor);
 274     }
 275   }
 276 }
 277
 278 } // namespace V8Plugin
 279
 280 } // namespace Dali