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::addAuxHint(etWin *tw, int hint_id, const char *hint_key, const char *hint_val)
 505 {
 506    Ecore_Wl2_Window *wlwin = NULL;
 507
 508    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 509
 510    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 511    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 512
 513    ecore_wl2_window_aux_hint_add(wlwin, hint_id, hint_key, hint_val);
 514
 515    return EINA_TRUE;
 516 }
 517
 518 Eina_Bool
 519 etRunner::changeAuxHint(etWin *tw, int hint_id, const char *hint_val)
 520 {
 521    Ecore_Wl2_Window *wlwin = NULL;
 522
 523    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 524
 525    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 526    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 527
 528    ecore_wl2_window_aux_hint_change(wlwin, hint_id, hint_val);
 529
 530    return EINA_TRUE;
 531 }
 532
 533 Eina_Bool
 534 etRunner::delAuxHint(etWin *tw, int hint_id)
 535 {
 536    Ecore_Wl2_Window *wlwin = NULL;
 537
 538    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 539
 540    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 541    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 542
 543    ecore_wl2_window_aux_hint_del(wlwin, hint_id);
 544
 545    return EINA_TRUE;
 546 }
 547
 548 Eina_Bool
 549 etRunner::setTCStart()
 550 {
 551    Eldbus_Pending *p = NULL;
 552    Eina_Bool res = EINA_FALSE;
 553
 554    p = eldbus_proxy_call(dbus.ds_proxy,
 555                          "StartTestCase",
 556                          _cb_method_set_tc_start_end,
 557                          &res,
 558                          -1,
 559                          "");
 560    EINA_SAFETY_ON_NULL_GOTO(p, err);
 561
 562    work();
 563
 564    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 565
 566    return EINA_TRUE;
 567
 568 err:
 569    setTCEnd();
 570    return EINA_FALSE;
 571 }
 572
 573 Eina_Bool
 574 etRunner::setTCEnd()
 575 {
 576    Eldbus_Pending *p = NULL;
 577    Eina_Bool res = EINA_FALSE;
 578
 579    p = eldbus_proxy_call(dbus.ds_proxy,
 580                          "EndTestCase",
 581                          _cb_method_set_tc_start_end,
 582                          &res,
 583                          -1,
 584                          "");
 585    if (p == NULL) res = EINA_FALSE;
 586
 587    work();
 588
 589    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 590
 591    return EINA_TRUE;
 592 }
 593
 594 Eina_Bool
 595 etRunner::getWinInfo(etWin *tw)
 596 {
 597    Eldbus_Pending *p = NULL;
 598    Ecore_Window win;
 599    int retry = 10;
 600
 601    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 602
 603    win = tw->native_win;
 604    retry = (int) win;
 605
 606    while (retry)
 607      {
 608         p = eldbus_proxy_call(dbus.ds_proxy,
 609                               "GetWinInfo",
 610                               _cb_method_win_info_get,
 611                               tw,
 612                               -1,
 613                               "u",
 614                               win);
 615         EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 616
 617         elm_run();
 618
 619         if ((tw->native_win == win) && (!tw->effect))
 620           return EINA_TRUE;
 621         else
 622           retry--;
 623      }
 624
 625    if (tw->native_win != win)
 626      {
 627         ERR("Something Wrong. Difference with quering window"
 628             "and received window from server");
 629         tw->native_win = win;
 630      }
 631
 632    return EINA_FALSE;
 633 }
 634
 635 Eina_List *
 636 etRunner::getWinInfoList()
 637 {
 638    Eldbus_Pending *p = NULL;
 639    Window_Info_List *info_list = NULL;
 640    etWin *tw = NULL;
 641    Eina_List *result = NULL;
 642
 643    info_list = E_NEW(Window_Info_List, 1);
 644    EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL);
 645
 646    while (info_list)
 647      {
 648         p = eldbus_proxy_call(dbus.ds_proxy,
 649                               "GetWinsInfo",
 650                               _cb_method_win_info_list_get,
 651                               info_list,
 652                               -1,
 653                               "");
 654         EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL);
 655
 656         work();
 657
 658         if (info_list->retry)
 659           {
 660              info_list->retry = EINA_FALSE;
 661              EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
 662                {
 663                   if (tw)
 664                     delete tw;
 665                }
 666
 667              continue;
 668           }
 669
 670         break;
 671      }
 672
 673    result = eina_list_clone(info_list->list);
 674    E_FREE(info_list);
 675
 676    freeLastWinInfoList();
 677    listWinInfo = result;
 678
 679    return result;
 680 }
 681
 682 void
 683 etRunner::freeWinInfoList(Eina_List *list)
 684 {
 685    etWin *tw = NULL;
 686
 687    EINA_SAFETY_ON_NULL_RETURN(list);
 688
 689    if (listWinInfo == list)
 690      listWinInfo = NULL;
 691
 692    EINA_LIST_CAST_FREE(list, tw, etWin*)
 693      {
 694         if (tw != NULL)
 695           delete tw;
 696      }
 697
 698    list = NULL;
 699 }
 700
 701 void
 702 etRunner::freeLastWinInfoList()
 703 {
 704    if (listWinInfo)
 705      freeWinInfoList(listWinInfo);
 706
 707    listWinInfo = NULL;
 708 }
 709
 710 void
 711 etRunner::setLastWinInfoList(Eina_List *list)
 712 {
 713    EINA_SAFETY_ON_NULL_RETURN(list);
 714
 715    freeLastWinInfoList();
 716
 717    listWinInfo = list;
 718 }
 719
 720 Ecore_Window
 721 etRunner::getWinId(Evas_Object *elm_win)
 722 {
 723    struct wl_surface *surf = NULL;
 724    Ecore_Window id = 0;
 725    struct tizen_resource *tzres = NULL;
 726
 727    surf = getWlSurface(elm_win);
 728    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
 729
 730    tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
 731    EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
 732
 733    tizen_resource_add_listener(tzres,
 734                                &_e_test_tizen_resource_listener, &id);
 735
 736    work();
 737
 738    tizen_resource_destroy(tzres);
 739
 740    return id;
 741 }
 742
 743 struct wl_surface *
 744 etRunner::getWlSurface(Evas_Object *elm_win)
 745 {
 746    Ecore_Wl2_Window *wlwin = NULL;
 747    struct wl_surface *surf = NULL;
 748
 749    EINA_SAFETY_ON_NULL_RETURN_VAL(elm_win, NULL);
 750
 751    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
 752    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, NULL);
 753
 754    surf = ecore_wl2_window_surface_get(wlwin);
 755    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, NULL);
 756
 757    return surf;
 758 }
 759
 760 Eina_Bool
 761 etRunner::setDpms(Eina_Bool on)
 762 {
 763    Eldbus_Pending *p = NULL;
 764    p = eldbus_proxy_call(dbus.ds_proxy,
 765                          "DPMS",
 766                          NULL,
 767                          NULL,
 768                          -1,
 769                          "u",
 770                          on);
 771    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 772    return EINA_TRUE;
 773 }
 774
 775 Eina_Bool
 776 etRunner::setDevctlDisplayLock(Eina_Bool lock)
 777 {
 778    Eldbus_Pending *p = NULL;
 779
 780    if (lock)
 781      {
 782         p = eldbus_proxy_call(dbus.deviced_proxy,
 783                               "lockstate",
 784                               NULL,
 785                               NULL,
 786                               -1,
 787                               "sssi",
 788                               "lcdon",
 789                               "gotostatenow",
 790                               "holdkeyblock",
 791                               "0");
 792      }
 793    else
 794      {
 795         p = eldbus_proxy_call(dbus.deviced_proxy,
 796                               "unlockstate",
 797                               NULL,
 798                               NULL,
 799                               -1,
 800                               "ss",
 801                               "lcdon",
 802                               "resettimer");
 803      }
 804    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 805
 806    return EINA_TRUE;
 807 }
 808
 809 Eina_Bool
 810 etRunner::setDevctlDisplayOn(Eina_Bool on)
 811 {
 812    Eldbus_Pending *p = NULL;
 813
 814    p = eldbus_proxy_call(dbus.deviced_proxy,
 815                          "changestate",
 816                          NULL,
 817                          NULL,
 818                          -1,
 819                          "s",
 820                          on? "lcdon" : "lcdoff");
 821    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 822
 823    return EINA_TRUE;
 824 }
 825
 826 Eina_Bool
 827 etRunner::feedMouseDown(int x, int y)
 828 {
 829    Eldbus_Pending *p = NULL;
 830    p = eldbus_proxy_call(dbus.ds_proxy,
 831                          "EventMouse",
 832                          NULL,
 833                          NULL,
 834                          -1,
 835                          "uii",
 836                          0,
 837                          x, y);
 838    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 839    return EINA_TRUE;
 840 }
 841
 842 Eina_Bool
 843 etRunner::feedMouseMove(int x, int y)
 844 {
 845    Eldbus_Pending *p = NULL;
 846    p = eldbus_proxy_call(dbus.ds_proxy,
 847                          "EventMouse",
 848                          NULL,
 849                          NULL,
 850                          -1,
 851                          "uii",
 852                          1,
 853                          x, y);
 854    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 855    return EINA_TRUE;
 856 }
 857
 858 Eina_Bool
 859 etRunner::feedMouseUp(int x, int y)
 860 {
 861    Eldbus_Pending *p = NULL;
 862    p = eldbus_proxy_call(dbus.ds_proxy,
 863                          "EventMouse",
 864                          NULL,
 865                          NULL,
 866                          -1,
 867                          "uii",
 868                          2,
 869                          x, y);
 870    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 871    return EINA_TRUE;
 872 }
 873
 874 Eina_Bool
 875 etRunner::feedKeyDown(const char *key)
 876 {
 877    Eldbus_Pending *p = NULL;
 878    p = eldbus_proxy_call(dbus.ds_proxy,
 879                          "EventKey",
 880                          NULL,
 881                          NULL,
 882                          -1,
 883                          "us",
 884                          0,
 885                          key);
 886    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 887    return EINA_TRUE;
 888 }
 889
 890 Eina_Bool
 891 etRunner::feedKeyUp(const char *key)
 892 {
 893    Eldbus_Pending *p = NULL;
 894    p = eldbus_proxy_call(dbus.ds_proxy,
 895                          "EventKey",
 896                          NULL,
 897                          NULL,
 898                          -1,
 899                          "us",
 900                          1,
 901                          key);
 902    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 903    return EINA_TRUE;
 904 }
 905
 906 Eina_Bool
 907 etRunner::generateMouseDown(int x, int y)
 908 {
 909    // Using efl_util_input_generate instead of generate event by eldbus
 910    int ret = EFL_UTIL_ERROR_NONE;
 911
 912    if (inputGenerator == NULL)
 913      {
 914         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 915         work();
 916      }
 917
 918    ret = efl_util_input_generate_touch(inputGenerator,
 919                                        0,
 920                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
 921                                        x, y);
 922    if (ret != EFL_UTIL_ERROR_NONE)
 923      {
 924         efl_util_input_deinitialize_generator(inputGenerator);
 925         inputGenerator = NULL;
 926         return EINA_FALSE;
 927      }
 928
 929    return EINA_TRUE;
 930 }
 931
 932 Eina_Bool
 933 etRunner::generateMouseMove(int x, int y)
 934 {
 935    // Using efl_util_input_generate instead of generate event by eldbus
 936    int ret = EFL_UTIL_ERROR_NONE;
 937
 938    if (inputGenerator == NULL)
 939      {
 940         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 941         work();
 942      }
 943
 944    ret = efl_util_input_generate_touch(inputGenerator,
 945                                        0,
 946                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
 947                                        x, y);
 948    if (ret != EFL_UTIL_ERROR_NONE)
 949      {
 950         efl_util_input_deinitialize_generator(inputGenerator);
 951         inputGenerator = NULL;
 952         return EINA_FALSE;
 953      }
 954
 955    return EINA_TRUE;
 956 }
 957
 958 Eina_Bool
 959 etRunner::generateMouseUp(int x, int y)
 960 {
 961    // Using efl_util_input_generate instead of generate event by eldbus
 962    int ret = EFL_UTIL_ERROR_NONE;
 963
 964    if (inputGenerator == NULL)
 965      {
 966         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
 967         work();
 968      }
 969
 970    ret = efl_util_input_generate_touch(inputGenerator,
 971                                        0,
 972                                        EFL_UTIL_INPUT_TOUCH_END,
 973                                        x, y);
 974    if (ret != EFL_UTIL_ERROR_NONE)
 975      {
 976         efl_util_input_deinitialize_generator(inputGenerator);
 977         inputGenerator = NULL;
 978         return EINA_FALSE;
 979      }
 980
 981    return EINA_TRUE;
 982 }
 983
 984 Eina_Bool
 985 etRunner::generateKeyPress(const char *keyname)
 986 {
 987    // Using efl_util_input_generate instead of generate event by eldbus
 988    int ret = EFL_UTIL_ERROR_NONE;
 989
 990    if (inputGenerator == NULL)
 991      {
 992         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
 993         work();
 994      }
 995
 996    ret = efl_util_input_generate_key(inputGenerator,
 997                                        keyname,
 998                                        1);
 999    if (ret != EFL_UTIL_ERROR_NONE)
1000      {
1001         efl_util_input_deinitialize_generator(inputGenerator);
1002         inputGenerator = NULL;
1003         return EINA_FALSE;
1004      }
1005
1006    return EINA_TRUE;
1007 }
1008
1009 Eina_Bool
1010 etRunner::generateKeyRelease(const char *keyname)
1011 {
1012    // Using efl_util_input_generate instead of generate event by eldbus
1013    int ret = EFL_UTIL_ERROR_NONE;
1014
1015    if (inputGenerator == NULL)
1016      {
1017         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
1018         work();
1019      }
1020
1021    ret = efl_util_input_generate_key(inputGenerator,
1022                                        keyname,
1023                                        0);
1024    if (ret != EFL_UTIL_ERROR_NONE)
1025      {
1026         efl_util_input_deinitialize_generator(inputGenerator);
1027         inputGenerator = NULL;
1028         return EINA_FALSE;
1029      }
1030
1031    return EINA_TRUE;
1032 }
1033
1034 Eina_Bool
1035 etRunner::generateKeyEvent(const char *keyname, double delay)
1036 {
1037    Eina_Bool res = EINA_FALSE;
1038
1039    res = etRunner::get().generateKeyPress(keyname);
1040    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
1041
1042    res = etRunner::get().generateKeyRelease(keyname);
1043    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
1044
1045    return res;
1046 }
1047
1048 Eina_Bool
1049 etRunner::generateTouchDown(int idx, int x, int y)
1050 {
1051    // Using efl_util_input_generate instead of generate event by eldbus
1052    int ret = EFL_UTIL_ERROR_NONE;
1053
1054    if (inputGenerator == NULL)
1055      {
1056         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1057         work();
1058      }
1059
1060    ret = efl_util_input_generate_touch(inputGenerator,
1061                                        idx,
1062                                        EFL_UTIL_INPUT_TOUCH_BEGIN,
1063                                        x, y);
1064    if (ret != EFL_UTIL_ERROR_NONE)
1065      {
1066         efl_util_input_deinitialize_generator(inputGenerator);
1067         inputGenerator = NULL;
1068         return EINA_FALSE;
1069      }
1070
1071    return EINA_TRUE;
1072 }
1073
1074 Eina_Bool
1075 etRunner::generateTouchMove(int idx, int x, int y)
1076 {
1077    // Using efl_util_input_generate instead of generate event by eldbus
1078    int ret = EFL_UTIL_ERROR_NONE;
1079
1080    if (inputGenerator == NULL)
1081      {
1082         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1083         work();
1084      }
1085
1086    ret = efl_util_input_generate_touch(inputGenerator,
1087                                        idx,
1088                                        EFL_UTIL_INPUT_TOUCH_UPDATE,
1089                                        x, y);
1090    if (ret != EFL_UTIL_ERROR_NONE)
1091      {
1092         efl_util_input_deinitialize_generator(inputGenerator);
1093         inputGenerator = NULL;
1094         return EINA_FALSE;
1095      }
1096
1097    return EINA_TRUE;
1098 }
1099
1100 Eina_Bool
1101 etRunner::generateTouchUp(int idx, int x, int y)
1102 {
1103    // Using efl_util_input_generate instead of generate event by eldbus
1104    int ret = EFL_UTIL_ERROR_NONE;
1105
1106    if (inputGenerator == NULL)
1107      {
1108         inputGenerator = efl_util_input_initialize_generator_with_sync(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
1109         work();
1110      }
1111
1112    ret = efl_util_input_generate_touch(inputGenerator,
1113                                        idx,
1114                                        EFL_UTIL_INPUT_TOUCH_END,
1115                                        x, y);
1116    if (ret != EFL_UTIL_ERROR_NONE)
1117      {
1118         efl_util_input_deinitialize_generator(inputGenerator);
1119         inputGenerator = NULL;
1120         return EINA_FALSE;
1121      }
1122
1123    return EINA_TRUE;
1124 }
1125
1126 Eina_Bool
1127 etRunner::setSplashLaunch(const char *path, int type)
1128 {
1129    const char *effect_type = "launch";
1130    struct wl_array option;
1131
1132    // init tzlaunch_splash
1133    if (tzlaunch_splash)
1134      {
1135         tizen_launch_splash_destroy(tzlaunch_splash);
1136         tzlaunch_splash = NULL;
1137      }
1138    if (tzlaunch_effect) tzlaunch_splash = tizen_launch_effect_create_splash_img(tzlaunch_effect);
1139    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1140
1141    wl_array_init(&option);
1142    tizen_launch_splash_launch(tzlaunch_splash, path, type,
1143                               24, 0, 0,
1144                               effect_type, NULL, &option);
1145    wl_array_release(&option);
1146
1147    return EINA_TRUE;
1148 }
1149
1150 Eina_Bool
1151 etRunner::setSplashOwner()
1152 {
1153
1154    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1155
1156    tizen_launch_splash_owner(tzlaunch_splash, (int)getpid());
1157
1158    return EINA_TRUE;
1159 }
1160
1161 Eina_Bool
1162 etRunner::setWinEffect(etWin *tw)
1163 {
1164    Eldbus_Pending *p = NULL;
1165    Eina_Bool accepted = EINA_FALSE;
1166
1167    this->ev.elm_win = tw->elm_win;
1168
1169    p = eldbus_proxy_call(dbus.ds_proxy,
1170                          "RenderTrace",
1171                          _cb_method_window_effect,
1172                          &accepted,
1173                          -1,
1174                          "us",
1175                          tw->native_win,
1176                          "effect");
1177    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1178
1179    work();
1180    return accepted;
1181 }
1182
1183 Eina_Bool
1184 etRunner::freezeEvent()
1185 {
1186    Eldbus_Pending *p = NULL;
1187    p = eldbus_proxy_call(dbus.ds_proxy,
1188                          "EventFreeze",
1189                          NULL,
1190                          NULL,
1191                          -1,
1192                          "u",
1193                          1);
1194    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1195    return EINA_TRUE;
1196 }
1197
1198 Eina_Bool
1199 etRunner::thawEvent()
1200 {
1201    Eldbus_Pending *p = NULL;
1202    p = eldbus_proxy_call(dbus.ds_proxy,
1203                          "EventFreeze",
1204                          NULL,
1205                          NULL,
1206                          -1,
1207                          "u",
1208                          0);
1209    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1210    return EINA_TRUE;
1211 }
1212
1213 Eina_Bool
1214 etRunner::addSupportedAuxHint(const char *hint)
1215 {
1216    Eldbus_Pending *p = NULL;
1217    p = eldbus_proxy_call(dbus.ds_proxy,
1218                          "AddSupportedAuxHint",
1219                          NULL,
1220                          NULL,
1221                          -1,
1222                          "s",
1223                          hint);
1224    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1225    return EINA_TRUE;
1226 }
1227
1228 Eina_Bool
1229 etRunner::delSupportedAuxHint(const char *hint)
1230 {
1231    Eldbus_Pending *p = NULL;
1232    p = eldbus_proxy_call(dbus.ds_proxy,
1233                          "DelSupportedAuxHint",
1234                          NULL,
1235                          NULL,
1236                          -1,
1237                          "s",
1238                          hint);
1239    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1240    return EINA_TRUE;
1241 }
1242
1243 Eina_Bool
1244 etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
1245 {
1246    E_TC_Event_Item *recv_item = NULL;
1247    Eina_Bool res = EINA_FALSE;
1248    Eina_List *l = NULL;
1249
1250    // swap event
1251    switch (ev_type)
1252      {
1253       case E_TC_EVENT_TYPE_VIS_ON:
1254       case E_TC_EVENT_TYPE_VIS_OFF:
1255       case E_TC_EVENT_TYPE_VIS_CHANGED:
1256          ev_type = E_TC_EVENT_TYPE_VIS_CHANGED;
1257          break;
1258       case E_TC_EVENT_TYPE_STACK_RAISE:
1259       case E_TC_EVENT_TYPE_STACK_LOWER:
1260       case E_TC_EVENT_TYPE_STACK_ABOVE:
1261       case E_TC_EVENT_TYPE_STACK_BELOW:
1262       case E_TC_EVENT_TYPE_STACK_CHANGED:
1263          ev_type = E_TC_EVENT_TYPE_STACK_CHANGED;
1264          break;
1265       default:
1266          break;
1267      }
1268
1269    // Add event callbacks if needs
1270    if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
1271      {
1272         ev.elm_win = win->elm_win;
1273         ev.native_win = win->native_win;
1274         ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
1275
1276         evas_object_smart_callback_add(this->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started, this);
1277         evas_object_smart_callback_add(this->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done, this);
1278         evas_object_smart_callback_add(this->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done, this);
1279      }
1280    else if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
1281      {
1282         ev.elm_win = win->elm_win;
1283         ev.native_win = win->native_win;
1284         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
1285         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
1286
1287         ev.key.evas_state = EINA_FALSE;
1288      }
1289
1290    // pre-waiting events
1291    work(0.5);
1292
1293    if (ev.wait_event_index == ev.last_event)
1294      {
1295         work(0.5); // waiting additional time
1296         if (ev.wait_event_index == ev.last_event)
1297           return EINA_FALSE;
1298      }
1299
1300    EINA_LIST_CAST_FOREACH(ev.recv_queue, l, recv_item, E_TC_Event_Item*)
1301      {
1302         if ((recv_item->win == (win?win->native_win:0)) &&
1303             (recv_item->type == ev_type))
1304           {
1305              ev.wait_event_index = recv_item;
1306              res = EINA_TRUE;
1307              break;
1308           }
1309      }
1310
1311    return res;
1312 }
1313
1314 void
1315 etRunner::flushEventQueue()
1316 {
1317    if (ev.recv_queue)
1318      {
1319         ev.recv_queue = eina_list_free(ev.recv_queue);
1320         ev.recv_queue = NULL;
1321      }
1322 }
1323
1324 Eina_Bool
1325 etRunner::insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type)
1326 {
1327    E_TC_Event_Item *item = E_NEW(E_TC_Event_Item, 1);
1328    EINA_SAFETY_ON_NULL_RETURN_VAL(item, EINA_FALSE);
1329
1330    item->win = id;
1331    item->type = ev_type;
1332    ev.recv_queue = eina_list_append(ev.recv_queue, item);
1333    ev.last_event = item;
1334
1335    return EINA_TRUE;
1336 }
1337
1338 Eina_Bool
1339 etRunner::isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type)
1340 {
1341    Eina_List *l = NULL;
1342    E_TC_Event_Item *item = NULL;
1343    Ecore_Window id = tw->native_win;
1344
1345    EINA_LIST_CAST_FOREACH(ev.recv_queue, l, item, E_TC_Event_Item*)
1346      {
1347         if (ev.last_checkpoint && ev.last_checkpoint != item)
1348           continue;
1349
1350         if ((item->win == id) && (item->type == ev_type))
1351           return EINA_TRUE;
1352      }
1353
1354    return EINA_FALSE;
1355 }
1356
1357 void
1358 etRunner::setEventCheckpoint()
1359 {
1360    ev.last_checkpoint = ev.last_event;
1361    return;
1362 }
1363
1364 Eina_Bool
1365 etRunner::addSignalHandlers()
1366 {
1367    Eldbus_Signal_Handler *sh = NULL;
1368    Ecore_Event_Handler *eh = NULL;
1369
1370    flushEventQueue();
1371
1372    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1373                                         "VisibilityChanged",
1374                                         _cb_signal_vis_changed,
1375                                         this);
1376    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1377    ev.sh_list = eina_list_append(ev.sh_list, sh);
1378
1379    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1380                                         "StackChanged",
1381                                         _cb_signal_stack_changed,
1382                                         this);
1383    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1384    ev.sh_list = eina_list_append(ev.sh_list, sh);
1385
1386    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1387                                         "WinRotationChanged",
1388                                         _cb_signal_win_rot_changed,
1389                                         this);
1390    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1391    ev.sh_list = eina_list_append(ev.sh_list, sh);
1392
1393    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1394                                         "FocusChanged",
1395                                         _cb_signal_focus_changed,
1396                                         this);
1397    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1398    ev.sh_list = eina_list_append(ev.sh_list, sh);
1399
1400    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1401                                         "RenderRun",
1402                                         _cb_signal_render_while_effect_run,
1403                                         this);
1404    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1405    ev.sh_list = eina_list_append(ev.sh_list, sh);
1406
1407    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1408                                         "AuxHintChanged",
1409                                         _cb_signal_aux_hint_changed,
1410                                         this);
1411    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1412    ev.sh_list = eina_list_append(ev.sh_list, sh);
1413
1414    eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key_down, this);
1415    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1416    ev.eh_list = eina_list_append(ev.eh_list, eh);
1417
1418    eh = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key_up, this);
1419    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1420    ev.eh_list = eina_list_append(ev.eh_list, eh);
1421
1422    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
1423    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1424    ev.eh_list = eina_list_append(ev.eh_list, eh);
1425
1426    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
1427    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1428    ev.eh_list = eina_list_append(ev.eh_list, eh);
1429
1430    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
1431    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1432    ev.eh_list = eina_list_append(ev.eh_list, eh);
1433
1434    ev.key.ecore_state = EINA_FALSE;
1435
1436    return EINA_TRUE;
1437
1438 err:
1439    printf("failed to init handlers\n");
1440    delSignalHandlers();
1441    return EINA_FALSE;
1442 }
1443
1444 void
1445 etRunner::delSignalHandlers()
1446 {
1447    Eldbus_Signal_Handler *sh = NULL;
1448    Ecore_Event_Handler *eh = NULL;
1449
1450    EINA_LIST_CAST_FREE(ev.sh_list, sh, Eldbus_Signal_Handler*)
1451      {
1452         eldbus_signal_handler_del(sh);
1453      }
1454
1455    EINA_LIST_CAST_FREE(ev.eh_list, eh, Ecore_Event_Handler*)
1456      {
1457         ecore_event_handler_del(eh);
1458      }
1459
1460    flushEventQueue();
1461 }
1462
1463 void
1464 etRunner::work()
1465 {
1466    /* give a turn to deal with deferred job for given time*/
1467    addTimer(worker.waitTime);
1468    elm_run();
1469 }
1470
1471 void
1472 etRunner::work(double time)
1473 {
1474    /* give a turn to deal with deferred job for given time*/
1475    if (time < 0.0) time = 0.0;
1476
1477    addTimer(time);
1478    elm_run();
1479 }
1480
1481 void
1482 etRunner::finishWork()
1483 {
1484    if (worker.timer)
1485      delTimer();
1486
1487    elm_exit();
1488 }
1489
1490 void
1491 etRunner::printWinInfoList()
1492 {
1493    etWin *tw = NULL;
1494    Eina_List *l = NULL, *ll = NULL;
1495
1496    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1497    l = getWinInfoList();
1498    EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
1499      {
1500         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",
1501                tw->layer,
1502                (unsigned int)tw->native_win,
1503                tw->alpha,
1504                tw->x, tw->y, tw->w, tw->h,
1505                tw->Vis.win,
1506                tw->Vis.obj,
1507                tw->Vis.opaque,
1508                tw->Vis.type,
1509                tw->Vis.skip,
1510                tw->iconic,
1511                tw->Focus.win,
1512                tw->Focus.obj,
1513                tw->name);
1514      }
1515    freeWinInfoList(l);
1516    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1517 }
1518
1519 void
1520 etRunner::delTimer()
1521 {
1522    if (!worker.timer) return;
1523
1524    ecore_timer_del(worker.timer);
1525    worker.timer = NULL;
1526 }
1527
1528 void
1529 etRunner::addTimer()
1530 {
1531    delTimer();
1532
1533    worker.timer = ecore_timer_add(worker.waitTime,
1534                                   _cb_work_timeout,
1535                                   this);
1536 }
1537
1538 void
1539 etRunner::addTimer(double time)
1540 {
1541    delTimer();
1542
1543    worker.timer = ecore_timer_add(time,
1544                                   _cb_work_timeout,
1545                                   this);
1546 }
1547
1548 void
1549 etRunner::waitForDestroy()
1550 {
1551    work(E_TEST_WORK_TIME);
1552 }
1553
1554 Eina_Bool
1555 etRunner::initProtocols()
1556 {
1557    Eina_Iterator *globals = NULL;
1558    Ecore_Wl2_Global *global = NULL;
1559    struct wl_registry *registry = NULL;
1560
1561    registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
1562    globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
1563
1564    EINA_SAFETY_ON_NULL_GOTO(registry, err);
1565    EINA_SAFETY_ON_NULL_GOTO(globals, err);
1566
1567    EINA_ITERATOR_FOREACH(globals, global)
1568      {
1569         if (!strcmp(global->interface, "tizen_policy"))
1570           {
1571              tzPolicy = (struct tizen_policy *)
1572                 wl_registry_bind(registry,
1573                                  global->id,
1574                                  &tizen_policy_interface,
1575                                  (global->version > 7)? 7 : global->version);
1576           }
1577         if (!strcmp(global->interface, "tizen_surface"))
1578           {
1579              tzSurface = (struct tizen_surface *)
1580                 wl_registry_bind(registry,
1581                                  global->id,
1582                                  &tizen_surface_interface,
1583                                  (global->version > 1)? 1 : global->version);
1584           }
1585         if (!strcmp(global->interface, "tizen_launch_effect"))
1586           {
1587              tzlaunch_effect = (struct tizen_launch_effect *)
1588                 wl_registry_bind(registry,
1589                                  global->id,
1590                                  &tizen_launch_effect_interface,
1591                                  (global->version > 1)? 1 : global->version);
1592           }
1593         if (!strcmp(global->interface, "wl_output"))
1594           {
1595              wlOutput = (struct wl_output *)
1596                 wl_registry_bind(registry,
1597                                  global->id,
1598                                  &wl_output_interface,
1599                                  (global->version > 2)? 2 : global->version);
1600              wl_output_add_listener(wlOutput, &_e_test_output_listener, NULL);
1601
1602              work();
1603
1604              if (wlOutput)
1605                {
1606                   wl_output_destroy(wlOutput);
1607                   wlOutput = NULL;
1608                }
1609           }
1610      }
1611
1612    EINA_SAFETY_ON_NULL_GOTO(tzPolicy, err);
1613    EINA_SAFETY_ON_NULL_GOTO(tzSurface, err);
1614    EINA_SAFETY_ON_NULL_GOTO(tzlaunch_effect, err);
1615
1616    eina_iterator_free(globals);
1617    return EINA_TRUE;
1618
1619 err:
1620    if (globals)
1621      eina_iterator_free(globals);
1622    return EINA_FALSE;
1623 }
1624
1625 /* callbacks - method */
1626 static void
1627 _cb_method_win_info_get(void *data,
1628                         const Eldbus_Message *msg,
1629                         Eldbus_Pending *p)
1630 {
1631    const char *name = NULL, *text = NULL, *wname = NULL;
1632    etWin *tw = NULL;
1633    Eina_Bool res = EINA_FALSE;
1634
1635    tw = (etWin *)data;
1636
1637    res = eldbus_message_error_get(msg, &name, &text);
1638    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1639
1640    res = eldbus_message_arguments_get
1641       (msg,
1642        E_TC_SIGN_WIN_INFO,
1643        &tw->native_win,
1644        &wname,
1645        &tw->x, &tw->y, &tw->w, &tw->h,
1646        &tw->layer,
1647        &tw->effect,
1648        &tw->Vis.win,
1649        &tw->Vis.obj,
1650        &tw->Vis.opaque,
1651        &tw->Vis.type,
1652        &tw->Vis.skip,
1653        &tw->iconic,
1654        &tw->alpha,
1655        &tw->Focus.win,
1656        &tw->Focus.obj,
1657        &tw->rot);
1658
1659    if (wname)
1660      {
1661         // change window name from char * to Eina_Stringshare
1662         if (tw->name)
1663           eina_stringshare_del(tw->name);
1664         tw->name = eina_stringshare_add(wname);
1665      }
1666
1667 finish:
1668    if ((name) || (text))
1669      {
1670         ERR("errname:%s errmsg:%s\n", name, text);
1671      }
1672
1673    etRunner::get().finishWork();
1674 }
1675
1676 static void
1677 _cb_method_win_info_list_get(void *data,
1678                              const Eldbus_Message *msg,
1679                              Eldbus_Pending *p)
1680 {
1681    const char *name = NULL, *text = NULL, *wname = NULL;
1682    Eldbus_Message_Iter *array = NULL, *ec = NULL;
1683    Window_Info_List *info_list = (Window_Info_List *)data;
1684    Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
1685
1686    if (info_list == NULL)
1687      goto finish;
1688
1689    res = eldbus_message_error_get(msg, &name, &text);
1690    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1691
1692    res = eldbus_message_arguments_get(msg, "a(" E_TC_SIGN_WIN_INFO ")", &array);
1693    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1694
1695    while (eldbus_message_iter_get_and_next(array, 'r', &ec))
1696      {
1697         etWin *tw = new etWin();
1698         if (!tw) continue;
1699
1700         res = eldbus_message_iter_arguments_get(
1701            ec,
1702            E_TC_SIGN_WIN_INFO,
1703            &tw->native_win,
1704            &wname,
1705            &tw->x, &tw->y, &tw->w, &tw->h,
1706            &tw->layer,
1707            &tw->effect,
1708            &tw->Vis.win,
1709            &tw->Vis.obj,
1710            &tw->Vis.opaque,
1711            &tw->Vis.type,
1712            &tw->Vis.skip,
1713            &tw->iconic,
1714            &tw->alpha,
1715            &tw->Focus.win,
1716            &tw->Focus.obj,
1717            &tw->rot);
1718
1719         if (wname)
1720           {
1721              // change name to eina_stringshare
1722              if (tw->name)
1723                {
1724                   WRN("Failed to get win info\n");
1725                   delete tw;
1726                   continue;
1727                }
1728              tw->name = eina_stringshare_add(wname);
1729           }
1730
1731         if (tw->effect)
1732           animating = EINA_TRUE;
1733
1734         if (!res)
1735           {
1736              WRN("Failed to get win info\n");
1737              delete tw;
1738              continue;
1739           }
1740
1741         info_list->list = eina_list_append(info_list->list, tw);
1742      }
1743
1744    if (animating)
1745      info_list->retry = EINA_TRUE;
1746
1747 finish:
1748    if ((name) || (text))
1749      {
1750         ERR("errname:%s errmsg:%s\n", name, text);
1751      }
1752
1753    etRunner::get().finishWork();
1754 }
1755
1756 static void
1757 _cb_method_window_register(void *data,
1758                            const Eldbus_Message *msg,
1759                            Eldbus_Pending *p)
1760 {
1761    const char *name = NULL, *text = NULL;
1762    Eina_Bool res = EINA_FALSE;
1763    Eina_Bool *accepted = (Eina_Bool *)data;
1764
1765    *accepted = EINA_FALSE;
1766
1767    res = eldbus_message_error_get(msg, &name, &text);
1768    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1769
1770    res = eldbus_message_arguments_get(msg, "b", accepted);
1771
1772 finish:
1773    if ((name) || (text))
1774      {
1775         ERR("errname: %s errmsg: %s\n", name, text);
1776      }
1777
1778    etRunner::get().finishWork();
1779 }
1780
1781 static void
1782 _cb_method_zone_rotation_change(void *data,
1783                                 const Eldbus_Message *msg,
1784                                 Eldbus_Pending *p)
1785 {
1786    const char *name = NULL, *text = NULL;
1787    Eina_Bool res = EINA_FALSE;
1788    Eina_Bool *allowed = (Eina_Bool *)data;
1789
1790    *allowed = EINA_FALSE;
1791
1792    res = eldbus_message_error_get(msg, &name, &text);
1793    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1794
1795    res = eldbus_message_arguments_get(msg, "b", allowed);
1796    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1797    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1798
1799 finish:
1800    if ((name) || (text))
1801      {
1802         ERR("errname: %s errmsg: %s\n", name, text);
1803      }
1804
1805    etRunner::get().finishWork();
1806 }
1807
1808 static void
1809 _cb_method_window_effect(void *data,
1810                                 const Eldbus_Message *msg,
1811                                 Eldbus_Pending *p)
1812 {
1813    const char *name = NULL, *text = NULL;
1814    Eina_Bool res = EINA_FALSE;
1815    Eina_Bool *allowed = (Eina_Bool *)data;
1816
1817    *allowed = EINA_FALSE;
1818
1819    res = eldbus_message_error_get(msg, &name, &text);
1820    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1821
1822    res = eldbus_message_arguments_get(msg, "b", allowed);
1823    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1824    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1825
1826 finish:
1827    if ((name) || (text))
1828      {
1829         ERR("errname: %s errmsg: %s\n", name, text);
1830      }
1831
1832    etRunner::get().finishWork();
1833 }
1834
1835 static void
1836 _cb_method_set_tc_start_end(void *data,
1837                             const Eldbus_Message *msg,
1838                             Eldbus_Pending *p)
1839 {
1840    const char *name = NULL, *text = NULL;
1841    Eina_Bool res = EINA_FALSE;
1842    Eina_Bool *accept = (Eina_Bool *)data;
1843
1844    *accept = EINA_FALSE;
1845
1846    res = eldbus_message_error_get(msg, &name, &text);
1847    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1848
1849    res = eldbus_message_arguments_get(msg, "b", accept);
1850    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1851    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1852
1853 finish:
1854    if ((name) || (text))
1855      {
1856         ERR("errname: %s errmsg: %s\n", name, text);
1857      }
1858
1859    etRunner::get().finishWork();
1860 }
1861
1862 static void
1863 _cb_method_transient_for_below(void *data,
1864                                const Eldbus_Message *msg,
1865                                Eldbus_Pending *p)
1866 {
1867    const char *name = NULL, *text = NULL;
1868    Eina_Bool res = EINA_FALSE;
1869    Eina_Bool *accept = (Eina_Bool *)data;
1870
1871    *accept = EINA_FALSE;
1872
1873    res = eldbus_message_error_get(msg, &name, &text);
1874    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1875
1876    res = eldbus_message_arguments_get(msg, "b", accept);
1877    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1878    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
1879
1880 finish:
1881    if ((name) || (text))
1882      {
1883         ERR("errname: %s errmsg: %s\n", name, text);
1884      }
1885
1886    etRunner::get().finishWork();
1887 }
1888
1889 /* callbacks - signal */
1890 static void
1891 _cb_signal_vis_changed(void *data,
1892                        const Eldbus_Message *msg)
1893 {
1894    etRunner *runner = (etRunner *)data;
1895    const char *name = NULL, *text = NULL;
1896    Eina_Bool res = EINA_FALSE;
1897    int vis = 0;
1898    Ecore_Window id;
1899
1900    res = eldbus_message_error_get(msg, &name, &text);
1901    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1902
1903    res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
1904    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1905
1906    runner->insertEventQueue(id, E_TC_EVENT_TYPE_VIS_CHANGED);
1907
1908 finish:
1909    if ((name) || (text))
1910      {
1911         ERR("errname:%s errmsg:%s\n", name, text);
1912      }
1913 }
1914
1915 static void
1916 _cb_signal_stack_changed(void *data,
1917                          const Eldbus_Message *msg)
1918 {
1919    etRunner *runner = (etRunner *)data;
1920    const char *name = NULL, *text = NULL;
1921    Eina_Bool res = EINA_FALSE;
1922    Ecore_Window id = 0;
1923
1924    res = eldbus_message_error_get(msg, &name, &text);
1925    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1926
1927    res = eldbus_message_arguments_get(msg, "u", &id);
1928    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1929
1930    runner->insertEventQueue(id, E_TC_EVENT_TYPE_STACK_CHANGED);
1931
1932 finish:
1933    if ((name) || (text))
1934      {
1935         ERR("errname:%s errmsg:%s\n", name, text);
1936      }
1937 }
1938
1939 static void
1940 _cb_signal_win_rot_changed(void *data,
1941                            const Eldbus_Message *msg)
1942 {
1943    etRunner *runner = (etRunner *)data;
1944    const char *name = NULL, *text = NULL;
1945    Eina_Bool res = EINA_FALSE;
1946    int angle = 0;
1947    Ecore_Window id;
1948
1949    res = eldbus_message_error_get(msg, &name, &text);
1950    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1951
1952    /* TODO unused 'window id' and 'angle' */
1953    res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
1954    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1955
1956    runner->insertEventQueue(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
1957
1958 finish:
1959    if ((name) || (text))
1960      {
1961         ERR("errname:%s errmsg:%s\n", name, text);
1962      }
1963 }
1964
1965 static void
1966 _cb_signal_focus_changed(void *data,
1967                          const Eldbus_Message *msg)
1968 {
1969    etRunner *runner = (etRunner *)data;
1970    const char *name = NULL, *text = NULL;
1971    Eina_Bool res = EINA_FALSE;
1972    Ecore_Window id = 0;
1973
1974    res = eldbus_message_error_get(msg, &name, &text);
1975    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1976
1977    res = eldbus_message_arguments_get(msg, "u", &id);
1978    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1979
1980    runner->insertEventQueue(id, E_TC_EVENT_TYPE_FOCUS_CHANGED);
1981
1982 finish:
1983    if ((name) || (text))
1984      {
1985         ERR("errname:%s errmsg:%s\n", name, text);
1986      }
1987 }
1988
1989 static void
1990 _cb_signal_render_while_effect_run(void *data,
1991                       const Eldbus_Message *msg)
1992 {
1993    etRunner *runner = (etRunner *)data;
1994    const char *name = NULL, *text = NULL;
1995    Eina_Bool res = EINA_FALSE;
1996    Ecore_Window id = 0;
1997
1998    res = eldbus_message_error_get(msg, &name, &text);
1999    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2000
2001    res = eldbus_message_arguments_get(msg, "u", &id);
2002    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2003
2004    runner->insertEventQueue(id, E_TC_EVENT_TYPE_EFFECT);
2005
2006 finish:
2007    if ((name) || (text))
2008      {
2009         ERR("errname:%s errmsg:%s\n", name, text);
2010      }
2011 }
2012
2013 static void
2014 _cb_signal_aux_hint_changed(void *data,
2015                          const Eldbus_Message *msg)
2016 {
2017    etRunner *runner = (etRunner *)data;
2018    const char *name = NULL, *text = NULL;
2019    Eina_Bool res = EINA_FALSE;
2020    Ecore_Window win = 0;
2021    uint32_t hint_id;
2022    const char *hint_key, *hint_val;
2023
2024    res = eldbus_message_error_get(msg, &name, &text);
2025    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2026
2027    res = eldbus_message_arguments_get(msg, "uuss", &win, &hint_id, &hint_key, &hint_val);
2028    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2029
2030    runner->insertEventQueue(win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED);
2031
2032 finish:
2033    if ((name) || (text))
2034      {
2035         ERR("errname:%s errmsg:%s\n", name, text);
2036      }
2037 }
2038
2039 /* callbacks - timer */
2040 static Eina_Bool
2041 _cb_work_timeout(void *data)
2042 {
2043    etRunner::get().finishWork();
2044    return ECORE_CALLBACK_CANCEL;
2045 }
2046
2047 /* callbacks - ecore */
2048 static Eina_Bool
2049 _cb_ecore_key_down(void *data, int type, void *event)
2050 {
2051    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
2052    etRunner *runner = (etRunner *)data;
2053
2054    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2055
2056    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2057      {
2058         if (runner->ev.key.ecore_state == EINA_FALSE &&
2059             type == ECORE_EVENT_KEY_DOWN)
2060           {
2061              runner->ev.key.ecore_state = EINA_TRUE;
2062           }
2063      }
2064
2065    return ECORE_CALLBACK_PASS_ON;
2066 }
2067
2068 static Eina_Bool
2069 _cb_ecore_key_up(void *data, int type, void *event)
2070 {
2071    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
2072    etRunner *runner = (etRunner *)data;
2073
2074    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2075
2076    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2077      {
2078         if (runner->ev.key.ecore_state == EINA_TRUE &&
2079             type == ECORE_EVENT_KEY_UP)
2080           {
2081              runner->ev.key.ecore_state = EINA_FALSE;
2082              runner->insertEventQueue(0, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
2083           }
2084      }
2085
2086    return ECORE_CALLBACK_PASS_ON;
2087 }
2088
2089 /* callbacks - evas */
2090 static void
2091 _cb_evas_key_down(void *data, Evas * evas, Evas_Object * obj, void * event_info)
2092 {
2093    Evas_Event_Key_Down *ev;
2094    etRunner *runner = (etRunner *)data;
2095
2096    ev = (Evas_Event_Key_Down *)event_info;
2097
2098    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2099      {
2100         if (runner->ev.key.evas_state == EINA_FALSE &&
2101             runner->ev.elm_win == obj)
2102           {
2103              runner->ev.key.evas_state = EINA_TRUE;
2104           }
2105      }
2106 }
2107
2108 static void
2109 _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info)
2110 {
2111    Evas_Event_Key_Up *ev;
2112    etRunner *runner = (etRunner *)data;
2113
2114    ev = (Evas_Event_Key_Up *)event_info;
2115
2116    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2117      {
2118         if (runner->ev.key.evas_state == EINA_TRUE &&
2119             runner->ev.elm_win == obj)
2120           {
2121              runner->ev.key.evas_state = EINA_FALSE;
2122              runner->ev.elm_win = NULL;
2123
2124              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
2125           }
2126      }
2127 }
2128
2129 /* callbacks -  smart object */
2130 static void
2131 _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info)
2132 {
2133    etRunner *runner = (etRunner *)data;
2134    if (runner && runner->ev.elm_win == obj)
2135      {
2136         runner->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED;
2137      }
2138 }
2139
2140 static void
2141 _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info)
2142 {
2143    etRunner *runner = (etRunner *)data;
2144    if (runner && runner->ev.elm_win == obj)
2145      {
2146         runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE;
2147
2148         runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2149
2150         evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2151         evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2152         evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2153      }
2154 }
2155
2156 static void
2157 _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info)
2158 {
2159    etRunner *runner = (etRunner *)data;
2160    if (runner && runner->ev.elm_win == obj)
2161      {
2162         runner->ev.effect.state_smcb  |= E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE;
2163
2164         if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
2165            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE) &&
2166            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE))
2167           {
2168              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2169
2170              evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2171              evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2172              evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2173           }
2174      }
2175 }
2176
2177 static Eina_Bool
2178 _cb_gesture_tap(void *data, int type, void *event)
2179 {
2180    etRunner *runner = (etRunner *)data;
2181    efl_util_event_gesture_tap_s *ev =
2182      (efl_util_event_gesture_tap_s *)event;
2183
2184    if ((ev->fingers == (unsigned int)runner->ev.gesture.tap.fingers) &&
2185        (ev->repeats == (unsigned int)runner->ev.gesture.tap.repeats))
2186      {
2187         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_TAP);
2188         //ecore_event_handler_del(runner->ev.key.eh);
2189      }
2190
2191    return ECORE_CALLBACK_PASS_ON;
2192 }
2193
2194 static Eina_Bool
2195 _cb_gesture_tap_delay_timer(void *data)
2196 {
2197    etRunner *runner = (etRunner *)data;
2198    int i;
2199
2200    for (i = 0; i < runner->ev.gesture.tap.fingers; i++)
2201      {
2202         if (!runner->ev.gesture.tap.pressed)
2203           {
2204             runner->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
2205           }
2206         else
2207           {
2208             runner->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
2209           }
2210      }
2211
2212    runner->ev.gesture.timer = NULL;
2213
2214    runner->ev.gesture.tap.pressed = !runner->ev.gesture.tap.pressed;
2215    if (!runner->ev.gesture.tap.pressed)
2216      {
2217         runner->ev.gesture.tap.current_repeats--;
2218      }
2219
2220    if (runner->ev.gesture.tap.current_repeats > 0)
2221      {
2222         runner->ev.gesture.timer = ecore_timer_add(0.11,
2223                                                    _cb_gesture_tap_delay_timer,
2224                                                    runner);
2225      }
2226
2227    return ECORE_CALLBACK_CANCEL;
2228 }
2229
2230 Eina_Bool
2231 etRunner::generateTapGesture()
2232 {
2233    ev.gesture.tap.current_repeats = ev.gesture.tap.repeats;
2234    ev.gesture.tap.pressed = EINA_FALSE;
2235
2236    ev.gesture.timer = ecore_timer_add(0.11,
2237                                       _cb_gesture_tap_delay_timer,
2238                                       this);
2239
2240    return EINA_TRUE;
2241 }
2242
2243 static Eina_Bool
2244 _cb_gesture_edge_swipe(void *data, int type, void *event)
2245 {
2246    etRunner *runner = (etRunner *)data;
2247    efl_util_event_gesture_edge_swipe_s *ev =
2248      (efl_util_event_gesture_edge_swipe_s *)event;
2249
2250    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2251        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge))
2252      {
2253         if (runner->ev.gesture.timer)
2254           runner->ev.gesture.edge.get_event = EINA_TRUE;
2255      }
2256
2257    return ECORE_CALLBACK_PASS_ON;
2258 }
2259
2260 static Eina_Bool
2261 _cb_gesture_edge_swipe_delay_timer(void *data)
2262 {
2263    etRunner *runner = (etRunner *)data;
2264    int i, cnt, fingers, w, h;
2265    efl_util_gesture_edge_e edge;
2266
2267    cnt = ++runner->ev.gesture.edge.touch_count;
2268    fingers = runner->ev.gesture.edge.fingers;
2269    edge = runner->ev.gesture.edge.edge;
2270    w = runner->output.w - 1;
2271    h = runner->output.h - 1;
2272
2273    if (cnt == 1)
2274      {
2275         for (i = 0; i < fingers; i++)
2276           {
2277              switch (edge)
2278                {
2279                   case EFL_UTIL_GESTURE_EDGE_TOP:
2280                     runner->generateTouchDown(i, 100 * (i + 1), 1);
2281                     break;
2282                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2283                     runner->generateTouchDown(i, w - 1, 100 * (i + 1));
2284                     break;
2285                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2286                     runner->generateTouchDown(i, 100 * (i + 1), h - 1);
2287                     break;
2288                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2289                     runner->generateTouchDown(i, 1, 100 * (i + 1));
2290                     break;
2291                   default:
2292                     break;
2293                }
2294           }
2295      }
2296    else if (cnt < 5)
2297      {
2298         for (i = 0; i < fingers; i++)
2299           {
2300              switch (edge)
2301                {
2302                   case EFL_UTIL_GESTURE_EDGE_TOP:
2303                     runner->generateTouchMove(i, 100 * (i + 1), 40 * cnt * cnt);
2304                     break;
2305                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2306                     runner->generateTouchMove(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2307                     break;
2308                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2309                     runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2310                     break;
2311                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2312                     runner->generateTouchMove(i, 40 * cnt * cnt, 100 * (i + 1));
2313                     break;
2314                   default:
2315                     break;
2316                }
2317           }
2318      }
2319    else
2320      {
2321         cnt--;
2322         for (i = 0; i < fingers; i++)
2323           {
2324              switch (edge)
2325                {
2326                   case EFL_UTIL_GESTURE_EDGE_TOP:
2327                     runner->generateTouchUp(i, 100 * (i + 1), 40 * cnt * cnt);
2328                     break;
2329                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2330                     runner->generateTouchUp(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2331                     break;
2332                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2333                     runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2334                     break;
2335                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2336                     runner->generateTouchUp(i, 40 * cnt * cnt, 100 * (i + 1));
2337                     break;
2338                   default:
2339                     break;
2340                }
2341           }
2342
2343         runner->ev.gesture.timer = NULL;
2344         if (runner->ev.gesture.edge.get_event)
2345           {
2346              runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
2347              //ecore_event_handler_del(runner->ev.key.eh);
2348           }
2349         return ECORE_CALLBACK_CANCEL;
2350      }
2351
2352    runner->ev.gesture.timer = NULL;
2353    runner->ev.gesture.timer = ecore_timer_add(0.11,
2354                                               _cb_gesture_edge_swipe_delay_timer,
2355                                               runner);
2356
2357    return ECORE_CALLBACK_CANCEL;
2358 }
2359
2360 Eina_Bool
2361 etRunner::generateEdgeSwipeGesture()
2362 {
2363    ev.gesture.edge.touch_count = 0;
2364    ev.gesture.edge.get_event = EINA_FALSE;
2365
2366    ev.gesture.timer = ecore_timer_add(0.11,
2367                                       _cb_gesture_edge_swipe_delay_timer,
2368                                       this);
2369
2370    return EINA_TRUE;
2371 }
2372
2373 static Eina_Bool
2374 _cb_gesture_edge_drag(void *data, int type, void *event)
2375 {
2376    etRunner *runner = (etRunner *)data;
2377    efl_util_event_gesture_edge_drag_s *ev =
2378      (efl_util_event_gesture_edge_drag_s *)event;
2379
2380    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2381        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge) &&
2382        (ev->mode == EFL_UTIL_GESTURE_MODE_END))
2383      {
2384         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
2385         //ecore_event_handler_del(runner->ev.key.eh);
2386      }
2387
2388    return ECORE_CALLBACK_PASS_ON;
2389 }
2390
2391 static Eina_Bool
2392 _cb_gesture_edge_drag_delay_timer(void *data)
2393 {
2394    etRunner *runner = (etRunner *)data;
2395    int i, cnt, fingers, w, h;
2396    efl_util_gesture_edge_e edge;
2397
2398    cnt = ++runner->ev.gesture.edge.touch_count;
2399    fingers = runner->ev.gesture.edge.fingers;
2400    edge = runner->ev.gesture.edge.edge;
2401    w = runner->output.w - 1;
2402    h = runner->output.h - 1;
2403
2404    if (cnt == 1)
2405      {
2406         for (i = 0; i < fingers; i++)
2407           {
2408              switch (edge)
2409                {
2410                   case EFL_UTIL_GESTURE_EDGE_TOP:
2411                     runner->generateTouchDown(i, 100 * (i + 1), 1);
2412                     break;
2413                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2414                     runner->generateTouchDown(i, w - 1, 100 * (i + 1));
2415                     break;
2416                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2417                     runner->generateTouchDown(i, 100 * (i + 1), h - 1);
2418                     break;
2419                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2420                     runner->generateTouchDown(i, 1, 100 * (i + 1));
2421                     break;
2422                   default:
2423                     break;
2424                }
2425           }
2426      }
2427    else if (cnt < 5)
2428      {
2429         for (i = 0; i < fingers; i++)
2430           {
2431              switch (edge)
2432                {
2433                   case EFL_UTIL_GESTURE_EDGE_TOP:
2434                     runner->generateTouchMove(i, 100 * (i + 1), 50 * cnt);
2435                     break;
2436                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2437                     runner->generateTouchMove(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2438                     break;
2439                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2440                     runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2441                     break;
2442                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2443                     runner->generateTouchMove(i, 50 * cnt, 100 * (i + 1));
2444                     break;
2445                   default:
2446                     break;
2447                }
2448           }
2449      }
2450    else
2451      {
2452         cnt--;
2453         for (i = 0; i < fingers; i++)
2454           {
2455              switch (edge)
2456                {
2457                   case EFL_UTIL_GESTURE_EDGE_TOP:
2458                     runner->generateTouchUp(i, 100 * (i + 1), 50 * cnt);
2459                     break;
2460                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2461                     runner->generateTouchUp(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2462                     break;
2463                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2464                     runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2465                     break;
2466                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2467                     runner->generateTouchUp(i, 50 * cnt, 100 * (i + 1));
2468                     break;
2469                   default:
2470                     break;
2471                }
2472           }
2473
2474         runner->ev.gesture.timer = NULL;
2475         return ECORE_CALLBACK_CANCEL;
2476      }
2477
2478    runner->ev.gesture.timer = NULL;
2479    runner->ev.gesture.timer = ecore_timer_add(0.11,
2480                                               _cb_gesture_edge_drag_delay_timer,
2481                                               runner);
2482
2483    return ECORE_CALLBACK_CANCEL;
2484 }
2485
2486 Eina_Bool
2487 etRunner::generateEdgeDragGesture()
2488 {
2489    ev.gesture.edge.touch_count = 0;
2490
2491    ev.gesture.timer = ecore_timer_add(0.11,
2492                                       _cb_gesture_edge_drag_delay_timer,
2493                                       this);
2494
2495    return EINA_TRUE;
2496 }