src/e_test_event.cpp

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