src/e_test_event.cpp

   1 #include <Ecore_Wl2.h>
   2 #include <png.h>
   3 #include <cairo.h>
   4 #include <pixman.h>
   5
   6 #include "e_test_event.h"
   7
   8 #define E_TEST_WORK_TIME 3.0
   9 #define E_TC_SIGN_WIN_INFO "usiiiiibbbiibibbbi"
  10
  11 #define UT_WAIT(fmt, ...) \
  12    do \
  13      { \
  14         char ch; \
  15         do \
  16           { \
  17              printf(fmt" [n]):next ", ##__VA_ARGS__); \
  18              ch = tc_getchar(); \
  19           } while (ch != 'n'); \
  20      } while (0)
  21
  22 char
  23 tc_getchar(void)
  24 {
  25    int c = getchar();
  26    int ch = c;
  27
  28    if (ch == '\n' || ch == '\r')
  29      ch = 'y';
  30    else if (ch < 'a')
  31      ch += ('a' - 'A');
  32
  33    while (c != '\n' && c != EOF)
  34      c = getchar();
  35
  36    return ch;
  37 }
  38
  39 static const char effect_started[] = "effect,started";
  40 static const char effect_done[] = "effect,done";
  41 static const char launch_done[] = "launch,done";
  42
  43 /* callbacks - event */
  44 static void
  45 _cb_resource_id(void *data,
  46                 struct tizen_resource *tizen_resource,
  47                 uint32_t id)
  48 {
  49    Ecore_Window *res_id = (Ecore_Window *)data;
  50    *res_id = id;
  51    etRunner::get().finishWork();
  52 }
  53
  54 static void
  55 _cb_geometry(void *data EINA_UNUSED,
  56              struct wl_output *wl_output EINA_UNUSED,
  57              int x, int y, int w, int h,
  58              int subpixel EINA_UNUSED,
  59              const char *make EINA_UNUSED,
  60              const char *model EINA_UNUSED,
  61              int transform EINA_UNUSED)
  62 {
  63    etRunner::get().output.x = x;
  64    etRunner::get().output.y = y;
  65    etRunner::get().output.w = w;
  66    etRunner::get().output.h = h;
  67 }
  68
  69 static void
  70 _cb_mode(void *data EINA_UNUSED,
  71          struct wl_output *wl_output EINA_UNUSED,
  72          unsigned int flags,
  73          int w, int h,
  74          int refresh EINA_UNUSED)
  75 {
  76    if (flags & WL_OUTPUT_MODE_CURRENT)
  77      {
  78         etRunner::get().output.w = w;
  79         etRunner::get().output.h = h;
  80      }
  81
  82    etRunner::get().finishWork();
  83 }
  84
  85 static void
  86 _cb_done(void *data EINA_UNUSED,
  87          struct wl_output *output EINA_UNUSED)
  88 {
  89    ;
  90 }
  91
  92 static void
  93 _cb_scale(void *data EINA_UNUSED,
  94           struct wl_output *output EINA_UNUSED,
  95           int scale EINA_UNUSED)
  96 {
  97    ;
  98 }
  99
 100 /* callbacks - method */
 101 static void _cb_method_win_info_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 102 static void _cb_method_win_info_list_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 103 static void _cb_method_window_register(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 104 static void _cb_method_zone_rotation_change(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 105 static void _cb_method_window_effect(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 106 static void _cb_method_set_tc_start_end(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 107 static void _cb_method_set_tc_timeout(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 108 static void _cb_method_transient_for_below(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 109 static void _cb_method_aux_hint_get(void *data, const Eldbus_Message *msg, Eldbus_Pending *p);
 110
 111 /* callbacks - signal */
 112 static void _cb_signal_vis_changed(void *data, const Eldbus_Message *msg);
 113 static void _cb_signal_stack_changed(void *data, const Eldbus_Message *msg);
 114 static void _cb_signal_win_rot_changed(void *data, const Eldbus_Message *msg);
 115 static void _cb_signal_focus_changed(void *data, const Eldbus_Message *msg);
 116 static void _cb_signal_render_while_effect_run(void *data, const Eldbus_Message *msg);
 117 static void _cb_signal_aux_hint_changed(void *data, const Eldbus_Message *msg);
 118 static void _cb_signal_iconic_state_changed(void *data, const Eldbus_Message *msg);
 119
 120 /* callbacks - ecore */
 121 static Eina_Bool _cb_ecore_key_down(void *data, int type, void *event);
 122 static Eina_Bool _cb_ecore_key_up(void *data, int type, void *event);
 123
 124 /* callbacks - evas */
 125 static void _cb_evas_key_down(void * data, Evas * evas, Evas_Object * obj, void * event_info);
 126 static void _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info);
 127
 128 /* callbacks -  smart  */
 129 static void _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info);
 130 static void _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info);
 131 static void _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info);
 132
 133 /* callbacks - timer */
 134 static Eina_Bool _cb_work_timeout(void *data);
 135
 136 /* callbacks - gesture */
 137 #ifndef DISABLE_GESTURE_TESTS
 138 static Eina_Bool _cb_gesture_tap(void *data, int type, void *event);
 139 static Eina_Bool _cb_gesture_edge_swipe(void *data, int type, void *event);
 140 static Eina_Bool _cb_gesture_edge_drag(void *data, int type, void *event);
 141 #endif
 142
 143 /**********************
 144       listeners
 145  **********************/
 146 static const struct tizen_resource_listener _e_test_tizen_resource_listener =
 147 {
 148    _cb_resource_id,
 149 };
 150
 151 static const struct wl_output_listener _e_test_output_listener =
 152 {
 153    _cb_geometry,
 154    _cb_mode,
 155    _cb_done,
 156    _cb_scale
 157 };
 158
 159 /**********************
 160    class etRunner
 161  **********************/
 162 etRunner etRunner::inst;
 163
 164 Eina_Bool
 165 etRunner::init()
 166 {
 167    Eina_Bool res = EINA_FALSE;
 168    int screenshot_w = 0, screenshot_h = 0;
 169
 170    worker.waitTime = E_TEST_WORK_TIME;
 171
 172    logDomain = eina_log_domain_register("e-tc", EINA_COLOR_BLUE);
 173
 174    // Init Ecore_Wl2
 175    if (!ecore_wl2_connected_display_get(NULL))
 176      ecore_wl2_display_connect(NULL);
 177
 178    // init tizen_extension protocol
 179    res = initProtocols();
 180    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 181
 182    // init eldbus
 183    eldbus_init();
 184
 185    dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
 186    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.conn, EINA_FALSE);
 187
 188    dbus.ds_obj = eldbus_object_get(dbus.conn,
 189                                 "org.enlightenment.wm",
 190                                 "/org/enlightenment/wm");
 191    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.ds_obj, EINA_FALSE);
 192
 193    dbus.ds_proxy = eldbus_proxy_get(dbus.ds_obj,
 194                                  "org.enlightenment.wm.Test");
 195    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.ds_proxy, EINA_FALSE);
 196
 197    dbus.deviced_obj = eldbus_object_get(dbus.conn,
 198                                         "org.tizen.system.deviced",
 199                                         "/Org/Tizen/System/DeviceD/Display");
 200    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.deviced_obj, EINA_FALSE);
 201
 202    dbus.deviced_proxy = eldbus_proxy_get(dbus.deviced_obj,
 203                                          "org.tizen.system.deviced.display");
 204    EINA_SAFETY_ON_NULL_RETURN_VAL(dbus.deviced_proxy, EINA_FALSE);
 205
 206    // reset registered window of e_test_helper
 207    res = resetRegisterWin();
 208    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 209
 210    // add signal handlers
 211    res = addSignalHandlers();
 212    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 213
 214    execute_verifyTC = EINA_FALSE;
 215    if (target.compare("mobile") == 0)
 216      {
 217         if ((output.w == CAPTURE_WIDTH_MOBILE) && (output.h == CAPTURE_HEIGHT_MOBILE))
 218           {
 219              execute_verifyTC = EINA_TRUE;
 220              screenshot_w = CAPTURE_WIDTH_MOBILE;
 221              screenshot_h = CAPTURE_HEIGHT_MOBILE;
 222           }
 223      }
 224 /*  //currently not supported
 225    else if (target.compare("common") == 0)
 226      {
 227         if ((output.w == CAPTURE_WIDTH_COMMON) && (output.h == CAPTURE_HEIGHT_COMMON))
 228           {
 229              execute_verifyTC = EINA_TRUE;
 230              screenshot_w = CAPTURE_WIDTH_COMMON;
 231              screenshot_h = CAPTURE_HEIGHT_COMMON;
 232           }
 233      }
 234 */
 235      if (execute_verifyTC == EINA_TRUE)
 236      {
 237         screenshot = efl_util_screenshot_initialize(screenshot_w, screenshot_h);
 238         if (screenshot == NULL)
 239           ERR("efl_util_screenshot_initialize fail\n");
 240      }
 241    else
 242      {
 243         ERR("not supported resolution. do not execute verifyTC");
 244      }
 245
 246    return EINA_TRUE;
 247 }
 248
 249 void
 250 etRunner::shutdown()
 251 {
 252    eina_log_domain_unregister(logDomain);
 253
 254    freeLastWinInfoList();
 255
 256    if (screenshot)
 257      {
 258         efl_util_screenshot_deinitialize(screenshot);
 259         screenshot = NULL;
 260      }
 261
 262    delSignalHandlers();
 263    delGestureSignalHandlers();
 264
 265    // deinit tizen_extension protocol
 266    if (tzPolicy)
 267      {
 268         tizen_policy_destroy(tzPolicy);
 269         tzPolicy = NULL;
 270      }
 271
 272    if (tzSurface)
 273      {
 274         tizen_surface_destroy(tzSurface);
 275         tzSurface = NULL;
 276      }
 277
 278    if (tzlaunch_splash)
 279      {
 280         tizen_launch_splash_destroy(tzlaunch_splash);
 281         tzlaunch_splash = NULL;
 282      }
 283
 284    if (tzlaunch_effect)
 285      {
 286         tizen_launch_effect_destroy(tzlaunch_effect);
 287         tzlaunch_effect = NULL;
 288      }
 289
 290    // deinit eldbus
 291    eldbus_proxy_unref(dbus.deviced_proxy);
 292    eldbus_object_unref(dbus.deviced_obj);
 293    eldbus_proxy_unref(dbus.ds_proxy);
 294    eldbus_object_unref(dbus.ds_obj);
 295    eldbus_connection_unref(dbus.conn);
 296    eldbus_shutdown();
 297 }
 298
 299 Eina_Bool
 300 etRunner::registerWin(etWin *tw)
 301 {
 302    Eldbus_Pending *p = NULL;
 303    Eina_Bool accepted = EINA_FALSE;
 304
 305    p = eldbus_proxy_call(dbus.ds_proxy,
 306                          "RegisterWindow",
 307                          _cb_method_window_register,
 308                          &accepted,
 309                          -1,
 310                          "u",
 311                          tw->native_win);
 312    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 313
 314    work();
 315
 316    return accepted;
 317 }
 318
 319 Eina_Bool
 320 etRunner::deregisterWin(etWin *tw)
 321 {
 322    Eldbus_Pending *p = NULL;
 323    Eina_Bool accepted = EINA_FALSE;
 324
 325    p = eldbus_proxy_call(dbus.ds_proxy,
 326                          "DeregisterWindow",
 327                          _cb_method_window_register,
 328                          &accepted,
 329                          -1,
 330                          "u",
 331                          tw->native_win);
 332    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 333
 334    work();
 335
 336    return accepted;
 337 }
 338
 339 Eina_Bool
 340 etRunner::resetRegisterWin()
 341 {
 342    Eldbus_Pending *p = NULL;
 343    Eina_Bool accepted = EINA_FALSE;
 344
 345    p = eldbus_proxy_call(dbus.ds_proxy,
 346                          "ResetRegisterWindow",
 347                          _cb_method_window_register,
 348                          &accepted,
 349                          -1,
 350                          "");
 351    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 352
 353    work();
 354
 355    return accepted;
 356 }
 357
 358 Eina_Bool
 359 etRunner::setWinActivate(etWin *tw)
 360 {
 361    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 362
 363    tw->updateGeometry();
 364
 365    tizen_policy_activate(tzPolicy,
 366                          getWlSurface(tw->elm_win));
 367
 368    return EINA_TRUE;
 369 }
 370
 371 Eina_Bool
 372 etRunner::setWinActivateAbove(etWin *tw, etWin *above_tw)
 373 {
 374    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 375    EINA_SAFETY_ON_NULL_RETURN_VAL(above_tw, EINA_FALSE);
 376
 377    tw->updateGeometry();
 378
 379    tizen_policy_activate_above_by_res_id(tzPolicy,
 380                          tw->native_win, above_tw->native_win);
 381
 382    return EINA_TRUE;
 383 }
 384
 385 Eina_Bool
 386 etRunner::setWinActivateBelow(etWin *tw, etWin *below_tw)
 387 {
 388    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 389    EINA_SAFETY_ON_NULL_RETURN_VAL(below_tw, EINA_FALSE);
 390
 391    tw->updateGeometry();
 392
 393    tizen_policy_activate_below_by_res_id(tzPolicy,
 394                          tw->native_win, below_tw->native_win);
 395
 396    return EINA_TRUE;
 397 }
 398
 399 Eina_Bool
 400 etRunner::requestKillWinByName(const char *name)
 401 {
 402    Eldbus_Pending *p = NULL;
 403
 404    EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
 405
 406    p = eldbus_proxy_call(dbus.ds_proxy,
 407                          "RequestKillWin",
 408                          NULL,
 409                          NULL,
 410                          -1,
 411                          "s",
 412                          name);
 413    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 414
 415    return EINA_TRUE;
 416 }
 417
 418 Eina_Bool
 419 etRunner::setWinIconic(etWin *tw,
 420                       Eina_Bool set)
 421 {
 422    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 423
 424    if (set)
 425      tizen_policy_iconify(tzPolicy,
 426                           getWlSurface(tw->elm_win));
 427    else
 428      {
 429         tizen_policy_uniconify(tzPolicy,
 430                                getWlSurface(tw->elm_win));
 431         tw->forceRender();
 432      }
 433
 434    return EINA_TRUE;
 435 }
 436
 437 Eina_Bool
 438 etRunner::setWinStack(etWin *tw,
 439                       etWin *sibiling,
 440                       Eina_Bool above)
 441 {
 442    Eldbus_Pending *p = NULL;
 443    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 444
 445    p = eldbus_proxy_call(dbus.ds_proxy,
 446                          "SetWindowStack",
 447                          NULL,
 448                          NULL,
 449                          -1,
 450                          "uui",
 451                          tw->native_win,
 452                          sibiling? sibiling->native_win : 0,
 453                          above);
 454    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 455
 456    return EINA_TRUE;
 457 }
 458
 459 Eina_Bool
 460 etRunner::setWinRaise(etWin *tw)
 461 {
 462    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 463
 464    tizen_policy_raise(tzPolicy, getWlSurface(tw->elm_win));
 465
 466    return EINA_TRUE;
 467 }
 468
 469 Eina_Bool
 470 etRunner::setWinLower(etWin *tw)
 471 {
 472    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 473
 474    tizen_policy_lower(tzPolicy, getWlSurface(tw->elm_win));
 475
 476    return EINA_TRUE;
 477 }
 478
 479 Eina_Bool
 480 etRunner::setWinBgState(etWin *tw, Eina_Bool set)
 481 {
 482    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 483
 484    if (set)
 485      tizen_policy_set_background_state(tzPolicy,
 486                                        getpid());
 487    else
 488      tizen_policy_unset_background_state(tzPolicy,
 489                                          getpid());
 490
 491    return EINA_TRUE;
 492 }
 493
 494 Eina_Bool
 495 etRunner::setWinTransientFor(etWin *tw_child,
 496                              etWin *tw_parent,
 497                              Eina_Bool set)
 498 {
 499    EINA_SAFETY_ON_NULL_RETURN_VAL(tw_child, EINA_FALSE);
 500    EINA_SAFETY_ON_NULL_RETURN_VAL(tw_parent, EINA_FALSE);
 501
 502    if (set)
 503      tizen_policy_set_transient_for(tzPolicy,
 504                                     tw_child->native_win,
 505                                     tw_parent->native_win);
 506    else
 507      tizen_policy_unset_transient_for(tzPolicy,
 508                                       tw_child->native_win);
 509
 510    return EINA_TRUE;
 511 }
 512
 513 Eina_Bool
 514 etRunner::setWinTransientForBelow(etWin *tw_child,
 515                                   etWin *tw_parent,
 516                                   Eina_Bool set)
 517 {
 518    Eina_Bool accepted = EINA_FALSE;
 519    Eldbus_Pending *p = NULL;
 520
 521    p = eldbus_proxy_call(dbus.ds_proxy,
 522                          "SetWindowTransientForBelow",
 523                          _cb_method_transient_for_below,
 524                          &accepted,
 525                          -1,
 526                          "uub",
 527                          tw_child->native_win,
 528                          tw_parent->native_win,
 529                          set);
 530    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 531
 532    work();
 533
 534    return accepted;
 535 }
 536
 537 Eina_Bool
 538 etRunner::setWinNotiLevel(etWin *tw,
 539                           efl_util_notification_level_e lv)
 540 {
 541    int res;
 542
 543    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 544
 545    res = efl_util_set_notification_window_level(tw->elm_win, lv);
 546    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EINA_FALSE);
 547
 548    return EINA_TRUE;
 549 }
 550
 551 efl_util_notification_level_e
 552 etRunner::getWinNotiLevel(etWin *tw)
 553 {
 554    int res;
 555    efl_util_notification_level_e lv = EFL_UTIL_NOTIFICATION_LEVEL_NONE;
 556
 557    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 558
 559    res = efl_util_get_notification_window_level(tw->elm_win, &lv);
 560    EINA_SAFETY_ON_FALSE_RETURN_VAL(res == EFL_UTIL_ERROR_NONE, EFL_UTIL_NOTIFICATION_LEVEL_NONE);
 561
 562    return lv;
 563 }
 564
 565 Eina_Bool
 566 etRunner::setFocusSkip(etWin *tw, Eina_Bool set)
 567 {
 568    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 569
 570    if (set)
 571      tizen_policy_set_focus_skip(tzPolicy,
 572                                  getWlSurface(tw->elm_win));
 573    else
 574      tizen_policy_unset_focus_skip(tzPolicy,
 575                                    getWlSurface(tw->elm_win));
 576
 577    return EINA_TRUE;
 578 }
 579
 580 Eina_Bool
 581 etRunner::setFocusSkipEcoreWl2(etWin *tw, Eina_Bool set)
 582 {
 583    Ecore_Wl2_Window *wlwin = NULL;
 584
 585    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 586
 587    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 588    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 589
 590    ecore_wl2_window_focus_skip_set(wlwin, set);
 591
 592    return EINA_TRUE;
 593 }
 594
 595 Eina_Bool
 596 etRunner::setZoneRotation(int angle)
 597 {
 598    Eldbus_Pending *p = NULL;
 599    Eina_Bool allowed = EINA_FALSE;
 600
 601    p = eldbus_proxy_call(dbus.ds_proxy,
 602                          "ChangeZoneRotation",
 603                          _cb_method_zone_rotation_change,
 604                          &allowed,
 605                          -1,
 606                          "i",
 607                          angle);
 608    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 609
 610    work();
 611
 612    return allowed;
 613 }
 614
 615 Eina_Bool
 616 etRunner::addAuxHint(etWin *tw, int hint_id, const char *hint_key, const char *hint_val)
 617 {
 618    Ecore_Wl2_Window *wlwin = NULL;
 619
 620    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 621
 622    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 623    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 624
 625    ecore_wl2_window_aux_hint_add(wlwin, hint_id, hint_key, hint_val);
 626
 627    return EINA_TRUE;
 628 }
 629
 630 Eina_Bool
 631 etRunner::changeAuxHint(etWin *tw, int hint_id, const char *hint_val)
 632 {
 633    Ecore_Wl2_Window *wlwin = NULL;
 634
 635    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 636
 637    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 638    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 639
 640    ecore_wl2_window_aux_hint_change(wlwin, hint_id, hint_val);
 641
 642    return EINA_TRUE;
 643 }
 644
 645 Eina_Bool
 646 etRunner::delAuxHint(etWin *tw, int hint_id)
 647 {
 648    Ecore_Wl2_Window *wlwin = NULL;
 649
 650    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 651
 652    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 653    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 654
 655    ecore_wl2_window_aux_hint_del(wlwin, hint_id);
 656
 657    return EINA_TRUE;
 658 }
 659
 660 int
 661 etRunner::generateAuxHint(etWin *tw, const char *hint_key, const char *hint_val)
 662 {
 663    Ecore_Wl2_Window *wlwin = NULL;
 664
 665    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 666
 667    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 668    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, EINA_FALSE);
 669
 670    return ecore_wl2_window_aux_hint_generate(wlwin, hint_key, hint_val);
 671 }
 672
 673 int
 674 etRunner::getAuxHintID(etWin *tw, const char *hint_key)
 675 {
 676    Ecore_Wl2_Window *wlwin = NULL;
 677
 678    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, -1);
 679
 680    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 681    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, -1);
 682
 683    return ecore_wl2_window_aux_hint_id_get(wlwin, hint_key);
 684 }
 685
 686 std::string
 687 etRunner::getAuxHintValue(etWin *tw, int hint_id)
 688 {
 689    Ecore_Wl2_Window *wlwin = NULL;
 690
 691    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, std::string(""));
 692
 693    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(tw->elm_win);
 694    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, std::string(""));
 695
 696    return std::string(ecore_wl2_window_aux_hint_value_get(wlwin, hint_id));
 697 }
 698
 699 Eina_Bool
 700 etRunner::setTCStart()
 701 {
 702    Eldbus_Pending *p = NULL;
 703    Eina_Bool res = EINA_FALSE;
 704
 705    p = eldbus_proxy_call(dbus.ds_proxy,
 706                          "StartTestCase",
 707                          _cb_method_set_tc_start_end,
 708                          &res,
 709                          -1,
 710                          "");
 711    EINA_SAFETY_ON_NULL_GOTO(p, err);
 712
 713    work();
 714
 715    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 716
 717    return EINA_TRUE;
 718
 719 err:
 720    setTCEnd();
 721    return EINA_FALSE;
 722 }
 723
 724 Eina_Bool
 725 etRunner::setTCEnd()
 726 {
 727    Eldbus_Pending *p = NULL;
 728    Eina_Bool res = EINA_FALSE;
 729
 730    p = eldbus_proxy_call(dbus.ds_proxy,
 731                          "EndTestCase",
 732                          _cb_method_set_tc_start_end,
 733                          &res,
 734                          -1,
 735                          "");
 736    if (p == NULL) res = EINA_FALSE;
 737
 738    work();
 739
 740    EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
 741
 742    return EINA_TRUE;
 743 }
 744
 745 Eina_Bool
 746 etRunner::setTCTimeout(Eina_Bool set, int timeout)
 747 {
 748    Eldbus_Pending *p = NULL;
 749    Eina_Bool res = EINA_FALSE;
 750
 751    if (timeout < 0) return EINA_FALSE;
 752
 753    p = eldbus_proxy_call(dbus.ds_proxy,
 754                          "SetTestTimeout",
 755                          _cb_method_set_tc_timeout,
 756                          &res,
 757                          -1,
 758                          "bu",
 759                          set,
 760                          timeout);
 761    EINA_SAFETY_ON_NULL_GOTO(p, err);
 762
 763    work();
 764
 765    EINA_SAFETY_ON_FALSE_GOTO(res, err);
 766
 767    return EINA_TRUE;
 768
 769 err:
 770    setTCEnd();
 771    return EINA_FALSE;
 772 }
 773
 774 Eina_Bool
 775 etRunner::getWinInfo(etWin *tw)
 776 {
 777    Eldbus_Pending *p = NULL;
 778    Ecore_Window win;
 779    int retry = 10;
 780
 781    EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
 782
 783    win = tw->native_win;
 784    retry = (int) win;
 785
 786    while (retry)
 787      {
 788         p = eldbus_proxy_call(dbus.ds_proxy,
 789                               "GetWinInfo",
 790                               _cb_method_win_info_get,
 791                               tw,
 792                               -1,
 793                               "u",
 794                               win);
 795         EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 796
 797         elm_run();
 798
 799         if ((tw->native_win == win) && (!tw->effect))
 800           return EINA_TRUE;
 801         else
 802           retry--;
 803      }
 804
 805    if (tw->native_win != win)
 806      {
 807         ERR("Something Wrong. Difference with quering window"
 808             "and received window from server");
 809         tw->native_win = win;
 810      }
 811
 812    return EINA_FALSE;
 813 }
 814
 815 Eina_List *
 816 etRunner::getWinInfoList()
 817 {
 818    Eldbus_Pending *p = NULL;
 819    Window_Info_List *info_list = NULL;
 820    etWin *tw = NULL;
 821    Eina_List *result = NULL;
 822
 823    info_list = E_NEW(Window_Info_List, 1);
 824    EINA_SAFETY_ON_NULL_RETURN_VAL(info_list, NULL);
 825
 826    while (info_list)
 827      {
 828         p = eldbus_proxy_call(dbus.ds_proxy,
 829                               "GetWinsInfo",
 830                               _cb_method_win_info_list_get,
 831                               info_list,
 832                               -1,
 833                               "");
 834         EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL);
 835
 836         work();
 837
 838         if (info_list->retry)
 839           {
 840              info_list->retry = EINA_FALSE;
 841              EINA_LIST_CAST_FREE(info_list->list, tw, etWin*)
 842                {
 843                   if (tw)
 844                     delete tw;
 845                }
 846
 847              continue;
 848           }
 849
 850         break;
 851      }
 852
 853    result = eina_list_clone(info_list->list);
 854    E_FREE(info_list);
 855
 856    freeLastWinInfoList();
 857    listWinInfo = result;
 858
 859    return result;
 860 }
 861
 862 void
 863 etRunner::freeWinInfoList(Eina_List *list)
 864 {
 865    etWin *tw = NULL;
 866
 867    EINA_SAFETY_ON_NULL_RETURN(list);
 868
 869    if (listWinInfo == list)
 870      listWinInfo = NULL;
 871
 872    EINA_LIST_CAST_FREE(list, tw, etWin*)
 873      {
 874         if (tw != NULL)
 875           delete tw;
 876      }
 877
 878    list = NULL;
 879 }
 880
 881 void
 882 etRunner::freeLastWinInfoList()
 883 {
 884    if (listWinInfo)
 885      freeWinInfoList(listWinInfo);
 886
 887    listWinInfo = NULL;
 888 }
 889
 890 void
 891 etRunner::setLastWinInfoList(Eina_List *list)
 892 {
 893    EINA_SAFETY_ON_NULL_RETURN(list);
 894
 895    freeLastWinInfoList();
 896
 897    listWinInfo = list;
 898 }
 899
 900 Ecore_Window
 901 etRunner::getWinId(Evas_Object *elm_win)
 902 {
 903    struct wl_surface *surf = NULL;
 904    Ecore_Window id = 0;
 905    struct tizen_resource *tzres = NULL;
 906
 907    surf = getWlSurface(elm_win);
 908    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, 0);
 909
 910    tzres = tizen_surface_get_tizen_resource(tzSurface, surf);
 911    EINA_SAFETY_ON_NULL_RETURN_VAL(tzres, 0);
 912
 913    tizen_resource_add_listener(tzres,
 914                                &_e_test_tizen_resource_listener, &id);
 915
 916    work();
 917
 918    tizen_resource_destroy(tzres);
 919
 920    return id;
 921 }
 922
 923 struct wl_surface *
 924 etRunner::getWlSurface(Evas_Object *elm_win)
 925 {
 926    Ecore_Wl2_Window *wlwin = NULL;
 927    struct wl_surface *surf = NULL;
 928
 929    EINA_SAFETY_ON_NULL_RETURN_VAL(elm_win, NULL);
 930
 931    wlwin = (Ecore_Wl2_Window *)elm_win_wl_window_get(elm_win);
 932    EINA_SAFETY_ON_NULL_RETURN_VAL(wlwin, NULL);
 933
 934    surf = ecore_wl2_window_surface_get(wlwin);
 935    EINA_SAFETY_ON_NULL_RETURN_VAL(surf, NULL);
 936
 937    return surf;
 938 }
 939
 940 Eina_Bool
 941 etRunner::setDpms(Eina_Bool on)
 942 {
 943    Eldbus_Pending *p = NULL;
 944    p = eldbus_proxy_call(dbus.ds_proxy,
 945                          "DPMS",
 946                          NULL,
 947                          NULL,
 948                          -1,
 949                          "u",
 950                          on);
 951    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
 952    return EINA_TRUE;
 953 }
 954
 955 Eina_Bool
 956 etRunner::setDevctlDisplayLock(Eina_Bool lock)
 957 {
 958    Eldbus_Pending *p = NULL;
 959
 960    if (lock)
 961      {
 962         p = eldbus_proxy_call(dbus.deviced_proxy,
 963                               "lockstate",
 964                               NULL,
 965                               NULL,
 966                               -1,
 967                               "sssi",
 968                               "lcdon",
 969                               "gotostatenow",
 970                               "holdkeyblock",
 971                               "0");
 972      }
 973    else
 974      {
 975         p = eldbus_proxy_call(dbus.deviced_proxy,
 976                               "unlockstate",
 977                               NULL,
 978                               NULL,
 979                               -1,
 980                               "ss",
 981                               "lcdon",
 982                               "resettimer");
 983      }
 984    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
 985
 986    return EINA_TRUE;
 987 }
 988
 989 Eina_Bool
 990 etRunner::setDevctlDisplayOn(Eina_Bool on)
 991 {
 992    Eldbus_Pending *p = NULL;
 993
 994    p = eldbus_proxy_call(dbus.deviced_proxy,
 995                          "changestate",
 996                          NULL,
 997                          NULL,
 998                          -1,
 999                          "s",
1000                          on? "lcdon" : "lcdoff");
1001    EINA_SAFETY_ON_TRUE_RETURN_VAL(p != NULL, EINA_FALSE);
1002
1003    return EINA_TRUE;
1004 }
1005
1006 Eina_Bool
1007 etRunner::feedMouseDown(int x, int y)
1008 {
1009    Eldbus_Pending *p = NULL;
1010    p = eldbus_proxy_call(dbus.ds_proxy,
1011                          "EventMouse",
1012                          NULL,
1013                          NULL,
1014                          -1,
1015                          "uii",
1016                          0,
1017                          x, y);
1018    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1019    return EINA_TRUE;
1020 }
1021
1022 Eina_Bool
1023 etRunner::feedMouseMove(int x, int y)
1024 {
1025    Eldbus_Pending *p = NULL;
1026    p = eldbus_proxy_call(dbus.ds_proxy,
1027                          "EventMouse",
1028                          NULL,
1029                          NULL,
1030                          -1,
1031                          "uii",
1032                          1,
1033                          x, y);
1034    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1035    return EINA_TRUE;
1036 }
1037
1038 Eina_Bool
1039 etRunner::feedMouseUp(int x, int y)
1040 {
1041    Eldbus_Pending *p = NULL;
1042    p = eldbus_proxy_call(dbus.ds_proxy,
1043                          "EventMouse",
1044                          NULL,
1045                          NULL,
1046                          -1,
1047                          "uii",
1048                          2,
1049                          x, y);
1050    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1051    return EINA_TRUE;
1052 }
1053
1054 Eina_Bool
1055 etRunner::feedKeyDown(const char *key)
1056 {
1057    Eldbus_Pending *p = NULL;
1058    p = eldbus_proxy_call(dbus.ds_proxy,
1059                          "EventKey",
1060                          NULL,
1061                          NULL,
1062                          -1,
1063                          "us",
1064                          0,
1065                          key);
1066    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1067    return EINA_TRUE;
1068 }
1069
1070 Eina_Bool
1071 etRunner::feedKeyUp(const char *key)
1072 {
1073    Eldbus_Pending *p = NULL;
1074    p = eldbus_proxy_call(dbus.ds_proxy,
1075                          "EventKey",
1076                          NULL,
1077                          NULL,
1078                          -1,
1079                          "us",
1080                          1,
1081                          key);
1082    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1083    return EINA_TRUE;
1084 }
1085
1086 Eina_Bool
1087 etRunner::setSplashLaunch(const char *path, int type)
1088 {
1089    const char *effect_type = "launch";
1090    struct wl_array option;
1091
1092    // init tzlaunch_splash
1093    if (tzlaunch_splash)
1094      {
1095         tizen_launch_splash_destroy(tzlaunch_splash);
1096         tzlaunch_splash = NULL;
1097      }
1098    if (tzlaunch_effect) tzlaunch_splash = tizen_launch_effect_create_splash_img(tzlaunch_effect);
1099    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1100
1101    wl_array_init(&option);
1102    tizen_launch_splash_launch(tzlaunch_splash, path, type,
1103                               24, 0, 0,
1104                               effect_type, NULL, &option);
1105    wl_array_release(&option);
1106
1107    return EINA_TRUE;
1108 }
1109
1110 Eina_Bool
1111 etRunner::setSplashOwner()
1112 {
1113
1114    EINA_SAFETY_ON_NULL_RETURN_VAL(tzlaunch_splash, EINA_FALSE);
1115
1116    tizen_launch_splash_owner(tzlaunch_splash, (int)getpid());
1117
1118    return EINA_TRUE;
1119 }
1120
1121 Eina_Bool
1122 etRunner::setWinEffect(etWin *tw)
1123 {
1124    Eldbus_Pending *p = NULL;
1125    Eina_Bool accepted = EINA_FALSE;
1126
1127    this->ev.elm_win = tw->elm_win;
1128
1129    p = eldbus_proxy_call(dbus.ds_proxy,
1130                          "RenderTrace",
1131                          _cb_method_window_effect,
1132                          &accepted,
1133                          -1,
1134                          "us",
1135                          tw->native_win,
1136                          "effect");
1137    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1138
1139    work();
1140    return accepted;
1141 }
1142
1143 Eina_Bool
1144 etRunner::freezeEvent()
1145 {
1146    Eldbus_Pending *p = NULL;
1147    p = eldbus_proxy_call(dbus.ds_proxy,
1148                          "EventFreeze",
1149                          NULL,
1150                          NULL,
1151                          -1,
1152                          "u",
1153                          1);
1154    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1155    return EINA_TRUE;
1156 }
1157
1158 Eina_Bool
1159 etRunner::thawEvent()
1160 {
1161    Eldbus_Pending *p = NULL;
1162    p = eldbus_proxy_call(dbus.ds_proxy,
1163                          "EventFreeze",
1164                          NULL,
1165                          NULL,
1166                          -1,
1167                          "u",
1168                          0);
1169    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1170    return EINA_TRUE;
1171 }
1172
1173 Eina_Bool
1174 etRunner::addSupportedAuxHint(const char *hint)
1175 {
1176    Eldbus_Pending *p = NULL;
1177    p = eldbus_proxy_call(dbus.ds_proxy,
1178                          "AddSupportedAuxHint",
1179                          NULL,
1180                          NULL,
1181                          -1,
1182                          "s",
1183                          hint);
1184    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1185    return EINA_TRUE;
1186 }
1187
1188 Eina_Bool
1189 etRunner::delSupportedAuxHint(const char *hint)
1190 {
1191    Eldbus_Pending *p = NULL;
1192    p = eldbus_proxy_call(dbus.ds_proxy,
1193                          "DelSupportedAuxHint",
1194                          NULL,
1195                          NULL,
1196                          -1,
1197                          "s",
1198                          hint);
1199    EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE);
1200    return EINA_TRUE;
1201 }
1202
1203 std::shared_ptr<auxHintEventItem>
1204 etRunner::getAuxHint(etWin *tw, const char *hint_key)
1205 {
1206    Eldbus_Pending *p = NULL;
1207    auxHintEventItem *hint = NULL;
1208
1209    p = eldbus_proxy_call(dbus.ds_proxy,
1210                          "GetAuxHint",
1211                          _cb_method_aux_hint_get,
1212                          &hint,
1213                          -1,
1214                          "us",
1215                          tw->native_win,
1216                          hint_key);
1217    EINA_SAFETY_ON_NULL_RETURN_VAL(p, nullptr);
1218
1219    work();
1220
1221    if (hint)
1222      {
1223         std::shared_ptr<auxHintEventItem> shared_hint = std::make_shared<auxHintEventItem>(tw->native_win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, hint->getID(), hint->getHint().c_str(), hint->getVal().c_str());
1224         delete hint;
1225         return shared_hint;
1226      }
1227
1228    return NULL;
1229 }
1230
1231 void
1232 etRunner::watchEventSignal(Ecore_Window win, E_TC_Event_Type ev_type)
1233 {
1234    ev.eventWatcher = std::make_shared<eventItem>(win, ev_type);
1235 }
1236
1237 void
1238 etRunner::unwatchEventSignal()
1239 {
1240    ev.eventWatcher = nullptr;
1241 }
1242
1243 Eina_Bool
1244 etRunner::isWatchingEventSignal(std::shared_ptr<eventItem> ei)
1245 {
1246    if (ei == nullptr) return EINA_FALSE;
1247    if (ev.eventWatcher == nullptr) return EINA_FALSE;
1248
1249    if (ev.eventWatcher->isSameEvent(ei))
1250      return EINA_TRUE;
1251
1252    return EINA_FALSE;
1253 }
1254
1255 Eina_Bool
1256 etRunner::isWatchingEventSignal(Ecore_Window win, E_TC_Event_Type ev_type)
1257 {
1258    if (ev.eventWatcher == nullptr) return EINA_FALSE;
1259
1260    if ((ev.eventWatcher->isSameWin(win) &&
1261         ev.eventWatcher->isSameType(ev_type)))
1262      return EINA_TRUE;
1263
1264    return EINA_FALSE;
1265 }
1266
1267 std::shared_ptr<eventItem>
1268 etRunner::waitEvent(etWin *win, E_TC_Event_Type ev_type)
1269 {
1270    std::shared_ptr<eventItem> recv_item = NULL;
1271    std::list<std::shared_ptr<eventItem>>::iterator itr;
1272
1273    // swap event
1274    switch (ev_type)
1275      {
1276       case E_TC_EVENT_TYPE_VIS_ON:
1277       case E_TC_EVENT_TYPE_VIS_OFF:
1278       case E_TC_EVENT_TYPE_VIS_CHANGED:
1279          ev_type = E_TC_EVENT_TYPE_VIS_CHANGED;
1280          break;
1281       case E_TC_EVENT_TYPE_STACK_RAISE:
1282       case E_TC_EVENT_TYPE_STACK_LOWER:
1283       case E_TC_EVENT_TYPE_STACK_ABOVE:
1284       case E_TC_EVENT_TYPE_STACK_BELOW:
1285       case E_TC_EVENT_TYPE_STACK_CHANGED:
1286          ev_type = E_TC_EVENT_TYPE_STACK_CHANGED;
1287          break;
1288       case E_TC_EVENT_TYPE_ICONIC_STATE_ICONIFIED:
1289       case E_TC_EVENT_TYPE_ICONIC_STATE_UNICONIFIED:
1290       case E_TC_EVENT_TYPE_ICONIC_STATE_CHANGED:
1291          ev_type = E_TC_EVENT_TYPE_ICONIC_STATE_CHANGED;
1292          break;
1293       default:
1294          break;
1295      }
1296
1297    // Add event callbacks if needs
1298    if (ev_type == E_TC_EVENT_TYPE_EFFECT_EVAS_CB)
1299      {
1300         ev.elm_win = win->elm_win;
1301         ev.native_win = win->native_win;
1302         ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_NONE;
1303
1304         evas_object_smart_callback_add(this->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started, this);
1305         evas_object_smart_callback_add(this->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done, this);
1306         evas_object_smart_callback_add(this->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done, this);
1307      }
1308    else if (ev_type == E_TC_EVENT_TYPE_INPUT_EVAS_KEY)
1309      {
1310         ev.elm_win = win->elm_win;
1311         ev.native_win = win->native_win;
1312         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down, this);
1313         evas_object_event_callback_add(this->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up, this);
1314
1315         ev.key.evas_state = EINA_FALSE;
1316      }
1317
1318    // pre-waiting events
1319    watchEventSignal(win?win->native_win:0, ev_type);
1320    work();
1321
1322    if (*ev.wait_event_index == ev.last_event)
1323      {
1324         work(); // waiting additional time
1325         if (*ev.wait_event_index == ev.last_event)
1326         {
1327            std::shared_ptr<eventItem> res = std::make_shared<eventItem>(0, E_TC_EVENT_TYPE_NONE);
1328            res->result = EINA_FALSE;
1329            res->isTimeout = EINA_TRUE;
1330           return res;
1331         }
1332      }
1333
1334    // search from latest waitEvent called point
1335    itr = ev.wait_event_index;
1336    if (itr == ev.recv_queue.end()) itr = ev.recv_queue.begin();
1337    else itr++;
1338
1339    for (; itr != ev.recv_queue.end() ; itr++)
1340      {
1341         recv_item = *itr;
1342         if ((recv_item->isSameWin(win?win->native_win:0)) &&
1343             (recv_item->isSameType(ev_type)))
1344           {
1345              ev.wait_event_index = itr;
1346              recv_item->result = EINA_TRUE;
1347              return recv_item;
1348           }
1349      }
1350
1351    if (recv_item == NULL)
1352    {
1353       recv_item = std::make_shared<eventItem>(0, E_TC_EVENT_TYPE_NONE);
1354       recv_item->result = EINA_FALSE;
1355    }
1356    return recv_item;
1357 }
1358
1359 void
1360 etRunner::flushEventQueue()
1361 {
1362    std::list<std::shared_ptr<eventItem>>::iterator itr;
1363    std::shared_ptr<eventItem> ei = NULL;
1364    if (!ev.recv_queue.empty())
1365         ev.recv_queue.erase(ev.recv_queue.begin(), ev.recv_queue.end());
1366    ev.wait_event_index = ev.recv_queue.end();
1367    ev.last_event = NULL;
1368    ev.last_checkpoint = NULL;
1369 }
1370
1371 Eina_Bool
1372 etRunner::insertEventQueue(std::shared_ptr<eventItem> ei)
1373 {
1374    EINA_SAFETY_ON_NULL_RETURN_VAL(ei, EINA_FALSE);
1375
1376    ev.recv_queue.push_back(ei);
1377    ev.last_event = ei;
1378
1379    if (isWatchingEventSignal(ei))
1380      {
1381         unwatchEventSignal();
1382         finishWork();
1383      }
1384
1385    return EINA_TRUE;
1386 }
1387
1388 Eina_Bool
1389 etRunner::insertEventQueue(Ecore_Window id, E_TC_Event_Type ev_type)
1390 {
1391    std::shared_ptr<eventItem> ei = std::make_shared<eventItem>(id, ev_type);
1392    EINA_SAFETY_ON_NULL_RETURN_VAL(ei, EINA_FALSE);
1393
1394    ev.recv_queue.push_back(ei);
1395    ev.last_event = ei;
1396
1397    if (isWatchingEventSignal(id, ev_type))
1398      {
1399         unwatchEventSignal();
1400         finishWork();
1401      }
1402
1403    return EINA_TRUE;
1404 }
1405
1406 Eina_Bool
1407 etRunner::isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type)
1408 {
1409    std::list<std::shared_ptr<eventItem>>::iterator itr;
1410    std::shared_ptr<eventItem> ei = NULL;
1411    Ecore_Window id = tw->native_win;
1412
1413    for(itr = ev.recv_queue.begin() ; itr != ev.recv_queue.end() ; itr++)
1414      {
1415         ei = *itr;
1416
1417         if (ev.last_checkpoint && ev.last_checkpoint != ei)
1418           continue;
1419
1420         if (ei->isSameWin(id) && ei->isSameType(ev_type))
1421           return EINA_TRUE;
1422      }
1423
1424    return EINA_FALSE;
1425 }
1426
1427 void
1428 etRunner::setEventCheckpoint()
1429 {
1430    ev.last_checkpoint = ev.last_event;
1431    return;
1432 }
1433
1434 Eina_Bool
1435 etRunner::addSignalHandlers()
1436 {
1437    Eldbus_Signal_Handler *sh = NULL;
1438    Ecore_Event_Handler *eh = NULL;
1439
1440    flushEventQueue();
1441
1442    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1443                                         "VisibilityChanged",
1444                                         _cb_signal_vis_changed,
1445                                         this);
1446    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1447    ev.sh_list = eina_list_append(ev.sh_list, sh);
1448
1449    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1450                                         "StackChanged",
1451                                         _cb_signal_stack_changed,
1452                                         this);
1453    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1454    ev.sh_list = eina_list_append(ev.sh_list, sh);
1455
1456    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1457                                         "WinRotationChanged",
1458                                         _cb_signal_win_rot_changed,
1459                                         this);
1460    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1461    ev.sh_list = eina_list_append(ev.sh_list, sh);
1462
1463    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1464                                         "FocusChanged",
1465                                         _cb_signal_focus_changed,
1466                                         this);
1467    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1468    ev.sh_list = eina_list_append(ev.sh_list, sh);
1469
1470    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1471                                         "RenderRun",
1472                                         _cb_signal_render_while_effect_run,
1473                                         this);
1474    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1475    ev.sh_list = eina_list_append(ev.sh_list, sh);
1476
1477    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1478                                         "AuxHintChanged",
1479                                         _cb_signal_aux_hint_changed,
1480                                         this);
1481    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1482    ev.sh_list = eina_list_append(ev.sh_list, sh);
1483
1484    sh = eldbus_proxy_signal_handler_add(dbus.ds_proxy,
1485                                         "IconicStateChanged",
1486                                         _cb_signal_iconic_state_changed,
1487                                         this);
1488    EINA_SAFETY_ON_NULL_GOTO(sh, err);
1489    ev.sh_list = eina_list_append(ev.sh_list, sh);
1490
1491    eh = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _cb_ecore_key_down, this);
1492    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1493    ev.eh_list = eina_list_append(ev.eh_list, eh);
1494
1495    eh = ecore_event_handler_add(ECORE_EVENT_KEY_UP, _cb_ecore_key_up, this);
1496    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1497    ev.eh_list = eina_list_append(ev.eh_list, eh);
1498
1499    ev.key.ecore_state = EINA_FALSE;
1500
1501    return EINA_TRUE;
1502
1503 err:
1504    printf("failed to init handlers\n");
1505    delSignalHandlers();
1506    return EINA_FALSE;
1507 }
1508
1509 Eina_Bool
1510 etRunner::addGestureSignalHandlers()
1511 {
1512    Ecore_Event_Handler *eh = NULL;
1513
1514 #ifndef DISABLE_GESTURE_TESTS
1515    if ((EFL_UTIL_EVENT_GESTURE_TAP == 0) ||
1516       (EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE == 0) ||
1517       (EFL_UTIL_EVENT_GESTURE_EDGE_DRAG == 0))
1518      goto err;
1519
1520    if (ev.last_gesture_tap_ev != EFL_UTIL_EVENT_GESTURE_TAP)
1521      delGestureSignalHandlers();
1522
1523    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
1524    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1525    ev.eh_gesture_list = eina_list_append(ev.eh_gesture_list, eh);
1526
1527    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
1528    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1529    ev.eh_gesture_list = eina_list_append(ev.eh_gesture_list, eh);
1530
1531    eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
1532    EINA_SAFETY_ON_NULL_GOTO(eh, err);
1533    ev.eh_gesture_list = eina_list_append(ev.eh_gesture_list, eh);
1534
1535    ev.last_gesture_tap_ev = EFL_UTIL_EVENT_GESTURE_TAP;
1536 #endif
1537
1538    return EINA_TRUE;
1539
1540 err:
1541    printf("failed to init gesture handlers\n");
1542    delGestureSignalHandlers();
1543    return EINA_FALSE;
1544 }
1545
1546 void
1547 etRunner::delSignalHandlers()
1548 {
1549    Eldbus_Signal_Handler *sh = NULL;
1550    Ecore_Event_Handler *eh = NULL;
1551
1552    EINA_LIST_CAST_FREE(ev.sh_list, sh, Eldbus_Signal_Handler*)
1553      {
1554         eldbus_signal_handler_del(sh);
1555      }
1556
1557    EINA_LIST_CAST_FREE(ev.eh_list, eh, Ecore_Event_Handler*)
1558      {
1559         ecore_event_handler_del(eh);
1560      }
1561
1562    flushEventQueue();
1563 }
1564
1565 void
1566 etRunner::delGestureSignalHandlers()
1567 {
1568    Ecore_Event_Handler *eh = NULL;
1569
1570    EINA_LIST_CAST_FREE(ev.eh_gesture_list, eh, Ecore_Event_Handler*)
1571      {
1572         ecore_event_handler_del(eh);
1573      }
1574
1575    flushEventQueue();
1576 }
1577
1578 void
1579 etRunner::work()
1580 {
1581    /* give a turn to deal with deferred job for given time*/
1582    addTimer(worker.waitTime);
1583    elm_run();
1584 }
1585
1586 void
1587 etRunner::work(double time)
1588 {
1589    /* give a turn to deal with deferred job for given time*/
1590    if (time < 0.0) time = 0.0;
1591
1592    addTimer(time);
1593    elm_run();
1594 }
1595
1596 void
1597 etRunner::finishWork()
1598 {
1599    if (worker.timer)
1600      delTimer();
1601
1602    elm_exit();
1603 }
1604
1605 void
1606 etRunner::printWinInfoList()
1607 {
1608    etWin *tw = NULL;
1609    Eina_List *l = NULL, *ll = NULL;
1610
1611    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1612    l = getWinInfoList();
1613    EINA_LIST_CAST_FOREACH(l, ll, tw, etWin*)
1614      {
1615         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",
1616                tw->layer,
1617                (unsigned int)tw->native_win,
1618                tw->alpha,
1619                tw->x, tw->y, tw->w, tw->h,
1620                tw->Vis.win,
1621                tw->Vis.obj,
1622                tw->Vis.opaque,
1623                tw->Vis.type,
1624                tw->Vis.skip,
1625                tw->iconic.by_client ? 2 : tw->iconic.set,
1626                tw->Focus.win,
1627                tw->Focus.obj,
1628                tw->name);
1629      }
1630    freeWinInfoList(l);
1631    printf("--------------------------------------------------------------------------------------------------------------------------\n");
1632 }
1633
1634 void
1635 etRunner::delTimer()
1636 {
1637    if (!worker.timer) return;
1638
1639    ecore_timer_del(worker.timer);
1640    worker.timer = NULL;
1641 }
1642
1643 void
1644 etRunner::addTimer()
1645 {
1646    delTimer();
1647
1648    worker.timer = ecore_timer_add(worker.waitTime,
1649                                   _cb_work_timeout,
1650                                   this);
1651 }
1652
1653 void
1654 etRunner::addTimer(double time)
1655 {
1656    delTimer();
1657
1658    worker.timer = ecore_timer_add(time,
1659                                   _cb_work_timeout,
1660                                   this);
1661 }
1662
1663 void
1664 etRunner::waitForDestroy()
1665 {
1666    work(E_TEST_WORK_TIME);
1667 }
1668
1669 Eina_Bool
1670 etRunner::initProtocols()
1671 {
1672    Eina_Iterator *globals = NULL;
1673    Ecore_Wl2_Global *global = NULL;
1674    struct wl_registry *registry = NULL;
1675
1676    registry = ecore_wl2_display_registry_get(ecore_wl2_connected_display_get(NULL));
1677    globals = ecore_wl2_display_globals_get(ecore_wl2_connected_display_get(NULL));
1678
1679    EINA_SAFETY_ON_NULL_GOTO(registry, err);
1680    EINA_SAFETY_ON_NULL_GOTO(globals, err);
1681
1682    EINA_ITERATOR_FOREACH(globals, global)
1683      {
1684         if (!strcmp(global->interface, "tizen_policy"))
1685           {
1686              tzPolicy = (struct tizen_policy *)
1687                 wl_registry_bind(registry,
1688                                  global->id,
1689                                  &tizen_policy_interface,
1690                                  (global->version > 7)? 7 : global->version);
1691           }
1692         if (!strcmp(global->interface, "tizen_surface"))
1693           {
1694              tzSurface = (struct tizen_surface *)
1695                 wl_registry_bind(registry,
1696                                  global->id,
1697                                  &tizen_surface_interface,
1698                                  (global->version > 1)? 1 : global->version);
1699           }
1700         if (!strcmp(global->interface, "tizen_launch_effect"))
1701           {
1702              tzlaunch_effect = (struct tizen_launch_effect *)
1703                 wl_registry_bind(registry,
1704                                  global->id,
1705                                  &tizen_launch_effect_interface,
1706                                  (global->version > 1)? 1 : global->version);
1707           }
1708         if (!strcmp(global->interface, "wl_output"))
1709           {
1710              wlOutput = (struct wl_output *)
1711                 wl_registry_bind(registry,
1712                                  global->id,
1713                                  &wl_output_interface,
1714                                  (global->version > 2)? 2 : global->version);
1715              wl_output_add_listener(wlOutput, &_e_test_output_listener, NULL);
1716
1717              work();
1718
1719              if (wlOutput)
1720                {
1721                   wl_output_destroy(wlOutput);
1722                   wlOutput = NULL;
1723                }
1724           }
1725      }
1726
1727    EINA_SAFETY_ON_NULL_GOTO(tzPolicy, err);
1728    EINA_SAFETY_ON_NULL_GOTO(tzSurface, err);
1729    EINA_SAFETY_ON_NULL_GOTO(tzlaunch_effect, err);
1730
1731    eina_iterator_free(globals);
1732    return EINA_TRUE;
1733
1734 err:
1735    if (globals)
1736      eina_iterator_free(globals);
1737    return EINA_FALSE;
1738 }
1739
1740 /* callbacks - method */
1741 static void
1742 _cb_method_win_info_get(void *data,
1743                         const Eldbus_Message *msg,
1744                         Eldbus_Pending *p)
1745 {
1746    const char *name = NULL, *text = NULL, *wname = NULL;
1747    int iconic = 0;
1748    etWin *tw = NULL;
1749    Eina_Bool res = EINA_FALSE;
1750
1751    tw = (etWin *)data;
1752
1753    res = eldbus_message_error_get(msg, &name, &text);
1754    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1755
1756    res = eldbus_message_arguments_get
1757       (msg,
1758        E_TC_SIGN_WIN_INFO,
1759        &tw->native_win,
1760        &wname,
1761        &tw->x, &tw->y, &tw->w, &tw->h,
1762        &tw->layer,
1763        &tw->effect,
1764        &tw->Vis.win,
1765        &tw->Vis.obj,
1766        &tw->Vis.opaque,
1767        &tw->Vis.type,
1768        &tw->Vis.skip,
1769        &iconic,
1770        &tw->alpha,
1771        &tw->Focus.win,
1772        &tw->Focus.obj,
1773        &tw->rot);
1774
1775    switch (iconic)
1776      {
1777       case 2:
1778         tw->iconic.set = EINA_TRUE;
1779         tw->iconic.by_client = EINA_TRUE;
1780         break;
1781       case 1:
1782         tw->iconic.set = EINA_TRUE;
1783         tw->iconic.by_client = EINA_FALSE;
1784         break;
1785       default:
1786         tw->iconic.set = EINA_FALSE;
1787         tw->iconic.by_client = EINA_FALSE;
1788         break;
1789      }
1790
1791    if (wname)
1792      {
1793         // change window name from char * to Eina_Stringshare
1794         if (tw->name)
1795           eina_stringshare_del(tw->name);
1796         tw->name = eina_stringshare_add(wname);
1797      }
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_win_info_list_get(void *data,
1810                              const Eldbus_Message *msg,
1811                              Eldbus_Pending *p)
1812 {
1813    const char *name = NULL, *text = NULL, *wname = NULL;
1814    int iconic = 0;
1815    Eldbus_Message_Iter *array = NULL, *ec = NULL;
1816    Window_Info_List *info_list = (Window_Info_List *)data;
1817    Eina_Bool res = EINA_FALSE, animating = EINA_FALSE;
1818
1819    if (info_list == NULL)
1820      goto finish;
1821
1822    res = eldbus_message_error_get(msg, &name, &text);
1823    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1824
1825    res = eldbus_message_arguments_get(msg, "a(" E_TC_SIGN_WIN_INFO ")", &array);
1826    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1827
1828    while (eldbus_message_iter_get_and_next(array, 'r', &ec))
1829      {
1830         etWin *tw = new etWin();
1831         if (!tw) continue;
1832
1833         res = eldbus_message_iter_arguments_get(
1834            ec,
1835            E_TC_SIGN_WIN_INFO,
1836            &tw->native_win,
1837            &wname,
1838            &tw->x, &tw->y, &tw->w, &tw->h,
1839            &tw->layer,
1840            &tw->effect,
1841            &tw->Vis.win,
1842            &tw->Vis.obj,
1843            &tw->Vis.opaque,
1844            &tw->Vis.type,
1845            &tw->Vis.skip,
1846            &iconic,
1847            &tw->alpha,
1848            &tw->Focus.win,
1849            &tw->Focus.obj,
1850            &tw->rot);
1851
1852         switch (iconic)
1853           {
1854            case 2:
1855              tw->iconic.set = EINA_TRUE;
1856              tw->iconic.by_client = EINA_TRUE;
1857              break;
1858            case 1:
1859              tw->iconic.set = EINA_TRUE;
1860              tw->iconic.by_client = EINA_FALSE;
1861              break;
1862            default:
1863              tw->iconic.set = EINA_FALSE;
1864              tw->iconic.by_client = EINA_FALSE;
1865              break;
1866           }
1867
1868         if (wname)
1869           {
1870              // change name to eina_stringshare
1871              if (tw->name)
1872                {
1873                   WRN("Failed to get win info\n");
1874                   delete tw;
1875                   continue;
1876                }
1877              tw->name = eina_stringshare_add(wname);
1878           }
1879
1880         if (tw->effect)
1881           animating = EINA_TRUE;
1882
1883         if (!res)
1884           {
1885              WRN("Failed to get win info\n");
1886              delete tw;
1887              continue;
1888           }
1889
1890         info_list->list = eina_list_append(info_list->list, tw);
1891      }
1892
1893    if (animating)
1894      info_list->retry = EINA_TRUE;
1895
1896 finish:
1897    if ((name) || (text))
1898      {
1899         ERR("errname:%s errmsg:%s\n", name, text);
1900      }
1901
1902    etRunner::get().finishWork();
1903 }
1904
1905 static void
1906 _cb_method_window_register(void *data,
1907                            const Eldbus_Message *msg,
1908                            Eldbus_Pending *p)
1909 {
1910    const char *name = NULL, *text = NULL;
1911    Eina_Bool res = EINA_FALSE;
1912    Eina_Bool *accepted = (Eina_Bool *)data;
1913
1914    *accepted = EINA_FALSE;
1915
1916    res = eldbus_message_error_get(msg, &name, &text);
1917    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1918
1919    res = eldbus_message_arguments_get(msg, "b", accepted);
1920
1921 finish:
1922    if ((name) || (text))
1923      {
1924         ERR("errname: %s errmsg: %s\n", name, text);
1925      }
1926
1927    etRunner::get().finishWork();
1928 }
1929
1930 static void
1931 _cb_method_zone_rotation_change(void *data,
1932                                 const Eldbus_Message *msg,
1933                                 Eldbus_Pending *p)
1934 {
1935    const char *name = NULL, *text = NULL;
1936    Eina_Bool res = EINA_FALSE;
1937    Eina_Bool *allowed = (Eina_Bool *)data;
1938
1939    *allowed = EINA_FALSE;
1940
1941    res = eldbus_message_error_get(msg, &name, &text);
1942    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1943
1944    res = eldbus_message_arguments_get(msg, "b", allowed);
1945    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1946    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1947
1948 finish:
1949    if ((name) || (text))
1950      {
1951         ERR("errname: %s errmsg: %s\n", name, text);
1952      }
1953
1954    etRunner::get().finishWork();
1955 }
1956
1957 static void
1958 _cb_method_window_effect(void *data,
1959                                 const Eldbus_Message *msg,
1960                                 Eldbus_Pending *p)
1961 {
1962    const char *name = NULL, *text = NULL;
1963    Eina_Bool res = EINA_FALSE;
1964    Eina_Bool *allowed = (Eina_Bool *)data;
1965
1966    *allowed = EINA_FALSE;
1967
1968    res = eldbus_message_error_get(msg, &name, &text);
1969    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1970
1971    res = eldbus_message_arguments_get(msg, "b", allowed);
1972    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
1973    EINA_SAFETY_ON_FALSE_GOTO(*allowed, finish);
1974
1975 finish:
1976    if ((name) || (text))
1977      {
1978         ERR("errname: %s errmsg: %s\n", name, text);
1979      }
1980
1981    etRunner::get().finishWork();
1982 }
1983
1984 static void
1985 _cb_method_set_tc_start_end(void *data,
1986                             const Eldbus_Message *msg,
1987                             Eldbus_Pending *p)
1988 {
1989    const char *name = NULL, *text = NULL;
1990    Eina_Bool res = EINA_FALSE;
1991    Eina_Bool *accept = (Eina_Bool *)data;
1992
1993    *accept = EINA_FALSE;
1994
1995    res = eldbus_message_error_get(msg, &name, &text);
1996    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
1997
1998    res = eldbus_message_arguments_get(msg, "b", accept);
1999    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2000    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
2001
2002 finish:
2003    if ((name) || (text))
2004      {
2005         ERR("errname: %s errmsg: %s\n", name, text);
2006      }
2007
2008    etRunner::get().finishWork();
2009 }
2010
2011 static void
2012 _cb_method_set_tc_timeout(void *data,
2013                           const Eldbus_Message *msg,
2014                           Eldbus_Pending *p)
2015 {
2016    const char *name = NULL, *text = NULL;
2017    Eina_Bool res = EINA_FALSE;
2018    Eina_Bool *accept = (Eina_Bool *)data;
2019
2020    *accept = EINA_FALSE;
2021
2022    res = eldbus_message_error_get(msg, &name, &text);
2023    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2024
2025    res = eldbus_message_arguments_get(msg, "b", accept);
2026    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2027    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
2028
2029 finish:
2030    if ((name) || (text))
2031      {
2032         ERR("errname: %s errmsg: %s\n", name, text);
2033      }
2034
2035    etRunner::get().finishWork();
2036 }
2037
2038 static void
2039 _cb_method_transient_for_below(void *data,
2040                                const Eldbus_Message *msg,
2041                                Eldbus_Pending *p)
2042 {
2043    const char *name = NULL, *text = NULL;
2044    Eina_Bool res = EINA_FALSE;
2045    Eina_Bool *accept = (Eina_Bool *)data;
2046
2047    *accept = EINA_FALSE;
2048
2049    res = eldbus_message_error_get(msg, &name, &text);
2050    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2051
2052    res = eldbus_message_arguments_get(msg, "b", accept);
2053    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2054    EINA_SAFETY_ON_FALSE_GOTO(*accept, finish);
2055
2056 finish:
2057    if ((name) || (text))
2058      {
2059         ERR("errname: %s errmsg: %s\n", name, text);
2060      }
2061
2062    etRunner::get().finishWork();
2063 }
2064
2065 static void
2066 _cb_method_aux_hint_get(void *data,
2067                         const Eldbus_Message *msg,
2068                         Eldbus_Pending *p)
2069 {
2070    auxHintEventItem **hint = (auxHintEventItem **) data;
2071    const char *name = NULL, *text = NULL;
2072    Eina_Bool res = EINA_FALSE;
2073    int id;
2074    const char *hint_key, *hint_val;
2075
2076    res = eldbus_message_error_get(msg, &name, &text);
2077    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2078
2079    res = eldbus_message_arguments_get(msg, "iss", &id, &hint_key, &hint_val);
2080    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2081
2082    *hint = new auxHintEventItem(0, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, id, hint_key, hint_val);
2083
2084 finish:
2085    if ((name) || (text))
2086      {
2087         ERR("errname: %s errmsg: %s\n", name, text);
2088      }
2089
2090    etRunner::get().finishWork();
2091 }
2092
2093 /* callbacks - signal */
2094 static void
2095 _cb_signal_vis_changed(void *data,
2096                        const Eldbus_Message *msg)
2097 {
2098    etRunner *runner = (etRunner *)data;
2099    std::shared_ptr<visibleEventItem> visibleEvent = NULL;
2100    const char *name = NULL, *text = NULL;
2101    Eina_Bool res = EINA_FALSE;
2102    int vis = 0;
2103    Ecore_Window id;
2104
2105    res = eldbus_message_error_get(msg, &name, &text);
2106    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2107
2108    res = eldbus_message_arguments_get(msg, "ub", &id, &vis);
2109    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2110
2111    visibleEvent = std::make_shared<visibleEventItem>(id, E_TC_EVENT_TYPE_VIS_CHANGED, vis);
2112    EINA_SAFETY_ON_NULL_GOTO(visibleEvent, finish);
2113
2114    runner->insertEventQueue(visibleEvent);
2115
2116 finish:
2117    if ((name) || (text))
2118      {
2119         ERR("errname:%s errmsg:%s\n", name, text);
2120      }
2121 }
2122
2123 static void
2124 _cb_signal_stack_changed(void *data,
2125                          const Eldbus_Message *msg)
2126 {
2127    etRunner *runner = (etRunner *)data;
2128    const char *name = NULL, *text = NULL;
2129    Eina_Bool res = EINA_FALSE;
2130    Ecore_Window id = 0;
2131
2132    res = eldbus_message_error_get(msg, &name, &text);
2133    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2134
2135    res = eldbus_message_arguments_get(msg, "u", &id);
2136    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2137
2138    runner->insertEventQueue(id, E_TC_EVENT_TYPE_STACK_CHANGED);
2139
2140 finish:
2141    if ((name) || (text))
2142      {
2143         ERR("errname:%s errmsg:%s\n", name, text);
2144      }
2145 }
2146
2147 static void
2148 _cb_signal_win_rot_changed(void *data,
2149                            const Eldbus_Message *msg)
2150 {
2151    etRunner *runner = (etRunner *)data;
2152    std::shared_ptr<rotationEventItem> rotationEvent = NULL;
2153    const char *name = NULL, *text = NULL;
2154    Eina_Bool res = EINA_FALSE;
2155    int angle = 0;
2156    Ecore_Window id;
2157
2158    res = eldbus_message_error_get(msg, &name, &text);
2159    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2160
2161    /* TODO unused 'window id' and 'angle' */
2162    res = eldbus_message_arguments_get(msg, "ui", &id, &angle);
2163    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2164
2165    rotationEvent = std::make_shared<rotationEventItem>(id, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE, angle);
2166    EINA_SAFETY_ON_NULL_GOTO(rotationEvent, finish);
2167
2168    runner->insertEventQueue(rotationEvent);
2169
2170 finish:
2171    if ((name) || (text))
2172      {
2173         ERR("errname:%s errmsg:%s\n", name, text);
2174      }
2175 }
2176
2177 static void
2178 _cb_signal_focus_changed(void *data,
2179                          const Eldbus_Message *msg)
2180 {
2181    etRunner *runner = (etRunner *)data;
2182    std::shared_ptr<focusEventItem> focusEvent = NULL;
2183    const char *name = NULL, *text = NULL;
2184    Eina_Bool res = EINA_FALSE, focused = EINA_FALSE;
2185    Ecore_Window id = 0;
2186
2187    res = eldbus_message_error_get(msg, &name, &text);
2188    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2189
2190    res = eldbus_message_arguments_get(msg, "ub", &id, &focused);
2191    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2192
2193    focusEvent = std::make_shared<focusEventItem>(id, E_TC_EVENT_TYPE_FOCUS_CHANGED, focused);
2194    EINA_SAFETY_ON_NULL_GOTO(focusEvent, finish);
2195
2196    runner->insertEventQueue(focusEvent);
2197
2198 finish:
2199    if ((name) || (text))
2200      {
2201         ERR("errname:%s errmsg:%s\n", name, text);
2202      }
2203 }
2204
2205 static void
2206 _cb_signal_render_while_effect_run(void *data,
2207                       const Eldbus_Message *msg)
2208 {
2209    etRunner *runner = (etRunner *)data;
2210    const char *name = NULL, *text = NULL;
2211    Eina_Bool res = EINA_FALSE;
2212    Ecore_Window id = 0;
2213
2214    res = eldbus_message_error_get(msg, &name, &text);
2215    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2216
2217    res = eldbus_message_arguments_get(msg, "u", &id);
2218    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2219
2220    runner->insertEventQueue(id, E_TC_EVENT_TYPE_EFFECT);
2221
2222 finish:
2223    if ((name) || (text))
2224      {
2225         ERR("errname:%s errmsg:%s\n", name, text);
2226      }
2227 }
2228
2229 static void
2230 _cb_signal_aux_hint_changed(void *data,
2231                          const Eldbus_Message *msg)
2232 {
2233    etRunner *runner = (etRunner *)data;
2234    const char *name = NULL, *text = NULL;
2235    Eina_Bool res = EINA_FALSE;
2236    Ecore_Window win = 0;
2237    uint32_t hint_id;
2238    std::shared_ptr<auxHintEventItem> hint = NULL;
2239    const char *hint_key, *hint_val;
2240
2241    res = eldbus_message_error_get(msg, &name, &text);
2242    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2243
2244    res = eldbus_message_arguments_get(msg, "uuss", &win, &hint_id, &hint_key, &hint_val);
2245    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2246
2247    hint = std::make_shared<auxHintEventItem>(win, E_TC_EVENT_TYPE_AUX_HINT_CHANGED, hint_id, hint_key, hint_val);
2248    EINA_SAFETY_ON_NULL_GOTO(hint, finish);
2249
2250    runner->insertEventQueue(hint);
2251
2252 finish:
2253    if ((name) || (text))
2254      {
2255         ERR("errname:%s errmsg:%s\n", name, text);
2256      }
2257 }
2258
2259 static void
2260 _cb_signal_iconic_state_changed(void *data,
2261                          const Eldbus_Message *msg)
2262 {
2263    etRunner *runner = (etRunner *)data;
2264    const char *name = NULL, *text = NULL;
2265    Eina_Bool res = EINA_FALSE;
2266    Ecore_Window win = 0;
2267    std::shared_ptr<iconicStateEventItem> iconicEvent = NULL;
2268    Eina_Bool iconic = EINA_FALSE, by_client = EINA_FALSE;
2269
2270    res = eldbus_message_error_get(msg, &name, &text);
2271    EINA_SAFETY_ON_TRUE_GOTO(res, finish);
2272
2273    res = eldbus_message_arguments_get(msg, "ubb", &win, &iconic, &by_client);
2274    EINA_SAFETY_ON_FALSE_GOTO(res, finish);
2275
2276    iconicEvent = std::make_shared<iconicStateEventItem>(win, E_TC_EVENT_TYPE_ICONIC_STATE_CHANGED, iconic, by_client);
2277    EINA_SAFETY_ON_NULL_GOTO(iconicEvent, finish);
2278
2279    runner->insertEventQueue(iconicEvent);
2280
2281 finish:
2282    if ((name) || (text))
2283      {
2284         ERR("errname:%s errmsg:%s\n", name, text);
2285      }
2286 }
2287
2288 /* callbacks - timer */
2289 static Eina_Bool
2290 _cb_work_timeout(void *data)
2291 {
2292    etRunner::get().finishWork();
2293    return ECORE_CALLBACK_CANCEL;
2294 }
2295
2296 /* callbacks - ecore */
2297 static Eina_Bool
2298 _cb_ecore_key_down(void *data, int type, void *event)
2299 {
2300    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
2301    etRunner *runner = (etRunner *)data;
2302
2303    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2304
2305    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2306      {
2307         if (runner->ev.key.ecore_state == EINA_FALSE &&
2308             type == ECORE_EVENT_KEY_DOWN)
2309           {
2310              runner->ev.key.ecore_state = EINA_TRUE;
2311           }
2312      }
2313
2314    return ECORE_CALLBACK_PASS_ON;
2315 }
2316
2317 static Eina_Bool
2318 _cb_ecore_key_up(void *data, int type, void *event)
2319 {
2320    Ecore_Event_Key *ev = (Ecore_Event_Key *)event;
2321    etRunner *runner = (etRunner *)data;
2322
2323    if (runner->ev.key.name == NULL) return ECORE_CALLBACK_PASS_ON;
2324
2325    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2326      {
2327         if (runner->ev.key.ecore_state == EINA_TRUE &&
2328             type == ECORE_EVENT_KEY_UP)
2329           {
2330              runner->ev.key.ecore_state = EINA_FALSE;
2331              runner->insertEventQueue(0, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
2332           }
2333      }
2334
2335    return ECORE_CALLBACK_PASS_ON;
2336 }
2337
2338 /* callbacks - evas */
2339 static void
2340 _cb_evas_key_down(void *data, Evas * evas, Evas_Object * obj, void * event_info)
2341 {
2342    Evas_Event_Key_Down *ev;
2343    etRunner *runner = (etRunner *)data;
2344
2345    ev = (Evas_Event_Key_Down *)event_info;
2346
2347    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2348      {
2349         if (runner->ev.key.evas_state == EINA_FALSE &&
2350             runner->ev.elm_win == obj)
2351           {
2352              runner->ev.key.evas_state = EINA_TRUE;
2353           }
2354      }
2355    evas_object_event_callback_del(runner->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down);
2356 }
2357
2358 static void
2359 _cb_evas_key_up(void * data, Evas * evas, Evas_Object * obj, void * event_info)
2360 {
2361    Evas_Event_Key_Up *ev;
2362    etRunner *runner = (etRunner *)data;
2363
2364    ev = (Evas_Event_Key_Up *)event_info;
2365
2366    if (!strncmp(runner->ev.key.name, ev->keyname, strlen(ev->keyname)))
2367      {
2368         if (runner->ev.key.evas_state == EINA_TRUE &&
2369             runner->ev.elm_win == obj)
2370           {
2371              runner->ev.key.evas_state = EINA_FALSE;
2372              runner->ev.elm_win = NULL;
2373
2374              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
2375           }
2376      }
2377    evas_object_event_callback_del(runner->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up);
2378 }
2379
2380 /* callbacks -  smart object */
2381 static void
2382 _cb_evas_smart_cb_effect_started(void *data, Evas_Object * obj, void *event_info)
2383 {
2384    etRunner *runner = (etRunner *)data;
2385    if (runner && runner->ev.elm_win == obj)
2386      {
2387         runner->ev.effect.state_smcb = E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED;
2388      }
2389 }
2390
2391 static void
2392 _cb_evas_smart_cb_effect_done(void *data, Evas_Object * obj, void *event_info)
2393 {
2394    etRunner *runner = (etRunner *)data;
2395    if (runner && runner->ev.elm_win == obj)
2396      {
2397         runner->ev.effect.state_smcb |= E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE;
2398
2399         runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2400
2401         evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2402         evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2403         evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2404      }
2405 }
2406
2407 static void
2408 _cb_evas_smart_cb_launch_done(void *data, Evas_Object * obj, void *event_info)
2409 {
2410    etRunner *runner = (etRunner *)data;
2411    if (runner && runner->ev.elm_win == obj)
2412      {
2413         runner->ev.effect.state_smcb  |= E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE;
2414
2415         if((runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_STARTED) &&
2416            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_EFFECT_DONE) &&
2417            (runner->ev.effect.state_smcb & E_TC_EVAS_SMART_CB_STATE_LAUNCH_DONE))
2418           {
2419              runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_EFFECT_EVAS_CB);
2420
2421              evas_object_smart_callback_del(runner->ev.elm_win, effect_started, _cb_evas_smart_cb_effect_started);
2422              evas_object_smart_callback_del(runner->ev.elm_win, effect_done, _cb_evas_smart_cb_effect_done);
2423              evas_object_smart_callback_del(runner->ev.elm_win, launch_done, _cb_evas_smart_cb_launch_done);
2424           }
2425      }
2426 }
2427
2428 #ifndef DISABLE_GESTURE_TESTS
2429 static Eina_Bool
2430 _cb_gesture_tap(void *data, int type, void *event)
2431 {
2432    etRunner *runner = (etRunner *)data;
2433    efl_util_event_gesture_tap_s *ev =
2434      (efl_util_event_gesture_tap_s *)event;
2435
2436    if ((ev->fingers == (unsigned int)runner->ev.gesture.tap.fingers) &&
2437        (ev->repeats == (unsigned int)runner->ev.gesture.tap.repeats))
2438      {
2439         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_TAP);
2440         //ecore_event_handler_del(runner->ev.key.eh);
2441      }
2442
2443    return ECORE_CALLBACK_PASS_ON;
2444 }
2445
2446 static Eina_Bool
2447 _cb_gesture_tap_delay_timer(void *data)
2448 {
2449    etRunner *runner = &etRunner::get();
2450    etInputGenHandler *inputgen_h = (etInputGenHandler *) data;
2451    int i;
2452
2453    for (i = 0; i < runner->ev.gesture.tap.fingers; i++)
2454      {
2455         if (!runner->ev.gesture.tap.pressed)
2456           {
2457             inputgen_h->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
2458           }
2459         else
2460           {
2461             inputgen_h->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
2462           }
2463      }
2464
2465    runner->ev.gesture.timer = NULL;
2466
2467    runner->ev.gesture.tap.pressed = !runner->ev.gesture.tap.pressed;
2468    if (!runner->ev.gesture.tap.pressed)
2469      {
2470         runner->ev.gesture.tap.current_repeats--;
2471      }
2472
2473    if (runner->ev.gesture.tap.current_repeats > 0)
2474      {
2475         runner->ev.gesture.timer = ecore_timer_add(0.11,
2476                                                    _cb_gesture_tap_delay_timer,
2477                                                    inputgen_h);
2478      }
2479
2480    return ECORE_CALLBACK_CANCEL;
2481 }
2482
2483 Eina_Bool
2484 etRunner::generateTapGesture(InputGenHandler handler)
2485 {
2486    addGestureSignalHandlers();
2487
2488    ev.gesture.tap.current_repeats = ev.gesture.tap.repeats;
2489    ev.gesture.tap.pressed = EINA_FALSE;
2490
2491    ev.gesture.timer = ecore_timer_add(0.11,
2492                                       _cb_gesture_tap_delay_timer,
2493                                       handler.get());
2494    return EINA_TRUE;
2495 }
2496
2497 static Eina_Bool
2498 _cb_gesture_edge_swipe(void *data, int type, void *event)
2499 {
2500    etRunner *runner = (etRunner *)data;
2501    efl_util_event_gesture_edge_swipe_s *ev =
2502      (efl_util_event_gesture_edge_swipe_s *)event;
2503
2504    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2505        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge))
2506      {
2507         if (runner->ev.gesture.timer)
2508           runner->ev.gesture.edge.get_event = EINA_TRUE;
2509      }
2510
2511    return ECORE_CALLBACK_PASS_ON;
2512 }
2513
2514 static Eina_Bool
2515 _cb_gesture_edge_swipe_delay_timer(void *data)
2516 {
2517    etRunner *runner = &etRunner::get();
2518    etInputGenHandler *inputgen_h = (etInputGenHandler *) data;
2519    int i, cnt, fingers, w, h;
2520    efl_util_gesture_edge_e edge;
2521
2522    cnt = ++runner->ev.gesture.edge.touch_count;
2523    fingers = runner->ev.gesture.edge.fingers;
2524    edge = runner->ev.gesture.edge.edge;
2525    w = runner->output.w - 1;
2526    h = runner->output.h - 1;
2527
2528    if (cnt == 1)
2529      {
2530         for (i = 0; i < fingers; i++)
2531           {
2532              switch (edge)
2533                {
2534                   case EFL_UTIL_GESTURE_EDGE_TOP:
2535                     inputgen_h->generateTouchDown(i, 100 * (i + 1), 1);
2536                     break;
2537                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2538                     inputgen_h->generateTouchDown(i, w - 1, 100 * (i + 1));
2539                     break;
2540                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2541                     inputgen_h->generateTouchDown(i, 100 * (i + 1), h - 1);
2542                     break;
2543                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2544                     inputgen_h->generateTouchDown(i, 1, 100 * (i + 1));
2545                     break;
2546                   default:
2547                     break;
2548                }
2549           }
2550      }
2551    else if (cnt < 5)
2552      {
2553         for (i = 0; i < fingers; i++)
2554           {
2555              switch (edge)
2556                {
2557                   case EFL_UTIL_GESTURE_EDGE_TOP:
2558                     inputgen_h->generateTouchMove(i, 100 * (i + 1), 40 * cnt * cnt);
2559                     break;
2560                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2561                     inputgen_h->generateTouchMove(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2562                     break;
2563                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2564                     inputgen_h->generateTouchMove(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2565                     break;
2566                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2567                     inputgen_h->generateTouchMove(i, 40 * cnt * cnt, 100 * (i + 1));
2568                     break;
2569                   default:
2570                     break;
2571                }
2572           }
2573      }
2574    else
2575      {
2576         cnt--;
2577         for (i = 0; i < fingers; i++)
2578           {
2579              switch (edge)
2580                {
2581                   case EFL_UTIL_GESTURE_EDGE_TOP:
2582                     inputgen_h->generateTouchUp(i, 100 * (i + 1), 40 * cnt * cnt);
2583                     break;
2584                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2585                     inputgen_h->generateTouchUp(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
2586                     break;
2587                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2588                     inputgen_h->generateTouchUp(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
2589                     break;
2590                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2591                     inputgen_h->generateTouchUp(i, 40 * cnt * cnt, 100 * (i + 1));
2592                     break;
2593                   default:
2594                     break;
2595                }
2596           }
2597
2598         runner->ev.gesture.timer = NULL;
2599         if (runner->ev.gesture.edge.get_event)
2600           {
2601              runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
2602              //ecore_event_handler_del(runner->ev.key.eh);
2603           }
2604         return ECORE_CALLBACK_CANCEL;
2605      }
2606
2607    runner->ev.gesture.timer = NULL;
2608    runner->ev.gesture.timer = ecore_timer_add(0.11,
2609                                               _cb_gesture_edge_swipe_delay_timer,
2610                                               inputgen_h);
2611
2612    return ECORE_CALLBACK_CANCEL;
2613 }
2614
2615 Eina_Bool
2616 etRunner::generateEdgeSwipeGesture(InputGenHandler handler)
2617 {
2618    ev.gesture.edge.touch_count = 0;
2619    ev.gesture.edge.get_event = EINA_FALSE;
2620
2621    ev.gesture.timer = ecore_timer_add(0.11,
2622                                       _cb_gesture_edge_swipe_delay_timer,
2623                                       handler.get());
2624
2625    return EINA_TRUE;
2626 }
2627
2628 static Eina_Bool
2629 _cb_gesture_edge_drag(void *data, int type, void *event)
2630 {
2631    etRunner *runner = (etRunner *)data;
2632    efl_util_event_gesture_edge_drag_s *ev =
2633      (efl_util_event_gesture_edge_drag_s *)event;
2634
2635    if ((ev->fingers == (unsigned int)runner->ev.gesture.edge.fingers) &&
2636        (ev->edge == (unsigned int)runner->ev.gesture.edge.edge) &&
2637        (ev->mode == EFL_UTIL_GESTURE_MODE_END))
2638      {
2639         runner->insertEventQueue(0, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
2640         //ecore_event_handler_del(runner->ev.key.eh);
2641      }
2642
2643    return ECORE_CALLBACK_PASS_ON;
2644 }
2645
2646 static Eina_Bool
2647 _cb_gesture_edge_drag_delay_timer(void *data)
2648 {
2649    etRunner *runner = &etRunner::get();
2650    etInputGenHandler *inputgen_h = (etInputGenHandler *)data;
2651
2652    int i, cnt, fingers, w, h;
2653    efl_util_gesture_edge_e edge;
2654
2655    cnt = ++runner->ev.gesture.edge.touch_count;
2656    fingers = runner->ev.gesture.edge.fingers;
2657    edge = runner->ev.gesture.edge.edge;
2658    w = runner->output.w - 1;
2659    h = runner->output.h - 1;
2660
2661    if (cnt == 1)
2662      {
2663         for (i = 0; i < fingers; i++)
2664           {
2665              switch (edge)
2666                {
2667                   case EFL_UTIL_GESTURE_EDGE_TOP:
2668                     inputgen_h->generateTouchDown(i, 100 * (i + 1), 1);
2669                     break;
2670                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2671                     inputgen_h->generateTouchDown(i, w - 1, 100 * (i + 1));
2672                     break;
2673                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2674                     inputgen_h->generateTouchDown(i, 100 * (i + 1), h - 1);
2675                     break;
2676                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2677                     inputgen_h->generateTouchDown(i, 1, 100 * (i + 1));
2678                     break;
2679                   default:
2680                     break;
2681                }
2682           }
2683      }
2684    else if (cnt < 5)
2685      {
2686         for (i = 0; i < fingers; i++)
2687           {
2688              switch (edge)
2689                {
2690                   case EFL_UTIL_GESTURE_EDGE_TOP:
2691                     inputgen_h->generateTouchMove(i, 100 * (i + 1), 50 * cnt);
2692                     break;
2693                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2694                     inputgen_h->generateTouchMove(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2695                     break;
2696                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2697                     inputgen_h->generateTouchMove(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2698                     break;
2699                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2700                     inputgen_h->generateTouchMove(i, 50 * cnt, 100 * (i + 1));
2701                     break;
2702                   default:
2703                     break;
2704                }
2705           }
2706      }
2707    else
2708      {
2709         cnt--;
2710         for (i = 0; i < fingers; i++)
2711           {
2712              switch (edge)
2713                {
2714                   case EFL_UTIL_GESTURE_EDGE_TOP:
2715                     inputgen_h->generateTouchUp(i, 100 * (i + 1), 50 * cnt);
2716                     break;
2717                   case EFL_UTIL_GESTURE_EDGE_RIGHT:
2718                     inputgen_h->generateTouchUp(i, (w - 1) - (50 * cnt), 100 * (i + 1));
2719                     break;
2720                   case EFL_UTIL_GESTURE_EDGE_BOTTOM:
2721                     inputgen_h->generateTouchUp(i, 100 * (i + 1), (h - 1) - (50 * cnt));
2722                     break;
2723                   case EFL_UTIL_GESTURE_EDGE_LEFT:
2724                     inputgen_h->generateTouchUp(i, 50 * cnt, 100 * (i + 1));
2725                     break;
2726                   default:
2727                     break;
2728                }
2729           }
2730
2731         runner->ev.gesture.timer = NULL;
2732         return ECORE_CALLBACK_CANCEL;
2733      }
2734
2735    runner->ev.gesture.timer = NULL;
2736    runner->ev.gesture.timer = ecore_timer_add(0.11,
2737                                               _cb_gesture_edge_drag_delay_timer,
2738                                               inputgen_h);
2739
2740    return ECORE_CALLBACK_CANCEL;
2741 }
2742
2743 Eina_Bool
2744 etRunner::generateEdgeDragGesture(InputGenHandler handler)
2745 {
2746    ev.gesture.edge.touch_count = 0;
2747
2748    ev.gesture.timer = ecore_timer_add(0.11,
2749                                       _cb_gesture_edge_drag_delay_timer,
2750                                       handler.get());
2751
2752    return EINA_TRUE;
2753 }
2754 #endif
2755
2756 void
2757 _verifyTCGetBufferSize(tbm_surface_h buffer, int *buffer_w, int *buffer_h, int *stride)
2758 {
2759    tbm_surface_info_s info;
2760    int ret;
2761
2762    EINA_SAFETY_ON_NULL_RETURN(buffer);
2763
2764    ret = tbm_surface_get_info(buffer, &info);
2765    if (ret != TBM_SURFACE_ERROR_NONE)
2766      return;
2767
2768    if (buffer_w)
2769      *buffer_w = info.planes[0].stride >> 2;
2770
2771    if (buffer_h)
2772      *buffer_h = info.planes[0].size / info.planes[0].stride;
2773
2774    if (stride)
2775      *stride = info.planes[0].stride;
2776 }
2777
2778 static void
2779 _verifyTCdumpPng(const char *file, const void *data, int width, int height, int stride)
2780 {
2781    pixman_image_t *image;
2782    cairo_surface_t *cairo_surface;
2783    cairo_status_t status;
2784
2785    image = pixman_image_create_bits_no_clear(PIXMAN_x8r8g8b8, width, height, (uint32_t *)data, stride);
2786    if (image == (pixman_image_t *)NULL)
2787      {
2788         ERR("pixman_image_create_bits_no_clear failed");
2789         return;
2790      }
2791
2792    cairo_surface = cairo_image_surface_create_for_data((unsigned char *)pixman_image_get_data(image),
2793                            CAIRO_FORMAT_RGB24, pixman_image_get_width(image), pixman_image_get_height(image),
2794                            pixman_image_get_stride(image));
2795    if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS)
2796      {
2797         ERR("cairo_image_surface_create_for_data failed");
2798         pixman_image_unref(image);
2799         return;
2800      }
2801
2802    status = cairo_surface_write_to_png(cairo_surface, file);
2803    if (status != CAIRO_STATUS_SUCCESS)
2804      {
2805         ERR("Failed to save image '%s': %s\n", file, cairo_status_to_string(status));
2806         pixman_image_unref(image);
2807         return;
2808      }
2809
2810    cairo_surface_destroy(cairo_surface);
2811    pixman_image_unref(image);
2812 }
2813
2814 std::string
2815 _verifyTCMakeDumpPath(std::string basetype, std::string tcname)
2816 {
2817    std::string path = "/tmp/etTestErr/";
2818    std::string format = ".png";
2819    int ret;
2820
2821    ret = mkdir(path.c_str(), 0755);
2822    if (ret < 0 && errno != EEXIST)
2823      {
2824         ERR("mkdir failed. (%s)\n", path.c_str());
2825         return "\0";
2826      }
2827
2828    path = path + basetype + '/';
2829    ret = mkdir(path.c_str(), 0755);
2830    if (ret < 0 && errno != EEXIST)
2831      {
2832         ERR("mkdir failed. (%s)\n", path.c_str());
2833         return "\0";
2834      }
2835
2836    path = path + tcname + format;
2837    ERR("path : %s", path.c_str());
2838
2839    return path;
2840 }
2841
2842 void
2843 _verifyTCDumpBuffer(tbm_surface_h buffer, std::string basetype, std::string tcname)
2844 {
2845    std::string dumppath;
2846    tbm_surface_info_s info;
2847    int ret;
2848    int bo_cnt;
2849    int bw, bh, stride;
2850
2851    EINA_SAFETY_ON_NULL_RETURN(buffer);
2852
2853    dumppath = _verifyTCMakeDumpPath(basetype, tcname);
2854    if (dumppath.length() == 0)
2855      {
2856        ERR("getting dumppath failed");
2857        return;
2858      }
2859
2860    ret = tbm_surface_map(buffer, TBM_OPTION_READ, &info);
2861    if (ret != TBM_SURFACE_ERROR_NONE)
2862      {
2863        ERR("tbm_surface_map failed");
2864        return;
2865      }
2866
2867    _verifyTCGetBufferSize(buffer, &bw, &bh, &stride);
2868
2869    bo_cnt = tbm_surface_internal_get_num_bos(buffer);
2870    DBG("buffer: bo_cnt(%d) %dx%d(%dx%d) %c%c%c%c, plane: (%p+%d, %d,%d) (%p+%d, %d,%d) (%p+%d, %d,%d)",
2871         bo_cnt, bw, bh, info.width, info.height, FOURCC_STR(info.format),
2872         info.planes[0].ptr, info.planes[0].offset, info.planes[0].stride, info.planes[0].size,
2873         info.planes[1].ptr, info.planes[1].offset, info.planes[1].stride, info.planes[1].size,
2874         info.planes[2].ptr, info.planes[2].offset, info.planes[2].stride, info.planes[2].size);
2875
2876    if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888)
2877      _verifyTCdumpPng(dumppath.c_str(), info.planes[0].ptr, bw, bh, stride);
2878    else
2879      DBG("not supported dump format");
2880
2881    tbm_surface_unmap(buffer);
2882 }
2883
2884 std::string
2885 _verifyTCMakeRefPath(std::string basetype, std::string tcname)
2886 {
2887    std::string path = "/usr/share/e_tizen_unittests/data/";
2888    std::string format = ".png";
2889
2890    path = path + etRunner::get().target + '/' + basetype + '/' + tcname + format;
2891
2892    return path;
2893 }
2894
2895 pixman_format_code_t
2896 _verifyTCCairo2Pixman(cairo_format_t fmt)
2897 {
2898    if (fmt == CAIRO_FORMAT_ARGB32)
2899      return PIXMAN_a8r8g8b8;
2900    else if (fmt == CAIRO_FORMAT_RGB24)
2901      return PIXMAN_x8r8g8b8;
2902    else
2903      return (pixman_format_code_t)0;
2904 }
2905
2906 static void
2907 destroy_cairo_surface(pixman_image_t *image, void *data)
2908 {
2909    cairo_surface_t *surface = (cairo_surface_t *)data;
2910
2911    cairo_surface_destroy(surface);
2912 }
2913
2914 pixman_image_t *
2915 _verifyTCConvertx8r8g8b8(pixman_image_t *image)
2916 {
2917    pixman_image_t *ret;
2918    int width;
2919    int height;
2920
2921    if (pixman_image_get_format(image) == PIXMAN_x8r8g8b8)
2922      return pixman_image_ref(image);
2923
2924    width = pixman_image_get_width(image);
2925    height = pixman_image_get_height(image);
2926
2927    ret = pixman_image_create_bits_no_clear(PIXMAN_x8r8g8b8, width, height, NULL, 0);
2928    if (ret == NULL)
2929      {
2930         ERR("pixman_image_create_bits_no_clear failed");
2931         return NULL;
2932      }
2933
2934    pixman_image_composite32(PIXMAN_OP_SRC, image, NULL, ret, 0, 0, 0, 0, 0, 0, width, height);
2935
2936    return ret;
2937 }
2938
2939 pixman_image_t *
2940 _verifyTCLoadImage(const char *fname)
2941 {
2942    pixman_image_t *image;
2943    pixman_image_t *converted;
2944    cairo_format_t cairo_fmt;
2945    pixman_format_code_t pixman_fmt;
2946    cairo_surface_t *reference_cairo_surface;
2947    cairo_status_t status;
2948    int width;
2949    int height;
2950    int stride;
2951    void *data;
2952
2953    reference_cairo_surface = cairo_image_surface_create_from_png(fname);
2954    cairo_surface_flush(reference_cairo_surface);
2955    status = cairo_surface_status(reference_cairo_surface);
2956    if (status != CAIRO_STATUS_SUCCESS)
2957      {
2958         ERR("Could not open %s: %s\n", fname, cairo_status_to_string(status));
2959         cairo_surface_destroy(reference_cairo_surface);
2960         return NULL;
2961      }
2962
2963    cairo_fmt = cairo_image_surface_get_format(reference_cairo_surface);
2964    pixman_fmt = _verifyTCCairo2Pixman(cairo_fmt);
2965    if (pixman_fmt == (pixman_format_code_t)0)
2966      {
2967         ERR("unknown format");
2968         cairo_surface_destroy(reference_cairo_surface);
2969         return NULL;
2970      }
2971
2972    width = cairo_image_surface_get_width(reference_cairo_surface);
2973    height = cairo_image_surface_get_height(reference_cairo_surface);
2974    stride = cairo_image_surface_get_stride(reference_cairo_surface);
2975    data = cairo_image_surface_get_data(reference_cairo_surface);
2976
2977    image = pixman_image_create_bits_no_clear(pixman_fmt, width, height, (uint32_t *)data, stride);
2978    if (image == (pixman_image_t *)NULL)
2979      {
2980         ERR("pixman_image_create_bits_no_clear failed");
2981         cairo_surface_destroy(reference_cairo_surface);
2982         return NULL;
2983      }
2984
2985    pixman_image_set_destroy_function(image, destroy_cairo_surface, reference_cairo_surface);
2986
2987    converted = _verifyTCConvertx8r8g8b8(image);
2988    pixman_image_unref(image);
2989
2990    return converted;
2991 }
2992
2993 Eina_Bool
2994 _verifyTCCheckPixel(uint32_t pix_a, uint32_t pix_b, int w, int h)
2995 {
2996    int i, shift;
2997    int diffmin = -3;
2998    int diffmax = 4;
2999    int val_a, val_b, diff;
3000
3001    for (shift = 8, i = 1; i < 4; shift += 8, i++)
3002      {
3003         val_a = (pix_a >> shift) & 0xFF;
3004         val_b = (pix_b >> shift) & 0xFF;
3005         diff = val_b - val_a;
3006
3007         if (diff < diffmin || diff > diffmax)
3008           return EINA_FALSE;
3009      }
3010
3011    return EINA_TRUE;
3012 }
3013
3014 Eina_Bool
3015 _verifyTCCheckImage(pixman_image_t *surface, pixman_image_t *ref)
3016 {
3017    Eina_Bool ret = EINA_TRUE;
3018    int surface_width, surface_height, surface_stride;
3019    uint32_t *surface_data;
3020    int pixman_width;
3021    uint32_t *pixman_data;
3022    int w, h;
3023    uint32_t *current_surface_data;
3024    uint32_t *current_pixman_data;
3025
3026    surface_width = pixman_image_get_width(surface);
3027    surface_height = pixman_image_get_height(surface);
3028    surface_stride = pixman_image_get_stride(surface);
3029    surface_data = pixman_image_get_data(surface);
3030
3031    pixman_width = pixman_image_get_width(ref);
3032    pixman_data = pixman_image_get_data(ref);
3033
3034    for (h = 0; h < surface_height; h++ )
3035      {
3036         current_surface_data = surface_data + h * surface_stride;
3037         current_pixman_data = pixman_data + h * pixman_width;
3038
3039         for (w = 0; w < surface_width; w++)
3040           {
3041              ret = _verifyTCCheckPixel(*current_surface_data, *current_pixman_data, w, h);
3042              if (ret == EINA_FALSE)
3043                 return ret;
3044
3045              current_surface_data++;
3046              current_pixman_data++;
3047           }
3048      }
3049
3050    return ret;
3051 }
3052
3053 Eina_Bool
3054 _verifyTC(tbm_surface_h surface, std::string basetype, std::string tcname)
3055 {
3056    std::string refpath;
3057    pixman_image_t *shot;
3058    pixman_image_t *ref;
3059    Eina_Bool ret = EINA_FALSE;
3060    tbm_surface_info_s info;
3061    int error;
3062
3063    refpath = _verifyTCMakeRefPath(basetype, tcname);
3064    if (refpath.length() == 0)
3065      {
3066         ERR("getting dumppath failed");
3067         return EINA_FALSE;
3068      }
3069
3070    ref = _verifyTCLoadImage(refpath.c_str());
3071    if (ref == (pixman_image_t *)NULL)
3072      {
3073         ERR("LoadImage failed");
3074         return EINA_FALSE;
3075      }
3076
3077    error = tbm_surface_map(surface, TBM_OPTION_READ, &info);
3078    if (error != TBM_SURFACE_ERROR_NONE)
3079      {
3080         ERR("tbm_surface_map failed");
3081         pixman_image_unref(ref);
3082         return EINA_FALSE;
3083      }
3084
3085    shot = pixman_image_create_bits_no_clear(PIXMAN_x8r8g8b8, info.width, info.height, (uint32_t *)info.planes[0].ptr, info.planes[0].stride >> 2);
3086    if (shot == (pixman_image_t *)NULL)
3087      {
3088         ERR("pixman_image_create_bits_no_clear failed");
3089         tbm_surface_unmap(surface);
3090         pixman_image_unref(ref);
3091         return EINA_FALSE;
3092      }
3093
3094    ret = _verifyTCCheckImage(shot, ref);
3095
3096    pixman_image_unref(shot);
3097    pixman_image_unref(ref);
3098
3099    return ret;
3100 }
3101
3102 Eina_Bool
3103 etRunner::verifyTC(std::string basetype, std::string tcname)
3104 {
3105    tbm_surface_h surface = NULL;
3106    Eina_Bool ret = EINA_FALSE;
3107
3108    EINA_SAFETY_ON_FALSE_RETURN_VAL(execute_verifyTC, EINA_TRUE);
3109    EINA_SAFETY_ON_NULL_RETURN_VAL(screenshot, EINA_FALSE);
3110
3111    work(0.3);
3112
3113    surface = efl_util_screenshot_take_tbm_surface(screenshot);
3114    if (surface == NULL)
3115      {
3116         ERR("screenshot failed");
3117         return EINA_FALSE;
3118      }
3119
3120    ret = _verifyTC(surface, basetype, tcname);
3121    if (ret == EINA_FALSE)
3122      {
3123         ERR("verify failed");
3124         _verifyTCDumpBuffer(surface, basetype, tcname);
3125      }
3126
3127    tbm_surface_destroy(surface);
3128 //   UT_WAIT("test");
3129
3130    return ret;
3131 }
3132
3133 Eina_Bool
3134 _parseTargetInfo(std::string target)
3135 {
3136    std::string tmp = "";
3137    std::string delimiter = "--target=";
3138
3139    if (target.find(delimiter.c_str()) == std::string::npos)
3140      return EINA_FALSE;
3141
3142    tmp = target.substr(delimiter.length());
3143
3144    if ((tmp.compare("mobile") == 0) || (tmp.compare("common") == 0))
3145      etRunner::get().target = tmp;
3146    else
3147      {
3148         ERR("not supported target. use mobile by default");
3149         etRunner::get().target = "mobile";
3150      }
3151
3152    return EINA_TRUE;
3153 }
3154
3155 void
3156 etRunner::parseTargetInfo(int argc, char **argv)
3157 {
3158    int i;
3159    Eina_Bool find = EINA_FALSE;
3160
3161    for (i = 0; i < argc; i++)
3162      {
3163         if (_parseTargetInfo(argv[i]) == EINA_TRUE)
3164           {
3165              find = EINA_TRUE;
3166              break;
3167           }
3168      }
3169    if (find == EINA_FALSE)
3170      {
3171         ERR("no target option. use mobile by default");
3172         etRunner::get().target = "mobile";
3173      }
3174 }