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         targetPropertyIndex = targetActor.GetPropertyIndex( propertyName );
 120
 121         if( targetPropertyIndex == Property::INVALID_INDEX )
 122         {
 123           DALI_SCRIPT_EXCEPTION( isolate, "Target property not found" );
 124           return false;
 125         }
 126       }
 127     }
 128     else
 129     {
 130       DALI_SCRIPT_EXCEPTION( isolate, "Target property not specified" );
 131       return false;
 132     }
 133
 134     //Get source property
 135     member = obj->Get( v8::String::NewFromUtf8( isolate, "sourceProperty" ) );
 136     if( member->IsString() )
 137     {
 138       std::string propertyName = V8Utils::v8StringToStdString( member );
 139       sourcePropertyIndex = targetActor.GetPropertyIndex( propertyName );
 140       if( sourcePropertyIndex == Property::INVALID_INDEX )
 141       {
 142         sourcePropertyIndex = targetActor.GetPropertyIndex( propertyName );
 143
 144         if( sourcePropertyIndex == Property::INVALID_INDEX )
 145         {
 146           DALI_SCRIPT_EXCEPTION( isolate, "Source property not found" );
 147           return false;
 148         }
 149       }
 150     }
 151     else
 152     {
 153       DALI_SCRIPT_EXCEPTION( isolate, "Source property not specified" );
 154       return false;
 155     }
 156
 157     //Get range
 158     member = obj->Get( v8::String::NewFromUtf8( isolate, "range" ) );
 159     if( member->IsObject() )
 160     {
 161       v8::Local<v8::Object> rangeObject = member->ToObject();
 162       Property::Value value = V8Utils::GetPropertyValueFromObject( found, isolate, rangeObject );
 163       value.Get( range );
 164     }
 165     else
 166     {
 167       DALI_SCRIPT_EXCEPTION( isolate, "Range not specified" );
 168       return false;
 169     }
 170
 171     //Get wrap range
 172     member = obj->Get( v8::String::NewFromUtf8( isolate, "wrap" ) );
 173     if( member->IsObject() )
 174     {
 175       v8::Local<v8::Object> wrapObject = member->ToObject();
 176       Property::Value value = V8Utils::GetPropertyValueFromObject( found, isolate, wrapObject );
 177       value.Get( wrap );
 178     }
 179     else
 180     {
 181       wrap =  Vector2(-FLT_MAX, FLT_MAX);
 182     }
 183
 184     return true;
 185   }
 186   else
 187   {
 188     DALI_SCRIPT_EXCEPTION( isolate, "Bad parameter (Object)" );
 189     return false;
 190   }
 191 }
 192
 193 } // un-named namespace
 194
 195 /**
 196  * Apply the constraint
 197  * @method applyConstraint
 198  * @for PathConstrainer and LinearConstrainer
 199  * @param {Object}  Constraint
 200  * @param {Object}  Constraint.targetActor
 201  * @param {String}  Constraint.targetProperty
 202  * @param {String}  Constraint.sourceProperty
 203  * @param {Vector2} Constraint.range
 204  * @param {Vector2} Constraint.wrap
 205  *
 206  * @example
 207  *
 208  *        var constraintPosition = {  "target":targetActor,
 209  *                                    "targetProperty":"position",
 210  *                                    "source":sourceActor,
 211  *                                    "sourceProperty":"colorAlpha",
 212  *                                    "range":range
 213  *                                    "wrap":wrap
 214  *                                 };
 215  *        pathConstrainer.applyConstraint( constraintPosition );
 216  */
 217 void ConstrainerApi::Apply( const v8::FunctionCallbackInfo< v8::Value >& args )
 218 {
 219   v8::Isolate* isolate = args.GetIsolate();
 220   v8::HandleScope handleScope( isolate );
 221
 222   Actor target, source;
 223   Property::Index targetPropertyIndex = Property::INVALID_INDEX;
 224   Property::Index sourcePropertyIndex = Property::INVALID_INDEX;
 225
 226   Vector2 range, wrap;
 227   if( GetApplyParameters(args, target, targetPropertyIndex, source,  sourcePropertyIndex, range, wrap ) )
 228   {
 229
 230     PathConstrainer pathConstrainer = GetPathConstrainer( isolate, args );
 231     if( pathConstrainer )
 232     {
 233       pathConstrainer.Apply( Property(target, targetPropertyIndex),
 234                              Property(source, sourcePropertyIndex),
 235                              range, wrap );
 236     }
 237     else
 238     {
 239       LinearConstrainer linearConstrainer = GetLinearConstrainer( isolate, args );
 240       if( linearConstrainer )
 241       {
 242         linearConstrainer.Apply( Property(target, targetPropertyIndex),
 243                                  Property(source, sourcePropertyIndex),
 244                                  range, wrap );
 245       }
 246     }
 247   }
 248 }
 249
 250 /**
 251  * Remove the constraint
 252  * @method remove
 253  * @for PathConstrainer
 254  * @param {Object} Actor
 255  * @example
 256  *        pathConstrainer.remove( targetActor );
 257  */
 258 void ConstrainerApi::Remove( const v8::FunctionCallbackInfo< v8::Value >& args )
 259 {
 260   v8::Isolate* isolate = args.GetIsolate();
 261   v8::HandleScope handleScope( isolate );
 262
 263   //Get target actor
 264   bool found( false );
 265   Actor targetActor = V8Utils::GetActorParameter( PARAMETER_0, found, isolate, args );
 266   if( !found )
 267   {
 268     DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 (Actor)" );
 269     return;
 270   }
 271
 272
 273   PathConstrainer pathConstrainer = GetPathConstrainer( isolate, args );
 274   if( pathConstrainer )
 275   {
 276     pathConstrainer.Remove(targetActor);
 277   }
 278   else
 279   {
 280     LinearConstrainer linearConstrainer = GetLinearConstrainer( isolate, args );
 281     if( linearConstrainer )
 282     {
 283       linearConstrainer.Remove(targetActor);
 284     }
 285   }
 286 }
 287
 288 } // namespace V8Plugin
 289
 290 } // namespace Dali