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 TouchDataPointState
  36 {
  37   PointState::Type state;
  38   const char* name;
  39 };
  40
  41 const TouchDataPointState TouchDataPointStateLookup[]=
  42 {
  43     { PointState::DOWN,         "DOWN"        },
  44     { PointState::UP,           "UP"          },
  45     { PointState::MOTION,       "MOTION"      },
  46     { PointState::LEAVE,        "LEAVE"       },
  47     { PointState::STATIONARY,   "STATIONARY"  },
  48     { PointState::INTERRUPTED,  "INTERRUPT"   },
  49     { PointState::STARTED,      "STARTED"     },
  50     { PointState::FINISHED,     "FINISHED"    },
  51 };
  52
  53 const unsigned int TouchDataPointStateLookupCount = sizeof(TouchDataPointStateLookup)/sizeof(TouchDataPointStateLookup[0]);
  54
  55 struct TouchPointState
  56 {
  57   TouchPoint::State state;
  58   const char* name;
  59 };
  60
  61 const TouchPointState PointStateLookup[]=
  62 {
  63     { TouchPoint::Down,         "down"        },       /**< Screen touched */
  64     { TouchPoint::Up,           "up"          },       /**< Touch stopped */
  65     { TouchPoint::Motion,       "motion"      },       /**< Touch stopped */
  66     { TouchPoint::Leave,        "leave"       },       /**< Touch stopped */
  67     { TouchPoint::Stationary,   "stationary"  },       /**< Touch stopped */
  68     { TouchPoint::Interrupted,  "interrupt"   },       /**< Touch stopped */
  69     { TouchPoint::Started,      "started"     },       /**< Touch or hover started */
  70     { TouchPoint::Finished,     "finished"    },       /**< Touch or hover finished */
  71 };
  72
  73 const unsigned int PointStateLookupCount = sizeof(PointStateLookup)/sizeof(PointStateLookup[0]);
  74
  75 struct GestureState
  76 {
  77   Gesture::State state;
  78   const char* name;
  79 };
  80
  81 const GestureState GestureStateLookup[]=
  82 {
  83     { Gesture::Clear,      "clear"        },       /**< No state associated */
  84     { Gesture::Started,    "started"      },       /**< Gesture started */
  85     { Gesture::Continuing, "continuing"   },       /**< Gesture continuing */
  86     { Gesture::Finished,   "finished"     },       /**< Gesture finished */
  87     { Gesture::Cancelled,  "cancelled"    },       /**< Gesture cancelled */
  88     { Gesture::Possible,   "possible"     },       /**< Gesture is possible */
  89 };
  90
  91 const unsigned int GestureStateLookupCount = sizeof(GestureStateLookup)/sizeof(GestureStateLookup[0]);
  92
  93 const char* GetTouchDataPointStateName( PointState::Type state )
  94 {
  95   // could use the enum as index, but dali-core may change, so for now just do a lookup
  96   for( unsigned int i = 0; i < TouchDataPointStateLookupCount; i++ )
  97   {
  98     if( TouchDataPointStateLookup[i].state == state )
  99     {
 100       return TouchDataPointStateLookup[i].name;
 101     }
 102   }
 103   return "error point state not found";
 104 }
 105
 106 const char* GetTouchPointStateName( TouchPoint::State state )
 107 {
 108   // could use the enum as index, but dali-core may change, so for now just do a lookup
 109   for( unsigned int i = 0; i < PointStateLookupCount; i++ )
 110   {
 111     if( PointStateLookup[i].state == state )
 112     {
 113       return PointStateLookup[i].name;
 114     }
 115   }
 116   return "error point state not found";
 117 }
 118
 119 const char* GetGestureStateName( Gesture::State state )
 120 {
 121   // could use the enum as index, but dali-core may change, so for now just do a lookup
 122   for( unsigned int i = 0; i < GestureStateLookupCount; i++ )
 123   {
 124     if( GestureStateLookup[i].state == state )
 125     {
 126       return GestureStateLookup[i].name;
 127     }
 128   }
 129   return "error gesture state not found";
 130 }
 131
 132 // create a point object, x,y
 133 v8::Local<v8::Object> CreateTouchPoint( v8::Isolate* isolate, const TouchPoint& touchPoint )
 134 {
 135   /*
 136    * touch point object
 137    *
 138    *   { "deviceId",  int }  Each touch point has a unique device ID
 139    *   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
 140    *   { "hitActor", actor } actor that was hit ( wrapped dali object)
 141    *   { "local",  {x,y} } co-ordinates of top left of hit actor
 142    *   { "screen", {x,y} } co-ordinates of top left of hit actor
 143    */
 144   v8::EscapableHandleScope handleScope( isolate );
 145
 146   v8::Local<v8::Object> pointObject = v8::Object::New( isolate );
 147
 148   // set device id
 149   pointObject->Set( v8::String::NewFromUtf8( isolate, "deviceId"), v8::Integer::New( isolate, touchPoint.deviceId ));
 150
 151   // set state
 152   pointObject->Set( v8::String::NewFromUtf8( isolate, "state"), v8::String::NewFromUtf8( isolate, GetTouchPointStateName(touchPoint.state)));
 153
 154   if(touchPoint.hitActor)
 155   {
 156     // set the hit actor
 157     pointObject->Set( v8::String::NewFromUtf8( isolate, "hitActor"), ActorWrapper::WrapActor(isolate, touchPoint.hitActor ));
 158   }
 159
 160   // Think about changing these Vector 2 from wrapped objects to JavaScript objects...
 161
 162   // Set the local co-ordinates
 163   v8::Local<v8::Object> localPointObject = v8::Object::New( isolate );
 164   localPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, touchPoint.local.x) );
 165   localPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, touchPoint.local.y) );
 166   pointObject->Set( v8::String::NewFromUtf8( isolate, "local"),  localPointObject);
 167
 168
 169   // set the screen co-ordinates
 170   v8::Local<v8::Object> screenPointObject = v8::Object::New( isolate );
 171   screenPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, touchPoint.screen.x) );
 172   screenPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, touchPoint.screen.y) );
 173   pointObject->Set( v8::String::NewFromUtf8( isolate, "screen"), screenPointObject );
 174
 175
 176   return handleScope.Escape( pointObject );
 177 }
 178
 179 } // un-named namespace
 180
 181
 182 v8::Handle<v8::Object> EventObjectGenerator::CreateTouchData( v8::Isolate* isolate, const TouchData& touch )
 183 {
 184   // we are creating a touch event object that looks like this
 185   //
 186   //  event.pointCount = points touched
 187   //  event.time       = The time (in ms) that the touch event occurred.
 188   //  event.point[]    = array of Points
 189   //
 190   // A Point =
 191   //   { "deviceId",  int }  Each touch point has a unique device ID
 192   //   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
 193   //   { "sourceActor", actor }  the actor that is emitting the callback (the actor that is hit maybe a child of it)
 194   //   { "hitActor", actor } actor that was hit
 195   //   { "local",  {x,y} } co-ordinates of top left of hit actor
 196   //   { "screen", {x,y} } co-ordinates of top left of hit actor
 197   //   { "radius", float } radius of the press point (average of both the horizontal & vertical radii)
 198   //   { "ellipseRadius", {x,y} } both the horizontal and the vertical radii of the press point
 199   //   { "pressure", float } the touch pressure
 200   //   { "angle", float } angle of the press point relative to the Y-Axis
 201   //
 202
 203   v8::EscapableHandleScope handleScope( isolate );
 204
 205   v8::Local<v8::Object> touchObject = v8::Object::New( isolate );
 206
 207   // Set the pointCount
 208   touchObject->Set( v8::String::NewFromUtf8( isolate, "pointCount" ), v8::Integer::New( isolate, touch.GetPointCount() ) );
 209
 210   // Set the time
 211   touchObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, touch.GetTime() ) );
 212
 213   // Set the emitting actor
 214   // touchObject->Set( v8::String::NewFromUtf8( isolate, "sourceActor" ), ActorWrapper::WrapActor(isolate, emittingActor));
 215
 216   // Create the array of touch points
 217   v8::Local < v8::Array > pointArrayObject = v8::Array::New( isolate, touch.GetPointCount() );
 218   for( unsigned int i = 0 ; i < touch.GetPointCount() ; ++i )
 219   {
 220     v8::Local<v8::Object> pointObject = v8::Object::New( isolate );
 221
 222     // set device id
 223     pointObject->Set( v8::String::NewFromUtf8( isolate, "deviceId" ), v8::Integer::New( isolate, touch.GetDeviceId( i ) ) );
 224
 225     // set state
 226     pointObject->Set( v8::String::NewFromUtf8( isolate, "state" ), v8::String::NewFromUtf8( isolate, GetTouchDataPointStateName( touch.GetState( i ) ) ) );
 227
 228     Actor hitActor = touch.GetHitActor( i );
 229     if( hitActor )
 230     {
 231       // set the hit actor
 232       pointObject->Set( v8::String::NewFromUtf8( isolate, "hitActor" ), ActorWrapper::WrapActor( isolate, hitActor ) );
 233     }
 234
 235     // set the local co-ordinates
 236     const Vector2& local = touch.GetLocalPosition( i );
 237     v8::Local<v8::Object> localPointObject = v8::Object::New( isolate );
 238     localPointObject->Set( v8::String::NewFromUtf8( isolate, "x" ), v8::Integer::New( isolate, local.x ) );
 239     localPointObject->Set( v8::String::NewFromUtf8( isolate, "y" ), v8::Integer::New( isolate, local.y ) );
 240     pointObject->Set( v8::String::NewFromUtf8( isolate, "local" ),  localPointObject );
 241
 242     // set the screen co-ordinates
 243     const Vector2& screen = touch.GetScreenPosition( i );
 244     v8::Local<v8::Object> screenPointObject = v8::Object::New( isolate );
 245     screenPointObject->Set( v8::String::NewFromUtf8( isolate, "x" ), v8::Integer::New( isolate, screen.x ) );
 246     screenPointObject->Set( v8::String::NewFromUtf8( isolate, "y" ), v8::Integer::New( isolate, screen.y ) );
 247     pointObject->Set( v8::String::NewFromUtf8( isolate, "screen" ), screenPointObject );
 248
 249     // set the radius
 250     pointObject->Set( v8::String::NewFromUtf8( isolate, "radius" ), v8::Integer::New( isolate, touch.GetRadius( i ) ) );
 251
 252     // set the ellipse Radius
 253     const Vector2& ellipse = touch.GetEllipseRadius( i );
 254     v8::Local<v8::Object> ellipseObject = v8::Object::New( isolate );
 255     ellipseObject->Set( v8::String::NewFromUtf8( isolate, "x" ), v8::Integer::New( isolate, ellipse.x ) );
 256     ellipseObject->Set( v8::String::NewFromUtf8( isolate, "y" ), v8::Integer::New( isolate, ellipse.y ) );
 257     pointObject->Set( v8::String::NewFromUtf8( isolate, "ellipseRadius" ),  ellipseObject );
 258
 259     // set the pressure
 260     pointObject->Set( v8::String::NewFromUtf8( isolate, "pressure" ), v8::Integer::New( isolate, touch.GetPressure( i ) ) );
 261
 262     // set the angle
 263     pointObject->Set( v8::String::NewFromUtf8( isolate, "angle" ), v8::Integer::New( isolate, touch.GetAngle( i ).degree ) );
 264
 265     // add the point
 266     pointArrayObject->Set( v8::Number::New( isolate, i ), pointObject  );
 267   }
 268
 269   // set the array
 270   touchObject->Set( v8::String::NewFromUtf8( isolate, "points" ), pointArrayObject );
 271
 272   return handleScope.Escape( touchObject );
 273 }
 274
 275 v8::Handle<v8::Object> EventObjectGenerator::CreateHoverEvent( v8::Isolate* isolate, const HoverEvent& hoverEvent)
 276 {
 277   // we are creating a hover event object that looks like this
 278   //
 279   //  event.pointCount = points hovered
 280   //  event.time       = The time (in ms) that the hover event occurred.
 281   //  event.point[]    = array of TouchPoints
 282   //
 283   // A TouchPoint =
 284   //   { "deviceId",  int }  Each touch point has a unique device ID
 285   //   { "state",   string } touch state ="Down,Up,Motion,Leave,Stationary, Interrupted }
 286   //   { "sourceActor", actor }  the actor that is emitting the callback (the actor that is hit maybe a child of it)
 287   //   { "hitActor", actor } actor that was hit
 288   //   { "local",  {x,y} } co-ordinates of top left of hit actor
 289   //   { "screen", {x,y} } co-ordinates of top left of hit actor
 290   //
 291
 292   v8::EscapableHandleScope handleScope( isolate );
 293
 294   v8::Local<v8::Object> hoverObject = v8::Object::New( isolate );
 295
 296   // Set the pointCount
 297   hoverObject->Set( v8::String::NewFromUtf8( isolate, "pointCount" ), v8::Integer::New( isolate, hoverEvent.GetPointCount() ) );
 298
 299   // Set the time
 300   hoverObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, hoverEvent.time ) );
 301
 302   // Set the emitting actor
 303   // hoverObject->Set( v8::String::NewFromUtf8( isolate, "sourceActor" ), ActorWrapper::WrapActor(isolate, emittingActor));
 304
 305   // Create the array of touch points
 306   v8::Local < v8::Array > pointArrayObject = v8::Array::New( isolate, hoverEvent.GetPointCount() );
 307   for( unsigned int i = 0 ; i < hoverEvent.GetPointCount() ; ++i )
 308   {
 309     v8::Local < v8::Object > pointObject = CreateTouchPoint( isolate, hoverEvent.points[i] );
 310     pointArrayObject->Set( v8::Number::New( isolate, i ), pointObject  );
 311   }
 312
 313   // set the array
 314   hoverObject->Set( v8::String::NewFromUtf8( isolate, "points" ), pointArrayObject );
 315
 316   return handleScope.Escape( hoverObject );
 317 }
 318
 319 v8::Handle<v8::Object> EventObjectGenerator::CreateWheelEvent( v8::Isolate* isolate, const WheelEvent& wheelEvent)
 320 {
 321   //  we are creating a wheel event object that looks like this
 322   //
 323   //  event.type = "mouseWheel" or "customWheel" type of the wheel event
 324   //  event.direction = "vertical" or "horizontal" direction the wheel is being rolled
 325   //  event.shiftPressed       = boolean, shift key is held
 326   //  event.ctrlPressed        = boolean, ctrl key is held
 327   //  event.altPressed     = boolean, alt key is held
 328   //  event.keyModifiers = bitmask of keys pressed
 329   //  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.
 330   //  event.rolled          = offset of wheel rolling, positive = rolling down or clockwise, negative = rolling up or counter-clockwise
 331   //  event.timestamp    = The time (in ms) that the touch event occurred
 332
 333   v8::EscapableHandleScope handleScope( isolate );
 334
 335   v8::Local<v8::Object> wheelObject = v8::Object::New( isolate );
 336
 337   // Set the type
 338   std::string type = wheelEvent.type ? "mouseWheel" : "customWheel";
 339   wheelObject->Set( v8::String::NewFromUtf8( isolate, "type" ), v8::String::NewFromUtf8( isolate, type.c_str() ) );
 340
 341   // Set the direction
 342   std::string direction = wheelEvent.direction ? "vertical" : "horizontal";
 343   wheelObject->Set( v8::String::NewFromUtf8( isolate, "direction" ), v8::String::NewFromUtf8( isolate, direction.c_str() ) );
 344
 345   // set shift / ctrl/ alt keys
 346   wheelObject->Set( v8::String::NewFromUtf8( isolate, "shiftPressed" ), v8::Boolean::New( isolate, wheelEvent.IsShiftModifier()) );
 347   wheelObject->Set( v8::String::NewFromUtf8( isolate, "ctrlPressed" ),  v8::Boolean::New( isolate, wheelEvent.IsCtrlModifier()) );
 348   wheelObject->Set( v8::String::NewFromUtf8( isolate, "altPressed" ),   v8::Boolean::New( isolate, wheelEvent.IsAltModifier()) );
 349
 350   // set keyModifiers
 351   wheelObject->Set( v8::String::NewFromUtf8( isolate, "keyModifiers" ),  v8::Integer::New( isolate, wheelEvent.modifiers) );
 352
 353   // set Point
 354   v8::Local<v8::Object> wheelPointObject = v8::Object::New( isolate );
 355   wheelPointObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Integer::New( isolate, wheelEvent.point.x ) );
 356   wheelPointObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Integer::New( isolate, wheelEvent.point.y ) );
 357   wheelObject->Set( v8::String::NewFromUtf8( isolate, "point"), wheelPointObject );
 358
 359   // set rolledAmout
 360   wheelObject->Set( v8::String::NewFromUtf8( isolate, "rolled" ),  v8::Integer::New( isolate, wheelEvent.z) );
 361
 362   // set timestamp
 363   wheelObject->Set( v8::String::NewFromUtf8( isolate, "timestamp" ),  v8::Integer::New( isolate, wheelEvent.timeStamp) );
 364
 365   return handleScope.Escape( wheelObject );
 366
 367 }
 368
 369 v8::Handle<v8::Object> EventObjectGenerator::CreateKeyEvent( v8::Isolate* isolate, const KeyEvent& keyEvent)
 370 {
 371   // keyCode
 372   // keyModifier
 373   // event.keyCode       = key code
 374   // event.key           = key presssed
 375   // event.keyDescription = key description, e.g. BackSpace
 376   // event.state = "down" or "up" key state
 377   // event.shiftPressed  = boolean, shift key is held
 378   // event.ctrlPressed   = boolean, ctrl key is held
 379   // event.altPressed    = boolean, alt key is held
 380   // event.keyModifiers  = key modifiers
 381   // event.timestamp     = Time stamp
 382
 383   v8::EscapableHandleScope handleScope( isolate );
 384
 385   v8::Local<v8::Object> keyObject = v8::Object::New( isolate );
 386
 387   // Set the direction
 388   std::string state ("up");
 389   if ( keyEvent.state == KeyEvent::Down)
 390   {
 391     state = "down";
 392   }
 393
 394   keyObject->Set( v8::String::NewFromUtf8( isolate, "state" ), v8::String::NewFromUtf8( isolate, state.c_str() ) );
 395
 396   // set keyCode
 397    keyObject->Set( v8::String::NewFromUtf8( isolate, "keyCode" ),  v8::Integer::New( isolate, keyEvent.keyCode) );
 398
 399   // set keyModifiers
 400   keyObject->Set( v8::String::NewFromUtf8( isolate, "keyModifier" ),  v8::Integer::New( isolate, keyEvent.keyModifier) );
 401
 402   // set Key pressed name
 403   keyObject->Set( v8::String::NewFromUtf8( isolate, "keyDescription" ),  v8::String::NewFromUtf8( isolate, keyEvent.keyPressedName.c_str() )  );
 404
 405   // set Key pressed
 406   keyObject->Set( v8::String::NewFromUtf8( isolate, "key" ),  v8::String::NewFromUtf8( isolate, keyEvent.keyPressed.c_str() )  );
 407
 408   // set time stamp
 409   keyObject->Set( v8::String::NewFromUtf8( isolate, "timestamp" ),  v8::Integer::New( isolate, keyEvent.time) );
 410
 411   // set shift / ctrl/ alt keys
 412   keyObject->Set( v8::String::NewFromUtf8( isolate, "shiftPressed" ), v8::Boolean::New( isolate, keyEvent.IsShiftModifier()) );
 413   keyObject->Set( v8::String::NewFromUtf8( isolate, "ctrlPressed" ),  v8::Boolean::New( isolate, keyEvent.IsCtrlModifier()) );
 414   keyObject->Set( v8::String::NewFromUtf8( isolate, "altPressed" ),   v8::Boolean::New( isolate, keyEvent.IsAltModifier()) );
 415
 416   return handleScope.Escape( keyObject );
 417
 418 }
 419
 420 v8::Handle<v8::Object> EventObjectGenerator::CreatePanGesture( v8::Isolate* isolate, const PanGesture& panGesture)
 421 {
 422   // gesture.numberOfTouches     = total number of fingers touching the screen
 423   // gesture.state               = pan state {Clear, Started, Continuing, Finished, Cancelled, Possible}
 424   // gesture.time                = Time stamp
 425   // gesture.velocity            = pan velocity in actor coordinates
 426   // gesture.displacement        = pan displacement in actor coordinates
 427   // gesture.position            = pan position in actor coordinates
 428   // gesture.screenVelocity      = pan velocity in screen coordinates
 429   // gesture.screenDisplacement  = pan displacement in screen coordinates
 430   // gesture.screenPosition      = pan position in screen coordinates
 431
 432   v8::EscapableHandleScope handleScope( isolate );
 433
 434   v8::Local<v8::Object> panObject = v8::Object::New( isolate );
 435
 436   // Set the numberOfTouches
 437   panObject->Set( v8::String::NewFromUtf8( isolate, "numberOfTouches" ), v8::Integer::New( isolate, panGesture.numberOfTouches ) );
 438
 439   // Set the state
 440   panObject->Set( v8::String::NewFromUtf8( isolate, "state"), v8::String::NewFromUtf8( isolate, GetGestureStateName(panGesture.state)));
 441
 442   // Set the time
 443   panObject->Set( v8::String::NewFromUtf8( isolate, "time" ), v8::Number::New( isolate, panGesture.time ) );
 444
 445   // Set the local velocity
 446   v8::Local<v8::Object> velocityObject = v8::Object::New( isolate );
 447   velocityObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.velocity.x) );
 448   velocityObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.velocity.y) );
 449   panObject->Set( v8::String::NewFromUtf8( isolate, "velocity"),  velocityObject);
 450
 451   // Set the local displacement
 452   v8::Local<v8::Object> displacementObject = v8::Object::New( isolate );
 453   displacementObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.displacement.x) );
 454   displacementObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.displacement.y) );
 455   panObject->Set( v8::String::NewFromUtf8( isolate, "displacement"),  displacementObject);
 456
 457   // Set the local position
 458   v8::Local<v8::Object> positionObject = v8::Object::New( isolate );
 459   positionObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.position.x) );
 460   positionObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.position.y) );
 461   panObject->Set( v8::String::NewFromUtf8( isolate, "position"),  positionObject);
 462
 463   // Set the screen velocity
 464   v8::Local<v8::Object> screenVelocityObject = v8::Object::New( isolate );
 465   screenVelocityObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenVelocity.x) );
 466   screenVelocityObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenVelocity.y) );
 467   panObject->Set( v8::String::NewFromUtf8( isolate, "screenVelocity"),  screenVelocityObject);
 468
 469   // Set the screen displacement
 470   v8::Local<v8::Object> screenDisplacementObject = v8::Object::New( isolate );
 471   screenDisplacementObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenDisplacement.x) );
 472   screenDisplacementObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenDisplacement.y) );
 473   panObject->Set( v8::String::NewFromUtf8( isolate, "screenDisplacement"),  screenDisplacementObject);
 474
 475   // Set the screen position
 476   v8::Local<v8::Object> screenPositionObject = v8::Object::New( isolate );
 477   screenPositionObject->Set( v8::String::NewFromUtf8( isolate, "x"),v8::Number::New( isolate, panGesture.screenPosition.x) );
 478   screenPositionObject->Set( v8::String::NewFromUtf8( isolate, "y"),v8::Number::New( isolate, panGesture.screenPosition.y) );
 479   panObject->Set( v8::String::NewFromUtf8( isolate, "screenPosition"),  screenPositionObject);
 480
 481   return handleScope.Escape( panObject );
 482
 483 }
 484
 485
 486
 487 } // V8Plugin
 488
 489 } // namespace Dali