From e47d25c5332ac9ac9e3e90041a4b9012667255ad Mon Sep 17 00:00:00 2001 From: Richard Huang Date: Thu, 21 Jan 2016 11:56:43 +0000 Subject: [PATCH] JavaScript binding for ScrollView This patch includes: 1. ScrollView API binding 2. Documentation for ScrollView JavaScript API 3. JavaScript example for ScrollView 4. Changed the type of built-in animation alpha function from string to enumeration Change-Id: I6482ffd6a0201a1d71258fbb6a53184a4a07e615 --- docs/content/images/scroll-view/scroll-view.png | Bin 0 -> 28825 bytes node-addon/binding.gyp | 1 + node-addon/build/tizen/CMakeLists.txt | 1 + node-addon/examples/scroll-view.js | 130 ++++++ plugins/dali-script-v8/docs/content/animation.js | 58 +-- plugins/dali-script-v8/docs/content/constants.js | 25 ++ .../dali-script-v8/docs/content/item-factory.js | 2 +- .../dali-script-v8/docs/content/path-animation.js | 2 +- plugins/dali-script-v8/docs/content/scroll-view.js | 89 ++++ plugins/dali-script-v8/file.list | 1 + plugins/dali-script-v8/src/actors/actor-api.cpp | 25 ++ plugins/dali-script-v8/src/actors/actor-api.h | 1 + .../dali-script-v8/src/actors/actor-wrapper.cpp | 1 + .../dali-script-v8/src/animation/animation-api.cpp | 100 +---- .../src/animation/constrainer-api.cpp | 18 +- .../src/constants/constants-wrapper.cpp | 23 + .../src/controls/control-wrapper.cpp | 22 +- .../dali-script-v8/src/controls/control-wrapper.h | 3 +- .../src/controls/scroll-view-api.cpp | 477 +++++++++++++++++++++ .../dali-script-v8/src/controls/scroll-view-api.h | 58 +++ .../src/shared/base-wrapped-object.h | 1 + 21 files changed, 894 insertions(+), 144 deletions(-) create mode 100755 docs/content/images/scroll-view/scroll-view.png create mode 100644 node-addon/examples/scroll-view.js create mode 100644 plugins/dali-script-v8/docs/content/scroll-view.js create mode 100644 plugins/dali-script-v8/src/controls/scroll-view-api.cpp create mode 100644 plugins/dali-script-v8/src/controls/scroll-view-api.h diff --git a/docs/content/images/scroll-view/scroll-view.png b/docs/content/images/scroll-view/scroll-view.png new file mode 100755 index 0000000000000000000000000000000000000000..fe2d40988b6a6dc675c377332fd96a28d6bb7ab7 GIT binary patch literal 28825 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 args ) } /** + * Return the value of negotiated dimension for the given dimension + * + * @for Actor + * @method getRelayoutSize + * @param {Integer} dimension The dimension of layout to retrieve (either dali.DIMENSION_WIDTH or dali.DIMENSION_HEIGHT) + * @return {Number} The value of the negotiated dimension + */ +void ActorApi::GetRelayoutSize( const v8::FunctionCallbackInfo& args ) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + Actor actor = GetActor( isolate, args ); + + bool found; + int dimension = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "missing dimension parameter"); + return; + } + + args.GetReturnValue().Set( v8::Number::New( isolate, actor.GetRelayoutSize( static_cast(dimension) ) ) ); +} + +/** * Calculate the width of the actor given a height * * The natural size is used for default calculation. diff --git a/plugins/dali-script-v8/src/actors/actor-api.h b/plugins/dali-script-v8/src/actors/actor-api.h index bcd600e..2963400 100644 --- a/plugins/dali-script-v8/src/actors/actor-api.h +++ b/plugins/dali-script-v8/src/actors/actor-api.h @@ -57,6 +57,7 @@ namespace ActorApi void SetKeyboardFocusable( const v8::FunctionCallbackInfo< v8::Value >& args ); void IsKeyboardFocusable( const v8::FunctionCallbackInfo< v8::Value >& args ); void GetNaturalSize( const v8::FunctionCallbackInfo< v8::Value >& args ); + void GetRelayoutSize( const v8::FunctionCallbackInfo< v8::Value >& args ); void GetWidthForHeight( const v8::FunctionCallbackInfo& args ); void GetHeightForWidth( const v8::FunctionCallbackInfo& args ); void TranslateBy( 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 a1c0f78..c9d3e1d 100644 --- a/plugins/dali-script-v8/src/actors/actor-wrapper.cpp +++ b/plugins/dali-script-v8/src/actors/actor-wrapper.cpp @@ -179,6 +179,7 @@ const ActorFunctions ActorFunctionTable[]= // ignore. SetSize() use Actor.size // ignore. GetCurrentSize() use Actor.size { "GetNaturalSize", ActorApi::GetNaturalSize, ACTOR_API }, + { "GetRelayoutSize", ActorApi::GetRelayoutSize, ACTOR_API }, { "GetWidthForHeight",ActorApi::GetWidthForHeight, ACTOR_API }, { "GetHeightForWidth",ActorApi::GetHeightForWidth, ACTOR_API }, // ignore. SetPosition(....) use Actor.position diff --git a/plugins/dali-script-v8/src/animation/animation-api.cpp b/plugins/dali-script-v8/src/animation/animation-api.cpp index 0db4482..e20e656 100644 --- a/plugins/dali-script-v8/src/animation/animation-api.cpp +++ b/plugins/dali-script-v8/src/animation/animation-api.cpp @@ -20,7 +20,6 @@ #include "path-wrapper.h" // EXTERNAL INCLUDES -#include // for strcmp #include @@ -38,85 +37,11 @@ namespace V8Plugin namespace // un named namespace { -// @todo think about alternative ways of passing around -struct AlphaFuncStruct -{ - const char* const name; - AlphaFunction alphaFunc; -}; -/** - * Contains a list of alpha functions that can be used. - */ -const AlphaFuncStruct AlphaFunctionTable[]= -{ - - {"default" , AlphaFunction::DEFAULT }, - {"linear" , AlphaFunction::LINEAR }, - {"reverse" , AlphaFunction::REVERSE }, - - {"easeInSquare" , AlphaFunction::EASE_IN_SQUARE }, - {"easeOutSquare" , AlphaFunction::EASE_OUT_SQUARE }, - - {"easeIn" , AlphaFunction::EASE_IN }, - {"easeOut" , AlphaFunction::EASE_OUT }, - {"easeInOut" , AlphaFunction::EASE_IN_OUT }, - - {"easeInSine" , AlphaFunction::EASE_IN_SINE }, - {"easeOutSine" , AlphaFunction::EASE_OUT_SINE }, - {"easeInOutSine" , AlphaFunction::EASE_IN_OUT_SINE }, - - {"bounce" , AlphaFunction::BOUNCE }, - {"sin" , AlphaFunction::SIN }, - {"easeOutBack" , AlphaFunction::EASE_OUT_BACK }, - -}; -const unsigned int AlphaFunctionTableCount = sizeof(AlphaFunctionTable)/sizeof(AlphaFunctionTable[0]); -const char* const DEFAULT_ALPHA_NAME = "default"; -static AlphaFunction DEFAULT_ALPHA_FUNCTION = AlphaFunction::DEFAULT; - - - -AlphaFunction GetAlphaFunction( const std::string& alphaFuncName ) -{ - // This will normally get called just a few times during the application, so no point in doing anything clever - for( unsigned int i = 0; i < AlphaFunctionTableCount; i++) - { - const AlphaFuncStruct& alphaStruct( AlphaFunctionTable[i] ); - - if( std::strcmp( alphaStruct.name , alphaFuncName.c_str() ) == 0 ) - { - return alphaStruct.alphaFunc; - } - } - - DALI_LOG_ERROR("Failed to find alpha func |%s| \n", alphaFuncName.c_str() ); - return DEFAULT_ALPHA_FUNCTION; -} - -const char* const GetAlphaFunctionName( AlphaFunction alphaFunc ) -{ - // This may get called 3 times during the application, so no point - // in doing anything clever - - for( unsigned int i = 0; i < AlphaFunctionTableCount; i++) - { - const AlphaFuncStruct& alphaStruct( AlphaFunctionTable[i] ); - - - if( alphaStruct.alphaFunc.GetBuiltinFunction() == alphaFunc.GetBuiltinFunction() ) - { - return alphaStruct.name; - } - } - return "default"; -} - - struct AnimationParameters { AnimationParameters( const Animation& anim) : propertyIndex( Property::INVALID_INDEX ), - alphaFunction( DEFAULT_ALPHA_FUNCTION), + alphaFunction( AlphaFunction::DEFAULT), delay( 0.f ), duration(anim.GetDuration()), optionsFound( false ) @@ -150,11 +75,10 @@ void GetAnimationOptions( v8::Isolate* isolate, { v8::Local obj = options->ToObject(); v8::Local alphaValue = obj->Get( v8::String::NewFromUtf8( isolate, "alpha" ) ); - if( alphaValue->IsString() ) + if( alphaValue->IsUint32() ) { animParams.optionsFound = true; - std::string alphaName = V8Utils::v8StringToStdString( alphaValue ); - animParams.alphaFunction = GetAlphaFunction( alphaName ); + animParams.alphaFunction = static_cast(alphaValue->ToUint32()->Value()); } v8::Local delayValue = obj->Get( v8::String::NewFromUtf8( isolate, "delay" ) ); @@ -225,10 +149,9 @@ KeyFrames GetKeyFrames( v8::Isolate* isolate, v8::Local keyFrameArra // get keyframe.alpha v8::Handle alphaValue = keyFrameObject->Get(v8::String::NewFromUtf8( isolate, "alpha")); - if( alphaValue->IsString() ) + if( alphaValue->IsUint32() ) { - std::string alphaName = V8Utils::v8StringToStdString( alphaValue ); - AlphaFunction alphaFunction = GetAlphaFunction( alphaName ); + AlphaFunction alphaFunction = static_cast(alphaValue->ToUint32()->Value()); keyframes.Add( progress->NumberValue(), value, alphaFunction ); } else @@ -529,7 +452,7 @@ void AnimationApi::GetDisconnectAction( const v8::FunctionCallbackInfo< v8::Valu * Set the default alpha function for an animation. * @method setDefaultAlphaFunction * @for Animation - * @param {string} alpha function + * @param {Integer} alpha function */ void AnimationApi::SetDefaultAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args ) { @@ -539,23 +462,22 @@ void AnimationApi::SetDefaultAlphaFunction( const v8::FunctionCallbackInfo< v8:: Animation anim = GetAnimation( isolate, args ); bool found( false ); - std::string alphaFunc = V8Utils::GetStringParameter( PARAMETER_0, found, isolate, args ); + int alphaFunc = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 ); if( !found ) { DALI_SCRIPT_EXCEPTION( isolate, "bad parameter" ); } else { - AlphaFunction func = GetAlphaFunction( alphaFunc ); + AlphaFunction func = static_cast(alphaFunc); anim.SetDefaultAlphaFunction( func ); } - } /** * Get the default alpha function for an animation. * @method getDefaultAlphaFunction * @for Animation - * @return {string} alpha function + * @return {Integer} alpha function */ void AnimationApi::GetDefaultAlphaFunction( const v8::FunctionCallbackInfo& args ) { @@ -564,10 +486,10 @@ void AnimationApi::GetDefaultAlphaFunction( const v8::FunctionCallbackInfo& args, Acto targetPropertyIndex = targetActor.GetPropertyIndex( propertyName ); if( targetPropertyIndex == Property::INVALID_INDEX ) { - targetPropertyIndex = targetActor.GetPropertyIndex( propertyName ); - - if( targetPropertyIndex == Property::INVALID_INDEX ) - { - DALI_SCRIPT_EXCEPTION( isolate, "Target property not found" ); - return false; - } + DALI_SCRIPT_EXCEPTION( isolate, "Target property not found" ); + return false; } } else @@ -139,14 +134,9 @@ bool GetApplyParameters( const v8::FunctionCallbackInfo< v8::Value >& args, Acto sourcePropertyIndex = targetActor.GetPropertyIndex( propertyName ); if( sourcePropertyIndex == Property::INVALID_INDEX ) { - sourcePropertyIndex = targetActor.GetPropertyIndex( propertyName ); - - if( sourcePropertyIndex == Property::INVALID_INDEX ) - { - DALI_SCRIPT_EXCEPTION( isolate, "Source property not found" ); - return false; + DALI_SCRIPT_EXCEPTION( isolate, "Source property not found" ); + return false; } - } } else { diff --git a/plugins/dali-script-v8/src/constants/constants-wrapper.cpp b/plugins/dali-script-v8/src/constants/constants-wrapper.cpp index edbd62b..a3a3dd7 100644 --- a/plugins/dali-script-v8/src/constants/constants-wrapper.cpp +++ b/plugins/dali-script-v8/src/constants/constants-wrapper.cpp @@ -36,6 +36,7 @@ #include #include #include +#include namespace Dali { @@ -248,9 +249,31 @@ const IntegerPair EnumTable[] = { "PROPERTY_READ_WRITE", Property::READ_WRITE }, { "PROPERTY_ANIMATABLE", Property::ANIMATABLE }, + { "DIMENSION_WIDTH", Dimension::WIDTH }, + { "DIMENSION_HEIGHT", Dimension::HEIGHT }, + { "ITEM_LAYOUT_LIST", Toolkit::DefaultItemLayout::LIST }, { "ITEM_LAYOUT_GRID", Toolkit::DefaultItemLayout::GRID }, + { "DIRECTION_BIAS_NONE", Toolkit::DirectionBiasNone }, + { "DIRECTION_BIAS_LEFT", Toolkit::DirectionBiasLeft }, + { "DIRECTION_BIAS_RIGHT", Toolkit::DirectionBiasRight }, + + { "ALPHA_FUNCTION_DEFAULT", AlphaFunction::DEFAULT }, + { "ALPHA_FUNCTION_LINEAR", AlphaFunction::LINEAR }, + { "ALPHA_FUNCTION_REVERSE", AlphaFunction::REVERSE }, + { "ALPHA_FUNCTION_EASE_IN_SQUARE", AlphaFunction::EASE_IN_SQUARE }, + { "ALPHA_FUNCTION_EASE_OUT_SQUARE", AlphaFunction::EASE_OUT_SQUARE }, + { "ALPHA_FUNCTION_EASE_IN", AlphaFunction::EASE_IN }, + { "ALPHA_FUNCTION_EASE_OUT", AlphaFunction::EASE_OUT }, + { "ALPHA_FUNCTION_EASE_IN_OUT", AlphaFunction::EASE_IN_OUT }, + { "ALPHA_FUNCTION_EASE_IN_SINE", AlphaFunction::EASE_IN_SINE }, + { "ALPHA_FUNCTION_EASE_OUT_SINE", AlphaFunction::EASE_OUT_SINE }, + { "ALPHA_FUNCTION_EASE_IN_OUT_SINE", AlphaFunction::EASE_IN_OUT_SINE }, + { "ALPHA_FUNCTION_BOUNCE", AlphaFunction::BOUNCE }, + { "ALPHA_FUNCTION_SIN", AlphaFunction::SIN }, + { "ALPHA_FUNCTION_EASE_OUT_BACK", AlphaFunction::EASE_OUT_BACK }, + }; const unsigned int EnumTableCount = sizeof(EnumTable)/sizeof(EnumTable[0]); diff --git a/plugins/dali-script-v8/src/controls/control-wrapper.cpp b/plugins/dali-script-v8/src/controls/control-wrapper.cpp index 09093a2..b3cc3dc 100644 --- a/plugins/dali-script-v8/src/controls/control-wrapper.cpp +++ b/plugins/dali-script-v8/src/controls/control-wrapper.cpp @@ -24,6 +24,7 @@ // INTERNAL INCLUDES #include +#include #include #include @@ -35,6 +36,7 @@ namespace V8Plugin v8::Persistent ControlWrapper::mControlTemplate; v8::Persistent ControlWrapper::mItemViewTemplate; +v8::Persistent ControlWrapper::mScrollViewTemplate; Vector< void* > ControlWrapper::mControlGarbageContainer; @@ -56,7 +58,8 @@ struct ControlTemplate const ControlTemplate ControlTemplateLookup[]= { { &ControlWrapper::mControlTemplate }, // CONTROL - { &ControlWrapper::mItemViewTemplate } // ITEMVIEW + { &ControlWrapper::mItemViewTemplate }, // ITEMVIEW + { &ControlWrapper::mScrollViewTemplate } // SCROLLVIEW }; /** @@ -65,7 +68,8 @@ const ControlTemplate ControlTemplateLookup[]= enum ControlApiBitMask { CONTROL_API = 1 << 0, - ITEMVIEW_API = 1 << 1 + ITEMVIEW_API = 1 << 1, + SCROLLVIEW_API = 1 << 2 }; /** @@ -87,6 +91,7 @@ const ControlApiStruct ControlApiLookup[]= { {"Control", ControlWrapper::CONTROL, NULL, CONTROL_API }, {"ItemView", ControlWrapper::ITEMVIEW, ItemViewApi::New, CONTROL_API | ITEMVIEW_API }, + {"ScrollView", ControlWrapper::SCROLLVIEW, ScrollViewApi::New, CONTROL_API | SCROLLVIEW_API } }; const unsigned int ControlApiLookupCount = sizeof(ControlApiLookup)/sizeof(ControlApiLookup[0]); @@ -171,6 +176,19 @@ const ControlFunctions ControlFunctionTable[]= { "GetItemId", ItemViewApi::GetItemId, ITEMVIEW_API }, { "GetItemsRange", ItemViewApi::GetItemsRange, ITEMVIEW_API }, + /************************************** + * ScrollView API + **************************************/ + { "SetScrollMode", ScrollViewApi::SetScrollMode, SCROLLVIEW_API }, + { "GetCurrentPage", ScrollViewApi::GetCurrentPage, SCROLLVIEW_API }, + { "ScrollToPosition", ScrollViewApi::ScrollToPosition, SCROLLVIEW_API }, + { "ScrollToPage", ScrollViewApi::ScrollToPage, SCROLLVIEW_API }, + { "ScrollToActor", ScrollViewApi::ScrollToActor, SCROLLVIEW_API }, + { "ScrollToSnapInterval", ScrollViewApi::ScrollToSnapInterval, SCROLLVIEW_API }, + { "SetScrollFlickAlphaFunction", ScrollViewApi::SetScrollFlickAlphaFunction, SCROLLVIEW_API }, + { "SetScrollSnapAlphaFunction", ScrollViewApi::SetScrollSnapAlphaFunction, SCROLLVIEW_API }, + { "SetSnapOvershootAlphaFunction", ScrollViewApi::SetSnapOvershootAlphaFunction, SCROLLVIEW_API }, + }; const unsigned int ControlFunctionTableCount = sizeof(ControlFunctionTable)/sizeof(ControlFunctionTable[0]); diff --git a/plugins/dali-script-v8/src/controls/control-wrapper.h b/plugins/dali-script-v8/src/controls/control-wrapper.h index dc4b636..8147d56 100644 --- a/plugins/dali-script-v8/src/controls/control-wrapper.h +++ b/plugins/dali-script-v8/src/controls/control-wrapper.h @@ -50,7 +50,8 @@ public: { UNKNOWN_CONTROL = -1, CONTROL = 0, - ITEMVIEW = 1 + ITEMVIEW = 1, + SCROLLVIEW = 2 }; /** diff --git a/plugins/dali-script-v8/src/controls/scroll-view-api.cpp b/plugins/dali-script-v8/src/controls/scroll-view-api.cpp new file mode 100644 index 0000000..969fbf7 --- /dev/null +++ b/plugins/dali-script-v8/src/controls/scroll-view-api.cpp @@ -0,0 +1,477 @@ +/* + * 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 "scroll-view-api.h" + +// EXTERNAL INCLUDES + +// INTERNAL INCLUDES +#include +#include +#include + +namespace Dali +{ + +namespace V8Plugin +{ + +namespace // unanmed namespace +{ + +Toolkit::ScrollView GetScrollView( v8::Isolate* isolate, const v8::FunctionCallbackInfo& args ) +{ + HandleWrapper* handleWrapper = HandleWrapper::Unwrap( isolate, args.This() ); + return Toolkit::ScrollView::DownCast( handleWrapper->mHandle ); +} + +} //unanmed namespace + +/*************************************** + * SCROLLVIEW API FUNCTIONS + ***************************************/ + +/** + * Constructor + * + * @for ScrollView + * @constructor + * @method ScrollView + * @return {Object} scrollView + */ +Toolkit::Control ScrollViewApi::New( const v8::FunctionCallbackInfo< v8::Value >& args ) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = Toolkit::ScrollView::New(); + return scrollView; +} + +/** + * Set the scroll mode of ScrollView. + * + * This defines whether scrolling is enabled horizontally or vertically, how + * scrolling is snapped, and the boundary in which the scroll view can pan. + * + * When no specific scroll mode is set, scroll view can scroll to any position + * both horizontally and vertically and no snapping is enabled. + * + * Example of setting the scroll boundary of scroll view in the X axis to + * three pages (page size equals to the width of scroll view) and allowing + * snapping between pages, and disabling scrolling in the Y axis. + * + * ``` + * var scrollMode = { + * xAxisScrollEnabled : true, + * xAxisSnapToInterval : scrollView.sizeWidth, + * xAxisScrollBoundary : scrollView.sizeWidth * 3, + * yAxisScrollEnabled : false + * } + * + * scrollView.setScrollMode(scrollMode); + * ``` + * + * @for ScrollView + * @method setScrollMode + * @param {Object} scrollMode + * @param {Boolean} scrollMode.xAxisScrollEnabled True if the content can be scrolled in X axis or false if not. + * @param {Float} [scrollMode.xAxisSnapToInterval] When set, causes scroll view to snap to multiples of the value of the interval in the X axis while flicking. (by default no snapping) + * @param {Float} [scrollMode.xAxisScrollBoundary] When set, causes scroll view unable to scroll beyond the value of the boundary in the X axis (by default no boundary) + * @param {Boolean} scrollMode.yAxisScrollEnabled True if the content can be scrolled in Y axis or false if not. + * @param {Float} [scrollMode.yAxisSnapToInterval] When set, causes scroll view to snap to multiples of the value of the interval in the Y axis while flicking. (by default no snapping) + * @param {Float} [scrollMode.yAxisScrollBoundary] When set, causes scroll view unable to scroll beyond the value of the boundary in the Y axis (by default no boundary) + */ +void ScrollViewApi::SetScrollMode( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + v8::Local scrollMode( args[0] ); + if( !scrollMode->IsObject() ) + { + DALI_SCRIPT_EXCEPTION( isolate, "invalid scroll mode parameter" ); + return; + } + + v8::Local scrollModeObj = scrollMode->ToObject(); + + Toolkit::RulerPtr rulerX, rulerY; + + // Check the scroll mode in the X axis + bool xAxisScrollEnabled = true; + v8::Local xAxisScrollEnabledValue= scrollModeObj->Get( v8::String::NewFromUtf8( isolate, "xAxisScrollEnabled" ) ); + if( xAxisScrollEnabledValue->IsBoolean() ) + { + xAxisScrollEnabled = xAxisScrollEnabledValue->ToBoolean()->Value(); + } + else + { + DALI_SCRIPT_EXCEPTION( isolate, "Missing xAxisScrollEnabled"); + return; + } + + if(!xAxisScrollEnabled) + { + // Default ruler and disabled + rulerX = new Toolkit::DefaultRuler(); + rulerX->Disable(); + } + else + { + v8::Local xAxisSnapToIntervalValue= scrollModeObj->Get( v8::String::NewFromUtf8( isolate, "xAxisSnapToInterval" ) ); + if( xAxisSnapToIntervalValue->IsNumber() ) + { + // Fixed ruler and enabled + float xAxisSnapToInterval = xAxisSnapToIntervalValue->ToNumber()->Value(); + rulerX = new Toolkit::FixedRuler(xAxisSnapToInterval); + } + else + { + // Default ruler and enabled + rulerX = new Toolkit::DefaultRuler(); + } + + v8::Local xAxisScrollBoundaryValue= scrollModeObj->Get( v8::String::NewFromUtf8( isolate, "xAxisScrollBoundary" ) ); + if( xAxisScrollBoundaryValue->IsNumber() ) + { + // By default ruler domain is disabled unless set + float xAxisScrollBoundary = xAxisScrollBoundaryValue->ToNumber()->Value(); + rulerX->SetDomain( Toolkit::RulerDomain( 0, xAxisScrollBoundary, true ) ); + } + } + + // Check the scroll mode in the Y axis + bool yAxisScrollEnabled = true; + v8::Local yAxisScrollEnabledValue= scrollModeObj->Get( v8::String::NewFromUtf8( isolate, "yAxisScrollEnabled" ) ); + if( yAxisScrollEnabledValue->IsBoolean() ) + { + yAxisScrollEnabled = yAxisScrollEnabledValue->ToBoolean()->Value(); + } + else + { + DALI_SCRIPT_EXCEPTION( isolate, "Missing yAxisScrollEnabled"); + return; + } + + if(!yAxisScrollEnabled) + { + // Default ruler and disabled + rulerY = new Toolkit::DefaultRuler(); + rulerY->Disable(); + } + else + { + v8::Local yAxisSnapToIntervalValue= scrollModeObj->Get( v8::String::NewFromUtf8( isolate, "yAxisSnapToInterval" ) ); + if( yAxisSnapToIntervalValue->IsNumber() ) + { + // Fixed ruler and enabled + float yAxisSnapToInterval = yAxisSnapToIntervalValue->ToNumber()->Value(); + rulerY = new Toolkit::FixedRuler(yAxisSnapToInterval); + } + else + { + // Default ruler and enabled + rulerY = new Toolkit::DefaultRuler(); + } + + v8::Local yAxisScrollBoundaryValue= scrollModeObj->Get( v8::String::NewFromUtf8( isolate, "yAxisScrollBoundary" ) ); + if( yAxisScrollBoundaryValue->IsNumber() ) + { + // By default ruler domain is disabled unless set + float yAxisScrollBoundary = yAxisScrollBoundaryValue->ToNumber()->Value(); + rulerY->SetDomain( Toolkit::RulerDomain( 0, yAxisScrollBoundary, true ) ); + } + } + + scrollView.SetRulerX(rulerX); + scrollView.SetRulerY(rulerY); +} + +/** + * Retrieves current scroll page based on the defined snap interval being the + * size of one page, and all pages laid out in a grid fashion, increasing from + * left to right until the end of the scroll boundary. Pages start from 0 as the + * first page. + * + * If no snap interval is defined, this API will return undefined value. + * + * @for ScrollView + * @method getCurrentPage + * @return {Integer} The index of current page in scroll view + */ +void ScrollViewApi::GetCurrentPage( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + args.GetReturnValue().Set( v8::Integer::New( isolate, scrollView.GetCurrentPage() ) ); +} + +/** + * Scrolls the contents to the given position. + * + * Position 0,0 is the origin. Increasing X scrolls contents left, while + * increasing Y scrolls contents up. If Rulers have been applied to the axes, + * then the contents will scroll until reaching the scroll boundary. + * Contents will not snap. + * + * The biasing parameters are provided such that in scenarios with 2 or 2x2 pages + * in wrap mode, the application developer can decide whether to scroll left or + * right to get to the target page. + * + * @for ScrollView + * @method scrollToPosition + * @param {Array} position The position to scroll to. + * @param {Float} [durationSeconds] The duration of the scroll animation in seconds (default value is scrollView.scrollSnapDuration) + * @param {Integer} [alphaFunction] The alpha function to use. + * @param {Integer} [horizontalBias] Whether to bias scrolling to left or right (by default no bias). + * @param {Integer} [verticalBias] Whether to bias scrolling to top or bottom (by default no bias). + * @example + * // scroll direction bias is one of the following + * dali.DIRECTION_BIAS_NONE // Don't bias scroll snap + * dali.DIRECTION_BIAS_LEFT // Bias scroll snap to Left + * dali.DIRECTION_BIAS_RIGHT // Bias scroll snap to Right + * + * scrollView.scrollToPosition( [150.0, 100.0], 0.5, dali.ALPHA_FUNCTION_EASE_IN_OUT, dali.DIRECTION_BIAS_LEFT, dali.DIRECTION_BIAS_NONE ); + */ +void ScrollViewApi::ScrollToPosition( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + bool found( false ); + Vector2 position = V8Utils::GetVector2Parameter( PARAMETER_0, found, isolate, args ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad position parameter" ); + return; + } + + float durationSeconds = V8Utils::GetFloatParameter( PARAMETER_1, found, isolate, args, scrollView.GetScrollSnapDuration() ); + + AlphaFunction alphaFunction = scrollView.GetScrollSnapAlphaFunction(); + + found = false; + int alpha = V8Utils::GetIntegerParameter( PARAMETER_2, found, isolate, args, 0 ); + if(found) + { + alphaFunction = static_cast(alpha); + } + + Toolkit::DirectionBias horizontalBias = static_cast( V8Utils::GetIntegerParameter( PARAMETER_3, found, isolate, args, Toolkit::DirectionBiasNone ) ); + Toolkit::DirectionBias verticalBias = static_cast( V8Utils::GetIntegerParameter( PARAMETER_4, found, isolate, args, Toolkit::DirectionBiasNone ) ); + + scrollView.ScrollTo( position, durationSeconds, alphaFunction, horizontalBias, verticalBias ); +} + +/** + * Scrolls the contents to the page with the given index. + * + * This is based on assumption that the page index starts from 0 and the + * position of each page is: [pageIndex * snapToInterval, 0]. + * + * If no snap interval is defined, calling this API will cause unexpected + * behaviour. + * + * The biasing parameter is provided such that in scenarios with 2 pages + * in wrap mode, the application developer can decide whether to scroll + * left or right to get to the target page. + * + * @for ScrollView + * @method scrollToPage + * @param {Integer} pageIndex The index of the page to scroll to. + * @param {Float} [durationSeconds] The duration of the scroll animation in seconds (default value is scrollView.scrollSnapDuration) + * @param {Integer} [bias] Whether to bias scrolling to left or right (by default no bias). + * @example + * // scroll direction bias is one of the following + * dali.DIRECTION_BIAS_NONE // Don't bias scroll snap + * dali.DIRECTION_BIAS_LEFT // Bias scroll snap to Left + * dali.DIRECTION_BIAS_RIGHT // Bias scroll snap to Right + * + * scrollView.scrollToPage( 1, 0.5, dali.DIRECTION_BIAS_RIGHT ); + */ +void ScrollViewApi::ScrollToPage( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + bool found( false ); + int pageIndex = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "bad page index parameter" ); + return; + } + + float durationSeconds = V8Utils::GetFloatParameter( PARAMETER_1, found, isolate, args, scrollView.GetScrollSnapDuration() ); + Toolkit::DirectionBias bias = static_cast( V8Utils::GetIntegerParameter( PARAMETER_2, found, isolate, args, Toolkit::DirectionBiasNone ) ); + + scrollView.ScrollTo( pageIndex, durationSeconds, bias ); +} + +/** + * Scrolls the contents such that the given actor appears in the center of + * the scroll view. + * + * The actor must be a direct child of scroll view. + * + * @for ScrollView + * @method scrollToActor + * @param {Object} actor The actor to scroll to. + * @param {Float} [durationSeconds] The duration of the scroll animation in seconds (default value is scrollView.scrollSnapDuration) + * @example + * scrollView.scrollToActor( childActor, 0.5 ); + */ +void ScrollViewApi::ScrollToActor( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + bool found( false ); + Actor actor = V8Utils::GetActorParameter( 0, found, isolate, args ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "invalid actor parameter" ); + return; + } + + float durationSeconds = V8Utils::GetFloatParameter( PARAMETER_1, found, isolate, args, scrollView.GetScrollSnapDuration() ); + + scrollView.ScrollTo( actor, durationSeconds ); +} + +/** + * Scrolls the content to the nearest snap point as specified by the snap interval. + * If already at snap points, it will not scroll. + * + * @for ScrollView + * @method scrollToSnapInterval + * @return {Boolean} True if snapping is needed or false if already at snap points + * @example + * var success = scrollView.scrollToSnapInterval(); + */ +void ScrollViewApi::ScrollToSnapInterval( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + args.GetReturnValue().Set( v8::Boolean::New( isolate, scrollView.ScrollToSnapPoint() ) ); +} + +/** + * Set the alpha function of flick animation. + * + * @for ScrollView + * @method setScrollFlickAlphaFunction + * @param {Integer} alphaFunction The alpha function to use. + * @example + * scrollView.setScrollFlickAlphaFunction( dali.ALPHA_FUNCTION_EASE_IN_OUT ); + */ +void ScrollViewApi::SetScrollFlickAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + bool found( false ); + int alphaFunction = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "invalid alpha function parameter" ); + return; + } + else + { + scrollView.SetScrollFlickAlphaFunction( static_cast(alphaFunction) ); + } +} + +/** + * Set the alpha function of snap animation. + * + * @for ScrollView + * @method setScrollSnapAlphaFunction + * @param {String} alphaFunction The alpha function to use. + * @example + * scrollView.setScrollSnapAlphaFunction( dali.ALPHA_FUNCTION_EASE_IN_OUT ); + */ +void ScrollViewApi::SetScrollSnapAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + bool found( false ); + int alphaFunction = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "invalid alpha function parameter" ); + return; + } + else + { + scrollView.SetScrollSnapAlphaFunction( static_cast(alphaFunction) ); + } +} + +/** + * Set the alpha function of overshoot snap animation. + * + * @for ScrollView + * @method setSnapOvershootAlphaFunction + * @param {String} alphaFunction The alpha function to use. + * @example + * scrollView.setSnapOvershootAlphaFunction( dali.ALPHA_FUNCTION_EASE_IN_OUT ); + */ +void ScrollViewApi::SetSnapOvershootAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args) +{ + v8::Isolate* isolate = args.GetIsolate(); + v8::HandleScope handleScope( isolate ); + + Toolkit::ScrollView scrollView = GetScrollView( isolate, args ); + + bool found( false ); + int alphaFunction = V8Utils::GetIntegerParameter( PARAMETER_0, found, isolate, args, 0 ); + if( !found ) + { + DALI_SCRIPT_EXCEPTION( isolate, "invalid alpha function parameter" ); + return; + } + else + { + scrollView.SetSnapOvershootAlphaFunction( static_cast(alphaFunction) ); + } +} + +} // namespace V8Plugin + +} // namespace Dali diff --git a/plugins/dali-script-v8/src/controls/scroll-view-api.h b/plugins/dali-script-v8/src/controls/scroll-view-api.h new file mode 100644 index 0000000..0ca74db --- /dev/null +++ b/plugins/dali-script-v8/src/controls/scroll-view-api.h @@ -0,0 +1,58 @@ +#ifndef __DALI_V8PLUGIN_SCROLL_VIEW_API_H__ +#define __DALI_V8PLUGIN_SCROLL_VIEW_API_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 + +namespace Dali +{ + +namespace V8Plugin +{ + +namespace ScrollViewApi +{ + + /** + * constructor + */ + Toolkit::Control New( const v8::FunctionCallbackInfo< v8::Value >& args ); + + /** + * ScrollView API. See scroll-view.h for description of functions + */ + void SetScrollMode( const v8::FunctionCallbackInfo< v8::Value >& args); + void GetCurrentPage( const v8::FunctionCallbackInfo< v8::Value >& args ); + void ScrollToPosition( const v8::FunctionCallbackInfo< v8::Value >& args ); + void ScrollToPage( const v8::FunctionCallbackInfo< v8::Value >& args ); + void ScrollToActor( const v8::FunctionCallbackInfo< v8::Value >& args ); + void ScrollToSnapInterval( const v8::FunctionCallbackInfo< v8::Value >& args ); + void SetScrollFlickAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args ); + void SetScrollSnapAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args ); + void SetSnapOvershootAlphaFunction( const v8::FunctionCallbackInfo< v8::Value >& args ); + +}; // namespace ScrollViewApi + +} // namespace V8Plugin + +} // namespace Dali + +#endif // header __DALI_V8PLUGIN_SCROLL_VIEW_API_H__ 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 0bd9840..0efc17e 100644 --- a/plugins/dali-script-v8/src/shared/base-wrapped-object.h +++ b/plugins/dali-script-v8/src/shared/base-wrapped-object.h @@ -82,6 +82,7 @@ public: ACTOR_PROPERTY, ITEMVIEW, ITEMFACTORY, + SCROLLVIEW, RENDER_TASK, RENDER_TASK_LIST, TIMER, -- 2.7.4