plugins/dali-script-v8/src/events/event-object-generator.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 "event-object-generator.h"
  20
  21 // INTERNAL INCLUDES
  22 #include <v8-utils.h>
  23 #include <actors/actor-wrapper.h>
  24 #include <object/property-value-wrapper.h>
  25
  26 namespace Dali
  27 {
  28
  29 namespace V8Plugin
  30 {
  31
  32 namespace
  33 {
  34
  35 struct PointState
  36 {
  37   TouchPoint::State state;
  38   const char* name;
  39 };
  40
  41 const PointState PointStateLookup[]=
  42 {
  43     { TouchPoint::Down,         "down"        },       /**< Screen touched */
  44     { TouchPoint::Up,           "up"          },       /**< Touch stopped */
  45     { TouchPoint::Motion,       "motion"      },       /**< Touch stopped */
  46     { TouchPoint::Leave,        "leave"       },       /**< Touch stopped */
  47     { TouchPoint::Stationary,   "stationary"  },       /**< Touch stopped */
  48     { TouchPoint::Interrupted,  "interrupt"   },       /**< Touch stopped */
  49     { TouchPoint::Started,      "started"     },       /**< Touch or hover started */
  50     { TouchPoint::Finished,     "finished"    },       /**< Touch or hover finished */
  51 };
  52
  53 const unsigned int PointStateLookupCount = sizeof(PointStateLookup)/sizeof(PointStateLookup[0]);
  54
  55 struct GestureState
  56 {
  57   Gesture::State state;
  58   const char* name;
  59 };
  60
  61 const GestureState GestureStateLookup[]=
  62 {
  63     { Gesture::Clear,      "clear"        },       /**< No state associated */
  64     { Gesture::Started,    "started"      },       /**< Gesture started */
  65     { Gesture::Continuing, "continuing"   },       /**< Gesture continuing */
  66     { Gesture::Finished,   "finished"     },       /**< Gesture finished */
  67     { Gesture::Cancelled,  "cancelled"    },       /**< Gesture cancelled */
  68     { Gesture::Possible,   "possible"     },       /**< Gesture is possible */
  69 };
  70
  71 const unsigned int GestureStateLookupCount = sizeof(GestureStateLookup)/sizeof(GestureStateLookup[0]);
  72
  73 const char* GetTouchPointStateName( TouchPoint::State state )
  74 {
  75   // could use the enum as index, but dali-core may change, so for now just do a lookup
  76   for( unsigned int i = 0; i < PointStateLookupCount; i++ )
  77   {
  78     if( PointStateLookup[i].state == state )
  79     {
  80       return PointStateLookup[i].name;
  81     }
  82   }
  83   return "error point state not found";
  84 }
  85
  86 const char* GetGestureStateName( Gesture::State state )
  87 {
  88   // could use the enum as index, but dali-core may change, so for now just do a lookup
  89   for( unsigned int i = 0; i < GestureStateLookupCount; i++ )
  90   {
  91     if( GestureStateLookup[i].state == state )
  92     {
  93       return GestureStateLookup[i].name;
  94     }
  95   }
  96   return "error gesture state not found";
  97 }
  98
  99 // create a point object, x,y
 100 v8::Local<v8::Object> CreateTouchPoint( v8::Isolate* isolate, const TouchPoint& touchPoint )
 101 {
 102   /*
 103    * touch point object
 104    *
 105    *   { "deviceId",  int }  Each touch point has a unique device ID
 106    *   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
 107    *   { "hitActor", actor } actor that was hit ( wrapped dali object)
 108    *   { "local",  {x,y} } co-ordinates of top left of hit actor
 109    *   { "screen", {x,y} } co-ordinates of top left of hit actor
 110    */
 111   v8::EscapableHandleScope handleScope( isolate );
 112
 113   v8::Local<v8::Object> pointObject = v8::Object::New( isolate );
 114
 115   // set device id
 116   pointObject->Set( v8::String::NewFromUtf8( isolate, "deviceId"), v8::Integer::New( isolate, touchPoint.deviceId ));
 117
 118   // set state
 119   pointObject->Set( v8::String::NewFromUtf8( isolate, "state"), v8::String::NewFromUtf8( isolate, GetTouchPointStateName(touchPoint.state)));
 120
 121   // set the hit actor
 122   pointObject->Set( v8::String::NewFromUtf8( isolate, "hitActor"), ActorWrapper::WrapActor(isolate, touchPoint.hitActor ));
 123
 124   // Think about changing these Vector 2 from wrapped objects to JavaScript objects...
 125
 126   // Set the local co-ordinates
 127   v8::Local<v8::Object> localPointObject = v8::Object::New( isolate );
 128   localPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, touchPoint.local.x) );
 129   localPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, touchPoint.local.y) );
 130   pointObject->Set( v8::String::NewFromUtf8( isolate, "local"),  localPointObject);
 131
 132
 133   // set the screen co-ordinates
 134   v8::Local<v8::Object> screenPointObject = v8::Object::New( isolate );
 135   screenPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, touchPoint.screen.x) );
 136   screenPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, touchPoint.screen.y) );
 137   pointObject->Set( v8::String::NewFromUtf8( isolate, "screen"), screenPointObject );
 138
 139
 140   return handleScope.Escape( pointObject );
 141 }
 142
 143 } // un-named namespace
 144
 145
 146 v8::Handle<v8::Object> EventObjectGenerator::CreateTouchEvent( v8::Isolate* isolate, const TouchEvent& touchEvent)
 147 {
 148   // we are creating a touch event object that looks like this
 149   //
 150   //  event.pointCount = points touched
 151   //  event.time       = The time (in ms) that the touch event occurred.
 152   //  event.point[]    = array of TouchPoints
 153   //
 154   // A TouchPoint =
 155   //   { "deviceId",  int }  Each touch point has a unique device ID
 156   //   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
 157   //   { "sourceActor", actor }  the actor that is emitting the callback (the actor that is hit maybe a child of it)
 158   //   { "hitActor", actor } actor that was hit
 159   //   { "local",  {x,y} } co-ordinates of top left of hit actor
 160   //   { "screen", {x,y} } co-ordinates of top left of hit actor
 161   //
 162
 163   v8::EscapableHandleScope handleScope( isolate );
 164
 165   v8::Local<v8::Object> touchObject = v8::Object::New( isolate );
 166
 167   // Set the pointCount
 168   touchObject->Set( v8::String::NewFromUtf8( isolate, "pointCount" ), v8::Integer::New( isolate, touchEvent.GetPointCount() ) );
 169
 170   // Set the time
 171   touchObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, touchEvent.time ) );
 172
 173   // Set the emitting actor
 174   // touchObject->Set( v8::String::NewFromUtf8( isolate, "sourceActor" ), ActorWrapper::WrapActor(isolate, emittingActor));
 175
 176   // Create the array of touch points
 177   v8::Local < v8::Array > pointArrayObject = v8::Array::New( isolate, touchEvent.GetPointCount() );
 178   for( unsigned int i = 0 ; i < touchEvent.GetPointCount() ; ++i )
 179   {
 180     v8::Local < v8::Object > pointObject = CreateTouchPoint( isolate, touchEvent.points[i] );
 181     pointArrayObject->Set( v8::Number::New( isolate, i ), pointObject  );
 182   }
 183
 184   // set the array
 185   touchObject->Set( v8::String::NewFromUtf8( isolate, "points" ), pointArrayObject );
 186
 187   return handleScope.Escape( touchObject );
 188 }
 189
 190 v8::Handle<v8::Object> EventObjectGenerator::CreateHoverEvent( v8::Isolate* isolate, const HoverEvent& hoverEvent)
 191 {
 192   // we are creating a hover event object that looks like this
 193   //
 194   //  event.pointCount = points hovered
 195   //  event.time       = The time (in ms) that the hover event occurred.
 196   //  event.point[]    = array of TouchPoints
 197   //
 198   // A TouchPoint =
 199   //   { "deviceId",  int }  Each touch point has a unique device ID
 200   //   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
 201   //   { "sourceActor", actor }  the actor that is emitting the callback (the actor that is hit maybe a child of it)
 202   //   { "hitActor", actor } actor that was hit
 203   //   { "local",  {x,y} } co-ordinates of top left of hit actor
 204   //   { "screen", {x,y} } co-ordinates of top left of hit actor
 205   //
 206
 207   v8::EscapableHandleScope handleScope( isolate );
 208
 209   v8::Local<v8::Object> hoverObject = v8::Object::New( isolate );
 210
 211   // Set the pointCount
 212   hoverObject->Set( v8::String::NewFromUtf8( isolate, "pointCount" ), v8::Integer::New( isolate, hoverEvent.GetPointCount() ) );
 213
 214   // Set the time
 215   hoverObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, hoverEvent.time ) );
 216
 217   // Set the emitting actor
 218   // hoverObject->Set( v8::String::NewFromUtf8( isolate, "sourceActor" ), ActorWrapper::WrapActor(isolate, emittingActor));
 219
 220   // Create the array of touch points
 221   v8::Local < v8::Array > pointArrayObject = v8::Array::New( isolate, hoverEvent.GetPointCount() );
 222   for( unsigned int i = 0 ; i < hoverEvent.GetPointCount() ; ++i )
 223   {
 224     v8::Local < v8::Object > pointObject = CreateTouchPoint( isolate, hoverEvent.points[i] );
 225     pointArrayObject->Set( v8::Number::New( isolate, i ), pointObject  );
 226   }
 227
 228   // set the array
 229   hoverObject->Set( v8::String::NewFromUtf8( isolate, "points" ), pointArrayObject );
 230
 231   return handleScope.Escape( hoverObject );
 232 }
 233
 234 v8::Handle<v8::Object> EventObjectGenerator::CreateWheelEvent( v8::Isolate* isolate, const WheelEvent& wheelEvent)
 235 {
 236   //  we are creating a wheel event object that looks like this
 237   //
 238   //  event.type = "mouseWheel" or "customWheel" type of the wheel event
 239   //  event.direction = "vertical" or "horizontal" direction the wheel is being rolled
 240   //  event.shiftPressed       = boolean, shift key is held
 241   //  event.ctrlPressed        = boolean, ctrl key is held
 242   //  event.altPressed     = boolean, alt key is held
 243   //  event.keyModifiers = bitmask of keys pressed
 244   //  event.point {x,y}    = The co-ordinates of the mouse cursor relative to the top-left of the screen when the wheel is being rolled.
 245   //  event.rolled          = offset of wheel rolling, positive = rolling down or clockwise, negative = rolling up or counter-clockwise
 246   //  event.timestamp    = The time (in ms) that the touch event occurred
 247
 248   v8::EscapableHandleScope handleScope( isolate );
 249
 250   v8::Local<v8::Object> wheelObject = v8::Object::New( isolate );
 251
 252   // Set the type
 253   std::string type = wheelEvent.type ? "mouseWheel" : "customWheel";
 254   wheelObject->Set( v8::String::NewFromUtf8( isolate, "type" ), v8::String::NewFromUtf8( isolate, type.c_str() ) );
 255
 256   // Set the direction
 257   std::string direction = wheelEvent.direction ? "vertical" : "horizontal";
 258   wheelObject->Set( v8::String::NewFromUtf8( isolate, "direction" ), v8::String::NewFromUtf8( isolate, direction.c_str() ) );
 259
 260   // set shift / ctrl/ alt keys
 261   wheelObject->Set( v8::String::NewFromUtf8( isolate, "shiftPressed" ), v8::Boolean::New( isolate, wheelEvent.IsShiftModifier()) );
 262   wheelObject->Set( v8::String::NewFromUtf8( isolate, "ctrlPressed" ),  v8::Boolean::New( isolate, wheelEvent.IsCtrlModifier()) );
 263   wheelObject->Set( v8::String::NewFromUtf8( isolate, "altPressed" ),   v8::Boolean::New( isolate, wheelEvent.IsAltModifier()) );
 264
 265   // set keyModifiers
 266   wheelObject->Set( v8::String::NewFromUtf8( isolate, "keyModifiers" ),  v8::Integer::New( isolate, wheelEvent.modifiers) );
 267
 268   // set Point
 269   v8::Local<v8::Object> wheelPointObject = v8::Object::New( isolate );
 270   wheelPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, wheelEvent.point.x ) );
 271   wheelPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, wheelEvent.point.y ) );
 272   wheelObject->Set( v8::String::NewFromUtf8( isolate, "point"), wheelPointObject );
 273
 274   // set rolledAmout
 275   wheelObject->Set( v8::String::NewFromUtf8( isolate, "rolled" ),  v8::Integer::New( isolate, wheelEvent.z) );
 276
 277   // set timestamp
 278   wheelObject->Set( v8::String::NewFromUtf8( isolate, "timestamp" ),  v8::Integer::New( isolate, wheelEvent.timeStamp) );
 279
 280   return handleScope.Escape( wheelObject );
 281
 282 }
 283
 284 v8::Handle<v8::Object> EventObjectGenerator::CreateKeyEvent( v8::Isolate* isolate, const KeyEvent& keyEvent)
 285 {
 286   // keyCode
 287   // keyModifier
 288   // event.keyCode       = key code
 289   // event.key           = key presssed
 290   // event.keyDescription = key description, e.g. BackSpace
 291   // event.state = "down" or "up" key state
 292   // event.shiftPressed  = boolean, shift key is held
 293   // event.ctrlPressed   = boolean, ctrl key is held
 294   // event.altPressed    = boolean, alt key is held
 295   // event.keyModifiers  = key modifiers
 296   // event.timestamp     = Time stamp
 297
 298   v8::EscapableHandleScope handleScope( isolate );
 299
 300   v8::Local<v8::Object> keyObject = v8::Object::New( isolate );
 301
 302   // Set the direction
 303   std::string state ("up");
 304   if ( keyEvent.state == KeyEvent::Down)
 305   {
 306     state = "down";
 307   }
 308
 309   keyObject->Set( v8::String::NewFromUtf8( isolate, "state" ), v8::String::NewFromUtf8( isolate, state.c_str() ) );
 310
 311   // set keyCode
 312    keyObject->Set( v8::String::NewFromUtf8( isolate, "keyCode" ),  v8::Integer::New( isolate, keyEvent.keyCode) );
 313
 314   // set keyModifiers
 315   keyObject->Set( v8::String::NewFromUtf8( isolate, "keyModifier" ),  v8::Integer::New( isolate, keyEvent.keyModifier) );
 316
 317   // set Key pressed name
 318   keyObject->Set( v8::String::NewFromUtf8( isolate, "keyDescription" ),  v8::String::NewFromUtf8( isolate, keyEvent.keyPressedName.c_str() )  );
 319
 320   // set Key pressed
 321   keyObject->Set( v8::String::NewFromUtf8( isolate, "key" ),  v8::String::NewFromUtf8( isolate, keyEvent.keyPressed.c_str() )  );
 322
 323   // set time stamp
 324   keyObject->Set( v8::String::NewFromUtf8( isolate, "timestamp" ),  v8::Integer::New( isolate, keyEvent.time) );
 325
 326   // set shift / ctrl/ alt keys
 327   keyObject->Set( v8::String::NewFromUtf8( isolate, "shiftPressed" ), v8::Boolean::New( isolate, keyEvent.IsShiftModifier()) );
 328   keyObject->Set( v8::String::NewFromUtf8( isolate, "ctrlPressed" ),  v8::Boolean::New( isolate, keyEvent.IsCtrlModifier()) );
 329   keyObject->Set( v8::String::NewFromUtf8( isolate, "altPressed" ),   v8::Boolean::New( isolate, keyEvent.IsAltModifier()) );
 330
 331   return handleScope.Escape( keyObject );
 332
 333 }
 334
 335 v8::Handle<v8::Object> EventObjectGenerator::CreatePanGesture( v8::Isolate* isolate, const PanGesture& panGesture)
 336 {
 337   // gesture.numberOfTouches     = total number of fingers touching the screen
 338   // gesture.state               = pan state {Clear, Started, Continuing, Finished, Cancelled, Possible}
 339   // gesture.time                = Time stamp
 340   // gesture.velocity            = pan velocity in actor coordinates
 341   // gesture.displacement        = pan displacement in actor coordinates
 342   // gesture.position            = pan position in actor coordinates
 343   // gesture.screenVelocity      = pan velocity in screen coordinates
 344   // gesture.screenDisplacement  = pan displacement in screen coordinates
 345   // gesture.screenPosition      = pan position in screen coordinates
 346
 347   v8::EscapableHandleScope handleScope( isolate );
 348
 349   v8::Local<v8::Object> panObject = v8::Object::New( isolate );
 350
 351   // Set the numberOfTouches
 352   panObject->Set( v8::String::NewFromUtf8( isolate, "numberOfTouches" ), v8::Integer::New( isolate, panGesture.numberOfTouches ) );
 353
 354   // Set the state
 355   panObject->Set( v8::String::NewFromUtf8( isolate, "state"), v8::String::NewFromUtf8( isolate, GetGestureStateName(panGesture.state)));
 356
 357   // Set the time
 358   panObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, panGesture.time ) );
 359
 360   // Set the local velocity
 361   v8::Local<v8::Object> velocityObject = v8::Object::New( isolate );
 362   velocityObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.velocity.x) );
 363   velocityObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.velocity.y) );
 364   panObject->Set( v8::String::NewFromUtf8( isolate, "velocity"),  velocityObject);
 365
 366   // Set the local displacement
 367   v8::Local<v8::Object> displacementObject = v8::Object::New( isolate );
 368   displacementObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.displacement.x) );
 369   displacementObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.displacement.y) );
 370   panObject->Set( v8::String::NewFromUtf8( isolate, "displacement"),  displacementObject);
 371
 372   // Set the local position
 373   v8::Local<v8::Object> positionObject = v8::Object::New( isolate );
 374   positionObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.position.x) );
 375   positionObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.position.y) );
 376   panObject->Set( v8::String::NewFromUtf8( isolate, "position"),  positionObject);
 377
 378   // Set the screen velocity
 379   v8::Local<v8::Object> screenVelocityObject = v8::Object::New( isolate );
 380   screenVelocityObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenVelocity.x) );
 381   screenVelocityObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenVelocity.y) );
 382   panObject->Set( v8::String::NewFromUtf8( isolate, "screenVelocity"),  screenVelocityObject);
 383
 384   // Set the screen displacement
 385   v8::Local<v8::Object> screenDisplacementObject = v8::Object::New( isolate );
 386   screenDisplacementObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenDisplacement.x) );
 387   screenDisplacementObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenDisplacement.y) );
 388   panObject->Set( v8::String::NewFromUtf8( isolate, "screenDisplacement"),  screenDisplacementObject);
 389
 390   // Set the screen position
 391   v8::Local<v8::Object> screenPositionObject = v8::Object::New( isolate );
 392   screenPositionObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenPosition.x) );
 393   screenPositionObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenPosition.y) );
 394   panObject->Set( v8::String::NewFromUtf8( isolate, "screenPosition"),  screenPositionObject);
 395
 396   return handleScope.Escape( panObject );
 397
 398 }
 399
 400
 401
 402 } // V8Plugin
 403
 404 } // namespace Dali