/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
#include <dali/public-api/events/pan-gesture-detector.h>
#include <dali/public-api/object/any.h>
#include <dali/public-api/images/image.h>
-#include <dali/public-api/events/touch-event.h>
+#include <dali/public-api/events/touch-data.h>
#include <dali/public-api/events/hover-event.h>
-#include <dali/public-api/events/mouse-wheel-event.h>
+#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/events/key-event.h>
#include <dali/public-api/events/pan-gesture.h>
+#include <dali/public-api/object/weak-handle.h>
// INTERNAL INCLUDES
#include <v8-utils.h>
namespace // un-named namespace
{
-const char* const SIGNAL_TOUCHED = "touched";
+const char* const SIGNAL_TOUCH = "touch";
const char* const SIGNAL_HOVERED = "hovered";
-const char* const SIGNAL_MOUSE_WHEEL_EVENT = "mouse-wheel-event";
-const char* const SIGNAL_ON_STAGE = "on-stage";
-const char* const SIGNAL_OFF_STAGE = "off-stage";
+const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
+const char* const SIGNAL_ON_STAGE = "onStage";
+const char* const SIGNAL_OFF_STAGE = "offStage";
const char* const ANIMATION_SIGNAL_FINISHED = "finished";
-const char* const SIGNAL_PAN_DETECTED = "pan-detected";
+const char* const SIGNAL_PAN_DETECTED = "panDetected";
-const char* const STAGE_SIGNAL_KEY_EVENT = "key-event";
-const char* const STAGE_SIGNAL_EVENT_PROCESSING_FINISHED = "event-processing-finished";
-const char* const STAGE_SIGNAL_TOUCHED = "touched";
-const char* const SIGNAL_IMAGE_LOADING_FINISHED = "image-loading-finished";
+const char* const STAGE_SIGNAL_KEY_EVENT = "keyEvent";
+const char* const STAGE_SIGNAL_EVENT_PROCESSING_FINISHED = "eventProcessingFinished";
+const char* const STAGE_SIGNAL_TOUCH = "touch";
+const char* const SIGNAL_IMAGE_LOADING_FINISHED = "imageLoadingFinished";
const char* const SIGNAL_IMAGE_UPLOADED = "uploaded";
-const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_PRE_FOCUS_CHANGE = "keyboard-pre-focus-change";
-const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_CHANGED = "keyboard-focus-changed";
-const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_GROUP_CHANGED = "keyboard-focus-group-changed";
-const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUSED_ACTOR_ACTIVATED = "keyboard-focused-actor-activated";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_PRE_FOCUS_CHANGE = "keyboardPreFocusChange";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_CHANGED = "keyboardFocusChanged";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUS_GROUP_CHANGED = "keyboardFocusGroupChanged";
+const char* const KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUSED_ACTOR_ENTER_KEY = "keyboardFocusedActorEnterKey";
const unsigned int MAX_SIGNAL_NAME_LENGTH = 64;
} // un-named name space
{
public:
- ActorCallback(v8::Isolate* isolate, const v8::Local<v8::Function>& callback ,const std::string& signalName )
- : BaseCallBack( isolate, callback, signalName )
+ ActorCallback(v8::Isolate* isolate, const v8::Local<v8::Function>& callback ,const std::string& signalName, Actor actor )
+ : BaseCallBack( isolate, callback, signalName ),
+ mActor(actor)
{
}
- bool OnTouch( Actor actor, const TouchEvent& event)
+ bool OnTouch( Actor actor, const TouchData& touch )
{
std::vector< Dali::Any > arguments; // Dali::Vector considers Dali::Any to be a non trivial type so won't compile
Dali::Any returnValue(false);
arguments.push_back( actor );
- arguments.push_back( event );
+ arguments.push_back( touch );
CallJavaScript( returnValue, arguments );
bool ret;
returnValue.Get(ret);
returnValue.Get(ret);
return ret;
}
- bool OnMouseWheel( Actor actor, const MouseWheelEvent& event)
+ bool OnWheel( Actor actor, const WheelEvent& event)
{
std::vector< Dali::Any > arguments;
Dali::Any returnValue(false);
CallJavaScript( returnValue, arguments );
}
-private:
+ WeakHandle< Actor > mActor;
+
+};
+
+struct ActorGenericCallbackFunctor
+{
+ ActorGenericCallbackFunctor(ActorCallback& callback) : callback(callback) { }
+ void operator()()
+ {
+ std::vector< Dali::Any > arguments;
+ Dali::Any returnValue; //no return
+ arguments.push_back(callback.mActor.GetHandle()); //pass the actor handle as the parameter
+ callback.CallJavaScript( returnValue, arguments );
+ }
+ ActorCallback& callback;
};
Dali::Any returnValue; //no return
CallJavaScript( returnValue, arguments );
}
- void TouchedSignal( const TouchEvent& touchEvent)
+ void TouchSignal( const TouchData& touch )
{
std::vector< Dali::Any > arguments;
Dali::Any returnValue; //no return
- arguments.push_back( touchEvent );
+ arguments.push_back( touch );
CallJavaScript( returnValue, arguments );
}
};
Actor PreFocusChangeSignal(Actor currentFocusedActor,
Actor proposedActorToFocus,
- Toolkit::Control::KeyboardFocusNavigationDirection direction )
+ Toolkit::Control::KeyboardFocus::Direction direction )
{
std::vector< Dali::Any > arguments;
Dali::Any returnValue = Actor(); // we want an actor as a return value
arguments.push_back( forward );
CallJavaScript( returnValue, arguments );
}
- void FocusedActorSignal( Actor activatedActor )
+ void EnterKeyPressedActorSignal( Actor enterKeyPressedActor )
{
std::vector< Dali::Any > arguments;
Dali::Any returnValue; //no return
- arguments.push_back( activatedActor );
+ arguments.push_back( enterKeyPressedActor );
CallJavaScript( returnValue, arguments );
}
};
{
bool connected(true);
- ActorCallback* callback =new ActorCallback( isolate, javaScriptCallback, signalName );
+ ActorCallback* callback =new ActorCallback( isolate, javaScriptCallback, signalName, actor );
- if( strcmp( signalName.c_str(), SIGNAL_TOUCHED ) == 0 )
+ if( strcmp( signalName.c_str(), SIGNAL_TOUCH ) == 0 )
{
- actor.TouchedSignal().Connect( callback, &ActorCallback::OnTouch );
+ actor.TouchSignal().Connect( callback, &ActorCallback::OnTouch );
}
else if( strcmp( signalName.c_str(), SIGNAL_HOVERED ) == 0 )
{
actor.HoveredSignal().Connect( callback, &ActorCallback::OnHover );
}
- else if ( strcmp( signalName.c_str(), SIGNAL_MOUSE_WHEEL_EVENT ) == 0 )
+ else if ( strcmp( signalName.c_str(), SIGNAL_WHEEL_EVENT ) == 0 )
{
- actor.MouseWheelEventSignal().Connect( callback, &ActorCallback::OnMouseWheel );
+ actor.WheelEventSignal().Connect( callback, &ActorCallback::OnWheel );
}
else if ( strcmp( signalName.c_str(), SIGNAL_ON_STAGE ) == 0 )
{
}
else
{
- connected = false;
+ connected = actor.ConnectSignal( callback, signalName, ActorGenericCallbackFunctor(*callback) );
}
if( connected )
else
{
delete callback;
+ DALI_SCRIPT_EXCEPTION( isolate, "the signal is not available in this object.");
}
}
{
stage.EventProcessingFinishedSignal().Connect( callback, &StageCallback::EventProcessingFinishedSignal );
}
- else if (strcmp( signalName.c_str(), STAGE_SIGNAL_TOUCHED ) == 0 )
+ else if (strcmp( signalName.c_str(), STAGE_SIGNAL_TOUCH ) == 0 )
{
- stage.TouchedSignal().Connect( callback, &StageCallback::TouchedSignal );
+ stage.TouchSignal().Connect( callback, &StageCallback::TouchSignal );
}
else
{
{
keyboardFocusManager.FocusGroupChangedSignal().Connect( callback, &KeyboardFocusCallback::FocusGroupSignal );
}
- else if ( strcmp( signalName.c_str(), KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUSED_ACTOR_ACTIVATED ) == 0 )
+ else if ( strcmp( signalName.c_str(), KEYBOARD_FOCUS_MANAGER_SIGNAL_FOCUSED_ACTOR_ENTER_KEY ) == 0 )
{
- keyboardFocusManager.FocusedActorActivatedSignal().Connect( callback, &KeyboardFocusCallback::FocusedActorSignal );
+ keyboardFocusManager.FocusedActorEnterKeySignal().Connect( callback, &KeyboardFocusCallback::EnterKeyPressedActorSignal );
}
else
{
// first paramter = signal to connect to
// Second parameter = function ( to run )
// args.This() = myActor
- // e.g. myActor.Connect("touched", myJavaScriptActorTouched );
+ // e.g. myActor.Connect("touch", myJavaScriptActorTouched );
// Inside Callback on myJavaScriptActorTouched
- // myActor.Disconnect("touched", myJavaScriptActorTouched );
+ // myActor.Disconnect("touch", myJavaScriptActorTouched );
v8::Isolate* isolate = args.GetIsolate();
v8::HandleScope handleScope( isolate );
// see if we're connecting to an Actor
switch( baseObject->GetType() )
{
- case BaseWrappedObject::ACTOR:
- {
- ActorWrapper* actorWrapper = static_cast< ActorWrapper*>( baseObject );
- ActorConnection( isolate, func, actorWrapper, signal, actorWrapper->GetActor() );
- break;
- }
- case BaseWrappedObject::ANIMATION:
- {
- AnimationWrapper* animWrapper = static_cast< AnimationWrapper*>( baseObject );
- AnimationConnection( isolate, func, animWrapper, signal, animWrapper->GetAnimation() );
- break;
- }
- case BaseWrappedObject::IMAGE:
- {
- ImageWrapper* imageWrapper = static_cast< ImageWrapper*>( baseObject );
- ImageConnection( isolate, func, imageWrapper, signal, imageWrapper->GetImage() );
- break;
- }
- case BaseWrappedObject::STAGE:
- {
- StageWrapper* stageWrapper = static_cast< StageWrapper*>( baseObject );
- StageConnection( isolate, func, stageWrapper, signal, stageWrapper->GetStage() );
- break;
- }
- case BaseWrappedObject::KEYBOARD_FOCUS_MANAGER:
- {
- KeyboardFocusManagerWrapper* keyboardFocusWrapper = static_cast< KeyboardFocusManagerWrapper*>( baseObject );
- KeyboardFocusManagerConnection( isolate, func, keyboardFocusWrapper, signal, keyboardFocusWrapper->GetKeyboardFocusManager() );
- break;
- }
- case BaseWrappedObject::PAN_GESTURE_DETECTOR:
- {
- PanGestureDetectorWrapper* panGestureDetectorWrapper = static_cast< PanGestureDetectorWrapper*>( baseObject );
- PanGestureDetectorConnection( isolate, func, panGestureDetectorWrapper, signal, panGestureDetectorWrapper->GetPanGestureDetector() );
- break;
- }
- default:
- {
- DALI_SCRIPT_EXCEPTION( isolate, "object does not support connections");
- break;
- }
+ case BaseWrappedObject::ACTOR:
+ {
+ ActorWrapper* actorWrapper = static_cast< ActorWrapper*>( baseObject );
+ ActorConnection( isolate, func, actorWrapper, signal, actorWrapper->GetActor() );
+ break;
+ }
+ case BaseWrappedObject::ANIMATION:
+ {
+ AnimationWrapper* animWrapper = static_cast< AnimationWrapper*>( baseObject );
+ AnimationConnection( isolate, func, animWrapper, signal, animWrapper->GetAnimation() );
+ break;
+ }
+ case BaseWrappedObject::IMAGE:
+ {
+ ImageWrapper* imageWrapper = static_cast< ImageWrapper*>( baseObject );
+ ImageConnection( isolate, func, imageWrapper, signal, imageWrapper->GetImage() );
+ break;
+ }
+ case BaseWrappedObject::STAGE:
+ {
+ StageWrapper* stageWrapper = static_cast< StageWrapper*>( baseObject );
+ StageConnection( isolate, func, stageWrapper, signal, stageWrapper->GetStage() );
+ break;
+ }
+ case BaseWrappedObject::KEYBOARD_FOCUS_MANAGER:
+ {
+ KeyboardFocusManagerWrapper* keyboardFocusWrapper = static_cast< KeyboardFocusManagerWrapper*>( baseObject );
+ KeyboardFocusManagerConnection( isolate, func, keyboardFocusWrapper, signal, keyboardFocusWrapper->GetKeyboardFocusManager() );
+ break;
+ }
+ case BaseWrappedObject::PAN_GESTURE_DETECTOR:
+ {
+ PanGestureDetectorWrapper* panGestureDetectorWrapper = static_cast< PanGestureDetectorWrapper*>( baseObject );
+ PanGestureDetectorConnection( isolate, func, panGestureDetectorWrapper, signal, panGestureDetectorWrapper->GetPanGestureDetector() );
+ break;
+ }
+ default:
+ {
+ DALI_SCRIPT_EXCEPTION( isolate, "object does not support connections");
+ break;
+ }
}
}