dali-extension/internal/evas-plugin/evas-event-handler.cpp

   1 /*
   2  * Copyright (c) 2019 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 "evas-event-handler.h"
  20
  21 namespace Dali
  22 {
  23
  24 namespace Extension
  25 {
  26
  27 namespace Internal
  28 {
  29
  30 /**
  31  * Copied from x server
  32  * @brief Retrieve the current milliseconds.
  33  *
  34  * @return the current milliseconds.
  35  */
  36 static unsigned int GetCurrentMilliSeconds(void)
  37 {
  38   struct timeval tv;
  39
  40   struct timespec tp;
  41   static clockid_t clockid;
  42
  43   if (!clockid)
  44   {
  45 #ifdef CLOCK_MONOTONIC_COARSE
  46     if (clock_getres(CLOCK_MONOTONIC_COARSE, &tp) == 0 &&
  47       (tp.tv_nsec / 1000) <= 1000 && clock_gettime(CLOCK_MONOTONIC_COARSE, &tp) == 0)
  48     {
  49       clockid = CLOCK_MONOTONIC_COARSE;
  50     }
  51     else
  52 #endif
  53     if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
  54     {
  55       clockid = CLOCK_MONOTONIC;
  56     }
  57     else
  58     {
  59       clockid = ~0L;
  60     }
  61   }
  62   if (clockid != ~0L && clock_gettime(clockid, &tp) == 0)
  63   {
  64     return (tp.tv_sec * 1000) + (tp.tv_nsec / 1000000L);
  65   }
  66
  67   gettimeofday(&tv, NULL);
  68   return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
  69 }
  70
  71 namespace
  72 {
  73
  74 const int TOUCH_DEVICE_ID = 0;
  75
  76 const char* EVAS_OBJECT_FOCUSED_EVENT_NAME = "focused";
  77 const char* EVAS_OBJECT_UNFOCUSED_EVENT_NAME = "unfocused";
  78
  79 /**
  80  * @brief Retrieve the dali screen touch point.
  81  *
  82  * @param[in] canvasX is the x of canvas position
  83  * @param[in] canvasY is the y of canvas position
  84  * @param[in] evasObject is rendered by dali
  85  * @param[out] screenX is the x of local position of evasObject
  86  * @param[out] screenY is the y of local position of evasObject
  87  */
  88 void GetScreenPosition(Evas_Coord canvasX, Evas_Coord canvasY, Evas_Object* evasObject, Evas_Coord &screenX, Evas_Coord &screenY)
  89 {
  90   Evas_Coord objX = 0, objY = 0, objW = 0, objH = 0;
  91   evas_object_geometry_get(evasObject, &objX, &objY, &objW, &objH);
  92
  93   screenX = canvasX - objX;
  94   screenY = canvasY - objY;
  95 }
  96
  97 #ifdef DALI_EVASPLUGIN_USE_IMF_MANAGER
  98 /**
  99  * @brief Evas_Modifier enums in Ecore_Input.h do not match Ecore_Event_Modifier in Ecore_Input.h.
 100  *        This function converts from Evas_Modifier to Ecore_Event_Modifier enums.
 101  *
 102  * @param[in] evasModifier the Evas_Modifier input.
 103  * @return the Ecore_Event_Modifier output.
 104  */
 105 unsigned int EvasModifierToEcoreModifier(Evas_Modifier* evasModifier)
 106 {
 107    unsigned int modifier = 0;  // If no other matches returns NONE.
 108
 109    if (evas_key_modifier_is_set(evasModifier, "Shift"))
 110    {
 111      modifier |= ECORE_EVENT_MODIFIER_SHIFT;
 112    }
 113
 114    if (evas_key_modifier_is_set(evasModifier, "Alt"))
 115    {
 116      modifier |= ECORE_EVENT_MODIFIER_ALT;
 117    }
 118
 119    if (evas_key_modifier_is_set(evasModifier, "AltGr"))
 120    {
 121      modifier |= ECORE_EVENT_MODIFIER_ALTGR;
 122    }
 123
 124    if (evas_key_modifier_is_set(evasModifier, "Control"))
 125    {
 126      modifier |= ECORE_EVENT_MODIFIER_CTRL;
 127    }
 128
 129    if (evas_key_modifier_is_set(evasModifier, "Win") ||
 130        evas_key_modifier_is_set(evasModifier, "Super") ||
 131        evas_key_modifier_is_set(evasModifier, "Hyper"))
 132    {
 133      modifier |= ECORE_EVENT_MODIFIER_WIN;
 134    }
 135
 136    return modifier;
 137 }
 138 #endif
 139
 140
 141 void ConvertActionInfo(Elm_Access_Action_Info* elmActionInfo, Dali::Extension::Internal::AccessActionInfo&  daliActionInfo)
 142 {
 143   daliActionInfo.x = elmActionInfo->x;
 144   daliActionInfo.y = elmActionInfo->y;
 145   daliActionInfo.mouseType = elmActionInfo->mouse_type;
 146
 147   switch(elmActionInfo->action_type)
 148   {
 149     case ELM_ACCESS_ACTION_HIGHLIGHT:
 150     {
 151       daliActionInfo.actionType = ACCESS_ACTION_HIGHLIGHT;
 152     }
 153     break;
 154
 155     case ELM_ACCESS_ACTION_READ:
 156     {
 157       daliActionInfo.actionType = ACCESS_ACTION_READ;
 158     }
 159     break;
 160
 161     case ELM_ACCESS_ACTION_HIGHLIGHT_PREV:
 162     {
 163       daliActionInfo.actionType = ACCESS_ACTION_HIGHLIGHT_PREV;
 164     }
 165     break;
 166
 167     case ELM_ACCESS_ACTION_HIGHLIGHT_NEXT:
 168     {
 169       daliActionInfo.actionType = ACCESS_ACTION_HIGHLIGHT_NEXT;
 170     }
 171     break;
 172
 173     case ELM_ACCESS_ACTION_ACTIVATE:
 174     {
 175       daliActionInfo.actionType = ACCESS_ACTION_ACTIVATE;
 176     }
 177     break;
 178
 179     case ELM_ACCESS_ACTION_UNHIGHLIGHT:
 180     {
 181       daliActionInfo.actionType = ACCESS_ACTION_UNHIGHLIGHT;
 182     }
 183     break;
 184
 185     case ELM_ACCESS_ACTION_SCROLL:
 186     {
 187       daliActionInfo.actionType = ACCESS_ACTION_SCROLL;
 188     }
 189     break;
 190
 191     case ELM_ACCESS_ACTION_UP:
 192     {
 193       daliActionInfo.actionType = ACCESS_ACTION_UP;
 194     }
 195     break;
 196
 197     case ELM_ACCESS_ACTION_DOWN:
 198     {
 199       daliActionInfo.actionType = ACCESS_ACTION_DOWN;
 200     }
 201     break;
 202
 203     case ELM_ACCESS_ACTION_BACK:
 204     {
 205       daliActionInfo.actionType = ACCESS_ACTION_BACK;
 206     }
 207     break;
 208
 209     default:
 210
 211     break;
 212   }
 213
 214   switch(elmActionInfo->action_by)
 215   {
 216     case ELM_ACCESS_ACTION_HIGHLIGHT:
 217     {
 218       daliActionInfo.actionBy = ACCESS_ACTION_HIGHLIGHT;
 219     }
 220     break;
 221
 222     case ELM_ACCESS_ACTION_READ:
 223     {
 224       daliActionInfo.actionBy = ACCESS_ACTION_READ;
 225     }
 226     break;
 227
 228     case ELM_ACCESS_ACTION_HIGHLIGHT_PREV:
 229     {
 230       daliActionInfo.actionBy = ACCESS_ACTION_HIGHLIGHT_PREV;
 231     }
 232     break;
 233
 234     case ELM_ACCESS_ACTION_HIGHLIGHT_NEXT:
 235     {
 236       daliActionInfo.actionBy = ACCESS_ACTION_HIGHLIGHT_NEXT;
 237     }
 238     break;
 239
 240     case ELM_ACCESS_ACTION_ACTIVATE:
 241     {
 242       daliActionInfo.actionBy = ACCESS_ACTION_ACTIVATE;
 243     }
 244     break;
 245
 246     case ELM_ACCESS_ACTION_UNHIGHLIGHT:
 247     {
 248       daliActionInfo.actionBy = ACCESS_ACTION_UNHIGHLIGHT;
 249     }
 250     break;
 251
 252     case ELM_ACCESS_ACTION_SCROLL:
 253     {
 254       daliActionInfo.actionBy = ACCESS_ACTION_SCROLL;
 255     }
 256     break;
 257
 258     case ELM_ACCESS_ACTION_UP:
 259     {
 260       daliActionInfo.actionBy = ACCESS_ACTION_UP;
 261     }
 262     break;
 263
 264     case ELM_ACCESS_ACTION_DOWN:
 265     {
 266       daliActionInfo.actionBy = ACCESS_ACTION_DOWN;
 267     }
 268     break;
 269
 270     case ELM_ACCESS_ACTION_BACK:
 271     {
 272       daliActionInfo.actionBy = ACCESS_ACTION_BACK;
 273     }
 274     break;
 275
 276     default:
 277
 278     break;
 279   }
 280
 281   daliActionInfo.highlightCycle = elmActionInfo->highlight_cycle;
 282   daliActionInfo.timeStamp = GetCurrentMilliSeconds();
 283 }
 284
 285 } // namespace
 286
 287 EvasEventHandler::EvasEventHandler(Evas_Object* imageEvasObject,
 288                                    Evas_Object* elmAccessEvasObject,
 289                                    Evas_Object* elmFocusEvasObject,
 290                                    EvasPluginEventInterface& evasPluginEventInterface)
 291 : mEvasPluginEventInterface(evasPluginEventInterface)
 292 , mEvas(evas_object_evas_get(imageEvasObject))
 293 , mImageEvasObject(imageEvasObject)
 294 , mElmAccessEvasObject(elmAccessEvasObject)
 295 , mElmFocusEvasObject(elmFocusEvasObject)
 296 {
 297   // Register the evas event callbacks
 298   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MOUSE_DOWN,  OnEvasObjectMouseDown,      &evasPluginEventInterface);
 299   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MOUSE_UP,    OnEvasObjectMouseUp,        &evasPluginEventInterface);
 300   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MOUSE_MOVE,  OnEvasObjectMouseMove,      &evasPluginEventInterface);
 301   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MOUSE_WHEEL, OnEvasObjectMouseWheel,     &evasPluginEventInterface);
 302   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MULTI_DOWN,  OnEvasObjectMultiTouchDown, &evasPluginEventInterface);
 303   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MULTI_UP,    OnEvasObjectMultiTouchUp,   &evasPluginEventInterface);
 304   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MULTI_MOVE,  OnEvasObjectMultiTouchMove, &evasPluginEventInterface);
 305   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_KEY_DOWN,    OnEvasObjectKeyDown,        &evasPluginEventInterface);
 306   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_KEY_UP,      OnEvasObjectKeyUp,          &evasPluginEventInterface);
 307
 308   // Register the evas geometry callbacks
 309   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_MOVE,   OnEvasObjectMove,   &evasPluginEventInterface);
 310   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_RESIZE, OnEvasObjectResize, &evasPluginEventInterface);
 311
 312   // Register the evas focus callbacks
 313   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_FOCUS_IN,  OnEvasObjectFocusIn,  &evasPluginEventInterface);
 314   evas_object_event_callback_add(mImageEvasObject, EVAS_CALLBACK_FOCUS_OUT, OnEvasObjectFocusOut, &evasPluginEventInterface);
 315
 316   evas_event_callback_add(mEvas, EVAS_CALLBACK_CANVAS_FOCUS_IN,  OnEvasFocusIn,  &evasPluginEventInterface);
 317   evas_event_callback_add(mEvas, EVAS_CALLBACK_CANVAS_FOCUS_OUT, OnEvasFocusOut, &evasPluginEventInterface);
 318
 319   // Register the evas render callbacks
 320   evas_event_callback_add(mEvas, EVAS_CALLBACK_RENDER_POST, OnEvasRenderPost, &evasPluginEventInterface);
 321
 322   // Register the elm access action callbacks and these callbacks are disconnected when mElmAccessEvasObject is unregistred
 323   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_HIGHLIGHT,      OnElmAccessActionHighlight,      &evasPluginEventInterface);
 324   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_UNHIGHLIGHT,    OnElmAccessActionUnhighlight,    &evasPluginEventInterface);
 325   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_HIGHLIGHT_NEXT, OnElmAccessActionHighlightNext,  &evasPluginEventInterface);
 326   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_HIGHLIGHT_PREV, OnElmAccessActionHighlightPrev, &evasPluginEventInterface);
 327   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_ACTIVATE,       OnElmAccessActionActivate,       &evasPluginEventInterface);
 328   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_UP,             OnElmAccessActionUp,             &evasPluginEventInterface);
 329   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_DOWN,           OnElmAccessActionDown,           &evasPluginEventInterface);
 330   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_SCROLL,         OnElmAccessActionScroll,         &evasPluginEventInterface);
 331   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_BACK,           OnElmAccessActionBack,           &evasPluginEventInterface);
 332   elm_access_action_cb_set(mElmAccessEvasObject, ELM_ACCESS_ACTION_READ,           OnElmAccessActionRead,           &evasPluginEventInterface);
 333
 334   // Register the elm focus callbacks
 335   evas_object_smart_callback_add(mElmFocusEvasObject, EVAS_OBJECT_FOCUSED_EVENT_NAME,   OnEvasObjectSmartFocused,   this);
 336   evas_object_smart_callback_add(mElmFocusEvasObject, EVAS_OBJECT_UNFOCUSED_EVENT_NAME, OnEvasObjectSmartUnfocused, this);
 337 }
 338
 339 EvasEventHandler::~EvasEventHandler()
 340 {
 341   // Unregister the evas event callbacks.
 342   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MOUSE_DOWN,  OnEvasObjectMouseDown);
 343   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MOUSE_UP,    OnEvasObjectMouseUp);
 344   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MOUSE_MOVE,  OnEvasObjectMouseMove);
 345   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MOUSE_WHEEL, OnEvasObjectMouseWheel);
 346   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MULTI_DOWN,  OnEvasObjectMultiTouchDown);
 347   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MULTI_UP,    OnEvasObjectMultiTouchUp);
 348   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MULTI_MOVE,  OnEvasObjectMultiTouchMove);
 349   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_KEY_DOWN,    OnEvasObjectKeyDown);
 350   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_KEY_UP,      OnEvasObjectKeyUp);
 351
 352   // Unregister the evas geometry callbacks.
 353   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_MOVE,   OnEvasObjectMove);
 354   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_RESIZE, OnEvasObjectResize);
 355
 356   // Unregister the evas focus callbacks
 357   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_FOCUS_IN,  OnEvasObjectFocusIn);
 358   evas_object_event_callback_del(mImageEvasObject, EVAS_CALLBACK_FOCUS_OUT, OnEvasObjectFocusOut);
 359
 360   evas_event_callback_del(mEvas, EVAS_CALLBACK_CANVAS_FOCUS_IN,  OnEvasFocusIn);
 361   evas_event_callback_del(mEvas, EVAS_CALLBACK_CANVAS_FOCUS_OUT, OnEvasFocusOut);
 362
 363   // Register the evas render callbacks
 364   evas_event_callback_del(mEvas, EVAS_CALLBACK_RENDER_POST, OnEvasRenderPost);
 365
 366   // Unregister the elm focus callbacks
 367   evas_object_smart_callback_del(mElmFocusEvasObject, EVAS_OBJECT_FOCUSED_EVENT_NAME,   OnEvasObjectSmartFocused);
 368   evas_object_smart_callback_del(mElmFocusEvasObject, EVAS_OBJECT_UNFOCUSED_EVENT_NAME, OnEvasObjectSmartUnfocused);
 369 }
 370
 371 /////////////////////////////////////////////////////////////////////////////////////////////////////
 372 // Event callbacks
 373 /////////////////////////////////////////////////////////////////////////////////////////////////////
 374
 375 void EvasEventHandler::OnEvasObjectMouseDown(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 376 {
 377   Evas_Event_Mouse_Down* eventMouseDown = static_cast<Evas_Event_Mouse_Down*>(event);
 378
 379   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 380   GetScreenPosition(eventMouseDown->canvas.x, eventMouseDown->canvas.y, evasObject, screenX, screenY);
 381
 382   TouchPoint touchPoint = TouchPoint(TOUCH_DEVICE_ID, TouchPoint::Down, screenX, screenY);
 383   unsigned long timeStamp = eventMouseDown->timestamp;
 384   if (timeStamp < 1)
 385   {
 386     timeStamp = GetCurrentMilliSeconds();
 387   }
 388
 389   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 390   pEvasPlugin->OnEvasObjectTouchEvent(touchPoint, timeStamp);
 391 }
 392
 393 void EvasEventHandler::OnEvasObjectMouseUp(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 394 {
 395   Evas_Event_Mouse_Up* eventMouseUp = static_cast<Evas_Event_Mouse_Up*>(event);
 396
 397   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 398   GetScreenPosition(eventMouseUp->canvas.x, eventMouseUp->canvas.y, evasObject, screenX, screenY);
 399
 400   TouchPoint touchPoint = TouchPoint(TOUCH_DEVICE_ID, TouchPoint::Up, screenX, screenY);
 401   unsigned long timeStamp = eventMouseUp->timestamp;
 402   if (timeStamp < 1)
 403   {
 404     timeStamp = GetCurrentMilliSeconds();
 405   }
 406
 407   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 408   pEvasPlugin->OnEvasObjectTouchEvent(touchPoint, timeStamp);
 409 }
 410
 411 void EvasEventHandler::OnEvasObjectMouseMove(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 412 {
 413   Evas_Event_Mouse_Move* eventMouseMove = static_cast<Evas_Event_Mouse_Move*>(event);
 414
 415   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 416   GetScreenPosition(eventMouseMove->cur.canvas.x, eventMouseMove->cur.canvas.y, evasObject, screenX, screenY);
 417
 418   TouchPoint touchPoint = TouchPoint(TOUCH_DEVICE_ID, TouchPoint::Motion, screenX, screenY);
 419   unsigned long timeStamp = eventMouseMove->timestamp;
 420   if (timeStamp < 1)
 421   {
 422     timeStamp = GetCurrentMilliSeconds();
 423   }
 424
 425   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 426   pEvasPlugin->OnEvasObjectTouchEvent(touchPoint, timeStamp);
 427 }
 428
 429 void EvasEventHandler::OnEvasObjectMouseWheel(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 430 {
 431   Evas_Event_Mouse_Wheel* eventMouseWheel = static_cast<Evas_Event_Mouse_Wheel*>(event);
 432
 433   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 434   GetScreenPosition(eventMouseWheel->canvas.x, eventMouseWheel->canvas.y, evasObject, screenX, screenY);
 435
 436   int direction = eventMouseWheel->direction;
 437   unsigned int modifiers = -1;  // TODO: Need to check evas modifier
 438   Vector2 point = Vector2(screenX, screenY);
 439   int z = eventMouseWheel->z;
 440   unsigned int timeStamp = eventMouseWheel->timestamp;
 441   if (timeStamp < 1)
 442   {
 443     timeStamp = GetCurrentMilliSeconds();
 444   }
 445
 446   WheelEvent wheelEvent(WheelEvent::MOUSE_WHEEL, direction, modifiers, point, z, timeStamp);
 447
 448   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 449   pEvasPlugin->OnEvasObjectWheelEvent(wheelEvent);
 450 }
 451
 452 void EvasEventHandler::OnEvasObjectMultiTouchDown(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 453 {
 454   Evas_Event_Multi_Down* eventMultiDown = static_cast<Evas_Event_Multi_Down*>(event);
 455
 456   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 457   GetScreenPosition(eventMultiDown->canvas.x, eventMultiDown->canvas.y, evasObject, screenX, screenY);
 458
 459   TouchPoint touchPoint = TouchPoint(eventMultiDown->device, TouchPoint::Down, screenX, screenY);
 460   unsigned long timeStamp = eventMultiDown->timestamp;
 461   if (timeStamp < 1)
 462   {
 463     timeStamp = GetCurrentMilliSeconds();
 464   }
 465
 466   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 467   pEvasPlugin->OnEvasObjectTouchEvent(touchPoint, timeStamp);
 468 }
 469
 470 void EvasEventHandler::OnEvasObjectMultiTouchUp(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 471 {
 472   Evas_Event_Multi_Up* eventMultiUp = static_cast<Evas_Event_Multi_Up*>(event);
 473
 474   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 475   GetScreenPosition(eventMultiUp->canvas.x, eventMultiUp->canvas.y, evasObject, screenX, screenY);
 476
 477   TouchPoint touchPoint = TouchPoint(eventMultiUp->device, TouchPoint::Up, screenX, screenY);
 478   unsigned long timeStamp = eventMultiUp->timestamp;
 479   if (timeStamp < 1)
 480   {
 481     timeStamp = GetCurrentMilliSeconds();
 482   }
 483
 484   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 485   pEvasPlugin->OnEvasObjectTouchEvent(touchPoint, timeStamp);
 486 }
 487
 488 void EvasEventHandler::OnEvasObjectMultiTouchMove(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 489 {
 490   Evas_Event_Multi_Move* eventMultiMove = static_cast<Evas_Event_Multi_Move*>(event);
 491
 492   Evas_Coord screenX = 0.0f, screenY = 0.0f;
 493   GetScreenPosition(eventMultiMove->cur.canvas.x, eventMultiMove->cur.canvas.y, evasObject, screenX, screenY);
 494
 495   TouchPoint touchPoint = TouchPoint(eventMultiMove->device, TouchPoint::Motion, screenX, screenY);
 496   unsigned long timeStamp = eventMultiMove->timestamp;
 497   if (timeStamp < 1)
 498   {
 499     timeStamp = GetCurrentMilliSeconds();
 500   }
 501
 502   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 503   pEvasPlugin->OnEvasObjectTouchEvent(touchPoint, timeStamp);
 504 }
 505
 506 void EvasEventHandler::OnEvasObjectKeyDown(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 507 {
 508 #ifdef DALI_EVASPLUGIN_USE_IMF_MANAGER
 509   Evas_Event_Key_Down* eventKeyDown = static_cast<Evas_Event_Key_Down*>(event);
 510   bool eventHandled = false;
 511
 512   // If a device key then skip ecore_imf_context_filter_event.
 513   if (!KeyLookup::IsDeviceButton(eventKeyDown->keyname))
 514   {
 515     ImfManager imfManager = ImfManager::Get();
 516     if(imfManager)
 517     {
 518       Ecore_IMF_Context* imfContext = Dali::Internal::Adaptor::ImfManager::GetImplementation(imfManager).GetContext();
 519       if (imfContext)
 520       {
 521         // We're consuming key down event so we have to pass to IMF so that it can parse it as well.
 522         Ecore_IMF_Event_Key_Down imfEventKeyDown;
 523         ecore_imf_evas_event_key_down_wrap(eventKeyDown, &imfEventKeyDown);
 524
 525         eventHandled = ecore_imf_context_filter_event(imfContext, ECORE_IMF_EVENT_KEY_DOWN, reinterpret_cast<Ecore_IMF_Event*>(&imfEventKeyDown));
 526
 527         if (!eventHandled)
 528         {
 529           // Menu, home, back button must skip ecore_imf_context_filter_event.
 530           static const char* escapeKeyName = KeyLookup::GetKeyName(DALI_KEY_ESCAPE);
 531           static const char* returnKeyName = KeyLookup::GetKeyName(static_cast<Dali::KEY>(DALI_EXTENSION_INTERNAL_KEY_RETURN));
 532           static const char* kpEnterKeyName = KeyLookup::GetKeyName(static_cast<Dali::KEY>(DALI_EXTENSION_INTERNAL_KEY_KP_ENTER));
 533           if ((escapeKeyName && !strcmp(eventKeyDown->keyname, escapeKeyName)) ||
 534               (returnKeyName && !strcmp(eventKeyDown->keyname, returnKeyName)) ||
 535               (kpEnterKeyName && !strcmp(eventKeyDown->keyname, kpEnterKeyName)))
 536           {
 537             ecore_imf_context_reset(imfContext);
 538           }
 539         }
 540       }
 541     }
 542   }
 543
 544   // If the event wasn't handled then we should send a key event.
 545   if (!eventHandled)
 546   {
 547     std::string keyName = eventKeyDown->keyname;
 548     std::string keyString = (eventKeyDown->string != NULL) ? eventKeyDown->string : "";
 549     int keyCode = KeyLookup::GetDaliKeyCode(eventKeyDown->keyname);
 550     int modifier = EvasModifierToEcoreModifier(eventKeyDown->modifiers);
 551     unsigned long timeStamp = eventKeyDown->timestamp;
 552     if (timeStamp < 1)
 553     {
 554       timeStamp = GetCurrentMilliSeconds();
 555     }
 556
 557     KeyEvent keyEvent(keyName, keyString, keyCode, modifier, timeStamp, KeyEvent::Down);
 558
 559     EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 560     pEvasPlugin->OnEvasObjectKeyEvent(keyEvent);
 561   }
 562 #endif
 563 }
 564
 565 void EvasEventHandler::OnEvasObjectKeyUp(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 566 {
 567 #ifdef DALI_EVASPLUGIN_USE_IMF_MANAGER
 568   Evas_Event_Key_Up* eventKeyUp = static_cast<Evas_Event_Key_Up*>(event);
 569   bool eventHandled = false;
 570
 571   // Menu, home, back button must skip ecore_imf_context_filter_event.
 572   static const char* menuKeyName = KeyLookup::GetKeyName(DALI_KEY_MENU);
 573   static const char* homeKeyName = KeyLookup::GetKeyName(DALI_KEY_HOME);
 574   static const char* backKeyName = KeyLookup::GetKeyName(DALI_KEY_BACK);
 575   if ((menuKeyName && !strcmp(eventKeyUp->keyname, menuKeyName)) &&
 576       (homeKeyName && !strcmp(eventKeyUp->keyname, homeKeyName)) &&
 577       (backKeyName && !strcmp(eventKeyUp->keyname, backKeyName)))
 578   {
 579     ImfManager imfManager = ImfManager::Get();
 580     if(imfManager)
 581     {
 582       Ecore_IMF_Context* imfContext = Dali::Internal::Adaptor::ImfManager::GetImplementation(imfManager).GetContext();
 583
 584       if (imfContext)
 585       {
 586         Ecore_IMF_Event_Key_Up imfEventKeyUp;
 587         ecore_imf_evas_event_key_up_wrap(eventKeyUp, &imfEventKeyUp);
 588
 589         eventHandled = ecore_imf_context_filter_event(imfContext, ECORE_IMF_EVENT_KEY_UP, reinterpret_cast<Ecore_IMF_Event*>(&imfEventKeyUp));
 590       }
 591     }
 592   }
 593
 594   if (!eventHandled)
 595   {
 596     std::string keyName = eventKeyUp->keyname;
 597     std::string keyString = (eventKeyUp->string != NULL) ? eventKeyUp->string : "";
 598     int keyCode = KeyLookup::GetDaliKeyCode(eventKeyUp->keyname);
 599     int modifier = EvasModifierToEcoreModifier(eventKeyUp->modifiers);
 600     unsigned long timeStamp = eventKeyUp->timestamp;
 601     if (timeStamp < 1)
 602     {
 603       timeStamp = GetCurrentMilliSeconds();
 604     }
 605
 606     KeyEvent keyEvent(keyName, keyString, keyCode, modifier, timeStamp, KeyEvent::Up);
 607
 608     EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 609     pEvasPlugin->OnEvasObjectKeyEvent(keyEvent);
 610   }
 611 #endif
 612 }
 613
 614 /////////////////////////////////////////////////////////////////////////////////////////////////////
 615 // Geometry callbacks
 616 /////////////////////////////////////////////////////////////////////////////////////////////////////
 617
 618 void EvasEventHandler::OnEvasObjectMove(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 619 {
 620   Rect<int> geometry;
 621   evas_object_geometry_get(evasObject, &geometry.x, &geometry.y, &geometry.width, &geometry.height);
 622
 623   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 624   pEvasPlugin->OnEvasObjectMove(geometry);
 625 }
 626
 627 void EvasEventHandler::OnEvasObjectResize(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 628 {
 629   Rect<int> geometry;
 630   evas_object_geometry_get(evasObject, &geometry.x, &geometry.y, &geometry.width, &geometry.height);
 631
 632   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 633   pEvasPlugin->OnEvasObjectResize(geometry);
 634 }
 635
 636 /////////////////////////////////////////////////////////////////////////////////////////////////////
 637 // Focus callbacks
 638 /////////////////////////////////////////////////////////////////////////////////////////////////////
 639
 640 void EvasEventHandler::OnEvasObjectFocusIn(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 641 {
 642   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 643   pEvasPlugin->OnEvasObjectFocusIn();
 644 }
 645
 646 void EvasEventHandler::OnEvasObjectFocusOut(void *data, Evas* evas, Evas_Object* evasObject, void* event)
 647 {
 648   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 649   pEvasPlugin->OnEvasObjectFocusOut();
 650 }
 651
 652 void EvasEventHandler::OnEvasFocusIn(void *data, Evas* evas, void* event)
 653 {
 654 }
 655
 656 void EvasEventHandler::OnEvasFocusOut(void *data, Evas* evas, void* event)
 657 {
 658 }
 659
 660 /////////////////////////////////////////////////////////////////////////////////////////////////////
 661 // Render callbacks
 662 /////////////////////////////////////////////////////////////////////////////////////////////////////
 663
 664 void EvasEventHandler::OnEvasRenderPost(void *data, Evas* evas, void* event)
 665 {
 666   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 667   pEvasPlugin->OnEvasPostRender();
 668 }
 669
 670 /////////////////////////////////////////////////////////////////////////////////////////////////////
 671 // Elm Access callbacks
 672 /////////////////////////////////////////////////////////////////////////////////////////////////////
 673
 674 Eina_Bool EvasEventHandler::OnElmAccessActionHighlight(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 675 {
 676   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 677   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 678   ConvertActionInfo(actionInfo, daliActionInfo);
 679
 680   return pEvasPlugin->OnElmAccessActionHighlight(daliActionInfo);
 681 }
 682
 683 Eina_Bool EvasEventHandler::OnElmAccessActionUnhighlight(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 684 {
 685   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 686   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 687   ConvertActionInfo(actionInfo, daliActionInfo);
 688
 689   return pEvasPlugin->OnElmAccessActionUnhighlight(daliActionInfo);
 690 }
 691
 692 Eina_Bool EvasEventHandler::OnElmAccessActionHighlightNext(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 693 {
 694   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 695   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 696   ConvertActionInfo(actionInfo, daliActionInfo);
 697
 698   return pEvasPlugin->OnElmAccessActionHighlightNext(daliActionInfo);
 699 }
 700
 701 Eina_Bool EvasEventHandler::OnElmAccessActionHighlightPrev(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 702 {
 703   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 704   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 705   ConvertActionInfo(actionInfo, daliActionInfo);
 706
 707   return pEvasPlugin->OnElmAccessActionHighlightPrev(daliActionInfo);
 708 }
 709
 710 Eina_Bool EvasEventHandler::OnElmAccessActionActivate(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 711 {
 712   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 713   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 714   ConvertActionInfo(actionInfo, daliActionInfo);
 715
 716   return pEvasPlugin->OnElmAccessActionActivate(daliActionInfo);
 717 }
 718
 719 Eina_Bool EvasEventHandler::OnElmAccessActionScroll(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 720 {
 721   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 722   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 723   ConvertActionInfo(actionInfo, daliActionInfo);
 724
 725   return pEvasPlugin->OnElmAccessActionScroll(daliActionInfo);
 726 }
 727
 728 Eina_Bool EvasEventHandler::OnElmAccessActionUp(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 729 {
 730   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 731   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 732   ConvertActionInfo(actionInfo, daliActionInfo);
 733
 734   return pEvasPlugin->OnElmAccessActionUp(daliActionInfo);
 735 }
 736
 737 Eina_Bool EvasEventHandler::OnElmAccessActionDown(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 738 {
 739   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 740   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 741   ConvertActionInfo(actionInfo, daliActionInfo);
 742
 743   return pEvasPlugin->OnElmAccessActionDown(daliActionInfo);
 744 }
 745
 746 Eina_Bool EvasEventHandler::OnElmAccessActionBack(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 747 {
 748   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 749   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 750   ConvertActionInfo(actionInfo, daliActionInfo);
 751
 752   return pEvasPlugin->OnElmAccessActionBack(daliActionInfo);
 753 }
 754
 755 Eina_Bool EvasEventHandler::OnElmAccessActionRead(void* data, Evas_Object* evasObject, Elm_Access_Action_Info* actionInfo)
 756 {
 757   EvasPluginEventInterface* pEvasPlugin = static_cast<EvasPluginEventInterface*>(data);
 758   Dali::Extension::Internal::AccessActionInfo daliActionInfo;
 759   ConvertActionInfo(actionInfo, daliActionInfo);
 760
 761   return pEvasPlugin->OnElmAccessActionRead(daliActionInfo);
 762 }
 763
 764 /////////////////////////////////////////////////////////////////////////////////////////////////////
 765 // Elm Focus callbacks
 766 /////////////////////////////////////////////////////////////////////////////////////////////////////
 767
 768 void EvasEventHandler::OnEvasObjectSmartFocused(void *data, Evas_Object* evasObject, void* event)
 769 {
 770   EvasEventHandler* eventHandler = static_cast<EvasEventHandler*>(data);
 771   EvasPluginEventInterface& evasPlugin = eventHandler->GetEvasPluginInterface();
 772
 773   if (eventHandler->mElmFocusEvasObject == evasObject)
 774   {
 775     Evas_Object* topWidget = elm_object_top_widget_get(evasObject);
 776
 777     if (!strcmp("elm_win", elm_object_widget_type_get(topWidget)))
 778     {
 779       if (elm_win_focus_highlight_enabled_get(topWidget) == EINA_TRUE)
 780       {
 781         // To allow that KeyboardFocusManager can handle the keyboard focus
 782         KeyEvent fakeKeyEvent("", "", 0, 0, 100, KeyEvent::Down);
 783
 784         evasPlugin.OnEvasObjectKeyEvent(fakeKeyEvent);
 785       }
 786     }
 787
 788     evas_object_focus_set(eventHandler->mImageEvasObject, EINA_TRUE);
 789   }
 790 }
 791
 792 void EvasEventHandler::OnEvasObjectSmartUnfocused(void *data, Evas_Object* evasObject, void* event)
 793 {
 794   EvasEventHandler* eventHandler = static_cast<EvasEventHandler*>(data);
 795   if (eventHandler->mElmFocusEvasObject == evasObject)
 796   {
 797     evas_object_focus_set(eventHandler->mImageEvasObject, EINA_FALSE);
 798   }
 799 }
 800
 801 }  // namespace Internal
 802
 803 }  // namespace Extension
 804
 805 }  // namespace Dali