Updates after RenderableActor removal
[platform/core/uifw/dali-toolkit.git] / plugins / dali-script-v8 / src / actors / actor-wrapper.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 "actor-wrapper.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/object/type-registry.h>
23 #include <dali-toolkit/public-api/controls/control.h>
24
25 // INTERNAL INCLUDES
26 #include <actors/layer-api.h>
27 #include <actors/actor-api.h>
28 #include <actors/image-actor-api.h>
29 #include <actors/camera-actor-api.h>
30 #include <v8-utils.h>
31 #include <dali-wrapper.h>
32
33 namespace Dali
34 {
35
36 namespace V8Plugin
37 {
38
39 v8::Persistent<v8::ObjectTemplate> ActorWrapper::mActorTemplate;
40 v8::Persistent<v8::ObjectTemplate> ActorWrapper::mImageActorTemplate;
41 v8::Persistent<v8::ObjectTemplate> ActorWrapper::mCameraActorTemplate;
42 v8::Persistent<v8::ObjectTemplate> ActorWrapper::mLayerActorTemplate;
43
44 namespace
45 {
46
47
48 /**
49  * pointer to a persistent template handle
50  */
51 struct ActorTemplate
52 {
53   v8::Persistent<v8::ObjectTemplate>* actorTemplate;
54 };
55
56 /**
57  * array of templates for each type of actor
58  */
59 const ActorTemplate ActorTemplateLookup[]=
60 {
61     { &ActorWrapper::mActorTemplate },        // ACTOR
62     { &ActorWrapper::mImageActorTemplate },   // IMAGE_ACTOR
63     { &ActorWrapper::mLayerActorTemplate },   // LAYER_ACTOR
64     { &ActorWrapper::mCameraActorTemplate}    // CAMERA_ACTOR
65 };
66
67 /**
68  * Bitmask of API's that an actor can support
69  */
70 enum ActorApiBitMask
71 {
72   ACTOR_API              = 1 << 0,
73   IMAGE_ACTOR_API        = 1 << 1,
74   LAYER_API              = 1 << 2,
75   CAMERA_ACTOR_API       = 1 << 3,
76 };
77
78 /**
79  * structure used for the ActorApiLookup.
80  */
81 struct ActorApiStruct
82 {
83   const char* actorName;
84   ActorWrapper::ActorType actorType;
85   Actor (*constructor)( const v8::FunctionCallbackInfo< v8::Value >& args);
86   int supportApis;
87 };
88
89 /**
90  * Lookup table to match a actor type with a constructor and supported API's.
91  * HandleWrapper::ActorType is used to index this table
92  */
93 const ActorApiStruct ActorApiLookup[]=
94 {
95   {"Actor",      ActorWrapper::ACTOR,        ActorApi::New,       ACTOR_API },
96   {"ImageActor", ActorWrapper::IMAGE_ACTOR,  ImageActorApi::New,  ACTOR_API | IMAGE_ACTOR_API   },
97   {"Layer",      ActorWrapper::LAYER_ACTOR,  LayerApi::New,       ACTOR_API | LAYER_API                                },
98   {"CameraActor",ActorWrapper::CAMERA_ACTOR, CameraActorApi::New, ACTOR_API | CAMERA_ACTOR_API                         },
99 };
100
101 const unsigned int ActorApiLookupCount = sizeof(ActorApiLookup)/sizeof(ActorApiLookup[0]);
102
103
104
105 /**
106  * Creates an actor given a type name
107  * Uses the type registry to create an actor of the correct type
108  */
109 Actor CreateActor( const v8::FunctionCallbackInfo< v8::Value >& args,
110                         const std::string& typeName )
111 {
112   Actor actor;
113
114   ActorWrapper::ActorType actorType = ActorWrapper::GetActorType( typeName );
115
116   // if we don't currently support the actor type, then use type registry to create it
117   if( actorType == ActorWrapper::UNKNOWN_ACTOR )
118   {
119       DALI_SCRIPT_EXCEPTION( args.GetIsolate(), "Unknown actor type" );
120       return Actor();
121   }
122   else
123   {
124     // run the constructor for this type of actor so it can pull out
125     // custom parameters, e.g. new ImageActor( MyImage );
126     actor = (ActorApiLookup[actorType].constructor)( args );
127   }
128   return actor;
129 }
130
131
132
133 /**
134  * given an actor type return what api's it supports
135  */
136 int GetActorSupportedApis( ActorWrapper::ActorType type )
137 {
138   return ActorApiLookup[ type].supportApis;
139 }
140
141 /**
142  * Used for the ActorFunctionTable to map function names to functions
143  * with for a specific API
144  */
145 struct ActorFunctions
146 {
147   const char* name;               ///< function name
148   void (*function)( const v8::FunctionCallbackInfo< v8::Value >& args);
149   ActorApiBitMask api;
150 };
151
152 /**
153  * Contains a list of all functions that can be called an
154  * actor / image-actor / layer / camera-actor
155  */
156 const ActorFunctions ActorFunctionTable[]=
157 {
158     /**************************************
159     * Actor API (in order of actor.h)
160     * Any properties that have accessor functions are ignored to avoid duplication
161     **************************************/
162     // ignore. GetName()  use Actor.name
163     // ignore. SetName()  use Actor.name
164     { "GetId",             ActorApi::GetId,            ACTOR_API },
165     { "IsRoot",            ActorApi::IsRoot,           ACTOR_API },
166     { "OnStage",           ActorApi::OnStage,          ACTOR_API },
167     { "IsLayer",           ActorApi::IsLayer,          ACTOR_API },
168     { "GetLayer",          ActorApi::GetLayer,         ACTOR_API },
169     { "Add",               ActorApi::AddActor,         ACTOR_API },
170     { "Remove",            ActorApi::RemoveActor,      ACTOR_API },
171     { "IsEqualTo" ,        ActorApi::IsEqualTo,        ACTOR_API },
172     { "Unparent",          ActorApi::Unparent,         ACTOR_API },
173     { "GetChildCount",     ActorApi::GetChildCount,    ACTOR_API },
174     { "GetChildAt"   ,     ActorApi::GetChildAt,       ACTOR_API },
175     { "FindChildByName",   ActorApi::FindChildByName,  ACTOR_API },
176     { "FindChildById",     ActorApi::FindChildById,    ACTOR_API },
177     { "GetParent" ,        ActorApi::GetParent,        ACTOR_API },
178     { "GetActorType" ,     ActorApi::GetActorType,     ACTOR_API }, // custom for javascript
179
180     // ignore. SetParentOrigin() use Actor.parentOrigin
181     // ignore. GetCurrentParentOrigin()  use Actor.parentOrigin
182     // ignore. SetAnchorPoint()  use Actor.anchorPoint
183     // ignore. GetCurrentAnchorPoint()  use Actor.anchorPoint
184     // ignore. SetSize() use Actor.size
185     // ignore. GetCurrentSize() use Actor.size
186     // ignore. SetPosition(....) use Actor.position
187     // ignore. SetX, SetY, SetZ,  use Actor.position.x, Actor.position.y, Actor.position.z
188     { "TranslateBy",         ActorApi::TranslateBy,              ACTOR_API },
189     // ignore GetCurrentPosition(). use Actor.position
190     // ignore GetCurrentWorldPosition() use Actor.worldPosition
191     // ignore SetPositionInheritanceMode() use Actor.positionInheritance
192     // ignore GetPositionInheritanceMode()  use Actor.positionInheritance
193     // ignore SetOrientation() use Actor.orientation
194     { "RotateBy",         ActorApi::RotateBy,          ACTOR_API },
195     // ignore GetCurrentOrientation() use Actor.orientation
196     // ignore SetInheritOrientation() use Actor.inheritOrientation
197     // ignore IsOrientationInherited() use Actor.inheritOrientation
198     // ignore GetCurrentWorldOrientation() use Actor.worldOrientation
199     // ignore SetScale() use Actor.scale
200     { "ScaleBy",         ActorApi::ScaleBy,            ACTOR_API },
201     // ignore GetCurrentScale() use Actor.scale
202     // ignore GetCurrentWorldScale() use Actor.worldScale
203     // ignore SetInheritScale() use Actor.inheritScale
204     // ignore IsScaleInherited() use Actor.inheritScale
205     // ignore GetCurrentWorldMatrix() use Actor.worldMatrix
206     // ignore SetVisible() use Actor.visible
207     // ignore IsVisible() use Actor.visible
208     // ignore SetOpacity() use Actor.opacity
209     // ignore GetCurrentOpacity() use Actor.opacity
210     // ignore SetColor() use Actor.color
211     // ignore GetCurrentColor() use Actor.color
212     // ignore SetColorMode() use Actor.colorMode
213     // ignore GetColorMode() use Actor.colorMode
214     // ignore GetCurrentWorldColor() use Actor.worldColor
215     // ignore SetInheritShaderEffect() use Actor.inheritShaderEffect
216     // ignore GetInheritShaderEffect() use Actor.inheritShaderEffect
217     // ignore SetDrawMode() use Actor.drawMode
218     // ignore GetDrawMode() use Actor.drawMode
219     // ignore SetSensitive() use Actor.sensitve
220     // ignore IsSensitive() use Actor.sensitive
221     { "ScreenToLocal"       , ActorApi::ScreenToLocal,         ACTOR_API},
222     // ignore SetLeaveRequired() use Actor.leaveRequired
223     // ignore GetLeaveRequired() use Actor.leaveRequired
224     { "SetKeyboardFocusable", ActorApi::SetKeyboardFocusable,  ACTOR_API }, //-- should this be a property???
225     { "IsKeyboardFocusable" , ActorApi::IsKeyboardFocusable,   ACTOR_API }, //-- should this be a property???
226
227     /**************************************
228      * Layer  API (in order of layer.h)
229      **************************************/
230     { "GetDepth",           LayerApi::GetDepth,                 LAYER_API  },
231     { "Raise",              LayerApi::Raise,                    LAYER_API  },
232     { "Lower",              LayerApi::Lower,                    LAYER_API  },
233     { "RaiseAbove",         LayerApi::RaiseAbove,               LAYER_API  },
234     { "RaiseBelow",         LayerApi::LowerBelow,               LAYER_API  },
235     { "RaiseToTop",         LayerApi::RaiseToTop,               LAYER_API  },
236     { "LowerToBottom",      LayerApi::ToBottom,                 LAYER_API  },
237     { "MoveAbove",          LayerApi::MoveAbove,                LAYER_API  },
238     { "MoveBelow",          LayerApi::MoveBelow,                LAYER_API  },
239     // ignore SetClipping, use layer.clippingEnable
240     // ignore IsClipping, use layer.clippingEnable
241     // ignore SetClippingBox, use layer.clippingBox
242     { "SetDepthTestDisabled", LayerApi::SetDepthTestDisabled,   LAYER_API },
243     { "IsDepthTestDisabled",  LayerApi::IsDepthTestDisabled,    LAYER_API },
244     // @todo SetSortFunction
245
246     /**************************************
247      * Image Actor API (in order of image-actor.h)
248      **************************************/
249
250     { "SetImage",           ImageActorApi::SetImage,              IMAGE_ACTOR_API },
251     { "GetImage",           ImageActorApi::GetImage,              IMAGE_ACTOR_API },
252     // ignore SetPixelArea, use imageActor.pixelArea
253     // ignore GetPixelArea, use imageActor.pixelArea
254     // ignore SetStyle, use imageActor.style
255     // ignore GetStyle, use imageActor.style
256     // ignore SetNinePatchBorder use imageActor.border
257     // ignore GetNinePatchBorder use imageActor.border
258     { "SetSortModifier",    ImageActorApi::SetSortModifier,   IMAGE_ACTOR_API  },
259     { "GetSortModifier",    ImageActorApi::GetSortModifier,   IMAGE_ACTOR_API  },
260     { "SetBlendMode",       ImageActorApi::SetBlendMode,      IMAGE_ACTOR_API  },
261     { "GetBlendMode",       ImageActorApi::GetBlendMode,      IMAGE_ACTOR_API  },
262     { "SetBlendFunc",       ImageActorApi::SetBlendFunc,      IMAGE_ACTOR_API  },
263     { "GetBlendFunc",       ImageActorApi::GetBlendFunc,      IMAGE_ACTOR_API  },
264     { "SetShaderEffect",    ImageActorApi::SetShaderEffect,   IMAGE_ACTOR_API  },
265     { "GetShaderEffect",    ImageActorApi::GetShaderEffect,   IMAGE_ACTOR_API  },
266     { "RemoveShaderEffect", ImageActorApi::RemoveShaderEffect,IMAGE_ACTOR_API  },
267     // ignore SetFadeIn use imageActor.fadeIn
268     // ignore GetFadeIn use imageActor.fadeIn
269     // ignore SetFadeInDuration use imageActor.fadeInDuration
270     // ignore GetFadeInDuration use imageActor.fadeInDuration
271     //{ "GetCurrentImageSize", ImageActorApi::GetCurrentImageSize,  IMAGE_ACTOR_API },
272
273     /**************************************
274      * Mesh Actor API (in order of mesh-actor.h)
275      **************************************/
276     // @todo a version of MeshActor::New( mesh )
277     // @todo a version of MeshActor::New( AnimatableMesh )
278     // @todo SetMaterial
279     // @todo GetMaterial
280     // @todo BindBonesToMesh
281
282     /**************************************
283      * Camera Actor API (in order of camera.h)
284      **************************************/
285     // ignore SetType use camera.type
286     // ignore GetType use camera.type
287     // ignore SetProjectionMode use camera.projectionMode
288     // ignore GetProjectionMode use camera.projectionMode
289     // ignore SetFieldOfView use camera.fieldOfView
290     // ignore GetFieldOfView use camera.fieldOfView
291     // ignore SetAspectRatio use camera.aspectRatio
292     // ignore GetAspectRatio use camera.aspectRatio
293     // ignore SetNearClippingPlane use camera.nearPlaneDistance
294     // ignore GetNearClippingPlane use camera.nearPlaneDistance
295     // ignore SetFarClippingPlane use camera.farPlaneDistance
296     // ignore GetFarClippingPlane use camera.farPlaneDistance
297     // ignore GetTargetPosition use camera.targetPosition
298     // ignore SetInvertYAxis use camera.invertYAxis
299     // ignore GetInvertYAxis use camera.invertYAxis
300     { "SetPerspectiveProjection",   CameraActorApi::SetPerspectiveProjection,   CAMERA_ACTOR_API },
301     { "SetOrthographicProjection",  CameraActorApi::SetOrthographicProjection,  CAMERA_ACTOR_API },
302
303 };
304
305 const unsigned int ActorFunctionTableCount = sizeof(ActorFunctionTable)/sizeof(ActorFunctionTable[0]);
306 } //un-named space
307
308
309 ActorWrapper::ActorWrapper( Actor actor,
310               GarbageCollectorInterface& gc )
311 : HandleWrapper( BaseWrappedObject::ACTOR , actor, gc ),
312   mActor( actor )
313
314 {
315 }
316
317 v8::Handle<v8::Object> ActorWrapper::WrapActor(v8::Isolate* isolate, Actor actor )
318 {
319   v8::EscapableHandleScope handleScope( isolate );
320
321   // Check whether the actor is a Control
322   ActorWrapper::ActorType type = Toolkit::Control::DownCast(actor) ? ACTOR : GetActorType( actor.GetTypeName() );
323   v8::Local<v8::Object> object = WrapActor( isolate, actor, type );
324
325   return handleScope.Escape( object );
326 }
327
328 Actor ActorWrapper::GetActor()
329 {
330   return mActor;
331 }
332
333 v8::Handle<v8::Object> ActorWrapper::WrapActor( v8::Isolate* isolate, Actor actor, ActorType actorType )
334 {
335   v8::EscapableHandleScope handleScope( isolate );
336   v8::Local<v8::ObjectTemplate> objectTemplate;
337
338   objectTemplate = GetActorTemplate( isolate, actorType );
339
340   // create an instance of the template
341   v8::Local<v8::Object> localObject = objectTemplate->NewInstance();
342
343   // create teh actor object
344   ActorWrapper* pointer = new ActorWrapper( actor, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() );
345
346   // assign the JavaScript object to the wrapper.
347   // This also stores Dali object, in an internal field inside the JavaScript object.
348   pointer->SetJavascriptObject( isolate, localObject );
349
350   return handleScope.Escape( localObject );
351 }
352
353 v8::Local<v8::ObjectTemplate> ActorWrapper::GetActorTemplate( v8::Isolate* isolate, ActorWrapper::ActorType type )
354 {
355   v8::EscapableHandleScope handleScope( isolate );
356   v8::Local<v8::ObjectTemplate> objectTemplate;
357
358   if( ActorTemplateLookup[type].actorTemplate->IsEmpty() )
359   {
360     objectTemplate = MakeDaliActorTemplate( isolate, type );
361     ActorTemplateLookup[type].actorTemplate->Reset( isolate, objectTemplate );
362   }
363   else
364   {
365     // get the object template
366     objectTemplate = v8::Local<v8::ObjectTemplate>::New( isolate, *ActorTemplateLookup[type].actorTemplate );
367   }
368
369   return handleScope.Escape( objectTemplate );
370 }
371
372 v8::Handle<v8::ObjectTemplate> ActorWrapper::MakeDaliActorTemplate( v8::Isolate* isolate, ActorType actorType )
373 {
374   v8::EscapableHandleScope handleScope( isolate );
375
376   v8::Local<v8::ObjectTemplate> objTemplate = v8::ObjectTemplate::New();
377
378   objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT );
379
380   // find out what API's this actor supports
381   int supportApis = GetActorSupportedApis( actorType );
382
383   // add our function properties
384   for( unsigned int i = 0; i < ActorFunctionTableCount; ++i )
385   {
386     const ActorFunctions property =  ActorFunctionTable[i];
387
388     // check to see if the actor supports a certain type of API
389     // e.g. ImageActor will support ACTOR_API, RENDERABLE_API and IMAGE_ACTOR_API
390     if( supportApis &  property.api )
391     {
392       std::string funcName = V8Utils::GetJavaScriptFunctionName( property.name);
393
394       objTemplate->Set( v8::String::NewFromUtf8(   isolate, funcName.c_str() ),
395                       v8::FunctionTemplate::New( isolate, property.function ) );
396     }
397   }
398
399   // property handle intercepts property getters and setters and signals
400   HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate );
401
402
403   return handleScope.Escape( objTemplate );
404 }
405
406 void ActorWrapper::NewActor( const v8::FunctionCallbackInfo< v8::Value >& args)
407 {
408   v8::Isolate* isolate = args.GetIsolate();
409   v8::HandleScope handleScope( isolate );
410
411   if( !args.IsConstructCall() )
412   {
413     DALI_SCRIPT_EXCEPTION( isolate, "constructor called without 'new" );
414     return;
415   }
416
417   // find out the callee function name...e.g. ImageActor, MeshActor
418   v8::Local<v8::Function> callee = args.Callee();
419   v8::Local<v8::Value> v8String = callee->GetName();
420   std::string typeName = V8Utils::v8StringToStdString( v8String );
421
422   // create a new actor based on type, using the type registry.
423   Actor actor = CreateActor( args, typeName );
424
425   v8::Local<v8::Object> localObject = WrapActor( isolate, actor );
426
427   args.GetReturnValue().Set( localObject );
428 }
429
430 void ActorWrapper::NewControl( const v8::FunctionCallbackInfo< v8::Value >& args)
431 {
432   v8::Isolate* isolate = args.GetIsolate();
433   v8::HandleScope handleScope( isolate );
434
435   if( !args.IsConstructCall() )
436   {
437     DALI_SCRIPT_EXCEPTION( isolate, "constructor called without 'new" );
438     return;
439   }
440
441   bool found( false );
442   std::string controlName = V8Utils::GetStringParameter( PARAMETER_0, found, isolate,  args );
443
444   if( !found )
445   {
446     DALI_SCRIPT_EXCEPTION( isolate, "missing control name" );
447     return;
448   }
449   Actor control;
450   Dali::TypeInfo typeInfo = Dali::TypeRegistry::Get().GetTypeInfo( controlName );
451   if( typeInfo ) // handle, check if it has a value
452   {
453     Dali::BaseHandle handle = typeInfo.CreateInstance();
454     if( handle )
455     {
456       control = Actor::DownCast( handle );
457     }
458   }
459
460   v8::Local<v8::Object> localObject = WrapActor( isolate, control, ACTOR );
461
462   args.GetReturnValue().Set( localObject );
463 }
464
465
466 /**
467  * given an actor type name, e.g. ImageActor returns the type, e.g. ActorWrapper::IMAGE_ACTOR
468  */
469 ActorWrapper::ActorType ActorWrapper::GetActorType( const std::string& name )
470 {
471   for( unsigned int i = 0 ; i < ActorApiLookupCount ; i++ )
472   {
473     if( ActorApiLookup[i].actorName == name )
474     {
475       return ActorApiLookup[i].actorType;
476     }
477   }
478   return ActorWrapper::UNKNOWN_ACTOR;
479 }
480
481
482
483 } // namespace V8Plugin
484
485 } // namespace Dali