From: Ferran Sole Date: Tue, 24 Mar 2015 09:21:22 +0000 (+0000) Subject: Added PathConstraint support to Javascript API X-Git-Tag: accepted/tizen/common/20150407.101646~11^2 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=8a45a421cfad72bfb791f1a98950cb1b9f52f650 Added PathConstraint support to Javascript API To create a new PathConstraint: var pathConstraint = new dali.PathConstraint( myPath, [1.0,0.0] ); To apply the path constraint to an actor: actor.applyPathConstraint( pathConstraint, "position", actor, "color-alpha" ); actor.applyPathConstraint( pathConstraint, "orientation", actor, "color-alpha", [1.0,0.0,0.0] ); The code above will constraint position and orientation of the actor to the path. The parameter to sample the path will be the color-alpha of the actor. Change-Id: I9d3f5c48f0e984d0626a0cf41b0ab2dcdd6d9516 --- diff --git a/plugins/dali-script-v8/file.list b/plugins/dali-script-v8/file.list index 13300ef..d87322f 100644 --- a/plugins/dali-script-v8/file.list +++ b/plugins/dali-script-v8/file.list @@ -23,6 +23,7 @@ script_v8_plugin_src_files = \ $(v8_plugin_dir)/animation/animation-api.cpp \ $(v8_plugin_dir)/animation/animation-wrapper.cpp \ $(v8_plugin_dir)/animation/path-api.cpp \ + $(v8_plugin_dir)/animation/path-constraint-wrapper.cpp \ $(v8_plugin_dir)/animation/path-wrapper.cpp \ $(v8_plugin_dir)/stage/stage-wrapper.cpp \ $(v8_plugin_dir)/events/event-object-generator.cpp \ diff --git a/plugins/dali-script-v8/src/actors/actor-api.cpp b/plugins/dali-script-v8/src/actors/actor-api.cpp index d068554..7237547 100644 --- a/plugins/dali-script-v8/src/actors/actor-api.cpp +++ b/plugins/dali-script-v8/src/actors/actor-api.cpp @@ -24,6 +24,7 @@ // INTERNAL INCLUDES #include #include +#include namespace Dali { @@ -609,6 +610,111 @@ void ActorApi::ScaleBy( const v8::FunctionCallbackInfo& args ) actor.ScaleBy( vector ); } +void ActorApi::ApplyPathConstraint( const v8::FunctionCallbackInfo< v8::Value >& args ) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + //Get target actor + Actor targetActor = GetActor( isolate, args ); + + //Get PathConstraint + bool found(false); + Handle pathConstraintHandle = V8Utils::GetHandleParameter(PARAMETER_0, found, isolate, args ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 (PathConstraint)" ); + return; + } + PathConstraint pathConstraint = PathConstraint::DownCast(pathConstraintHandle); + + //Get target property + std::string propertyName = V8Utils::GetStringParameter( PARAMETER_1, found, isolate, args ); + if(!found) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 1 (Property name)" ); + return; + } + + // try both properties with dashes and without + Property::Index targetPropertyIndex = targetActor.GetPropertyIndex( propertyName ); + if( targetPropertyIndex == Property::INVALID_INDEX ) + { + std::string convertedName = V8Utils::JavaScriptNameToPropertyName( propertyName ); + targetPropertyIndex = targetActor.GetPropertyIndex( convertedName ); + + if( targetPropertyIndex == Property::INVALID_INDEX ) + { + DALI_SCRIPT_EXCEPTION( isolate, "Property not found" ); + } + } + + //Get source actor + Actor sourceActor = V8Utils::GetActorParameter( PARAMETER_2, found, isolate, args ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 2 (Actor)" ); + } + + // try both properties with dashes and without + propertyName = V8Utils::GetStringParameter( PARAMETER_3, found, isolate, args ); + if(!found) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 3 (Property name)" ); + return; + } + + Property::Index sourcePropertyIndex = sourceActor.GetPropertyIndex( propertyName ); + if( sourcePropertyIndex == Property::INVALID_INDEX ) + { + std::string convertedName = V8Utils::JavaScriptNameToPropertyName( propertyName ); + sourcePropertyIndex = sourceActor.GetPropertyIndex( convertedName ); + + if( sourcePropertyIndex == Property::INVALID_INDEX ) + { + DALI_SCRIPT_EXCEPTION( isolate, "Property not found" ); + return; + } + } + + //Check if forward vector is specified + Vector3 forward( 0.0f,0.0f,0.0f); + if( args.Length() > 4 ) + { + forward = V8Utils::GetVector3Parameter( PARAMETER_4, found, isolate, args ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 4 (Vector3)" ); + return; + } + } + + pathConstraint.Apply( Dali::Property(sourceActor,sourcePropertyIndex), + Dali::Property(targetActor,targetPropertyIndex), + forward ); + +} + +void ActorApi::RemovePathConstraint( const v8::FunctionCallbackInfo< v8::Value >& args ) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + //Get target actor + Actor actor = GetActor( isolate, args ); + + //Get PathConstraint + bool found(false); + Handle pathConstraintHandle = V8Utils::GetHandleParameter(PARAMETER_0, found, isolate, args ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 (PathConstraint)" ); + return; + } + PathConstraint pathConstraint = PathConstraint::DownCast(pathConstraintHandle); + pathConstraint.Remove(actor); +} + } // namespace V8Plugin } // namespace Dali diff --git a/plugins/dali-script-v8/src/actors/actor-api.h b/plugins/dali-script-v8/src/actors/actor-api.h index 9d1bb16..b1dfd4b 100644 --- a/plugins/dali-script-v8/src/actors/actor-api.h +++ b/plugins/dali-script-v8/src/actors/actor-api.h @@ -68,6 +68,12 @@ namespace ActorApi void RotateBy( const v8::FunctionCallbackInfo< v8::Value >& args ); void ScaleBy( const v8::FunctionCallbackInfo< v8::Value >& args ); + // new function just for JavaScript API, to apply a PathConstraint to an actor + void ApplyPathConstraint( const v8::FunctionCallbackInfo< v8::Value >& args ); + + // new function just for JavaScript API, to remove a PathConstraint from an actor + void RemovePathConstraint( const v8::FunctionCallbackInfo< v8::Value >& args ); + // new function just for JavaScript API, to help developers know what type of actor // they're dealing with, returns actor name as a string void GetActorType( const v8::FunctionCallbackInfo< v8::Value >& args ); diff --git a/plugins/dali-script-v8/src/actors/actor-wrapper.cpp b/plugins/dali-script-v8/src/actors/actor-wrapper.cpp index 6f2d6f0..7613178 100644 --- a/plugins/dali-script-v8/src/actors/actor-wrapper.cpp +++ b/plugins/dali-script-v8/src/actors/actor-wrapper.cpp @@ -202,6 +202,8 @@ const ActorFunctions ActorFunctionTable[]= { "FindChildById", ActorApi::FindChildById, ACTOR_API }, { "GetParent" , ActorApi::GetParent, ACTOR_API }, { "GetActorType" , ActorApi::GetActorType, ACTOR_API }, // custom for javascript + { "ApplyPathConstraint", ActorApi::ApplyPathConstraint, ACTOR_API }, // custom for javascript + { "RemovePathConstraint", ActorApi::RemovePathConstraint, ACTOR_API }, // custom for javascript // ignore. SetParentOrigin() use Actor.parentOrigin // ignore. GetCurrentParentOrigin() use Actor.parentOrigin diff --git a/plugins/dali-script-v8/src/animation/path-constraint-wrapper.cpp b/plugins/dali-script-v8/src/animation/path-constraint-wrapper.cpp new file mode 100644 index 0000000..72434d9 --- /dev/null +++ b/plugins/dali-script-v8/src/animation/path-constraint-wrapper.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include "path-constraint-wrapper.h" + +// INTERNAL INCLUDES +#include +#include +#include + +namespace Dali +{ + +namespace V8Plugin +{ + +PathConstraintWrapper::PathConstraintWrapper( PathConstraint pathConstraint, GarbageCollectorInterface& gc ) +:HandleWrapper( BaseWrappedObject::PATH_CONSTRAINT, pathConstraint, gc ), + mPathConstraint( pathConstraint ) +{ +} + +v8::Handle PathConstraintWrapper::MakePathConstraintTemplate( v8::Isolate* isolate ) +{ + v8::EscapableHandleScope handleScope( isolate ); + + v8::Local objTemplate = v8::ObjectTemplate::New(); + objTemplate->SetInternalFieldCount( BaseWrappedObject::FIELD_COUNT ); + + // property handle intercepts property getters and setters and signals + HandleWrapper::AddInterceptsToTemplate( isolate, objTemplate ); + + return handleScope.Escape( objTemplate ); +} + +v8::Handle PathConstraintWrapper::WrapPathConstraint( v8::Isolate* isolate, PathConstraint pathConstraint ) +{ + v8::EscapableHandleScope handleScope( isolate ); + v8::Local objectTemplate; + + objectTemplate = MakePathConstraintTemplate( isolate ); + + // create an instance of the template + v8::Local localObject = objectTemplate->NewInstance(); + + // create the pathconstraint object + PathConstraintWrapper* pointer = new PathConstraintWrapper( pathConstraint, Dali::V8Plugin::DaliWrapper::Get().GetDaliGarbageCollector() ); + + // assign the JavaScript object to the wrapper. + // This also stores Dali object, in an internal field inside the JavaScript object. + pointer->SetJavascriptObject( isolate, localObject ); + + return handleScope.Escape( localObject ); +} + +PathConstraint PathConstraintWrapper::GetPathConstraint() +{ + return mPathConstraint; +} + +/** + * Create an initialized PathConstraint handle. + * @constructor + * @for Path + * @method Path + */ +void PathConstraintWrapper::NewPathConstraint( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + if( !args.IsConstructCall() ) + { + DALI_SCRIPT_EXCEPTION( isolate, "constructor called without 'new" ); + return; + } + + //Extract Path Handle + bool parameterFound; + Handle pathHandle = V8Utils::GetHandleParameter( PARAMETER_0, parameterFound, isolate, args ); + if( !parameterFound ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 0 (Path)" ); + return; + } + Dali::Path path = Path::DownCast(pathHandle); + + //Extract range + Vector2 range = V8Utils::GetVector2Parameter( PARAMETER_1, parameterFound, isolate, args ); + if( !parameterFound ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad parameter 1 (Range)" ); + return; + } + + PathConstraint pathConstraint = PathConstraint::New(path, range ); + v8::Local localObject = WrapPathConstraint( isolate, pathConstraint ); + args.GetReturnValue().Set( localObject ); +} + + +} // namespace V8Plugin + +} // namespace Dali diff --git a/plugins/dali-script-v8/src/animation/path-constraint-wrapper.h b/plugins/dali-script-v8/src/animation/path-constraint-wrapper.h new file mode 100644 index 0000000..bbc4c92 --- /dev/null +++ b/plugins/dali-script-v8/src/animation/path-constraint-wrapper.h @@ -0,0 +1,83 @@ +#ifndef __DALI_V8PLUGIN_PATH_CONSTRAINT_WRAPPER_H__ +#define __DALI_V8PLUGIN_PATH_CONSTRAINT_WRAPPER_H__ + +/* + * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include + + +namespace Dali +{ + +namespace V8Plugin +{ + +/** + * Wraps a Path. + */ +class PathConstraintWrapper : public HandleWrapper +{ + +public: + + /** + * Constructor + */ + PathConstraintWrapper( PathConstraint pathConstraint, GarbageCollectorInterface& gc ); + + /** + * Virtual destructor + */ + virtual ~PathConstraintWrapper(){}; + + /** + * Creates a new PathConstraint wrapped inside a Javascript Object. + * @param[in] args v8 function call arguments interpreted + */ + static void NewPathConstraint( const v8::FunctionCallbackInfo< v8::Value >& args); + + /** + * Wraps a PathConstraint inside a Javascript object + */ + static v8::Handle WrapPathConstraint(v8::Isolate* isolate, PathConstraint pathConstraint ); + + /* + * Get the wrapped PathConstraint + */ + PathConstraint GetPathConstraint(); + +private: + + /** + * Create a v8 object template for the PathConstraint + */ + static v8::Handle MakePathConstraintTemplate( v8::Isolate* isolate ); + + PathConstraint mPathConstraint; +}; + +} // namespace V8Plugin + +} // namespace Dali + +#endif // header diff --git a/plugins/dali-script-v8/src/dali-wrapper.cpp b/plugins/dali-script-v8/src/dali-wrapper.cpp index 1bb2dfc..5bce721 100644 --- a/plugins/dali-script-v8/src/dali-wrapper.cpp +++ b/plugins/dali-script-v8/src/dali-wrapper.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -61,6 +62,7 @@ const ApiFunction ConstructorFunctionTable[]= { "Matrix", PropertyValueWrapper::NewMatrix}, { "Font", FontWrapper::NewFont }, { "Path", PathWrapper::NewPath }, + { "PathConstraint", PathConstraintWrapper::NewPathConstraint }, { "Actor", ActorWrapper::NewActor }, { "TextActor", ActorWrapper::NewActor }, { "ImageActor", ActorWrapper::NewActor }, diff --git a/plugins/dali-script-v8/src/shared/base-wrapped-object.h b/plugins/dali-script-v8/src/shared/base-wrapped-object.h index 7e473cd..fee9d8c 100644 --- a/plugins/dali-script-v8/src/shared/base-wrapped-object.h +++ b/plugins/dali-script-v8/src/shared/base-wrapped-object.h @@ -71,6 +71,7 @@ public: CONNECTION, ANIMATION, PATH, + PATH_CONSTRAINT, BUILDER, STAGE, FONT, diff --git a/plugins/dali-script-v8/src/utils/v8-utils.h b/plugins/dali-script-v8/src/utils/v8-utils.h index e8933be..534c547 100644 --- a/plugins/dali-script-v8/src/utils/v8-utils.h +++ b/plugins/dali-script-v8/src/utils/v8-utils.h @@ -46,6 +46,7 @@ enum PARAMETER_1 = 1, ///< second parameter of a function call PARAMETER_2 = 2, ///< third parameter of a function call PARAMETER_3 = 3, ///< forth parameter of a function call + PARAMETER_4 = 4, ///< fifth parameter of a function call }; #define DALI_SCRIPT_EXCEPTION( isolate, message ) V8Utils::ScriptError( __FUNCTION__ , isolate, message );