src/e_test_event.cpp

   1 #include <Ecore_Wl2.h>
   2
   3 #include "e_test_event.h"
   4
   5 #define E_TEST_WORK_TIME 3.0
   6 #define E_TC_SIGN_WIN_INFO "usiiiiibbbiibbbbbi"
   7
   8 static const char effect_started[] = "effect,started";
   9 static const char effect_done[] = "effect,done";
  10 static const char launch_done[] = "launch,done";
  11
  12 /* callbacks - event */
  13 static void
  14 _cb_resource_id(void *data,
  15                 struct tizen_resource *tizen_resource,
  16                 uint32_t id)
  17 {
  18    Ecore_Window *res_id = (Ecore_Window *)data;
  19    *res_id = id;
  20    etRunner::get().finishWork();
  21 }
  22
  23 static void
  24 _cb_geometry(void *data EINA_UNUSED,
  25              struct wl_output *wl_output EINA_UNUSED,
  26              int x, int y, int w, int h,
  27              int subpixel EINA_UNUSED,
  28              const char *make EINA_UNUSED,
  29              const char *model EINA_UNUSED,
  30              int transform EINA_UNUSED)
  31 {
  32    etRunner::get().output.x = x;
  33    etRunner::get().output.y = y;
  34    etRunner::get().output.w = w;
  35    etRunner::get().output.h = h;
  36 }
  37
  38 static void
  39 _cb_mode(void *data EINA_UNUSED,
  40          struct wl_output *wl_output EINA_UNUSED,
  41          unsigned int flags,
  42          int w, int h,
  43          int refresh EINA_UNUSED)
  44 {
  45    if (flags & WL_OUTPUT_MODE_CURRENT)
  46      {
  47         etRunner::get().output.w = w;
  48         etRunner::get().output.h = h;
  49      }
  50
  51    etRunner::get().finishWork();
  52 }
  53
  54 static void
  55 _cb_done(void *data EINA_UNUSED,
  56          struct wl_output *output EINA_UNUSED)
  57 {
  58    ;
  59 }
  60
  61 static void
  62 _cb_scale(void *data EINA_UNUSED,
  63           struct wl_output *output EINA_UNUSED,
  64           int scale EINA_UNUSED)
  65 {
  66    ;
  67 }
  68
  69 /* callbacks - method */
  70 static void _cb_method_win_info_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  71 static void _cb_method_win_info_list_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  72 static void _cb_method_window_register(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  73 static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  74 static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  75 static void _cb_method_set_tc_start_end(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  76 static void _cb_method_transient_for_below(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
  77
  78 /* callbacks - signal */
  79 static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg);
  80 static void _cb_signal_stack_changed(void *data, const Eldbus_Message *msg);
  81 static void _cb_signal_win_rot_changed(void *data, const Eldbus_Message *msg);
  82 static void _cb_signal_focus_changed(void *data, const Eldbus_Message *msg);
  83 static void _cb_signal_render_while_effect_run(void *data, const Eldbus_Message *msg);
  84 static void _cb_signal_aux_hint_changed(void *data, const Eldbus_Message *msg);
  85
  86 /* callbacks - ecore */
  87 static Eina_Bool _cb_ecore_key_down(void *data, int type, void *event);
  88 static Eina_Bool _cb_ecore_key_up(void *data, int type, void *event);
  89
  90 /* callbacks - evas */
  91 static void _cb_evas_key_down(void * data, Evas * evas, Evas_Object * obj, void * event_info);
  92 static void _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info);
  93
  94 /* callbacks -  smart  */
  95 static void _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info);
  96 static void _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info);
  97 static void _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info);
  98
  99 /* callbacks - timer */
 100 static Eina_Bool _cb_work_timeout(void *data);
 101
 102 /* callbacks - gesture */
 103 static Eina_Bool _cb_gesture_tap(void *data, int type, void *event);
 104 static Eina_Bool _cb_gesture_edge_swipe(void *data, int type, void *event);
 105 static Eina_Bool _cb_gesture_edge_drag(void *data, int type, void *event);
 106
 107 /**********************
 108       listeners
 109  **********************/
 110 static const struct tizen_resource_listener _e_test_tizen_resource_listener =
 111 {
 112    _cb_resource_id,
 113 };
 114
 115 static const struct wl_output_listener _e_test_output_listener =
 116 {
 117    _cb_geometry,
 118    _cb_mode,
 119    _cb_done,
 120    _cb_scale
 121 };
 122
 123 /**********************
 124    class etRunner
 125  **********************/
 126 etRunner etRunner::inst;
 127
 128 Eina_Bool
 129 etRunner::init()
 130 {
 131    Eina_Bool res = EINA_FALSE;
 132
 133    worker.waitTime = E_TEST_WORK_TIME;
 134
 135    logDomain = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
 136
 137    // Init Ecore_Wl2
 138    if (!ecore_wl2_connected_display_get(NULL))
 139      ecore_wl2_display_connect(NULL);
 140
 141    // init tizen_extension protocol
 142    res = initProtocols();
 143    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 144
 145    // init eldbus
 146    eldbus_init();
 147
 148    dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
 149    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.conn, EINA_FALSE);
 150
 151    dbus.ds_obj = eldbus_object_get(dbus.conn,
 152                                 "org.enlightenment.wm",
 153                                 "/org/enlightenment/wm");
 154    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.ds_obj, EINA_FALSE);
 155
 156    dbus.ds_proxy = eldbus_proxy_get(dbus.ds_obj,
 157                                  "org.enlightenment.wm.Test");
 158    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.ds_proxy, EINA_FALSE);
 159
 160    dbus.deviced_obj = eldbus_object_get(dbus.conn,
 161                                         "org.tizen.system.deviced",
 162                                         "/Org/Tizen/System/DeviceD/Display");
 163    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.deviced_obj, EINA_FALSE);
 164
 165    dbus.deviced_proxy = eldbus_proxy_get(dbus.deviced_obj,
 166                                          "org.tizen.system.deviced.display");
 167    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.deviced_proxy, EINA_FALSE);
 168
 169    // reset registered window of e_test_helper
 170    res = resetRegisterWin();
 171    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 172
 173    // init input generator
 174    inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
 175    EINA_SAFETY_ON_NULL_RETURN_VAL(inputGenerator, EINA_FALSE);
 176
 177    // init gesture handler
 178    gestureHandler = efl_util_gesture_initialize();
 179    EINA_SAFETY_ON_NULL_RETURN_VAL(gestureHandler, EINA_FALSE);
 180
 181    // add signal handlers
 182    res = addSignalHandlers();
 183    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 184
 185    return EINA_TRUE;
 186 }
 187
 188 void
 189 etRunner::shutdown()
 190 {
 191    eina_log_domain_unregister(logDomain);
 192
 193    freeLastWinInfoList();
 194    delSignalHandlers();
 195
 196    // deinit tizen_extension protocol
 197    if (tzPolicy)
 198      {
 199         tizen_policy_destroy(tzPolicy);
 200         tzPolicy = NULL;
 201      }
 202
 203    if (tzSurface)
 204      {
 205         tizen_surface_destroy(tzSurface);
 206         tzSurface = NULL;
 207      }
 208
 209    if (tzlaunch_splash)
 210      {
 211         tizen_launch_splash_destroy(tzlaunch_splash);
 212         tzlaunch_splash = NULL;
 213      }
 214
 215    if (tzlaunch_effect)
 216      {
 217         tizen_launch_effect_destroy(tzlaunch_effect);
 218         tzlaunch_effect = NULL;
 219      }
 220
 221    // deinit eldbus
 222    eldbus_proxy_unref(dbus.deviced_proxy);
 223    eldbus_object_unref(dbus.deviced_obj);
 224    eldbus_proxy_unref(dbus.ds_proxy);
 225    eldbus_object_unref(dbus.ds_obj);
 226    eldbus_connection_unref(dbus.conn);
 227    eldbus_shutdown();
 228
 229    // deinit input generator
 230    efl_util_input_deinitialize_generator(inputGenerator);
 231
 232    // deinit gesture handler
 233    efl_util_gesture_deinitialize(gestureHandler);
 234 }
 235
 236 Eina_Bool
 237 etRunner::registerWin(etWin *tw)
 238 {
 239    Eldbus_Pending *p = NULL;
 240    Eina_Bool accepted = EINA_FALSE;
 241
 242    p = eldbus_proxy_call(dbus.ds_proxy,
 243                          "RegisterWindow",
 244                          _cb_method_window_register,
 245                          &accepted,
 246                          -1,
 247                          "u",
 248                          tw->native_win);
 249    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 250
 251    work();
 252
 253    return accepted;
 254 }
 255
 256 Eina_Bool
 257 etRunner::deregisterWin(etWin *tw)
 258 {
 259    Eldbus_Pending *p = NULL;
 260    Eina_Bool accepted = EINA_FALSE;
 261
 262    p = eldbus_proxy_call(dbus.ds_proxy,
 263                          "DeregisterWindow",
 264                          _cb_method_window_register,
 265                          &accepted,
 266                          -1,
 267                          "u",
 268                          tw->native_win);
 269    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 270
 271    work();
 272
 273    return accepted;
 274 }
 275
 276 Eina_Bool
 277 etRunner::resetRegisterWin()
 278 {
 279    Eldbus_Pending *p = NULL;
 280    Eina_Bool accepted = EINA_FALSE;
 281
 282    p = eldbus_proxy_call(dbus.ds_proxy,
 283                          "ResetRegisterWindow",
 284                          _cb_method_window_register,
 285                          &accepted,
 286                          -1,
 287                          "");
 288    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 289
 290    work();
 291
 292    return accepted;
 293 }
 294
 295 Eina_Bool
 296 etRunner::setWinActivate(etWin *tw)
 297 {
 298    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 299
 300    tw->updateGeometry();
 301
 302    tizen_policy_activate(tzPolicy,
 303                          getWlSurface(tw->elm_win));
 304
 305    return EINA_TRUE;
 306 }
 307
 308 Eina_Bool
 309 etRunner::requestKillWinByName(const char *name)
 310 {
 311    Eldbus_Pending *p = NULL;
 312
 313    EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
 314
 315    p = eldbus_proxy_call(dbus.ds_proxy,
 316                          "RequestKillWin",
 317                          NULL,
 318                          NULL,
 319                          -1,
 320                          "s",
 321                          name);
 322    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 323
 324    return EINA_TRUE;
 325 }
 326
 327 Eina_Bool
 328 etRunner::setWinIconic(etWin *tw,
 329                       Eina_Bool set)
 330 {
 331    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 332
 333    if (set)
 334      tizen_policy_iconify(tzPolicy,
 335                           getWlSurface(tw->elm_win));
 336    else
 337      tizen_policy_uniconify(tzPolicy,
 338                             getWlSurface(tw->elm_win));
 339
 340    return EINA_TRUE;
 341 }
 342
 343 Eina_Bool
 344 etRunner::setWinStack(etWin *tw,
 345                       etWin *sibiling,
 346                       Eina_Bool above)
 347 {
 348    Eldbus_Pending *p = NULL;
 349    p = eldbus_proxy_call(dbus.ds_proxy,
 350                          "SetWindowStack",
 351                          NULL,
 352                          NULL,
 353                          -1,
 354                          "uui",
 355                          tw->native_win,
 356                          sibiling? sibiling->native_win : 0,
 357                          above);
 358    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 359
 360    return EINA_TRUE;
 361 }
 362
 363 Eina_Bool
 364 etRunner::setWinRaise(etWin *tw)
 365 {
 366    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 367
 368    tizen_policy_raise(tzPolicy, getWlSurface(tw->elm_win));
 369
 370    return EINA_TRUE;
 371 }
 372
 373 Eina_Bool
 374 etRunner::setWinLower(etWin *tw)
 375 {
 376    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 377
 378    tizen_policy_lower(tzPolicy, getWlSurface(tw->elm_win));
 379
 380    return EINA_TRUE;
 381 }
 382
 383 Eina_Bool
 384 etRunner::setWinTransientFor(etWin *tw_child,
 385                              etWin *tw_parent,
 386                              Eina_Bool set)
 387 {
 388    EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
 389
 390    if (set)
 391      tizen_policy_set_transient_for(tzPolicy,
 392                                     tw_child->native_win,
 393                                     tw_parent->native_win);
 394    else
 395      tizen_policy_unset_transient_for(tzPolicy,
 396                                       tw_child->native_win);
 397
 398    return EINA_TRUE;
 399 }
 400
 401 Eina_Bool
 402 etRunner::setWinTransientForBelow(etWin *tw_child,
 403                                   etWin *tw_parent,
 404                                   Eina_Bool set)
 405 {
 406    Eina_Bool accepted = EINA_FALSE;
 407    Eldbus_Pending *p = NULL;
 408
 409    p = eldbus_proxy_call(dbus.ds_proxy,
 410                          "SetWindowTransientForBelow",
 411                          _cb_method_transient_for_below,
 412                          &accepted,
 413                          -1,
 414                          "uub",
 415                          tw_child->native_win,
 416                          tw_parent->native_win,
 417                          set);
 418    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 419
 420    work();
 421
 422    return accepted;
 423 }
 424
 425 Eina_Bool
 426 etRunner::setWinNotiLevel(etWin *tw,
 427                           efl_util_notification_level_e lv)
 428 {
 429    Eina_Bool res = EINA_FALSE;
 430
 431    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 432
 433    res = efl_util_set_notification_window_level(tw->elm_win, lv);
 434    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EINA_FALSE);
 435
 436    return EINA_TRUE;
 437 }
 438
 439 efl_util_notification_level_e
 440 etRunner::getWinNotiLevel(etWin *tw)
 441 {
 442    Eina_Bool res = EINA_FALSE;
 443    efl_util_notification_level_e lv = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
 444
 445    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 446
 447    res = efl_util_get_notification_window_level(tw->elm_win, &lv);
 448    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 449
 450    return lv;
 451 }
 452
 453 Eina_Bool
 454 etRunner::setFocusSkip(etWin *tw, Eina_Bool set)
 455 {
 456    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 457
 458    if (set)
 459      tizen_policy_set_focus_skip(tzPolicy,
 460                                  getWlSurface(tw->elm_win));
 461    else
 462      tizen_policy_unset_focus_skip(tzPolicy,
 463                                    getWlSurface(tw->elm_win));
 464
 465    return EINA_TRUE;
 466 }
 467
 468 Eina_Bool
 469 etRunner::setFocusSkipEcoreWl2(etWin *tw, Eina_Bool set)
 470 {
 471    Ecore_Wl2_Window *wlwin = NULL;
 472
 473    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 474
 475    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 476    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 477
 478    ecore_wl2_window_focus_skip_set(wlwin, set);
 479
 480    return EINA_TRUE;
 481 }
 482
 483 Eina_Bool
 484 etRunner::setZoneRotation(int angle)
 485 {
 486    Eldbus_Pending *p = NULL;
 487    Eina_Bool allowed = EINA_FALSE;
 488
 489    p = eldbus_proxy_call(dbus.ds_proxy,
 490                          "ChangeZoneRotation",
 491                          _cb_method_zone_rotation_change,
 492                          &allowed,
 493                          -1,
 494                          "i",
 495                          angle);
 496    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 497
 498    work();
 499
 500    return allowed;
 501 }
 502
 503 Eina_Bool
 504 etRunner::setTCStart()
 505 {
 506    Eldbus_Pending *p = NULL;
 507    Eina_Bool res = EINA_FALSE;
 508
 509    p = eldbus_proxy_call(dbus.ds_proxy,
 510                          "StartTestCase",
 511                          _cb_method_set_tc_start_end,
 512                          &res,
 513                          -1,
 514                          "");
 515    EINA_SAFETY_ON_NULL_GOTO(p, err);
 516
 517    work();
 518
 519    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 520
 521    return EINA_TRUE;
 522
 523 err:
 524    setTCEnd();
 525    return EINA_FALSE;
 526 }
 527
 528 Eina_Bool
 529 etRunner::setTCEnd()
 530 {
 531    Eldbus_Pending *p = NULL;
 532    Eina_Bool res = EINA_FALSE;
 533
 534    p = eldbus_proxy_call(dbus.ds_proxy,
 535                          "EndTestCase",
 536                          _cb_method_set_tc_start_end,
 537                          &res,
 538                          -1,
 539                          "");
 540    if (p == NULL) res = EINA_FALSE;
 541
 542    work();
 543
 544    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 545
 546    return EINA_TRUE;
 547 }
 548
 549 Eina_Bool
 550 etRunner::getWinInfo(etWin *tw)
 551 {
 552    Eldbus_Pending *p = NULL;
 553    Ecore_Window win;
 554    int retry = 10;
 555
 556    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 557
 558    win = tw->native_win;
 559    retry = (int) win;
 560
 561    while (retry)
 562      {
 563         p = eldbus_proxy_call(dbus.ds_proxy,
 564                               "GetWinInfo",
 565                               _cb_method_win_info_get,
 566                               tw,
 567                               -1,
 568                               "u",
 569                               win);
 570         EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 571
 572         elm_run();
 573
 574         if ((tw->native_win == win) && (!tw->effect))
 575           return EINA_TRUE;
 576         else
 577           retry--;
 578      }
 579
 580    if (tw->native_win != win)
 581      {
 582         ERR("Something Wrong. Difference with quering window"
 583             "and received window from server");
 584         tw->native_win = win;
 585      }
 586
 587    return EINA_FALSE;
 588 }
 589
 590 Eina_List *
 591 etRunner::getWinInfoList()
 592 {
 593    Eldbus_Pending *p = NULL;
 594    Window_Info_List *info_list = NULL;
 595    etWin *tw = NULL;
 596    Eina_List *result = NULL;
 597
 598    info_list = E_NEW(Window_Info_List, 1);
 599    EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL);
 600
 601    while (info_list)
 602      {
 603         p = eldbus_proxy_call(dbus.ds_proxy,
 604                               "GetWinsInfo",
 605                               _cb_method_win_info_list_get,
 606                               info_list,
 607                               -1,
 608                               "");
 609         EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL);
 610
 611         work();
 612
 613         if (info_list->retry)
 614           {
 615              info_list->retry = EINA_FALSE;
 616              EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
 617                {
 618                   if (tw)
 619                     delete tw;
 620                }
 621
 622              continue;
 623           }
 624
 625         break;
 626      }
 627
 628    result = eina_list_clone(info_list->list);
 629    E_FREE(info_list);
 630
 631    freeLastWinInfoList();
 632    listWinInfo = result;
 633
 634    return result;
 635 }
 636
 637 void
 638 etRunner::freeWinInfoList(Eina_List *list)
 639 {
 640    etWin *tw = NULL;
 641
 642    EINA_SAFETY_ON_NULL_RETURN(list);
 643
 644    if (listWinInfo == list)
 645      listWinInfo = NULL;
 646
 647    EINA_LIST_CAST_FREE(list, tw, etWin*)
 648      {
 649         if (tw != NULL)
 650           delete tw;
 651      }
 652
 653    list = NULL;
 654 }
 655
 656 void
 657 etRunner::freeLastWinInfoList()
 658 {
 659    if (listWinInfo)
 660      freeWinInfoList(listWinInfo);
 661
 662    listWinInfo = NULL;
 663 }
 664
 665 void
 666 etRunner::setLastWinInfoList(Eina_List *list)
 667 {
 668    EINA_SAFETY_ON_NULL_RETURN(list);
 669
 670    freeLastWinInfoList();
 671
 672    listWinInfo = list;
 673 }
 674
 675 Ecore_Window
 676 etRunner::getWinId(Evas_Object *elm_win)
 677 {
 678    struct wl_surface *surf = NULL;
 679    Ecore_Window id = 0;
 680    struct tizen_resource *tzres = NULL;
 681
 682    surf = getWlSurface(elm_win);
 683    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
 684
 685    tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
 686    EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
 687
 688    tizen_resource_add_listener(tzres,
 689                                &_e_test_tizen_resource_listener, &id);
 690
 691    work();
 692
 693    tizen_resource_destroy(tzres);
 694
 695    return id;
 696 }
 697
 698 struct wl_surface *
 699 etRunner::getWlSurface(Evas_Object *elm_win)
 700 {
 701    Ecore_Wl2_Window *wlwin = NULL;
 702    struct wl_surface *surf = NULL;
 703
 704    EINA_SAFETY_ON_NULL_RETURN_VAL(elm_win, NULL);
 705
 706    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
 707    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, NULL);
 708
 709    surf = ecore_wl2_window_surface_get(wlwin);
 710    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, NULL);
 711
 712    return surf;
 713 }
 714
 715 Eina_Bool
 716 etRunner::setDpms(Eina_Bool on)
 717 {
 718    Eldbus_Pending *p = NULL;
 719    p = eldbus_proxy_call(dbus.ds_proxy,
 720                          "DPMS",
 721                          NULL,
 722                          NULL,
 723                          -1,
 724                          "u",
 725                          on);
 726    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 727    return EINA_TRUE;
 728 }
 729
 730 Eina_Bool
 731 etRunner::setDevctlDisplayLock(Eina_Bool lock)
 732 {
 733    Eldbus_Pending *p = NULL;
 734
 735    if (lock)
 736      {
 737         p = eldbus_proxy_call(dbus.deviced_proxy,
 738                               "lockstate",
 739                               NULL,
 740                               NULL,
 741                               -1,
 742                               "sssi",
 743                               "lcdon",
 744                               "gotostatenow",
 745                               "holdkeyblock",
 746                               "0");
 747      }
 748    else
 749      {
 750         p = eldbus_proxy_call(dbus.deviced_proxy,
 751                               "unlockstate",
 752                               NULL,
 753                               NULL,
 754                               -1,
 755                               "ss",
 756                               "lcdon",
 757                               "resettimer");
 758      }
 759    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 760
 761    return EINA_TRUE;
 762 }
 763
 764 Eina_Bool
 765 etRunner::setDevctlDisplayOn(Eina_Bool on)
 766 {
 767    Eldbus_Pending *p = NULL;
 768
 769    p = eldbus_proxy_call(dbus.deviced_proxy,
 770                          "changestate",
 771                          NULL,
 772                          NULL,
 773                          -1,
 774                          "s",
 775                          on? "lcdon" : "lcdoff");
 776    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 777
 778    return EINA_TRUE;
 779 }
 780
 781 Eina_Bool
 782 etRunner::feedMouseDown(int x, int y)
 783 {
 784    Eldbus_Pending *p = NULL;
 785    p = eldbus_proxy_call(dbus.ds_proxy,
 786                          "EventMouse",
 787                          NULL,
 788                          NULL,
 789                          -1,
 790                          "uii",
 791                          0,
 792                          x, y);
 793    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 794    return EINA_TRUE;
 795 }
 796
 797 Eina_Bool
 798 etRunner::feedMouseMove(int x, int y)
 799 {
 800    Eldbus_Pending *p = NULL;
 801    p = eldbus_proxy_call(dbus.ds_proxy,
 802                          "EventMouse",
 803                          NULL,
 804                          NULL,
 805                          -1,
 806                          "uii",
 807                          1,
 808                          x, y);
 809    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 810    return EINA_TRUE;
 811 }
 812
 813 Eina_Bool
 814 etRunner::feedMouseUp(int x, int y)
 815 {
 816    Eldbus_Pending *p = NULL;
 817    p = eldbus_proxy_call(dbus.ds_proxy,
 818                          "EventMouse",
 819                          NULL,
 820                          NULL,
 821                          -1,
 822                          "uii",
 823                          2,
 824                          x, y);
 825    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 826    return EINA_TRUE;
 827 }
 828
 829 Eina_Bool
 830 etRunner::feedKeyDown(const char *key)
 831 {
 832    Eldbus_Pending *p = NULL;
 833    p = eldbus_proxy_call(dbus.ds_proxy,
 834                          "EventKey",
 835                          NULL,
 836                          NULL,
 837                          -1,
 838                          "us",
 839                          0,
 840                          key);
 841    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 842    return EINA_TRUE;
 843 }
 844
 845 Eina_Bool
 846 etRunner::feedKeyUp(const char *key)
 847 {
 848    Eldbus_Pending *p = NULL;
 849    p = eldbus_proxy_call(dbus.ds_proxy,
 850                          "EventKey",
 851                          NULL,
 852                          NULL,
 853                          -1,
 854                          "us",
 855                          1,
 856                          key);
 857    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 858    return EINA_TRUE;
 859 }
 860
 861 Eina_Bool
 862 etRunner::generateMouseDown(int x, int y)
 863 {
 864    // Using efl_util_input_generate instead of generate event by eldbus
 865    int ret = EFL_UTIL_ERROR_NONE;
 866
 867    if (inputGenerator == NULL)
 868      {
 869         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 870         work();
 871      }
 872
 873    ret = efl_util_input_generate_touch(inputGenerator,
 874                                        0,
 875                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
 876                                        x, y);
 877    if (ret != EFL_UTIL_ERROR_NONE)
 878      {
 879         efl_util_input_deinitialize_generator(inputGenerator);
 880         inputGenerator = NULL;
 881         return EINA_FALSE;
 882      }
 883
 884    return EINA_TRUE;
 885 }
 886
 887 Eina_Bool
 888 etRunner::generateMouseMove(int x, int y)
 889 {
 890    // Using efl_util_input_generate instead of generate event by eldbus
 891    int ret = EFL_UTIL_ERROR_NONE;
 892
 893    if (inputGenerator == NULL)
 894      {
 895         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 896         work();
 897      }
 898
 899    ret = efl_util_input_generate_touch(inputGenerator,
 900                                        0,
 901                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
 902                                        x, y);
 903    if (ret != EFL_UTIL_ERROR_NONE)
 904      {
 905         efl_util_input_deinitialize_generator(inputGenerator);
 906         inputGenerator = NULL;
 907         return EINA_FALSE;
 908      }
 909
 910    return EINA_TRUE;
 911 }
 912
 913 Eina_Bool
 914 etRunner::generateMouseUp(int x, int y)
 915 {
 916    // Using efl_util_input_generate instead of generate event by eldbus
 917    int ret = EFL_UTIL_ERROR_NONE;
 918
 919    if (inputGenerator == NULL)
 920      {
 921         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 922         work();
 923      }
 924
 925    ret = efl_util_input_generate_touch(inputGenerator,
 926                                        0,
 927                                        EFL_UTIL_INPUT_TOUCH_END,
 928                                        x, y);
 929    if (ret != EFL_UTIL_ERROR_NONE)
 930      {
 931         efl_util_input_deinitialize_generator(inputGenerator);
 932         inputGenerator = NULL;
 933         return EINA_FALSE;
 934      }
 935
 936    return EINA_TRUE;
 937 }
 938
 939 Eina_Bool
 940 etRunner::generateKeyPress(const char *keyname)
 941 {
 942    // Using efl_util_input_generate instead of generate event by eldbus
 943    int ret = EFL_UTIL_ERROR_NONE;
 944
 945    if (inputGenerator == NULL)
 946      {
 947         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
 948         work();
 949      }
 950
 951    ret = efl_util_input_generate_key(inputGenerator,
 952                                        keyname,
 953                                        1);
 954    if (ret != EFL_UTIL_ERROR_NONE)
 955      {
 956         efl_util_input_deinitialize_generator(inputGenerator);
 957         inputGenerator = NULL;
 958         return EINA_FALSE;
 959      }
 960
 961    return EINA_TRUE;
 962 }
 963
 964 Eina_Bool
 965 etRunner::generateKeyRelease(const char *keyname)
 966 {
 967    // Using efl_util_input_generate instead of generate event by eldbus
 968    int ret = EFL_UTIL_ERROR_NONE;
 969
 970    if (inputGenerator == NULL)
 971      {
 972         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
 973         work();
 974      }
 975
 976    ret = efl_util_input_generate_key(inputGenerator,
 977                                        keyname,
 978                                        0);
 979    if (ret != EFL_UTIL_ERROR_NONE)
 980      {
 981         efl_util_input_deinitialize_generator(inputGenerator);
 982         inputGenerator = NULL;
 983         return EINA_FALSE;
 984      }
 985
 986    return EINA_TRUE;
 987 }
 988
 989 Eina_Bool
 990 etRunner::generateKeyEvent(const char *keyname, double delay)
 991 {
 992    Eina_Bool res = EINA_FALSE;
 993
 994    res = etRunner::get().generateKeyPress(keyname);
 995    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 996
 997    res = etRunner::get().generateKeyRelease(keyname);
 998    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 999
1000    return res;
1001 }
1002
1003 Eina_Bool
1004 etRunner::generateTouchDown(int idx, int x, int y)
1005 {
1006    // Using efl_util_input_generate instead of generate event by eldbus
1007    int ret = EFL_UTIL_ERROR_NONE;
1008
1009    if (inputGenerator == NULL)
1010      {
1011         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1012         work();
1013      }
1014
1015    ret = efl_util_input_generate_touch(inputGenerator,
1016                                        idx,
1017                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
1018                                        x, y);
1019    if (ret != EFL_UTIL_ERROR_NONE)
1020      {
1021         efl_util_input_deinitialize_generator(inputGenerator);
1022         inputGenerator = NULL;
1023         return EINA_FALSE;
1024      }
1025
1026    return EINA_TRUE;
1027 }
1028
1029 Eina_Bool
1030 etRunner::generateTouchMove(int idx, int x, int y)
1031 {
1032    // Using efl_util_input_generate instead of generate event by eldbus
1033    int ret = EFL_UTIL_ERROR_NONE;
1034
1035    if (inputGenerator == NULL)
1036      {
1037         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1038         work();
1039      }
1040
1041    ret = efl_util_input_generate_touch(inputGenerator,
1042                                        idx,
1043                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
1044                                        x, y);
1045    if (ret != EFL_UTIL_ERROR_NONE)
1046      {
1047         efl_util_input_deinitialize_generator(inputGenerator);
1048         inputGenerator = NULL;
1049         return EINA_FALSE;
1050      }
1051
1052    return EINA_TRUE;
1053 }
1054
1055 Eina_Bool
1056 etRunner::generateTouchUp(int idx, int x, int y)
1057 {
1058    // Using efl_util_input_generate instead of generate event by eldbus
1059    int ret = EFL_UTIL_ERROR_NONE;
1060
1061    if (inputGenerator == NULL)
1062      {
1063         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1064         work();
1065      }
1066
1067    ret = efl_util_input_generate_touch(inputGenerator,
1068                                        idx,
1069                                        EFL_UTIL_INPUT_TOUCH_END,
1070                                        x, y);
1071    if (ret != EFL_UTIL_ERROR_NONE)
1072      {
1073         efl_util_input_deinitialize_generator(inputGenerator);
1074         inputGenerator = NULL;
1075         return EINA_FALSE;
1076      }
1077
1078    return EINA_TRUE;
1079 }
1080
1081 Eina_Bool
1082 etRunner::setSplashLaunch(const char *path, int type)
1083 {
1084    const char *effect_type = "launch";
1085    struct wl_array option;
1086
1087    // init tzlaunch_splash
1088    if (tzlaunch_splash)
1089      {
1090         tizen_launch_splash_destroy(tzlaunch_splash);
1091         tzlaunch_splash = NULL;
1092      }
1093    if (tzlaunch_effect) tzlaunch_splash = tizen_launch_effect_create_splash_img(tzlaunch_effect);
1094    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1095
1096    wl_array_init(&option);
1097    tizen_launch_splash_launch(tzlaunch_splash, path, type,
1098                               24, 0, 0,
1099                               effect_type, NULL, &option);
1100    wl_array_release(&option);
1101
1102    return EINA_TRUE;
1103 }
1104
1105 Eina_Bool
1106 etRunner::setSplashOwner()
1107 {
1108
1109    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1110
1111    tizen_launch_splash_owner(tzlaunch_splash, (int)getpid());
1112
1113    return EINA_TRUE;
1114 }
1115
1116 Eina_Bool
1117 etRunner::setWinEffect(etWin *tw)
1118 {
1119    Eldbus_Pending *p = NULL;
1120    Eina_Bool accepted = EINA_FALSE;
1121
1122    this->ev.elm_win = tw->elm_win;
1123
1124    p = eldbus_proxy_call(dbus.ds_proxy,
1125                          "RenderTrace",
1126                          _cb_method_window_effect,
1127                          &accepted,
1128                          -1,
1129                          "us",
1130                          tw->native_win,
1131                          "effect");
1132    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1133
1134    work();
1135    return accepted;
1136 }
1137
1138 Eina_Bool
1139 etRunner::freezeEvent()
1140 {
1141    Eldbus_Pending *p = NULL;
1142    p = eldbus_proxy_call(dbus.ds_proxy,
1143                          "EventFreeze",
1144                          NULL,
1145                          NULL,
1146                          -1,
1147                          "u",
1148                          1);
1149    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1150    return EINA_TRUE;
1151 }
1152
1153 Eina_Bool
1154 etRunner::thawEvent()
1155 {
1156    Eldbus_Pending *p = NULL;
1157    p = eldbus_proxy_call(dbus.ds_proxy,
1158                          "EventFreeze",
1159                          NULL,
1160                          NULL,
1161                          -1,
1162                          "u",
1163                          0);
1164    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1165    return EINA_TRUE;
1166 }
1167
1168 Eina_Bool
1169 etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
1170 {
1171    E_TC_Event_Item *recv_item = NULL;
1172    Eina_Bool res = EINA_FALSE;
1173    Eina_List *l = NULL;
1174
1175    // swap event
1176    switch (ev_type)
1177      {
1178       case E_TC_EVENT_TYPE_VIS_ON:
1179       case E_TC_EVENT_TYPE_VIS_OFF:
1180       case E_TC_EVENT_TYPE_VIS_CHANGED:
1181          ev_type = E_TC_EVENT_TYPE_VIS_CHANGED;
1182          break;
1183       case E_TC_EVENT_TYPE_STACK_RAISE:
1184       case E_TC_EVENT_TYPE_STACK_LOWER:
1185       case E_TC_EVENT_TYPE_STACK_ABOVE:
1186       case E_TC_EVENT_TYPE_STACK_BELOW:
1187       case E_TC_EVENT_TYPE_STACK_CHANGED:
1188          ev_type = E_TC_EVENT_TYPE_STACK_CHANGED;
1189          break;
1190       default:
1191          break;
1192      }
1193
1194    // Add event callbacks if needs
1195    if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
1196      {
1197         ev.elm_win = win->elm_win;
1198         ev.native_win = win->native_win;
1199         ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
1200
1201         evas_object_smart_callback_add(this->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started, this);
1202         evas_object_smart_callback_add(this->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done, this);
1203         evas_object_smart_callback_add(this->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done, this);
1204      }
1205    else if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
1206      {
1207         ev.elm_win = win->elm_win;
1208         ev.native_win = win->native_win;
1209         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
1210         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
1211
1212         ev.key.evas_state = EINA_FALSE;
1213      }
1214
1215    // pre-waiting events
1216    work(0.5);
1217
1218    if (ev.wait_event_index == ev.last_event)
1219      {
1220         work(0.5); // waiting additional time
1221         if (ev.wait_event_index == ev.last_event)
1222           return EINA_FALSE;
1223      }
1224
1225    EINA_LIST_CAST_FOREACH(ev.recv_queue, l, recv_item, E_TC_Event_Item*)
1226      {
1227         if ((recv_item->win == (win?win->native_win:0)) &&
1228             (recv_item->type == ev_type))
1229           {
1230              ev.wait_event_index = recv_item;
1231              res = EINA_TRUE;
1232              break;
1233           }
1234      }
1235
1236    return res;
1237 }
1238
1239 void
1240 etRunner::flushEventQueue()
1241 {
1242    if (ev.recv_queue)
1243      {
1244         ev.recv_queue = eina_list_free(ev.recv_queue);
1245         ev.recv_queue = NULL;
1246      }
1247 }
1248
1249 Eina_Bool
1250 etRunner::insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type)
1251 {
1252    E_TC_Event_Item *item = E_NEW(E_TC_Event_Item, 1);
1253    EINA_SAFETY_ON_NULL_RETURN_VAL(item, EINA_FALSE);
1254
1255    item->win = id;
1256    item->type = ev_type;
1257    ev.recv_queue = eina_list_append(ev.recv_queue, item);
1258    ev.last_event = item;
1259
1260    return EINA_TRUE;
1261 }
1262
1263 Eina_Bool
1264 etRunner::isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type)
1265 {
1266    Eina_List *l = NULL;
1267    E_TC_Event_Item *item = NULL;
1268    Ecore_Window id = tw->native_win;
1269
1270    EINA_LIST_CAST_FOREACH(ev.recv_queue, l, item, E_TC_Event_Item*)
1271      {
1272         if (ev.last_checkpoint && ev.last_checkpoint != item)
1273           continue;
1274
1275         if ((item->win == id) && (item->type == ev_type))
1276           return EINA_TRUE;
1277      }
1278
1279    return EINA_FALSE;
1280 }
1281
1282 void
1283 etRunner::setEventCheckpoint()
1284 {
1285    ev.last_checkpoint = ev.last_event;
1286    return;
1287 }
1288
1289 Eina_Bool
1290 etRunner::addSignalHandlers()
1291 {
1292    Eldbus_Signal_Handler *sh = NULL;
1293    Ecore_Event_Handler *eh = NULL;
1294
1295    flushEventQueue();
1296
1297    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1298                                         "VisibilityChanged",
1299                                         _cb_signal_vis_changed,
1300                                         this);
1301    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1302    ev.sh_list = eina_list_append(ev.sh_list, sh);
1303
1304    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1305                                         "StackChanged",
1306                                         _cb_signal_stack_changed,
1307                                         this);
1308    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1309    ev.sh_list = eina_list_append(ev.sh_list, sh);
1310
1311    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1312                                         "WinRotationChanged",
1313                                         _cb_signal_win_rot_changed,
1314                                         this);
1315    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1316    ev.sh_list = eina_list_append(ev.sh_list, sh);
1317
1318    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1319                                         "FocusChanged",
1320                                         _cb_signal_focus_changed,
1321                                         this);
1322    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1323    ev.sh_list = eina_list_append(ev.sh_list, sh);
1324
1325    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1326                                         "RenderRun",
1327                                         _cb_signal_render_while_effect_run,
1328                                         this);
1329    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1330    ev.sh_list = eina_list_append(ev.sh_list, sh);
1331
1332    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1333                                         "AuxHintChanged",
1334                                         _cb_signal_aux_hint_changed,
1335                                         this);
1336    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1337    ev.sh_list = eina_list_append(ev.sh_list, sh);
1338
1339    eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key_down, this);
1340    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1341    ev.eh_list = eina_list_append(ev.eh_list, eh);
1342
1343    eh = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key_up, this);
1344    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1345    ev.eh_list = eina_list_append(ev.eh_list, eh);
1346
1347    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
1348    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1349    ev.eh_list = eina_list_append(ev.eh_list, eh);
1350
1351    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
1352    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1353    ev.eh_list = eina_list_append(ev.eh_list, eh);
1354
1355    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
1356    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1357    ev.eh_list = eina_list_append(ev.eh_list, eh);
1358
1359    ev.key.ecore_state = EINA_FALSE;
1360
1361    return EINA_TRUE;
1362
1363 err:
1364    printf("failed to init handlers\n");
1365    delSignalHandlers();
1366    return EINA_FALSE;
1367 }
1368
1369 void
1370 etRunner::delSignalHandlers()
1371 {
1372    Eldbus_Signal_Handler *sh = NULL;
1373    Ecore_Event_Handler *eh = NULL;
1374
1375    EINA_LIST_CAST_FREE(ev.sh_list, sh, Eldbus_Signal_Handler*)
1376      {
1377         eldbus_signal_handler_del(sh);
1378      }
1379
1380    EINA_LIST_CAST_FREE(ev.eh_list, eh, Ecore_Event_Handler*)
1381      {
1382         ecore_event_handler_del(eh);
1383      }
1384
1385    flushEventQueue();
1386 }
1387
1388 void
1389 etRunner::work()
1390 {
1391    /* give a turn to deal with deferred job for given time*/
1392    addTimer(worker.waitTime);
1393    elm_run();
1394 }
1395
1396 void
1397 etRunner::work(double time)
1398 {
1399    /* give a turn to deal with deferred job for given time*/
1400    if (time < 0.0) time = 0.0;
1401
1402    addTimer(time);
1403    elm_run();
1404 }
1405
1406 void
1407 etRunner::finishWork()
1408 {
1409    if (worker.timer)
1410      delTimer();
1411
1412    elm_exit();
1413 }
1414
1415 void
1416 etRunner::printWinInfoList()
1417 {
1418    etWin *tw = NULL;
1419    Eina_List *l = NULL, *ll = NULL;
1420
1421    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1422    l = getWinInfoList();
1423    EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
1424      {
1425         printf("%04d WinID:%5u alpha:%d %5d,%5d (%5dx%5d) vis(Win:%d Obj:%d Opaque:%2d Type:%2d Skip:%d) Icon:%d Focus(Win:%d Obj:%d) :: %20s\n",
1426                tw->layer,
1427                (unsigned int)tw->native_win,
1428                tw->alpha,
1429                tw->x, tw->y, tw->w, tw->h,
1430                tw->Vis.win,
1431                tw->Vis.obj,
1432                tw->Vis.opaque,
1433                tw->Vis.type,
1434                tw->Vis.skip,
1435                tw->iconic,
1436                tw->Focus.win,
1437                tw->Focus.obj,
1438                tw->name);
1439      }
1440    freeWinInfoList(l);
1441    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1442 }
1443
1444 void
1445 etRunner::delTimer()
1446 {
1447    if (!worker.timer) return;
1448
1449    ecore_timer_del(worker.timer);
1450    worker.timer = NULL;
1451 }
1452
1453 void
1454 etRunner::addTimer()
1455 {
1456    delTimer();
1457
1458    worker.timer = ecore_timer_add(worker.waitTime,
1459                                   _cb_work_timeout,
1460                                   this);
1461 }
1462
1463 void
1464 etRunner::addTimer(double time)
1465 {
1466    delTimer();
1467
1468    worker.timer = ecore_timer_add(time,
1469                                   _cb_work_timeout,
1470                                   this);
1471 }
1472
1473 void
1474 etRunner::waitForDestroy()
1475 {
1476    work(E_TEST_WORK_TIME);
1477 }
1478
1479 Eina_Bool
1480 etRunner::initProtocols()
1481 {
1482    Eina_Iterator *globals = NULL;
1483    Ecore_Wl2_Global *global = NULL;
1484    struct wl_registry *registry = NULL;
1485
1486    registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
1487    globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
1488
1489    EINA_SAFETY_ON_NULL_GOTO(registry, err);
1490    EINA_SAFETY_ON_NULL_GOTO(globals, err);
1491
1492    EINA_ITERATOR_FOREACH(globals, global)
1493      {
1494         if (!strcmp(global->interface, "tizen_policy"))
1495           {
1496              tzPolicy = (struct tizen_policy *)
1497                 wl_registry_bind(registry,
1498                                  global->id,
1499                                  &tizen_policy_interface,
1500                                  (global->version > 7)? 7 : global->version);
1501           }
1502         if (!strcmp(global->interface, "tizen_surface"))
1503           {
1504              tzSurface = (struct tizen_surface *)
1505                 wl_registry_bind(registry,
1506                                  global->id,
1507                                  &tizen_surface_interface,
1508                                  (global->version > 1)? 1 : global->version);
1509           }
1510         if (!strcmp(global->interface, "tizen_launch_effect"))
1511           {
1512              tzlaunch_effect = (struct tizen_launch_effect *)
1513                 wl_registry_bind(registry,
1514                                  global->id,
1515                                  &tizen_launch_effect_interface,
1516                                  (global->version > 1)? 1 : global->version);
1517           }
1518         if (!strcmp(global->interface, "wl_output"))
1519           {
1520              wlOutput = (struct wl_output *)
1521                 wl_registry_bind(registry,
1522                                  global->id,
1523                                  &wl_output_interface,
1524                                  (global->version > 2)? 2 : global->version);
1525              wl_output_add_listener(wlOutput, &_e_test_output_listener, NULL);
1526
1527              work();
1528
1529              if (wlOutput)
1530                {
1531                   wl_output_destroy(wlOutput);
1532                   wlOutput = NULL;
1533                }
1534           }
1535      }
1536
1537    EINA_SAFETY_ON_NULL_GOTO(tzPolicy, err);
1538    EINA_SAFETY_ON_NULL_GOTO(tzSurface, err);
1539    EINA_SAFETY_ON_NULL_GOTO(tzlaunch_effect, err);
1540
1541    eina_iterator_free(globals);
1542    return EINA_TRUE;
1543
1544 err:
1545    if (globals)
1546      eina_iterator_free(globals);
1547    return EINA_FALSE;
1548 }
1549
1550 /* callbacks - method */
1551 static void
1552 _cb_method_win_info_get(void *data,
1553                         const Eldbus_Message *msg,
1554                         Eldbus_Pending *p)
1555 {
1556    const char *name = NULL, *text = NULL, *wname = NULL;
1557    etWin *tw = NULL;
1558    Eina_Bool res = EINA_FALSE;
1559
1560    tw = (etWin *)data;
1561
1562    res = eldbus_message_error_get(msg, &name, &text);
1563    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1564
1565    res = eldbus_message_arguments_get
1566       (msg,
1567        E_TC_SIGN_WIN_INFO,
1568        &tw->native_win,
1569        &wname,
1570        &tw->x, &tw->y, &tw->w, &tw->h,
1571        &tw->layer,
1572        &tw->effect,
1573        &tw->Vis.win,
1574        &tw->Vis.obj,
1575        &tw->Vis.opaque,
1576        &tw->Vis.type,
1577        &tw->Vis.skip,
1578        &tw->iconic,
1579        &tw->alpha,
1580        &tw->Focus.win,
1581        &tw->Focus.obj,
1582        &tw->rot);
1583
1584    if (wname)
1585      {
1586         // change window name from char * to Eina_Stringshare
1587         if (tw->name)
1588           eina_stringshare_del(tw->name);
1589         tw->name = eina_stringshare_add(wname);
1590      }
1591
1592 finish:
1593    if ((name) || (text))
1594      {
1595         ERR("errname:%s errmsg:%s\n", name, text);
1596      }
1597
1598    etRunner::get().finishWork();
1599 }
1600
1601 static void
1602 _cb_method_win_info_list_get(void *data,
1603                              const Eldbus_Message *msg,
1604                              Eldbus_Pending *p)
1605 {
1606    const char *name = NULL, *text = NULL, *wname = NULL;
1607    Eldbus_Message_Iter *array = NULL, *ec = NULL;
1608    Window_Info_List *info_list = (Window_Info_List *)data;
1609    Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
1610
1611    if (info_list == NULL)
1612      goto finish;
1613
1614    res = eldbus_message_error_get(msg, &name, &text);
1615    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1616
1617    res = eldbus_message_arguments_get(msg, "a(" E_TC_SIGN_WIN_INFO ")", &array);
1618    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1619
1620    while (eldbus_message_iter_get_and_next(array, 'r', &ec))
1621      {
1622         etWin *tw = new etWin();
1623         if (!tw) continue;
1624
1625         res = eldbus_message_iter_arguments_get(
1626            ec,
1627            E_TC_SIGN_WIN_INFO,
1628            &tw->native_win,
1629            &wname,
1630            &tw->x, &tw->y, &tw->w, &tw->h,
1631            &tw->layer,
1632            &tw->effect,
1633            &tw->Vis.win,
1634            &tw->Vis.obj,
1635            &tw->Vis.opaque,
1636            &tw->Vis.type,
1637            &tw->Vis.skip,
1638            &tw->iconic,
1639            &tw->alpha,
1640            &tw->Focus.win,
1641            &tw->Focus.obj,
1642            &tw->rot);
1643
1644         if (wname)
1645           {
1646              // change name to eina_stringshare
1647              if (tw->name)
1648                {
1649                   WRN("Failed to get win info\n");
1650                   delete tw;
1651                   continue;
1652                }
1653              tw->name = eina_stringshare_add(wname);
1654           }
1655
1656         if (tw->effect)
1657           animating = EINA_TRUE;
1658
1659         if (!res)
1660           {
1661              WRN("Failed to get win info\n");
1662              delete tw;
1663              continue;
1664           }
1665
1666         info_list->list = eina_list_append(info_list->list, tw);
1667      }
1668
1669    if (animating)
1670      info_list->retry = EINA_TRUE;
1671
1672 finish:
1673    if ((name) || (text))
1674      {
1675         ERR("errname:%s errmsg:%s\n", name, text);
1676      }
1677
1678    etRunner::get().finishWork();
1679 }
1680
1681 static void
1682 _cb_method_window_register(void *data,
1683                            const Eldbus_Message *msg,
1684                            Eldbus_Pending *p)
1685 {
1686    const char *name = NULL, *text = NULL;
1687    Eina_Bool res = EINA_FALSE;
1688    Eina_Bool *accepted = (Eina_Bool *)data;
1689
1690    *accepted = EINA_FALSE;
1691
1692    res = eldbus_message_error_get(msg, &name, &text);
1693    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1694
1695    res = eldbus_message_arguments_get(msg, "b", accepted);
1696
1697 finish:
1698    if ((name) || (text))
1699      {
1700         ERR("errname: %s errmsg: %s\n", name, text);
1701      }
1702
1703    etRunner::get().finishWork();
1704 }
1705
1706 static void
1707 _cb_method_zone_rotation_change(void *data,
1708                                 const Eldbus_Message *msg,
1709                                 Eldbus_Pending *p)
1710 {
1711    const char *name = NULL, *text = NULL;
1712    Eina_Bool res = EINA_FALSE;
1713    Eina_Bool *allowed = (Eina_Bool *)data;
1714
1715    *allowed = EINA_FALSE;
1716
1717    res = eldbus_message_error_get(msg, &name, &text);
1718    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1719
1720    res = eldbus_message_arguments_get(msg, "b", allowed);
1721    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1722    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1723
1724 finish:
1725    if ((name) || (text))
1726      {
1727         ERR("errname: %s errmsg: %s\n", name, text);
1728      }
1729
1730    etRunner::get().finishWork();
1731 }
1732
1733 static void
1734 _cb_method_window_effect(void *data,
1735                                 const Eldbus_Message *msg,
1736                                 Eldbus_Pending *p)
1737 {
1738    const char *name = NULL, *text = NULL;
1739    Eina_Bool res = EINA_FALSE;
1740    Eina_Bool *allowed = (Eina_Bool *)data;
1741
1742    *allowed = EINA_FALSE;
1743
1744    res = eldbus_message_error_get(msg, &name, &text);
1745    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1746
1747    res = eldbus_message_arguments_get(msg, "b", allowed);
1748    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1749    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1750
1751 finish:
1752    if ((name) || (text))
1753      {
1754         ERR("errname: %s errmsg: %s\n", name, text);
1755      }
1756
1757    etRunner::get().finishWork();
1758 }
1759
1760 static void
1761 _cb_method_set_tc_start_end(void *data,
1762                             const Eldbus_Message *msg,
1763                             Eldbus_Pending *p)
1764 {
1765    const char *name = NULL, *text = NULL;
1766    Eina_Bool res = EINA_FALSE;
1767    Eina_Bool *accept = (Eina_Bool *)data;
1768
1769    *accept = EINA_FALSE;
1770
1771    res = eldbus_message_error_get(msg, &name, &text);
1772    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1773
1774    res = eldbus_message_arguments_get(msg, "b", accept);
1775    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1776    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1777
1778 finish:
1779    if ((name) || (text))
1780      {
1781         ERR("errname: %s errmsg: %s\n", name, text);
1782      }
1783
1784    etRunner::get().finishWork();
1785 }
1786
1787 static void
1788 _cb_method_transient_for_below(void *data,
1789                                const Eldbus_Message *msg,
1790                                Eldbus_Pending *p)
1791 {
1792    const char *name = NULL, *text = NULL;
1793    Eina_Bool res = EINA_FALSE;
1794    Eina_Bool *accept = (Eina_Bool *)data;
1795
1796    *accept = EINA_FALSE;
1797
1798    res = eldbus_message_error_get(msg, &name, &text);
1799    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1800
1801    res = eldbus_message_arguments_get(msg, "b", accept);
1802    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1803    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1804
1805 finish:
1806    if ((name) || (text))
1807      {
1808         ERR("errname: %s errmsg: %s\n", name, text);
1809      }
1810
1811    etRunner::get().finishWork();
1812 }
1813
1814 /* callbacks - signal */
1815 static void
1816 _cb_signal_vis_changed(void *data,
1817                        const Eldbus_Message *msg)
1818 {
1819    etRunner *runner = (etRunner *)data;
1820    const char *name = NULL, *text = NULL;
1821    Eina_Bool res = EINA_FALSE;
1822    int vis = 0;
1823    Ecore_Window id;
1824
1825    res = eldbus_message_error_get(msg, &name, &text);
1826    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1827
1828    res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
1829    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1830
1831    runner->insertEventQueue(id, E_TC_EVENT_TYPE_VIS_CHANGED);
1832
1833 finish:
1834    if ((name) || (text))
1835      {
1836         ERR("errname:%s errmsg:%s\n", name, text);
1837      }
1838 }
1839
1840 static void
1841 _cb_signal_stack_changed(void *data,
1842                          const Eldbus_Message *msg)
1843 {
1844    etRunner *runner = (etRunner *)data;
1845    const char *name = NULL, *text = NULL;
1846    Eina_Bool res = EINA_FALSE;
1847    Ecore_Window id = 0;
1848
1849    res = eldbus_message_error_get(msg, &name, &text);
1850    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1851
1852    res = eldbus_message_arguments_get(msg, "u", &id);
1853    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1854
1855    runner->insertEventQueue(id, E_TC_EVENT_TYPE_STACK_CHANGED);
1856
1857 finish:
1858    if ((name) || (text))
1859      {
1860         ERR("errname:%s errmsg:%s\n", name, text);
1861      }
1862 }
1863
1864 static void
1865 _cb_signal_win_rot_changed(void *data,
1866                            const Eldbus_Message *msg)
1867 {
1868    etRunner *runner = (etRunner *)data;
1869    const char *name = NULL, *text = NULL;
1870    Eina_Bool res = EINA_FALSE;
1871    int angle = 0;
1872    Ecore_Window id;
1873
1874    res = eldbus_message_error_get(msg, &name, &text);
1875    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1876
1877    /* TODO unused 'window id' and 'angle' */
1878    res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
1879    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1880
1881    runner->insertEventQueue(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
1882
1883 finish:
1884    if ((name) || (text))
1885      {
1886         ERR("errname:%s errmsg:%s\n", name, text);
1887      }
1888 }
1889
1890 static void
1891 _cb_signal_focus_changed(void *data,
1892                          const Eldbus_Message *msg)
1893 {
1894    etRunner *runner = (etRunner *)data;
1895    const char *name = NULL, *text = NULL;
1896    Eina_Bool res = EINA_FALSE;
1897    Ecore_Window id = 0;
1898
1899    res = eldbus_message_error_get(msg, &name, &text);
1900    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1901
1902    res = eldbus_message_arguments_get(msg, "u", &id);
1903    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1904
1905    runner->insertEventQueue(id, E_TC_EVENT_TYPE_FOCUS_CHANGED);
1906
1907 finish:
1908    if ((name) || (text))
1909      {
1910         ERR("errname:%s errmsg:%s\n", name, text);
1911      }
1912 }
1913
1914 static void
1915 _cb_signal_render_while_effect_run(void *data,
1916                       const Eldbus_Message *msg)
1917 {
1918    etRunner *runner = (etRunner *)data;
1919    const char *name = NULL, *text = NULL;
1920    Eina_Bool res = EINA_FALSE;
1921    Ecore_Window id = 0;
1922
1923    res = eldbus_message_error_get(msg, &name, &text);
1924    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1925
1926    res = eldbus_message_arguments_get(msg, "u", &id);
1927    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1928
1929    runner->insertEventQueue(id, E_TC_EVENT_TYPE_EFFECT);
1930
1931 finish:
1932    if ((name) || (text))
1933      {
1934         ERR("errname:%s errmsg:%s\n", name, text);
1935      }
1936 }
1937
1938 static void
1939 _cb_signal_aux_hint_changed(void *data,
1940                          const Eldbus_Message *msg)
1941 {
1942    etRunner *runner = (etRunner *)data;
1943    const char *name = NULL, *text = NULL;
1944    Eina_Bool res = EINA_FALSE;
1945    Ecore_Window win = 0;
1946    uint32_t hint_id;
1947    const char *hint_key, *hint_val;
1948
1949    res = eldbus_message_error_get(msg, &name, &text);
1950    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1951
1952    res = eldbus_message_arguments_get(msg, "uuss", &win, &hint_id, &hint_key, &hint_val);
1953    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1954
1955    runner->insertEventQueue(win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED);
1956
1957 finish:
1958    if ((name) || (text))
1959      {
1960         ERR("errname:%s errmsg:%s\n", name, text);
1961      }
1962 }
1963
1964 /* callbacks - timer */
1965 static Eina_Bool
1966 _cb_work_timeout(void *data)
1967 {
1968    etRunner::get().finishWork();
1969    return ECORE_CALLBACK_CANCEL;
1970 }
1971
1972 /* callbacks - ecore */
1973 static Eina_Bool
1974 _cb_ecore_key_down(void *data, int type, void *event)
1975 {
1976    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1977    etRunner *runner = (etRunner *)data;
1978
1979    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
1980
1981    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
1982      {
1983         if (runner->ev.key.ecore_state == EINA_FALSE &&
1984             type == ECORE_EVENT_KEY_DOWN)
1985           {
1986              runner->ev.key.ecore_state = EINA_TRUE;
1987           }
1988      }
1989
1990    return ECORE_CALLBACK_PASS_ON;
1991 }
1992
1993 static Eina_Bool
1994 _cb_ecore_key_up(void *data, int type, void *event)
1995 {
1996    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
1997    etRunner *runner = (etRunner *)data;
1998
1999    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2000
2001    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2002      {
2003         if (runner->ev.key.ecore_state == EINA_TRUE &&
2004             type == ECORE_EVENT_KEY_UP)
2005           {
2006              runner->ev.key.ecore_state = EINA_FALSE;
2007              runner->insertEventQueue(0, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
2008           }
2009      }
2010
2011    return ECORE_CALLBACK_PASS_ON;
2012 }
2013
2014 /* callbacks - evas */
2015 static void
2016 _cb_evas_key_down(void *data, Evas * evas, Evas_Object * obj, void * event_info)
2017 {
2018    Evas_Event_Key_Down *ev;
2019    etRunner *runner = (etRunner *)data;
2020
2021    ev = (Evas_Event_Key_Down *)event_info;
2022
2023    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2024      {
2025         if (runner->ev.key.evas_state == EINA_FALSE &&
2026             runner->ev.elm_win == obj)
2027           {
2028              runner->ev.key.evas_state = EINA_TRUE;
2029           }
2030      }
2031 }
2032
2033 static void
2034 _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info)
2035 {
2036    Evas_Event_Key_Up *ev;
2037    etRunner *runner = (etRunner *)data;
2038
2039    ev = (Evas_Event_Key_Up *)event_info;
2040
2041    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2042      {
2043         if (runner->ev.key.evas_state == EINA_TRUE &&
2044             runner->ev.elm_win == obj)
2045           {
2046              runner->ev.key.evas_state = EINA_FALSE;
2047              runner->ev.elm_win = NULL;
2048
2049              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
2050           }
2051      }
2052 }
2053
2054 /* callbacks -  smart object */
2055 static void
2056 _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info)
2057 {
2058    etRunner *runner = (etRunner *)data;
2059    if (runner && runner->ev.elm_win == obj)
2060      {
2061         runner->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED;
2062      }
2063 }
2064
2065 static void
2066 _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info)
2067 {
2068    etRunner *runner = (etRunner *)data;
2069    if (runner && runner->ev.elm_win == obj)
2070      {
2071         runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE;
2072
2073         runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2074
2075         evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2076         evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2077         evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2078      }
2079 }
2080
2081 static void
2082 _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info)
2083 {
2084    etRunner *runner = (etRunner *)data;
2085    if (runner && runner->ev.elm_win == obj)
2086      {
2087         runner->ev.effect.state_smcb  |= E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE;
2088
2089         if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
2090            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE) &&
2091            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE))
2092           {
2093              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2094
2095              evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2096              evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2097              evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2098           }
2099      }
2100 }
2101
2102 static Eina_Bool
2103 _cb_gesture_tap(void *data, int type, void *event)
2104 {
2105    etRunner *runner = (etRunner *)data;
2106    efl_util_event_gesture_tap_s *ev =
2107      (efl_util_event_gesture_tap_s *)event;
2108
2109    if ((ev->fingers == (unsigned int)runner->ev.gesture.tap.fingers) &&
2110        (ev->repeats == (unsigned int)runner->ev.gesture.tap.repeats))
2111      {
2112         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_TAP);
2113         //ecore_event_handler_del(runner->ev.key.eh);
2114      }
2115
2116    return ECORE_CALLBACK_PASS_ON;
2117 }
2118
2119 static Eina_Bool
2120 _cb_gesture_tap_delay_timer(void *data)
2121 {
2122    etRunner *runner = (etRunner *)data;
2123    int i;
2124
2125    for (i = 0; i < runner->ev.gesture.tap.fingers; i++)
2126      {
2127         if (!runner->ev.gesture.tap.pressed)
2128           {
2129             runner->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
2130           }
2131         else
2132           {
2133             runner->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
2134           }
2135      }
2136
2137    runner->ev.gesture.timer = NULL;
2138
2139    runner->ev.gesture.tap.pressed = !runner->ev.gesture.tap.pressed;
2140    if (!runner->ev.gesture.tap.pressed)
2141      {
2142         runner->ev.gesture.tap.current_repeats--;
2143      }
2144
2145    if (runner->ev.gesture.tap.current_repeats > 0)
2146      {
2147         runner->ev.gesture.timer = ecore_timer_add(0.11,
2148                                                    _cb_gesture_tap_delay_timer,
2149                                                    runner);
2150      }
2151
2152    return ECORE_CALLBACK_CANCEL;
2153 }
2154
2155 Eina_Bool
2156 etRunner::generateTapGesture()
2157 {
2158    ev.gesture.tap.current_repeats = ev.gesture.tap.repeats;
2159    ev.gesture.tap.pressed = EINA_FALSE;
2160
2161    ev.gesture.timer = ecore_timer_add(0.11,
2162                                       _cb_gesture_tap_delay_timer,
2163                                       this);
2164
2165    return EINA_TRUE;
2166 }
2167
2168 static Eina_Bool
2169 _cb_gesture_edge_swipe(void *data, int type, void *event)
2170 {
2171    etRunner *runner = (etRunner *)data;
2172    efl_util_event_gesture_edge_swipe_s *ev =
2173      (efl_util_event_gesture_edge_swipe_s *)event;
2174
2175    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2176        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge))
2177      {
2178         if (runner->ev.gesture.timer)
2179           runner->ev.gesture.edge.get_event = EINA_TRUE;
2180      }
2181
2182    return ECORE_CALLBACK_PASS_ON;
2183 }
2184
2185 static Eina_Bool
2186 _cb_gesture_edge_swipe_delay_timer(void *data)
2187 {
2188    etRunner *runner = (etRunner *)data;
2189    int i, cnt, fingers, w, h;
2190    efl_util_gesture_edge_e edge;
2191
2192    cnt = ++runner->ev.gesture.edge.touch_count;
2193    fingers = runner->ev.gesture.edge.fingers;
2194    edge = runner->ev.gesture.edge.edge;
2195    w = runner->output.w - 1;
2196    h = runner->output.h - 1;
2197
2198    if (cnt == 1)
2199      {
2200         for (i = 0; i < fingers; i++)
2201           {
2202              switch (edge)
2203                {
2204                   case EFL_UTIL_GESTURE_EDGE_TOP:
2205                     runner->generateTouchDown(i, 100 * (i + 1), 1);
2206                     break;
2207                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2208                     runner->generateTouchDown(i, w - 1, 100 * (i + 1));
2209                     break;
2210                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2211                     runner->generateTouchDown(i, 100 * (i + 1), h - 1);
2212                     break;
2213                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2214                     runner->generateTouchDown(i, 1, 100 * (i + 1));
2215                     break;
2216                   default:
2217                     break;
2218                }
2219           }
2220      }
2221    else if (cnt < 5)
2222      {
2223         for (i = 0; i < fingers; i++)
2224           {
2225              switch (edge)
2226                {
2227                   case EFL_UTIL_GESTURE_EDGE_TOP:
2228                     runner->generateTouchMove(i, 100 * (i + 1), 40 * cnt * cnt);
2229                     break;
2230                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2231                     runner->generateTouchMove(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2232                     break;
2233                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2234                     runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2235                     break;
2236                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2237                     runner->generateTouchMove(i, 40 * cnt * cnt, 100 * (i + 1));
2238                     break;
2239                   default:
2240                     break;
2241                }
2242           }
2243      }
2244    else
2245      {
2246         cnt--;
2247         for (i = 0; i < fingers; i++)
2248           {
2249              switch (edge)
2250                {
2251                   case EFL_UTIL_GESTURE_EDGE_TOP:
2252                     runner->generateTouchUp(i, 100 * (i + 1), 40 * cnt * cnt);
2253                     break;
2254                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2255                     runner->generateTouchUp(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2256                     break;
2257                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2258                     runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2259                     break;
2260                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2261                     runner->generateTouchUp(i, 40 * cnt * cnt, 100 * (i + 1));
2262                     break;
2263                   default:
2264                     break;
2265                }
2266           }
2267
2268         runner->ev.gesture.timer = NULL;
2269         if (runner->ev.gesture.edge.get_event)
2270           {
2271              runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
2272              //ecore_event_handler_del(runner->ev.key.eh);
2273           }
2274         return ECORE_CALLBACK_CANCEL;
2275      }
2276
2277    runner->ev.gesture.timer = NULL;
2278    runner->ev.gesture.timer = ecore_timer_add(0.11,
2279                                               _cb_gesture_edge_swipe_delay_timer,
2280                                               runner);
2281
2282    return ECORE_CALLBACK_CANCEL;
2283 }
2284
2285 Eina_Bool
2286 etRunner::generateEdgeSwipeGesture()
2287 {
2288    ev.gesture.edge.touch_count = 0;
2289    ev.gesture.edge.get_event = EINA_FALSE;
2290
2291    ev.gesture.timer = ecore_timer_add(0.11,
2292                                       _cb_gesture_edge_swipe_delay_timer,
2293                                       this);
2294
2295    return EINA_TRUE;
2296 }
2297
2298 static Eina_Bool
2299 _cb_gesture_edge_drag(void *data, int type, void *event)
2300 {
2301    etRunner *runner = (etRunner *)data;
2302    efl_util_event_gesture_edge_drag_s *ev =
2303      (efl_util_event_gesture_edge_drag_s *)event;
2304
2305    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2306        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge) &&
2307        (ev->mode == EFL_UTIL_GESTURE_MODE_END))
2308      {
2309         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
2310         //ecore_event_handler_del(runner->ev.key.eh);
2311      }
2312
2313    return ECORE_CALLBACK_PASS_ON;
2314 }
2315
2316 static Eina_Bool
2317 _cb_gesture_edge_drag_delay_timer(void *data)
2318 {
2319    etRunner *runner = (etRunner *)data;
2320    int i, cnt, fingers, w, h;
2321    efl_util_gesture_edge_e edge;
2322
2323    cnt = ++runner->ev.gesture.edge.touch_count;
2324    fingers = runner->ev.gesture.edge.fingers;
2325    edge = runner->ev.gesture.edge.edge;
2326    w = runner->output.w - 1;
2327    h = runner->output.h - 1;
2328
2329    if (cnt == 1)
2330      {
2331         for (i = 0; i < fingers; i++)
2332           {
2333              switch (edge)
2334                {
2335                   case EFL_UTIL_GESTURE_EDGE_TOP:
2336                     runner->generateTouchDown(i, 100 * (i + 1), 1);
2337                     break;
2338                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2339                     runner->generateTouchDown(i, w - 1, 100 * (i + 1));
2340                     break;
2341                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2342                     runner->generateTouchDown(i, 100 * (i + 1), h - 1);
2343                     break;
2344                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2345                     runner->generateTouchDown(i, 1, 100 * (i + 1));
2346                     break;
2347                   default:
2348                     break;
2349                }
2350           }
2351      }
2352    else if (cnt < 5)
2353      {
2354         for (i = 0; i < fingers; i++)
2355           {
2356              switch (edge)
2357                {
2358                   case EFL_UTIL_GESTURE_EDGE_TOP:
2359                     runner->generateTouchMove(i, 100 * (i + 1), 50 * cnt);
2360                     break;
2361                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2362                     runner->generateTouchMove(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2363                     break;
2364                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2365                     runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2366                     break;
2367                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2368                     runner->generateTouchMove(i, 50 * cnt, 100 * (i + 1));
2369                     break;
2370                   default:
2371                     break;
2372                }
2373           }
2374      }
2375    else
2376      {
2377         cnt--;
2378         for (i = 0; i < fingers; i++)
2379           {
2380              switch (edge)
2381                {
2382                   case EFL_UTIL_GESTURE_EDGE_TOP:
2383                     runner->generateTouchUp(i, 100 * (i + 1), 50 * cnt);
2384                     break;
2385                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2386                     runner->generateTouchUp(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2387                     break;
2388                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2389                     runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2390                     break;
2391                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2392                     runner->generateTouchUp(i, 50 * cnt, 100 * (i + 1));
2393                     break;
2394                   default:
2395                     break;
2396                }
2397           }
2398
2399         runner->ev.gesture.timer = NULL;
2400         return ECORE_CALLBACK_CANCEL;
2401      }
2402
2403    runner->ev.gesture.timer = NULL;
2404    runner->ev.gesture.timer = ecore_timer_add(0.11,
2405                                               _cb_gesture_edge_drag_delay_timer,
2406                                               runner);
2407
2408    return ECORE_CALLBACK_CANCEL;
2409 }
2410
2411 Eina_Bool
2412 etRunner::generateEdgeDragGesture()
2413 {
2414    ev.gesture.edge.touch_count = 0;
2415
2416    ev.gesture.timer = ecore_timer_add(0.11,
2417                                       _cb_gesture_edge_drag_delay_timer,
2418                                       this);
2419
2420    return EINA_TRUE;
2421 }