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