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