src/bin/e_test_helper.c

   1 #include "e.h"
   2 #include "e_test_helper_intern.h"
   3 #include "e_policy_wl.h"
   4 #include "e_comp_canvas_intern.h"
   5 #include "e_comp_intern.h"
   6 #include "e_devicemgr_intern.h"
   7
   8 #define BUS "org.enlightenment.wm"
   9 #define PATH "/org/enlightenment/wm"
  10 #define IFACE "org.enlightenment.wm.Test"
  11
  12 #define E_TH_SIGN_WIN_INFO  "usiiiiibbbiibibbbi"
  13 #define E_TC_TIMEOUT 10.0
  14
  15 typedef struct _Test_Helper_Reg_Win
  16 {
  17    Ecore_Window win;
  18    E_Client *ec;
  19    int vis;
  20    Eina_Bool render_send;
  21 } Test_Helper_Reg_Win;
  22
  23
  24 typedef struct _Test_Helper_Data
  25 {
  26    Eldbus_Connection *conn;
  27    Eldbus_Service_Interface *iface;
  28    Ecore_Event_Handler *dbus_init_done_h;
  29
  30    Eina_List *hdlrs;
  31    Eina_List *hooks;
  32    Eina_List *reg_wins;
  33
  34    Eina_Bool tc_running;
  35    Eina_Bool tc_timer_needs;
  36    Ecore_Timer *tc_timer;
  37 } Test_Helper_Data;
  38
  39 static Test_Helper_Data *th_data = NULL;
  40
  41 static Eina_Bool _e_test_helper_cb_property_get(const Eldbus_Service_Interface *iface, const char *name, Eldbus_Message_Iter *iter, const Eldbus_Message *msg, Eldbus_Message **err);
  42
  43 static Eldbus_Message *_e_test_helper_cb_testcase_start(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  44 static Eldbus_Message *_e_test_helper_cb_testcase_end(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  45 static Eldbus_Message *_e_test_helper_cb_testcase_timeout_set(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  46 static Eldbus_Message *_e_test_helper_cb_register_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  47 static Eldbus_Message *_e_test_helper_cb_deregister_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  48 static Eldbus_Message *_e_test_helper_cb_reset_register_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  49 static Eldbus_Message *_e_test_helper_cb_change_stack(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  50 static Eldbus_Message *_e_test_helper_cb_activate_window(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  51 static Eldbus_Message *_e_test_helper_cb_change_iconic_state(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  52 static Eldbus_Message *_e_test_helper_cb_set_transient_for(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  53 static Eldbus_Message *_e_test_helper_cb_unset_transient_for(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  54 static Eldbus_Message *_e_test_helper_cb_set_transient_for_below(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  55 static Eldbus_Message *_e_test_helper_cb_set_noti_level(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  56 static Eldbus_Message *_e_test_helper_cb_set_focus_skip(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  57 static Eldbus_Message *_e_test_helper_cb_get_client_info(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg);
  58 static Eldbus_Message *_e_test_helper_cb_get_clients(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  59 static Eldbus_Message *_e_test_helper_cb_get_noti_level(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  60 static Eldbus_Message *_e_test_helper_cb_dpms(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  61 static Eldbus_Message *_e_test_helper_cb_ev_freeze(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  62 static Eldbus_Message *_e_test_helper_cb_kill_win(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  63 static Eldbus_Message *_e_test_helper_cb_ev_mouse(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  64 static Eldbus_Message *_e_test_helper_cb_ev_key(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  65 static Eldbus_Message *_e_test_helper_cb_hwc(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  66 static Eldbus_Message *_e_test_helper_cb_zone_rot_change(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  67 static Eldbus_Message *_e_test_helper_cb_zone_rot_get(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  68 static Eldbus_Message *_e_test_helper_cb_set_render_condition(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  69 static Eldbus_Message *_e_test_helper_cb_add_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  70 static Eldbus_Message *_e_test_helper_cb_del_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  71 static Eldbus_Message *_e_test_helper_cb_get_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg);
  72 static Eina_Bool _e_test_helper_cb_img_render(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
  73 static Eina_Bool _e_test_helper_cb_effect_start(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
  74 static Eina_Bool _e_test_helper_cb_effect_end(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
  75
  76 enum
  77 {
  78    E_TEST_HELPER_SIGNAL_CHANGE_VISIBILITY = 0,
  79    E_TEST_HELPER_SIGNAL_RESTACK,
  80    E_TEST_HELPER_SIGNAL_WINDOW_ROTATION_CHANGED,
  81    E_TEST_HELPER_SIGNAL_FOCUS_CHANGED,
  82    E_TEST_HELPER_SIGNAL_RENDER,
  83    E_TEST_HELPER_AUX_HINT_CHANGED,
  84    E_TEST_HELPER_SIGNAL_ICONIC_STATE_CHANGED,
  85 };
  86
  87 static const Eldbus_Signal signals[] = {
  88      [E_TEST_HELPER_SIGNAL_CHANGE_VISIBILITY] =
  89        {
  90           "VisibilityChanged",
  91           ELDBUS_ARGS({"ub", "window id, visibility"}),
  92           0
  93        },
  94      [E_TEST_HELPER_SIGNAL_RESTACK] =
  95        {
  96           "StackChanged",
  97           ELDBUS_ARGS({"u", "window id was restacked"}),
  98           0
  99        },
 100      [E_TEST_HELPER_SIGNAL_WINDOW_ROTATION_CHANGED] =
 101        {
 102           "WinRotationChanged",
 103           ELDBUS_ARGS({"ui", "a window id was rotated to given angle"}),
 104           0
 105        },
 106      [E_TEST_HELPER_SIGNAL_FOCUS_CHANGED] =
 107        {
 108           "FocusChanged",
 109           ELDBUS_ARGS({"ub", "window id, focus state"}),
 110           0
 111        },
 112      [E_TEST_HELPER_SIGNAL_RENDER] =
 113        {
 114           "RenderRun",
 115           ELDBUS_ARGS({"u", "window id for tracing rendering"}),
 116           0
 117        },
 118      [E_TEST_HELPER_AUX_HINT_CHANGED] =
 119        {
 120           "AuxHintChanged",
 121           ELDBUS_ARGS({"uuss", "window id, aux_hint id, aux_hint key, aux_hint value"}),
 122           0
 123        },
 124      [E_TEST_HELPER_SIGNAL_ICONIC_STATE_CHANGED] =
 125        {
 126           "IconicStateChanged",
 127           ELDBUS_ARGS({"ubb", "window id, iconic state"}),
 128           0
 129        },
 130        { }
 131 };
 132
 133 static const Eldbus_Method methods[] ={
 134        {
 135           "StartTestCase",
 136           NULL,
 137           ELDBUS_ARGS({"b", "accept or not"}),
 138           _e_test_helper_cb_testcase_start, 0
 139        },
 140        {
 141           "EndTestCase",
 142           NULL,
 143           ELDBUS_ARGS({"b", "accept or not"}),
 144           _e_test_helper_cb_testcase_end, 0
 145        },
 146        {
 147           "SetTestTimeout",
 148           ELDBUS_ARGS({"bu", "needs timer and time in millisecond"}),
 149           ELDBUS_ARGS({"b", "accept or not"}),
 150           _e_test_helper_cb_testcase_timeout_set, 0
 151        },
 152        {
 153           "RegisterWindow",
 154           ELDBUS_ARGS({"u", "window id to be registered"}),
 155           ELDBUS_ARGS({"b", "accept or not"}),
 156           _e_test_helper_cb_register_window, 0
 157        },
 158        {
 159           "DeregisterWindow",
 160           ELDBUS_ARGS({"u", "window id to be deregistered"}),
 161           ELDBUS_ARGS({"b", "accept or not"}),
 162           _e_test_helper_cb_deregister_window, 0
 163        },
 164        {
 165           "ResetRegisterWindow",
 166           NULL,
 167           ELDBUS_ARGS({"b", "accept or not"}),
 168           _e_test_helper_cb_reset_register_window, 0
 169        },
 170        {
 171           "SetWindowStack",
 172           ELDBUS_ARGS({"uui", "window id to restack, above or below, stacking type"}),
 173           NULL,
 174           _e_test_helper_cb_change_stack, 0
 175        },
 176        {
 177           "SetWindowActivate",
 178           ELDBUS_ARGS({"u", "window id to activate"}),
 179           NULL,
 180           _e_test_helper_cb_activate_window, 0
 181        },
 182        {
 183           "SetWindowIconify",
 184           ELDBUS_ARGS({"ub", "window id to change iconic state, iconify or uniconify"}),
 185           NULL,
 186           _e_test_helper_cb_change_iconic_state, 0
 187        },
 188        {
 189           "SetWindowTransientFor",
 190           ELDBUS_ARGS({"uu", "child window id to set transient_for, parent window id to set transient_for"}),
 191           ELDBUS_ARGS({"b", "accept or not"}),
 192           _e_test_helper_cb_set_transient_for, 0
 193        },
 194        {
 195           "UnsetWindowTransientFor",
 196           ELDBUS_ARGS({"u", "child window id to set transient_for"}),
 197           ELDBUS_ARGS({"b", "accept or not"}),
 198           _e_test_helper_cb_unset_transient_for, 0
 199        },
 200        {
 201           "SetWindowTransientForBelow",
 202           ELDBUS_ARGS({"uub", "child window id to set transient_for, parent window id to set transient_for, set or unset"}),
 203           ELDBUS_ARGS({"b", "accept or not"}),
 204           _e_test_helper_cb_set_transient_for_below, 0
 205        },
 206        {
 207           "SetWindowNotiLevel",
 208           ELDBUS_ARGS({"ui", "window id to set notification level, notification level"}),
 209           NULL,
 210           _e_test_helper_cb_set_noti_level, 0
 211        },
 212        {
 213           "SetWindowFocusSkip",
 214           ELDBUS_ARGS({"ub", "window id to set focus skip, skip set or skip unset"}),
 215           NULL,
 216           _e_test_helper_cb_set_focus_skip, 0
 217        },
 218        {
 219           "GetWinInfo",
 220           ELDBUS_ARGS({"u", "window id"}),
 221           ELDBUS_ARGS({E_TH_SIGN_WIN_INFO, "information of ec"}),
 222           _e_test_helper_cb_get_client_info, 0
 223        },
 224        {
 225           "GetWinsInfo",
 226           NULL,
 227           ELDBUS_ARGS({"ua("E_TH_SIGN_WIN_INFO")", "array of ec"}),
 228           _e_test_helper_cb_get_clients, 0
 229        },
 230        {
 231           "GetWindowNotiLevel",
 232           ELDBUS_ARGS({"u", "window id to get notification level"}),
 233           ELDBUS_ARGS({"i", "notification level"}),
 234           _e_test_helper_cb_get_noti_level, 0
 235        },
 236        {
 237           "DPMS",
 238           ELDBUS_ARGS({"u", "DPMS 0=off or 1=on"}),
 239           ELDBUS_ARGS({"b", "accept or not"}),
 240           _e_test_helper_cb_dpms, 0
 241        },
 242        {
 243           "EventFreeze",
 244           ELDBUS_ARGS({"u", "0=events will start to be processed or 1=freeze input events processing"}),
 245           ELDBUS_ARGS({"b", "accept or not"}),
 246           _e_test_helper_cb_ev_freeze, 0
 247        },
 248        {
 249           "RequestKillWin",
 250           ELDBUS_ARGS({"s", "window name to kill"}),
 251           NULL,
 252           _e_test_helper_cb_kill_win, 0
 253        },
 254        {
 255           "EventMouse",
 256           ELDBUS_ARGS({"uii", "type 0=down 1=move 2=up, x position, y position"}),
 257           ELDBUS_ARGS({"b", "accept or not"}),
 258           _e_test_helper_cb_ev_mouse, 0
 259        },
 260        {
 261           "EventKey",
 262           ELDBUS_ARGS({"us", "type 0=down 1=up, key name"}),
 263           ELDBUS_ARGS({"b", "accept or not"}),
 264           _e_test_helper_cb_ev_key, 0
 265        },
 266        {
 267           "HWC",
 268           ELDBUS_ARGS({"u", "0=off or 1=on"}),
 269           ELDBUS_ARGS({"b", "accept or not"}),
 270           _e_test_helper_cb_hwc, 0
 271        },
 272        {
 273           "GetCurrentZoneRotation",
 274           NULL,
 275           ELDBUS_ARGS({"i", "a angle of current zone"}),
 276           _e_test_helper_cb_zone_rot_get, 0,
 277        },
 278        {
 279           "ChangeZoneRotation",
 280           ELDBUS_ARGS({"i", "(0, 90, 180, 270) = specific angle, -1 = unknown state"}),
 281           ELDBUS_ARGS({"b", "accept or not"}),
 282           _e_test_helper_cb_zone_rot_change, 0,
 283        },
 284        {
 285           "RenderTrace",
 286           ELDBUS_ARGS({"us", "window id and type of rendering to trace"}),
 287           ELDBUS_ARGS({"b", "accept or not"}),
 288           _e_test_helper_cb_set_render_condition, 0,
 289        },
 290        {
 291           "AddSupportedAuxHint",
 292           ELDBUS_ARGS({"s", "Aux hint string to add supported aux hint"}),
 293           ELDBUS_ARGS({"b", "accept or not"}),
 294           _e_test_helper_cb_add_supported_aux_hint, 0,
 295        },
 296        {
 297           "DelSupportedAuxHint",
 298           ELDBUS_ARGS({"s", "Aux hint string to del supported aux hint"}),
 299           ELDBUS_ARGS({"b", "accept or not"}),
 300           _e_test_helper_cb_del_supported_aux_hint, 0,
 301        },
 302        {
 303           "GetAuxHint",
 304           ELDBUS_ARGS({"us", "window id and Aux hint string to get aux hint data"}),
 305           ELDBUS_ARGS({"iss", "id, name, value"}),
 306           _e_test_helper_cb_get_aux_hint, 0,
 307        },
 308        { }
 309 };
 310
 311 static const Eldbus_Property properties[] = {
 312        { "Registrant", "au", NULL, NULL, 0 },
 313        { }
 314 };
 315
 316 static const Eldbus_Service_Interface_Desc iface_desc = {
 317      IFACE, methods, signals, properties, _e_test_helper_cb_property_get, NULL
 318 };
 319
 320 static void
 321 _e_test_helper_registrant_clear(void)
 322 {
 323    Test_Helper_Reg_Win *reg_win = NULL;
 324
 325    EINA_SAFETY_ON_NULL_RETURN(th_data);
 326    EINA_SAFETY_ON_NULL_RETURN(th_data->reg_wins);
 327
 328    EINA_LIST_FREE(th_data->reg_wins, reg_win)
 329      {
 330         if (reg_win->ec && reg_win->ec->frame)
 331           e_comp_object_render_trace_set(reg_win->ec->frame, EINA_FALSE);
 332      }
 333 }
 334
 335 static Eina_Bool
 336 _e_test_helper_registrant_remove(Ecore_Window target_win)
 337 {
 338    Test_Helper_Reg_Win *reg_win = NULL;
 339    Eina_List *l = NULL, *ll = NULL;
 340    Eina_Bool res = EINA_FALSE;
 341
 342    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, EINA_FALSE);
 343    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data->reg_wins, EINA_FALSE);
 344
 345    EINA_LIST_FOREACH_SAFE(th_data->reg_wins, l, ll, reg_win)
 346      {
 347         if (reg_win->win == target_win)
 348           {
 349              if (reg_win->ec && reg_win->ec->frame)
 350                e_comp_object_render_trace_set(reg_win->ec->frame, EINA_FALSE);
 351              th_data->reg_wins = eina_list_remove(th_data->reg_wins, reg_win);
 352              res = EINA_TRUE;
 353           }
 354      }
 355
 356    return res;
 357 }
 358
 359 static void
 360 _e_test_helper_message_append_client(Eldbus_Message_Iter *iter, E_Client *ec)
 361 {
 362    eldbus_message_iter_arguments_append
 363       (iter, E_TH_SIGN_WIN_INFO,
 364        e_pixmap_res_id_get(ec->pixmap),
 365        e_client_util_name_get(ec) ?: "NO NAME",
 366
 367        /* geometry */
 368        ec->x, ec->y, ec->w, ec->h,
 369
 370        /* layer */
 371        evas_object_layer_get(ec->frame),
 372
 373        /* effect */
 374        evas_object_data_get(ec->frame, "effect_running"),
 375
 376        /* visibility & iconify */
 377        ec->visible,
 378        evas_object_visible_get(ec->frame),
 379        ec->visibility.opaque,
 380        ec->visibility.obscured,
 381        ec->visibility.skip,
 382        ec->iconic ? (e_client_is_iconified_by_client(ec) ? 2 : 1) : 0,
 383
 384        /* color depth */
 385        ec->argb,
 386
 387        /* focus */
 388        ec->focused,
 389        evas_object_focus_get(ec->frame),
 390
 391        /* rotation */
 392        ec->e.state.rot.ang.curr);
 393 }
 394
 395 static Eina_Bool
 396 _e_test_helper_cb_dbus_init_done(void *data EINA_UNUSED, int type, void *event)
 397 {
 398    E_DBus_Conn_Init_Done_Event *e = event;
 399
 400    if ((e->status == E_DBUS_CONN_INIT_SUCCESS) && (e->conn_type == ELDBUS_CONNECTION_TYPE_SYSTEM))
 401      {
 402         th_data->conn = e_dbus_conn_connection_ref(ELDBUS_CONNECTION_TYPE_SYSTEM);
 403
 404         if (th_data->conn)
 405           th_data->iface = eldbus_service_interface_register(th_data->conn, PATH, &iface_desc);
 406      }
 407
 408    ecore_event_handler_del(th_data->dbus_init_done_h);
 409    th_data->dbus_init_done_h = NULL;
 410
 411    return ECORE_CALLBACK_PASS_ON;
 412 }
 413
 414 static void
 415 _e_test_helper_message_append_client_info_by_window_id(Eldbus_Message_Iter *iter, Ecore_Window win)
 416 {
 417    E_Client *ec;
 418
 419    ec = e_pixmap_find_client_by_res_id(win);
 420    if (!ec)
 421      return;
 422
 423    _e_test_helper_message_append_client(iter, ec);
 424 }
 425
 426 static void
 427 _e_test_helper_message_append_clients(Eldbus_Message_Iter *iter)
 428 {
 429    Eldbus_Message_Iter *array_of_ec;
 430    E_Client *ec;
 431    Evas_Object *o;
 432    E_Comp *comp;
 433
 434    EINA_SAFETY_ON_NULL_RETURN(th_data);
 435
 436    if (!(comp = e_comp)) return;
 437
 438    eldbus_message_iter_arguments_append(iter, "a("E_TH_SIGN_WIN_INFO")", &array_of_ec);
 439
 440    // append clients.
 441    for (o = evas_object_top_get(comp->evas); o; o = evas_object_below_get(o))
 442      {
 443         Eldbus_Message_Iter* struct_of_ec;
 444
 445         ec = evas_object_data_get(o, "E_Client");
 446         if (!ec) continue;
 447         if (e_client_util_ignored_get(ec)) continue;
 448
 449         eldbus_message_iter_arguments_append(array_of_ec, "("E_TH_SIGN_WIN_INFO")", &struct_of_ec);
 450         _e_test_helper_message_append_client(struct_of_ec, ec);
 451         eldbus_message_iter_container_close(array_of_ec, struct_of_ec);
 452      }
 453
 454    eldbus_message_iter_container_close(iter, array_of_ec);
 455 }
 456
 457 static void
 458 _e_test_helper_restack(Ecore_Window win, Ecore_Window target, int above)
 459 {
 460    E_Client *ec = NULL, *tec = NULL;
 461
 462    ec = e_pixmap_find_client_by_res_id(win);
 463    tec = e_pixmap_find_client_by_res_id(target);
 464
 465    if (!ec) return;
 466
 467    if(!tec)
 468      {
 469         if (above)
 470           {
 471              if (ec->parent)
 472                e_policy_stack_transient_child_raise(ec);
 473
 474              e_client_raise(ec);
 475           }
 476         else
 477           {
 478              if (ec->parent)
 479                e_policy_stack_transient_child_lower(ec);
 480
 481              e_client_lower(ec);
 482           }
 483      }
 484    else
 485      {
 486
 487         if (above)
 488           e_client_stack_above(ec, tec);
 489         else
 490           e_client_stack_below(ec, tec);
 491      }
 492 }
 493
 494 static Eina_Bool
 495 _e_test_helper_cb_tc_timeout(void *data)
 496 {
 497    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_DONE);
 498
 499    th_data->tc_running = EINA_FALSE;
 500    _e_test_helper_registrant_clear();
 501
 502    if (th_data->tc_timer)
 503      {
 504         ecore_timer_del(th_data->tc_timer);
 505         th_data->tc_timer = NULL;
 506      }
 507
 508    return ECORE_CALLBACK_DONE;
 509 }
 510
 511 /* Signal senders */
 512 static void
 513 _e_test_helper_send_change_visibility(Ecore_Window win, Eina_Bool vis)
 514 {
 515    Eldbus_Message *signal;
 516
 517    EINA_SAFETY_ON_NULL_RETURN(th_data);
 518
 519    signal = eldbus_service_signal_new(th_data->iface,
 520                                       E_TEST_HELPER_SIGNAL_CHANGE_VISIBILITY);
 521    eldbus_message_arguments_append(signal, "ub", win, vis);
 522    eldbus_service_signal_send(th_data->iface, signal);
 523 }
 524
 525 static void
 526 _e_test_helper_send_render(Ecore_Window win)
 527 {
 528    Eldbus_Message *signal;
 529
 530    EINA_SAFETY_ON_NULL_RETURN(th_data);
 531
 532    signal = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_RENDER);
 533    eldbus_message_arguments_append(signal, "u", win);
 534    eldbus_service_signal_send(th_data->iface, signal);
 535 }
 536
 537 static void
 538 _e_test_helper_send_aux_hint_change(Ecore_Window win, int hint_id, const char *hint_key, const char *hint_val)
 539 {
 540    Eldbus_Message *signal;
 541
 542    EINA_SAFETY_ON_NULL_RETURN(th_data);
 543
 544    signal = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_AUX_HINT_CHANGED);
 545    eldbus_message_arguments_append(signal, "uuss", win, hint_id, hint_key, hint_val);
 546    eldbus_service_signal_send(th_data->iface, signal);
 547 }
 548
 549 static Test_Helper_Reg_Win *
 550 _e_test_helper_find_win_on_reg_list(Ecore_Window win)
 551 {
 552    Eina_List *l = NULL;
 553    Test_Helper_Reg_Win *reg_win = NULL;
 554
 555    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, NULL);
 556    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data->reg_wins, NULL);
 557
 558    EINA_LIST_FOREACH(th_data->reg_wins, l, reg_win)
 559      {
 560         if (reg_win->win == win)
 561           return reg_win;
 562      }
 563
 564    return NULL;
 565 }
 566
 567 /* Method Handlers */
 568 static Eldbus_Message *
 569 _e_test_helper_cb_testcase_start(const Eldbus_Service_Interface *iface EINA_UNUSED,
 570                                  const Eldbus_Message *msg)
 571 {
 572    Eldbus_Message *reply;
 573    Eina_Bool res = EINA_FALSE;
 574
 575    reply = eldbus_message_method_return_new(msg);
 576
 577    if (th_data)
 578      {
 579         if (th_data->tc_timer)
 580           ecore_timer_del(th_data->tc_timer);
 581
 582         if (th_data->tc_timer_needs)
 583           th_data->tc_timer = ecore_timer_add(E_TC_TIMEOUT, _e_test_helper_cb_tc_timeout, NULL);
 584         res = th_data->tc_running = EINA_TRUE;
 585      }
 586
 587    eldbus_message_arguments_append(reply, "b", res);
 588
 589    return reply;
 590 }
 591
 592 static Eldbus_Message *
 593 _e_test_helper_cb_testcase_end(const Eldbus_Service_Interface *iface EINA_UNUSED,
 594                                const Eldbus_Message *msg)
 595 {
 596    Eldbus_Message *reply;
 597    Eina_Bool res = EINA_FALSE;
 598
 599    reply = eldbus_message_method_return_new(msg);
 600
 601    if (th_data)
 602      {
 603         if (th_data->tc_timer)
 604           {
 605              ecore_timer_del(th_data->tc_timer);
 606              th_data->tc_timer = NULL;
 607           }
 608         th_data->tc_running = EINA_FALSE;
 609         res = EINA_TRUE;
 610      }
 611
 612    eldbus_message_arguments_append(reply, "b", res);
 613
 614    return reply;
 615 }
 616
 617 static Eldbus_Message *
 618 _e_test_helper_cb_testcase_timeout_set(const Eldbus_Service_Interface *iface EINA_UNUSED,
 619                                        const Eldbus_Message *msg)
 620 {
 621    Eldbus_Message *reply;
 622    Eina_Bool res = EINA_FALSE;
 623    Eina_Bool set = EINA_TRUE;
 624    uint32_t timeout = E_TC_TIMEOUT;
 625
 626    reply = eldbus_message_method_return_new(msg);
 627
 628    if (!eldbus_message_arguments_get(msg, "bu", &set, &timeout))
 629      {
 630         ERR("Error on eldbus_message_arguments_get()\n");
 631         goto err;
 632      }
 633
 634    if (th_data)
 635      {
 636         if (set != th_data->tc_timer_needs)
 637           {
 638              th_data->tc_timer_needs = set;
 639              if (!set)
 640                ecore_timer_del(th_data->tc_timer);
 641           }
 642
 643         if (timeout > 0)
 644           {
 645              if (th_data->tc_timer)
 646                ecore_timer_del(th_data->tc_timer);
 647
 648              if (th_data->tc_timer_needs)
 649                th_data->tc_timer = ecore_timer_add(timeout, _e_test_helper_cb_tc_timeout, NULL);
 650           }
 651         res = EINA_TRUE;
 652      }
 653
 654    eldbus_message_arguments_append(reply, "b", res);
 655
 656    return reply;
 657
 658 err:
 659    eldbus_message_arguments_append(reply, "b", EINA_FALSE);
 660    return reply;
 661 }
 662
 663 static Eldbus_Message *
 664 _e_test_helper_cb_register_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
 665                                   const Eldbus_Message *msg)
 666 {
 667    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 668    Ecore_Window id;
 669    Test_Helper_Reg_Win *new_win = NULL;
 670
 671    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
 672
 673    if (!eldbus_message_arguments_get(msg, "u", &id))
 674      {
 675         ERR("Error on eldbus_message_arguments_get()\n");
 676         goto err;
 677      }
 678
 679    new_win = E_NEW(Test_Helper_Reg_Win, 1);
 680    EINA_SAFETY_ON_NULL_GOTO(new_win, err);
 681
 682    new_win->win = id;
 683    new_win->ec = e_pixmap_find_client_by_res_id(id);
 684
 685    th_data->reg_wins = eina_list_append(th_data->reg_wins, new_win);
 686    eldbus_message_arguments_append(reply, "b", EINA_TRUE);
 687
 688    return reply;
 689
 690 err:
 691    eldbus_message_arguments_append(reply, "b", EINA_FALSE);
 692    return reply;
 693 }
 694
 695 static Eldbus_Message *
 696 _e_test_helper_cb_dpms(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 697 {
 698    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 699    Eina_Bool accept = EINA_FALSE;
 700    unsigned int dpms;
 701
 702    if (!eldbus_message_arguments_get(msg, "u", &dpms))
 703      {
 704         ERR("Error on eldbus_message_arguments_get()\n");
 705         return reply;
 706      }
 707
 708    /* TODO */
 709    switch (dpms)
 710      {
 711       case 0:
 712          /* dpms off */
 713          accept = EINA_TRUE;
 714          break;
 715       case 1:
 716          /* dpms on */
 717          accept = EINA_TRUE;
 718          break;
 719       default:
 720          break;
 721      }
 722
 723    eldbus_message_arguments_append(reply, "b", accept);
 724
 725    return reply;
 726 }
 727
 728 static Eldbus_Message *
 729 _e_test_helper_cb_ev_freeze(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 730 {
 731    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 732    Eina_Bool accept = EINA_TRUE;
 733    unsigned int freeze;
 734
 735    if (!eldbus_message_arguments_get(msg, "u", &freeze))
 736      {
 737         ERR("Error on eldbus_message_arguments_get()\n");
 738         return reply;
 739      }
 740
 741    switch (freeze)
 742      {
 743       case 0: e_comp_all_thaw(); break;
 744       case 1: e_comp_all_freeze(); break;
 745       default: accept = EINA_FALSE; break;
 746      }
 747
 748    eldbus_message_arguments_append(reply, "b", accept);
 749
 750    return reply;
 751 }
 752
 753 static Eldbus_Message *
 754 _e_test_helper_cb_kill_win(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 755 {
 756    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 757    E_Client *ec = NULL;
 758    Evas_Object *o = NULL;
 759    char *win_name = NULL;
 760
 761    if (!eldbus_message_arguments_get(msg, "s", &win_name))
 762      {
 763         ERR("Error on eldbus_message_arguments_get()\n");
 764         return reply;
 765      }
 766
 767    for (o = evas_object_top_get(e_comp->evas); o; o = evas_object_below_get(o))
 768      {
 769         const char *ec_name = NULL;
 770         ec = evas_object_data_get(o, "E_Client");
 771         if (!ec) continue;
 772         if (e_client_util_ignored_get(ec)) continue;
 773
 774         ec_name = e_client_util_name_get(ec) ?: "NO NAME";
 775
 776         if (e_util_strcmp(ec_name, win_name)) continue;
 777         ELOGF("E_TEST_HELPER", "Window killed by request(ec: %s)", ec, ec? ec->icccm.name : "NO NAME");
 778         e_client_act_kill_begin(ec);
 779      }
 780
 781    return reply;
 782 }
 783
 784 static Eldbus_Message *
 785 _e_test_helper_cb_ev_mouse(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 786 {
 787    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 788    Eina_Bool accept = EINA_TRUE;
 789    Ecore_Event_Mouse_Button *ev = NULL;
 790    unsigned int type;
 791    int x, y;
 792
 793    if (!eldbus_message_arguments_get(msg, "uii", &type, &x, &y))
 794      {
 795         ERR("Error on eldbus_message_arguments_get()\n");
 796         return reply;
 797      }
 798
 799    ev = E_NEW(Ecore_Event_Mouse_Button, 1);
 800    EINA_SAFETY_ON_NULL_RETURN_VAL(ev, reply);
 801
 802    ev->timestamp = (unsigned int)(ecore_time_unix_get() * (double)1000);
 803    ev->same_screen = 1;
 804    ev->x = ev->root.x = x;
 805    ev->y = ev->root.y = y;
 806    ev->buttons = 1;
 807
 808    switch (type)
 809      {
 810       case 0: ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, ev, NULL, NULL); break;
 811       case 1: ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, NULL, NULL); break;
 812       case 2: ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, ev, NULL, NULL); break;
 813       default: accept = EINA_FALSE; break;
 814      }
 815
 816    eldbus_message_arguments_append(reply, "b", accept);
 817
 818    if (!accept)
 819      E_FREE(ev);
 820
 821    return reply;
 822 }
 823
 824 static int
 825 _e_test_helper_key_event_add(char *key_name, unsigned int type)
 826 {
 827    int res;
 828    char *device_identifier = NULL;
 829
 830    EINA_SAFETY_ON_NULL_RETURN_VAL(key_name, EINA_FALSE);
 831    EINA_SAFETY_ON_NULL_RETURN_VAL(e_devicemgr, EINA_FALSE);
 832    EINA_SAFETY_ON_NULL_RETURN_VAL(e_devicemgr->last_device_kbd, EINA_FALSE);
 833
 834    device_identifier = (char *)e_devicemgr->last_device_kbd->identifier;
 835
 836    EINA_SAFETY_ON_NULL_RETURN_VAL(device_identifier, EINA_FALSE);
 837
 838    res = e_devicemgr_inputgen_key_event_add(key_name, (Eina_Bool)type, device_identifier);
 839
 840    if (res)
 841      {
 842         ERR("[E_Test_Helper] Failed on generating key event ! (key_name=%s, type=%d)\n", key_name, type);
 843         return EINA_FALSE;
 844      }
 845
 846    return EINA_TRUE;
 847 }
 848
 849 static Eldbus_Message *
 850 _e_test_helper_cb_ev_key(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 851 {
 852    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 853    Eina_Bool accept = EINA_FALSE;
 854    unsigned int type;
 855    char *key;
 856
 857    if (!eldbus_message_arguments_get(msg, "us", &type, &key))
 858      {
 859         ERR("Error on eldbus_message_arguments_get()\n");
 860         return reply;
 861      }
 862
 863    /* TODO */
 864    switch (type)
 865      {
 866       case 0:
 867          /* key down */
 868       case 1:
 869          /* key up */
 870          accept = _e_test_helper_key_event_add(key, type);
 871          break;
 872       default:
 873          break;
 874      }
 875
 876    eldbus_message_arguments_append(reply, "b", accept);
 877
 878    return reply;
 879 }
 880
 881 static Eldbus_Message *
 882 _e_test_helper_cb_hwc(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 883 {
 884    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 885    Eina_Bool r, accept = EINA_FALSE;
 886    unsigned int on;
 887
 888    r = eldbus_message_arguments_get(msg, "u", &on);
 889    EINA_SAFETY_ON_FALSE_RETURN_VAL(r, reply);
 890
 891    if (e_comp->hwc)
 892      {
 893         switch (on)
 894           {
 895            case 0: accept = EINA_TRUE; e_comp_hwc_deactive_set(EINA_TRUE); break;
 896            case 1: accept = EINA_TRUE; e_comp_hwc_deactive_set(EINA_FALSE); break;
 897            default: break;
 898           }
 899      }
 900
 901    eldbus_message_arguments_append(reply, "b", accept);
 902
 903    return reply;
 904 }
 905
 906 static void
 907 _e_test_helper_event_zone_rot_change_free(void *data EINA_UNUSED, void *event)
 908 {
 909    E_Event_Info_Rotation_Message *ev = event;
 910
 911    e_object_unref(E_OBJECT(ev->zone));
 912    free(ev);
 913 }
 914
 915
 916 static Eldbus_Message *
 917 _e_test_helper_cb_zone_rot_change(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 918 {
 919    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 920    E_Event_Info_Rotation_Message *ev;
 921    E_Zone *zone;
 922    Eina_Bool r, accept = EINA_FALSE;
 923    int rot;
 924
 925    r = eldbus_message_arguments_get(msg, "i", &rot);
 926    EINA_SAFETY_ON_FALSE_GOTO(r, end);
 927
 928    if ((rot < 0) || (rot > 270) || ((rot % 90) != 0))
 929      goto end;
 930
 931    zone = e_zone_current_get();
 932    if (!zone)
 933      goto end;
 934
 935    ev = E_NEW(E_Event_Info_Rotation_Message, 1);
 936    if (EINA_UNLIKELY(!ev))
 937      {
 938         ERR("Failed to allocate 'E_Event_Info_Rotation_Message'");
 939         goto end;
 940      }
 941
 942    e_object_ref(E_OBJECT(zone));
 943    ev->zone = zone;
 944    ev->message = E_INFO_ROTATION_MESSAGE_SET;
 945    ev->rotation = rot;
 946    ecore_event_add(E_EVENT_INFO_ROTATION_MESSAGE, ev, _e_test_helper_event_zone_rot_change_free, NULL);
 947
 948    accept = EINA_TRUE;
 949
 950 end:
 951    eldbus_message_arguments_append(reply, "b", accept);
 952
 953    return reply;
 954 }
 955
 956 static Eldbus_Message *
 957 _e_test_helper_cb_zone_rot_get(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
 958 {
 959    E_Zone *zone;
 960    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 961    Eina_Bool r;
 962    int rot = -1;
 963
 964    r = eldbus_message_arguments_get(msg, "i", &rot);
 965    EINA_SAFETY_ON_FALSE_GOTO(r, end);
 966
 967    if ((rot < 0) || (rot > 270) || ((rot % 90) != 0))
 968      goto end;
 969
 970    zone = e_zone_current_get();
 971    if (!zone)
 972      goto end;
 973
 974    eldbus_message_arguments_append(reply, "b", zone->rot.curr);
 975 end:
 976    return reply;
 977 }
 978
 979 static Eldbus_Message *
 980 _e_test_helper_cb_deregister_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
 981                                     const Eldbus_Message *msg)
 982 {
 983    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
 984    Ecore_Window id;
 985    Eina_Bool res = EINA_FALSE;
 986
 987    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
 988
 989    if (!eldbus_message_arguments_get(msg, "u", &id))
 990      {
 991         ERR("Error on eldbus_message_arguments_get()\n");
 992         return reply;
 993      }
 994
 995    res = _e_test_helper_registrant_remove(id);
 996    eldbus_message_arguments_append(reply, "b", res);
 997
 998    return reply;
 999 }
1000
1001 static Eldbus_Message *
1002 _e_test_helper_cb_reset_register_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
1003                                         const Eldbus_Message *msg)
1004 {
1005    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1006
1007    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1008
1009    _e_test_helper_registrant_clear();
1010
1011    eldbus_message_arguments_append(reply, "b", EINA_TRUE);
1012
1013    return reply;
1014 }
1015
1016 static Eldbus_Message*
1017 _e_test_helper_cb_change_stack(const Eldbus_Service_Interface *iface EINA_UNUSED,
1018                                const Eldbus_Message *msg)
1019 {
1020    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1021    Ecore_Window win, target;
1022    int above = -1;
1023
1024    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1025
1026    if (!eldbus_message_arguments_get(msg, "uui", &win, &target, &above))
1027      {
1028         ERR("error on eldbus_message_arguments_get()\n");
1029         return reply;
1030      }
1031
1032    if ((win) && (above != -1))
1033      _e_test_helper_restack(win, target, above);
1034
1035    return reply;
1036 }
1037
1038 static Eldbus_Message*
1039 _e_test_helper_cb_activate_window(const Eldbus_Service_Interface *iface EINA_UNUSED,
1040                                   const Eldbus_Message *msg)
1041 {
1042    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1043    Ecore_Window win = 0x0;
1044    E_Client *ec = NULL;
1045
1046    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1047
1048    if (!eldbus_message_arguments_get(msg, "u", &win))
1049      {
1050         ERR("error on eldbus_message_arguments_get()\n");
1051         return reply;
1052      }
1053
1054    if (win)
1055      {
1056         ec = e_pixmap_find_client_by_res_id(win);
1057         e_policy_wl_activate(ec);
1058      }
1059
1060    return reply;
1061 }
1062
1063 static Eldbus_Message*
1064 _e_test_helper_cb_change_iconic_state(const Eldbus_Service_Interface *iface EINA_UNUSED,
1065                                       const Eldbus_Message *msg)
1066 {
1067    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1068    Ecore_Window win = 0x0;
1069    Eina_Bool iconic = EINA_FALSE;
1070    E_Client *ec = NULL;
1071
1072    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1073
1074    if (!eldbus_message_arguments_get(msg, "ub", &win, &iconic))
1075      {
1076         ERR("error on eldbus_message_arguments_get()\n");
1077         return reply;
1078      }
1079
1080    if (win)
1081      {
1082         ec = e_pixmap_find_client_by_res_id(win);
1083         if (iconic)
1084           e_policy_wl_iconify(ec);
1085         else
1086           e_policy_wl_uniconify(ec);
1087      }
1088
1089    return reply;
1090 }
1091
1092 static Eldbus_Message*
1093 _e_test_helper_cb_set_transient_for(const Eldbus_Service_Interface *iface EINA_UNUSED,
1094                                     const Eldbus_Message *msg)
1095 {
1096    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1097    Ecore_Window parent = 0x0, child = 0x0;
1098    E_Client *ec = NULL, *pec = NULL;
1099    Eina_Bool accept = EINA_FALSE;
1100
1101    EINA_SAFETY_ON_NULL_GOTO(th_data, fin);
1102
1103    if (!eldbus_message_arguments_get(msg, "uu", &child, &parent))
1104      {
1105         ERR("error on eldbus_message_arguments_get()\n");
1106         goto fin;
1107      }
1108
1109    if (parent && child)
1110      {
1111         pec = e_pixmap_find_client_by_res_id(parent);
1112         EINA_SAFETY_ON_NULL_GOTO(pec, fin);
1113
1114         ec = e_pixmap_find_client_by_res_id(child);
1115         EINA_SAFETY_ON_NULL_GOTO(ec, fin);
1116
1117         e_policy_stack_transient_for_set(ec, pec);
1118         accept = EINA_TRUE;
1119      }
1120
1121 fin:
1122    eldbus_message_arguments_append(reply, "b", accept);
1123    return reply;
1124 }
1125
1126 static Eldbus_Message*
1127 _e_test_helper_cb_unset_transient_for(const Eldbus_Service_Interface *iface EINA_UNUSED,
1128                                       const Eldbus_Message *msg)
1129 {
1130    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1131    Ecore_Window child = 0x0;
1132    E_Client *ec = NULL;
1133    Eina_Bool accept = EINA_FALSE;
1134
1135    EINA_SAFETY_ON_NULL_GOTO(th_data, fin);
1136
1137    if (!eldbus_message_arguments_get(msg, "u", &child))
1138      {
1139         ERR("error on eldbus_message_arguments_get()\n");
1140         goto fin;
1141      }
1142
1143    if (child)
1144      {
1145         ec = e_pixmap_find_client_by_res_id(child);
1146         EINA_SAFETY_ON_NULL_GOTO(ec, fin);
1147
1148         e_policy_stack_transient_for_set(ec, NULL);
1149         accept = EINA_TRUE;
1150      }
1151
1152 fin:
1153    eldbus_message_arguments_append(reply, "b", accept);
1154    return reply;
1155 }
1156
1157 static Eldbus_Message*
1158 _e_test_helper_cb_set_transient_for_below(const Eldbus_Service_Interface *iface EINA_UNUSED,
1159                                           const Eldbus_Message *msg)
1160 {
1161    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1162    Ecore_Window parent = 0x0, child = 0x0;
1163    E_Client *ec = NULL, *pec = NULL;
1164    Eina_Bool set = EINA_FALSE;
1165    Eina_Bool accept = EINA_FALSE;
1166
1167    EINA_SAFETY_ON_NULL_GOTO(th_data, fin);
1168
1169    if (!eldbus_message_arguments_get(msg, "uub", &child, &parent, &set))
1170      {
1171         ERR("error on eldbus_message_arguments_get()\n");
1172         goto fin;
1173      }
1174
1175    if (parent && child)
1176      {
1177         pec = e_pixmap_find_client_by_res_id(parent);
1178         EINA_SAFETY_ON_NULL_GOTO(pec, fin);
1179
1180         ec = e_pixmap_find_client_by_res_id(child);
1181         EINA_SAFETY_ON_NULL_GOTO(ec, fin);
1182
1183         if (set)
1184           {
1185              e_policy_stack_transient_for_below_set(ec, pec, EINA_TRUE);
1186              accept = EINA_TRUE;
1187           }
1188         else
1189           {
1190              e_policy_stack_transient_for_below_set(ec, NULL, EINA_TRUE);
1191              accept = EINA_TRUE;
1192           }
1193      }
1194
1195 fin:
1196    eldbus_message_arguments_append(reply, "b", accept);
1197    return reply;
1198 }
1199
1200 static Eldbus_Message*
1201 _e_test_helper_cb_set_noti_level(const Eldbus_Service_Interface *iface EINA_UNUSED,
1202                                  const Eldbus_Message *msg)
1203 {
1204    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1205    Ecore_Window win = 0x0;
1206    int layer = 0;
1207    E_Client *ec = NULL;
1208
1209    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1210
1211    if (!eldbus_message_arguments_get(msg, "ui", &win, &layer))
1212      {
1213         ERR("error on eldbus_message_arguments_get()\n");
1214         return reply;
1215      }
1216
1217    if (win)
1218      {
1219         ec = e_pixmap_find_client_by_res_id(win);
1220         if (!ec) return reply;
1221
1222         e_client_layer_set(ec, layer);
1223      }
1224
1225    return reply;
1226 }
1227
1228 static Eldbus_Message*
1229 _e_test_helper_cb_set_focus_skip(const Eldbus_Service_Interface *iface EINA_UNUSED,
1230                                  const Eldbus_Message *msg)
1231 {
1232    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1233    Ecore_Window win = 0x0;
1234    Eina_Bool skip_set = EINA_FALSE;
1235    E_Client *ec = NULL;
1236
1237    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1238
1239    if (!eldbus_message_arguments_get(msg, "ub", &win, &skip_set))
1240      {
1241         ERR("error on eldbus_message_arguments_get()\n");
1242         return reply;
1243      }
1244
1245    if (win)
1246      {
1247         ec = e_pixmap_find_client_by_res_id(win);
1248         if (!ec) return reply;
1249
1250         ec->icccm.accepts_focus = ec->icccm.take_focus = !skip_set;
1251         ec->changes.accepts_focus = 1;
1252         ec->changed = 1;
1253      }
1254
1255    return reply;
1256 }
1257
1258 static Eldbus_Message *
1259 _e_test_helper_cb_get_client_info(const Eldbus_Service_Interface *iface EINA_UNUSED,
1260                                   const Eldbus_Message *msg)
1261 {
1262    Eldbus_Message *reply;
1263    Ecore_Window win;
1264
1265    reply = eldbus_message_method_return_new(msg);
1266    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, reply);
1267
1268    if (!eldbus_message_arguments_get(msg, "u", &win))
1269      {
1270         ERR("error getting window ID");
1271         return reply;
1272      }
1273
1274    _e_test_helper_message_append_client_info_by_window_id(eldbus_message_iter_get(reply), win);
1275
1276    return reply;
1277 }
1278
1279 static Eldbus_Message *
1280 _e_test_helper_cb_get_clients(const Eldbus_Service_Interface *iface EINA_UNUSED,
1281                               const Eldbus_Message *msg)
1282 {
1283    Eldbus_Message *reply;
1284
1285    reply = eldbus_message_method_return_new(msg);
1286    _e_test_helper_message_append_clients(eldbus_message_iter_get(reply));
1287
1288    return reply;
1289 }
1290
1291 static Eldbus_Message *
1292 _e_test_helper_cb_get_noti_level(const Eldbus_Service_Interface *iface EINA_UNUSED,
1293                                  const Eldbus_Message *msg)
1294 {
1295    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1296    Ecore_Window win = 0x0;
1297    E_Client *ec = NULL;
1298    int layer = -1;
1299
1300    if (!eldbus_message_arguments_get(msg, "u", &win))
1301      {
1302         ERR("error on eldbus_message_arguments_get()\n");
1303         goto fin;
1304      }
1305
1306    ec = e_pixmap_find_client_by_res_id(win);
1307    if (!ec) goto fin;
1308
1309    layer = ec->layer;
1310
1311 fin:
1312    eldbus_message_arguments_append(reply, "i", layer);
1313    return reply;
1314 }
1315
1316 static Eina_Bool
1317 _e_test_helper_cb_visibility_change(void *data EINA_UNUSED,
1318                                     int type EINA_UNUSED,
1319                                     void *event)
1320 {
1321    E_Client *ec;
1322    Ecore_Window win = 0;
1323    E_Event_Client *ev = event;
1324    Test_Helper_Reg_Win *reg_win = NULL;
1325
1326    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1327    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1328
1329    ec = ev->ec;
1330    win = e_pixmap_res_id_get(ec->pixmap);
1331    reg_win = _e_test_helper_find_win_on_reg_list(win);
1332
1333    if (reg_win == NULL) return ECORE_CALLBACK_PASS_ON;
1334
1335    if (reg_win->vis != !ec->visibility.obscured)
1336      _e_test_helper_send_change_visibility(win, !ec->visibility.obscured);
1337
1338    reg_win->vis = !ec->visibility.obscured;
1339
1340    return ECORE_CALLBACK_PASS_ON;
1341 }
1342
1343 static Eina_Bool
1344 _e_test_helper_cb_client_remove(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1345 {
1346    E_Client *ec;
1347    E_Event_Client *ev = event;
1348    Ecore_Window win = 0;
1349
1350    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1351
1352    ec = ev->ec;
1353    if (ec && ec->pixmap)
1354      win = e_pixmap_res_id_get(ec->pixmap);
1355
1356    if (win <= 0) return ECORE_CALLBACK_PASS_ON;
1357
1358    _e_test_helper_registrant_remove(win);
1359
1360    return ECORE_CALLBACK_PASS_ON;
1361 }
1362
1363 static Eina_Bool
1364 _e_test_helper_cb_client_restack(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1365 {
1366    E_Event_Client *ev = event;
1367    E_Client *ec;
1368    Eldbus_Message *sig;
1369    Ecore_Window win;
1370
1371    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1372    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1373
1374    ec = ev->ec;
1375
1376    win = e_pixmap_res_id_get(ec->pixmap);
1377    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1378
1379    if (win)
1380      {
1381         sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_RESTACK);
1382         eldbus_message_arguments_append(sig, "u", win);
1383         eldbus_service_signal_send(th_data->iface, sig);
1384      }
1385
1386    return ECORE_CALLBACK_PASS_ON;
1387 }
1388
1389 static Eina_Bool
1390 _e_test_helper_cb_client_rotation_end(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1391 {
1392    E_Event_Client *ev = event;
1393    E_Client *ec;
1394    Eldbus_Message *sig;
1395    Ecore_Window win;
1396    int rot;
1397
1398    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1399    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1400
1401    ec = ev->ec;
1402
1403    win = e_pixmap_res_id_get(ec->pixmap);
1404    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1405
1406    rot = ec->e.state.rot.ang.curr;
1407
1408    if (win)
1409      {
1410         sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_WINDOW_ROTATION_CHANGED);
1411         eldbus_message_arguments_append(sig, "ui", win, rot);
1412         eldbus_service_signal_send(th_data->iface, sig);
1413      }
1414
1415    return ECORE_CALLBACK_PASS_ON;
1416 }
1417
1418 static Eina_Bool
1419 _e_test_helper_cb_client_focus_changed(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1420 {
1421    E_Event_Client *ev = event;
1422    E_Client *ec = NULL;
1423    Eldbus_Message *sig = NULL;
1424    Ecore_Window win = 0;
1425
1426    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, ECORE_CALLBACK_PASS_ON);
1427    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1428
1429    ec = ev->ec;
1430
1431    win = e_pixmap_res_id_get(ec->pixmap);
1432    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1433
1434    if (win)
1435      {
1436         sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_FOCUS_CHANGED);
1437         eldbus_message_arguments_append(sig, "ub", win, ec->focused);
1438         eldbus_service_signal_send(th_data->iface, sig);
1439      }
1440
1441    return ECORE_CALLBACK_PASS_ON;
1442 }
1443
1444 static Eina_Bool
1445 _e_test_helper_cb_property_get(const Eldbus_Service_Interface *iface EINA_UNUSED, const char *name, Eldbus_Message_Iter *iter, const Eldbus_Message *msg EINA_UNUSED, Eldbus_Message **err EINA_UNUSED)
1446 {
1447    EINA_SAFETY_ON_NULL_RETURN_VAL(th_data, EINA_FALSE);
1448
1449    Eldbus_Message_Iter *arr_of_win = NULL;
1450    Test_Helper_Reg_Win *reg_win = NULL;
1451    Eina_List *l = NULL;
1452
1453    if (!e_util_strcmp(name, "Registrant"))
1454      {
1455         arr_of_win = eldbus_message_iter_container_new(iter, 'a', "u");
1456
1457         EINA_LIST_FOREACH(th_data->reg_wins, l, reg_win)
1458           {
1459              eldbus_message_iter_basic_append(arr_of_win, 'u', reg_win->win);
1460           }
1461         eldbus_message_iter_container_close(iter, arr_of_win);
1462      }
1463
1464    return EINA_TRUE;
1465 }
1466
1467 static Eldbus_Message *
1468 _e_test_helper_cb_set_render_condition(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1469 {
1470    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1471    Ecore_Window win = 0x0;
1472    Eina_Bool accept = EINA_FALSE;
1473    char *cond;
1474
1475    if (!eldbus_message_arguments_get(msg, "us", &win, &cond))
1476      {
1477         ERR("error on eldbus_message_arguments_get()\n");
1478         goto fin;
1479      }
1480
1481    // a window should be registered for tracing, otherwise reply accept FALSE
1482    if (!th_data) goto fin;
1483    if (!th_data->tc_running) goto fin;
1484    if (!th_data->reg_wins) goto fin;
1485    if (!_e_test_helper_find_win_on_reg_list(win)) goto fin;
1486
1487    // tracning condition on and off depending on "cond" string.
1488    if (!e_util_strcmp(cond, "effect"))
1489      {
1490         E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_COMP_OBJECT_EFFECT_START,
1491                               _e_test_helper_cb_effect_start, NULL);
1492         E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_COMP_OBJECT_EFFECT_END,
1493                               _e_test_helper_cb_effect_end, NULL);
1494         accept = EINA_TRUE;
1495      }
1496
1497 fin:
1498    eldbus_message_arguments_append(reply, "b", accept);
1499
1500    return reply;
1501 }
1502
1503 static Eldbus_Message *
1504 _e_test_helper_cb_add_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1505 {
1506    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1507    Eina_Bool accept = EINA_FALSE;
1508    const Eina_List *supported_list = NULL;
1509    char *hint;
1510
1511    if (!eldbus_message_arguments_get(msg, "s", &hint))
1512      {
1513         ERR("error on eldbus_message_arguments_get()\n");
1514         goto fin;
1515      }
1516
1517    if (!th_data) goto fin;
1518    if (!th_data->tc_running) goto fin;
1519
1520    supported_list = e_hints_aux_hint_supported_add(hint);
1521
1522    if (eina_list_data_find(supported_list, hint))
1523      accept = EINA_TRUE;
1524
1525 fin:
1526    eldbus_message_arguments_append(reply, "b", accept);
1527
1528    return reply;
1529 }
1530
1531 static Eldbus_Message *
1532 _e_test_helper_cb_del_supported_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1533 {
1534    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1535    Eina_Bool accept = EINA_FALSE;
1536    const Eina_List *supported_list = NULL;
1537    char *hint;
1538
1539    if (!eldbus_message_arguments_get(msg, "s", &hint))
1540      {
1541         ERR("error on eldbus_message_arguments_get()\n");
1542         goto fin;
1543      }
1544
1545    if (!th_data) goto fin;
1546    if (!th_data->tc_running) goto fin;
1547
1548    supported_list = e_hints_aux_hint_supported_del(hint);
1549
1550    if (eina_list_data_find(supported_list, hint))
1551      accept = EINA_TRUE;
1552
1553 fin:
1554    eldbus_message_arguments_append(reply, "b", accept);
1555
1556    return reply;
1557 }
1558
1559 static Eldbus_Message *
1560 _e_test_helper_cb_get_aux_hint(const Eldbus_Service_Interface *iface, const Eldbus_Message *msg)
1561 {
1562    Eldbus_Message *reply = eldbus_message_method_return_new(msg);
1563    Ecore_Window win = 0x0;
1564    Test_Helper_Reg_Win *reg_win = NULL;
1565    E_Comp_Wl_Aux_Hint *ecah;
1566    E_Client *ec;
1567    Eina_List *l;
1568
1569    int id = -1;
1570    const char *hint = NULL, *val = NULL;
1571
1572    if (!eldbus_message_arguments_get(msg, "us", &win, &hint))
1573      {
1574         ERR("error on eldbus_message_arguments_get()\n");
1575         goto fin;
1576      }
1577
1578    if (!th_data) goto fin;
1579    if (!th_data->tc_running) goto fin;
1580    if (!th_data->reg_wins) goto fin;
1581    if (!(reg_win = _e_test_helper_find_win_on_reg_list(win))) goto fin;
1582    if (!(ec = reg_win->ec)) goto fin;
1583
1584    EINA_LIST_REVERSE_FOREACH(ec->comp_data->aux_hint.hints, l, ecah)
1585      {
1586         if ((!ecah->deleted) &&
1587             (!e_util_strcmp(ecah->hint, hint)))
1588           {
1589              id = ecah->id;
1590              hint = ecah->hint;
1591              val = ecah->val;
1592              break;
1593           }
1594      }
1595
1596 fin:
1597    eldbus_message_arguments_append(reply, "iss", id, hint, val);
1598
1599    return reply;
1600 }
1601
1602 static Eina_Bool
1603 _e_test_helper_cb_img_render(void *data EINA_UNUSED,
1604                              int type EINA_UNUSED,
1605                              void *event)
1606 {
1607    E_Client *ec;
1608    E_Event_Comp_Object *ev = event;
1609    Ecore_Window win = 0;
1610    Test_Helper_Reg_Win *reg_win = NULL;
1611
1612    if (!(ec = evas_object_data_get(ev->comp_object, "E_Client")))
1613      return ECORE_CALLBACK_DONE;
1614
1615    // a window should be registered for tracing
1616    if (!th_data) return ECORE_CALLBACK_DONE;
1617    if (!th_data->tc_running) return ECORE_CALLBACK_DONE;
1618    if (!th_data->reg_wins) return ECORE_CALLBACK_DONE;
1619
1620    win = e_pixmap_res_id_get(ec->pixmap);
1621    reg_win = _e_test_helper_find_win_on_reg_list(win);
1622
1623    if (reg_win && reg_win->render_send)
1624      _e_test_helper_send_render(win);
1625
1626    return ECORE_CALLBACK_DONE;
1627 }
1628
1629 static Eina_Bool
1630 _e_test_helper_cb_effect_start(void *data EINA_UNUSED,
1631                                int type EINA_UNUSED,
1632                                void *event)
1633 {
1634    E_Client *ec;
1635    E_Event_Comp_Object *ev = event;
1636    Ecore_Window win = 0;
1637    Test_Helper_Reg_Win *reg_win = NULL;
1638
1639    if (!(ec = evas_object_data_get(ev->comp_object, "E_Client")))
1640      return ECORE_CALLBACK_DONE;
1641
1642    // a window should be registered for tracing
1643    if (!th_data) return ECORE_CALLBACK_DONE;
1644    if (!th_data->tc_running) return ECORE_CALLBACK_DONE;
1645    if (!th_data->reg_wins) return ECORE_CALLBACK_DONE;
1646
1647    win = e_pixmap_res_id_get(ec->pixmap);
1648    reg_win = _e_test_helper_find_win_on_reg_list(win);
1649
1650    if (reg_win && ec && ec->frame)
1651      {
1652         reg_win->render_send = EINA_TRUE;
1653         e_comp_object_render_trace_set(ec->frame, EINA_TRUE);
1654         e_pixmap_image_refresh(ec->pixmap);
1655         e_comp_object_dirty(ec->frame);
1656      }
1657
1658    return ECORE_CALLBACK_DONE;
1659 }
1660
1661 static Eina_Bool
1662 _e_test_helper_cb_effect_end(void *data EINA_UNUSED,
1663                              int type EINA_UNUSED,
1664                              void *event)
1665 {
1666    E_Client *ec;
1667    E_Event_Comp_Object *ev = event;
1668    Ecore_Window win = 0;
1669    Test_Helper_Reg_Win *reg_win = NULL;
1670
1671    ec = evas_object_data_get(ev->comp_object, "E_Client");
1672    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, ECORE_CALLBACK_DONE);
1673
1674    // a window should be registered for tracing
1675    if (!th_data) return ECORE_CALLBACK_DONE;
1676    if (!th_data->tc_running) return ECORE_CALLBACK_DONE;
1677    if (!th_data->reg_wins) return ECORE_CALLBACK_DONE;
1678
1679    win = e_pixmap_res_id_get(ec->pixmap);
1680    reg_win = _e_test_helper_find_win_on_reg_list(win);
1681
1682    if (reg_win && ec->frame)
1683      {
1684         e_comp_object_render_trace_set(ec->frame, EINA_FALSE);
1685         reg_win->render_send = EINA_FALSE;
1686      }
1687
1688    return ECORE_CALLBACK_DONE;
1689 }
1690
1691 static void
1692 _e_test_helper_hook_cb_client_aux_hint_change(void *data EINA_UNUSED, E_Client *ec)
1693 {
1694    Ecore_Window win = 0;
1695    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
1696    Eina_List *l, *ll;
1697    E_Comp_Wl_Aux_Hint *hint;
1698
1699    EINA_SAFETY_ON_NULL_RETURN(th_data);
1700    if (!th_data->tc_running) return;
1701
1702    win = e_pixmap_res_id_get(ec->pixmap);
1703    if (!_e_test_helper_find_win_on_reg_list(win)) return;
1704
1705    if (win)
1706      {
1707         EINA_LIST_FOREACH_SAFE(cdata->aux_hint.hints, l, ll, hint)
1708           {
1709              if (hint->changed)
1710                {
1711                   _e_test_helper_send_aux_hint_change(win, hint->id, hint->hint, hint->val);
1712                }
1713           }
1714      }
1715 }
1716
1717 static Eina_Bool
1718 _e_test_helper_cb_client_iconic_state_changed(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
1719 {
1720    E_Event_Client *ev = event;
1721    E_Client *ec;
1722    Eldbus_Message *sig;
1723    Ecore_Window win;
1724
1725    if (!th_data->tc_running) return ECORE_CALLBACK_PASS_ON;
1726
1727    ec = ev->ec;
1728    if (!ec) return ECORE_CALLBACK_PASS_ON;
1729
1730    win = e_pixmap_res_id_get(ec->pixmap);
1731    if (!win) return ECORE_CALLBACK_PASS_ON;
1732
1733    if (!_e_test_helper_find_win_on_reg_list(win)) return ECORE_CALLBACK_PASS_ON;
1734
1735    sig = eldbus_service_signal_new(th_data->iface, E_TEST_HELPER_SIGNAL_ICONIC_STATE_CHANGED);
1736    eldbus_message_arguments_append(sig, "ubb", win, ec->iconic, e_client_is_iconified_by_client(ec));
1737    eldbus_service_signal_send(th_data->iface, sig);
1738
1739    return ECORE_CALLBACK_PASS_ON;
1740 }
1741
1742 /* externally accessible functions */
1743 EINTERN int
1744 e_test_helper_init(void)
1745 {
1746    Eina_Bool res = EINA_FALSE;
1747
1748    EINA_SAFETY_ON_TRUE_GOTO((e_dbus_conn_init() <= 0), err);
1749
1750    th_data = E_NEW(Test_Helper_Data, 1);
1751    EINA_SAFETY_ON_NULL_GOTO(th_data, err);
1752
1753    th_data->dbus_init_done_h = ecore_event_handler_add(E_EVENT_DBUS_CONN_INIT_DONE, _e_test_helper_cb_dbus_init_done, NULL);
1754    EINA_SAFETY_ON_NULL_GOTO(th_data->dbus_init_done_h, err);
1755
1756    res = e_dbus_conn_dbus_init(ELDBUS_CONNECTION_TYPE_SYSTEM);
1757    EINA_SAFETY_ON_FALSE_GOTO(res, err);
1758
1759    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_VISIBILITY_CHANGE,
1760                          _e_test_helper_cb_visibility_change, NULL);
1761    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_REMOVE,
1762                          _e_test_helper_cb_client_remove, NULL);
1763    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_STACK,
1764                         _e_test_helper_cb_client_restack, NULL);
1765    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_ROTATION_CHANGE_END,
1766                          _e_test_helper_cb_client_rotation_end, NULL);
1767    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_FOCUS_IN,
1768                          _e_test_helper_cb_client_focus_changed, NULL);
1769    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_FOCUS_OUT,
1770                          _e_test_helper_cb_client_focus_changed, NULL);
1771    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_COMP_OBJECT_IMG_RENDER,
1772                           _e_test_helper_cb_img_render, NULL);
1773    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_ICONIFY,
1774                           _e_test_helper_cb_client_iconic_state_changed, NULL);
1775    E_LIST_HANDLER_APPEND(th_data->hdlrs, E_EVENT_CLIENT_UNICONIFY,
1776                           _e_test_helper_cb_client_iconic_state_changed, NULL);
1777
1778    E_LIST_HOOK_APPEND(th_data->hooks, E_CLIENT_HOOK_AUX_HINT_CHANGE,
1779                       _e_test_helper_hook_cb_client_aux_hint_change, NULL);
1780
1781    return 1;
1782
1783 err:
1784    e_test_helper_shutdown();
1785    return 0;
1786 }
1787
1788 EINTERN int
1789 e_test_helper_shutdown(void)
1790 {
1791    if (th_data)
1792      {
1793         E_FREE_LIST(th_data->hdlrs, ecore_event_handler_del);
1794
1795         _e_test_helper_registrant_clear();
1796
1797         if (th_data->tc_timer)
1798           {
1799              ecore_timer_del(th_data->tc_timer);
1800              th_data->tc_timer = NULL;
1801           }
1802
1803         if (th_data->dbus_init_done_h)
1804           {
1805              ecore_event_handler_del(th_data->dbus_init_done_h);
1806              th_data->dbus_init_done_h = NULL;
1807           }
1808
1809         if (th_data->conn)
1810           {
1811              if (th_data->iface)
1812                eldbus_service_interface_unregister(th_data->iface);
1813
1814              e_dbus_conn_connection_unref(th_data->conn);
1815              th_data->conn = NULL;
1816           }
1817
1818         e_dbus_conn_shutdown();
1819
1820         E_FREE(th_data);
1821      }
1822
1823    return 1;
1824 }