src/lib/elm_main.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #ifdef HAVE_FORK
   6 #include <dlfcn.h> /* dlopen,dlclose,etc */
   7 #endif
   8
   9 #ifdef HAVE_CRT_EXTERNS_H
  10 # include <crt_externs.h>
  11 #endif
  12
  13 #ifdef HAVE_EVIL
  14 # include <Evil.h>
  15 #endif
  16
  17 #include <Elementary.h>
  18 #include "elm_priv.h"
  19
  20 #define SEMI_BROKEN_QUICKLAUNCH 1
  21
  22 static Elm_Version _version = { VMAJ, VMIN, VMIC, VREV };
  23 EAPI Elm_Version *elm_version = &_version;
  24
  25 Eina_Bool
  26 _elm_dangerous_call_check(const char *call)
  27 {
  28    char buf[256];
  29    const char *eval;
  30
  31    snprintf(buf, sizeof(buf), "%i.%i.%i.%i", VMAJ, VMIN, VMIC, VREV);
  32    eval = getenv("ELM_NO_FINGER_WAGGLING");
  33    if ((eval) && (!strcmp(eval, buf)))
  34      return 0;
  35    printf("ELEMENTARY FINGER WAGGLE!!!!!!!!!!\n"
  36           "\n"
  37           "  %s() used.\n"
  38           "PLEASE see the API documentation for this function. This call\n"
  39           "should almost never be used. Only in very special cases.\n"
  40           "\n"
  41           "To remove this warning please set the environment variable:\n"
  42           "  ELM_NO_FINGER_WAGGLING\n"
  43           "To the value of the Elementary version + revision number. e.g.:\n"
  44           "  1.2.5.40295\n"
  45           "\n"
  46           ,
  47           call);
  48    return 1;
  49 }
  50
  51 static Eina_Bool _elm_signal_exit(void *data,
  52                                   int   ev_type,
  53                                   void *ev);
  54
  55 static Eina_Prefix *pfx = NULL;
  56 char *_elm_appname = NULL;
  57 const char *_elm_data_dir = NULL;
  58 const char *_elm_lib_dir = NULL;
  59 int _elm_log_dom = -1;
  60
  61 EAPI int ELM_EVENT_POLICY_CHANGED = 0;
  62
  63 static int _elm_init_count = 0;
  64 static int _elm_sub_init_count = 0;
  65 static int _elm_ql_init_count = 0;
  66 static int _elm_policies[ELM_POLICY_LAST];
  67 static Ecore_Event_Handler *_elm_exit_handler = NULL;
  68 static Eina_Bool quicklaunch_on = 0;
  69
  70 static Eina_Bool
  71 _elm_signal_exit(void *data  __UNUSED__,
  72                  int ev_type __UNUSED__,
  73                  void *ev    __UNUSED__)
  74 {
  75    elm_exit();
  76    return ECORE_CALLBACK_PASS_ON;
  77 }
  78
  79 void
  80 _elm_rescale(void)
  81 {
  82    edje_scale_set(_elm_config->scale);
  83    _elm_win_rescale(NULL, EINA_FALSE);
  84    _elm_ews_wm_rescale(NULL, EINA_FALSE);
  85 }
  86
  87 static void *app_mainfunc = NULL;
  88 static const char *app_domain = NULL;
  89 static const char *app_checkfile = NULL;
  90
  91 static const char *app_compile_bin_dir = NULL;
  92 static const char *app_compile_lib_dir = NULL;
  93 static const char *app_compile_data_dir = NULL;
  94 static const char *app_compile_locale_dir = NULL;
  95 static const char *app_prefix_dir = NULL;
  96 static const char *app_bin_dir = NULL;
  97 static const char *app_lib_dir = NULL;
  98 static const char *app_data_dir = NULL;
  99 static const char *app_locale_dir = NULL;
 100
 101 static Eina_Prefix *app_pfx = NULL;
 102
 103 static void
 104 _prefix_check(void)
 105 {
 106    int argc = 0;
 107    char **argv = NULL;
 108    const char *dirs[4] = { NULL, NULL, NULL, NULL };
 109    char *caps = NULL, *p1, *p2;
 110    char buf[PATH_MAX];
 111
 112    if (app_pfx) return;
 113    if (!app_domain) return;
 114
 115    ecore_app_args_get(&argc, &argv);
 116    if (argc < 1) return;
 117
 118    dirs[0] = app_compile_bin_dir;
 119    dirs[1] = app_compile_lib_dir;
 120    dirs[2] = app_compile_data_dir;
 121    dirs[3] = app_compile_locale_dir;
 122
 123    if (!dirs[0]) dirs[0] = "/usr/local/bin";
 124    if (!dirs[1]) dirs[1] = "/usr/local/lib";
 125    if (!dirs[2])
 126      {
 127         snprintf(buf, sizeof(buf), "/usr/local/share/%s", app_domain);
 128         dirs[2] = buf;
 129      }
 130    if (!dirs[3]) dirs[3] = dirs[2];
 131
 132    if (app_domain)
 133      {
 134         caps = alloca(strlen(app_domain) + 1);
 135         for (p1 = (char *)app_domain, p2 = caps; *p1; p1++, p2++)
 136            *p2 = toupper(*p1);
 137         *p2 = 0;
 138      }
 139    app_pfx = eina_prefix_new(argv[0], app_mainfunc, caps, app_domain,
 140                              app_checkfile, dirs[0], dirs[1], dirs[2], dirs[3]);
 141 }
 142
 143 static void
 144 _prefix_shutdown(void)
 145 {
 146    if (app_pfx) eina_prefix_free(app_pfx);
 147    if (app_domain) eina_stringshare_del(app_domain);
 148    if (app_checkfile) eina_stringshare_del(app_checkfile);
 149    if (app_compile_bin_dir) eina_stringshare_del(app_compile_bin_dir);
 150    if (app_compile_lib_dir) eina_stringshare_del(app_compile_lib_dir);
 151    if (app_compile_data_dir) eina_stringshare_del(app_compile_data_dir);
 152    if (app_compile_locale_dir) eina_stringshare_del(app_compile_locale_dir);
 153    if (app_prefix_dir) eina_stringshare_del(app_prefix_dir);
 154    if (app_bin_dir) eina_stringshare_del(app_bin_dir);
 155    if (app_lib_dir) eina_stringshare_del(app_lib_dir);
 156    if (app_data_dir) eina_stringshare_del(app_data_dir);
 157    if (app_locale_dir) eina_stringshare_del(app_locale_dir);
 158    app_mainfunc = NULL;
 159    app_domain = NULL;
 160    app_checkfile = NULL;
 161    app_compile_bin_dir = NULL;
 162    app_compile_lib_dir = NULL;
 163    app_compile_data_dir = NULL;
 164    app_compile_locale_dir = NULL;
 165    app_prefix_dir = NULL;
 166    app_bin_dir = NULL;
 167    app_lib_dir = NULL;
 168    app_data_dir = NULL;
 169    app_locale_dir = NULL;
 170    app_pfx = NULL;
 171 }
 172
 173 EAPI int
 174 elm_init(int    argc,
 175          char **argv)
 176 {
 177    _elm_init_count++;
 178    if (_elm_init_count > 1) return _elm_init_count;
 179    elm_quicklaunch_init(argc, argv);
 180    elm_quicklaunch_sub_init(argc, argv);
 181    _prefix_shutdown();
 182    return _elm_init_count;
 183 }
 184
 185 EAPI int
 186 elm_shutdown(void)
 187 {
 188    _elm_init_count--;
 189    if (_elm_init_count > 0) return _elm_init_count;
 190    _elm_win_shutdown();
 191    while (_elm_win_deferred_free) ecore_main_loop_iterate();
 192 // wrningz :(
 193 //   _prefix_shutdown();
 194    elm_quicklaunch_sub_shutdown();
 195    elm_quicklaunch_shutdown();
 196    return _elm_init_count;
 197 }
 198
 199 EAPI void
 200 elm_app_info_set(void *mainfunc, const char *dom, const char *checkfile)
 201 {
 202    app_mainfunc = mainfunc;
 203    eina_stringshare_replace(&app_domain, dom);
 204    eina_stringshare_replace(&app_checkfile, checkfile);
 205 }
 206
 207 EAPI void
 208 elm_app_compile_bin_dir_set(const char *dir)
 209 {
 210    eina_stringshare_replace(&app_compile_bin_dir, dir);
 211 }
 212
 213 EAPI void
 214 elm_app_compile_lib_dir_set(const char *dir)
 215 {
 216    eina_stringshare_replace(&app_compile_lib_dir, dir);
 217 }
 218
 219 EAPI void
 220 elm_app_compile_data_dir_set(const char *dir)
 221 {
 222    eina_stringshare_replace(&app_compile_data_dir, dir);
 223 }
 224
 225 EAPI void
 226 elm_app_compile_locale_set(const char *dir)
 227 {
 228    eina_stringshare_replace(&app_compile_locale_dir, dir);
 229 }
 230
 231 EAPI const char *
 232 elm_app_prefix_dir_get(void)
 233 {
 234    if (app_prefix_dir) return app_prefix_dir;
 235    _prefix_check();
 236   if (!app_pfx) return "";
 237    app_prefix_dir = eina_prefix_get(app_pfx);
 238    return app_prefix_dir;
 239 }
 240
 241 EAPI const char *
 242 elm_app_bin_dir_get(void)
 243 {
 244    if (app_bin_dir) return app_bin_dir;
 245    _prefix_check();
 246    if (!app_pfx) return "";
 247    app_bin_dir = eina_prefix_bin_get(app_pfx);
 248    return app_bin_dir;
 249 }
 250
 251 EAPI const char *
 252 elm_app_lib_dir_get(void)
 253 {
 254    if (app_lib_dir) return app_lib_dir;
 255    _prefix_check();
 256    if (!app_pfx) return "";
 257    app_lib_dir = eina_prefix_lib_get(app_pfx);
 258    return app_lib_dir;
 259 }
 260
 261 EAPI const char *
 262 elm_app_data_dir_get(void)
 263 {
 264    if (app_data_dir) return app_data_dir;
 265    _prefix_check();
 266    if (!app_pfx) return "";
 267    app_data_dir = eina_prefix_data_get(app_pfx);
 268    return app_data_dir;
 269 }
 270
 271 EAPI const char *
 272 elm_app_locale_dir_get(void)
 273 {
 274    if (app_locale_dir) return app_locale_dir;
 275    _prefix_check();
 276    if (!app_pfx) return "";
 277    app_locale_dir = eina_prefix_locale_get(app_pfx);
 278    return app_locale_dir;
 279 }
 280
 281 #ifdef ELM_EDBUS
 282 static int _elm_need_e_dbus = 0;
 283 #endif
 284 EAPI Eina_Bool
 285 elm_need_e_dbus(void)
 286 {
 287 #ifdef ELM_EDBUS
 288    if (_elm_need_e_dbus++) return EINA_TRUE;
 289    e_dbus_init();
 290    return EINA_TRUE;
 291 #else
 292    return EINA_FALSE;
 293 #endif
 294 }
 295
 296 static void
 297 _elm_unneed_e_dbus(void)
 298 {
 299 #ifdef ELM_EDBUS
 300    if (--_elm_need_e_dbus) return;
 301
 302    _elm_need_e_dbus = 0;
 303    e_dbus_shutdown();
 304 #endif
 305 }
 306
 307 #ifdef ELM_EFREET
 308 static int _elm_need_efreet = 0;
 309 #endif
 310 EAPI Eina_Bool
 311 elm_need_efreet(void)
 312 {
 313 #ifdef ELM_EFREET
 314    if (_elm_need_efreet++) return EINA_TRUE;
 315    efreet_init();
 316    efreet_mime_init();
 317    efreet_trash_init();
 318     /*
 319      {
 320         Eina_List **list;
 321
 322         list = efreet_icon_extra_list_get();
 323         if (list)
 324           {
 325              e_user_dir_concat_static(buf, "icons");
 326              *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
 327              e_prefix_data_concat_static(buf, "data/icons");
 328              *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
 329           }
 330      }
 331    */
 332    return EINA_TRUE;
 333 #else
 334    return EINA_FALSE;
 335 #endif
 336 }
 337
 338 static void
 339 _elm_unneed_efreet(void)
 340 {
 341 #ifdef ELM_EFREET
 342    if (--_elm_need_efreet) return;
 343
 344    _elm_need_efreet = 0;
 345    efreet_trash_shutdown();
 346    efreet_mime_shutdown();
 347    efreet_shutdown();
 348 #endif
 349 }
 350
 351 EAPI void
 352 elm_quicklaunch_mode_set(Eina_Bool ql_on)
 353 {
 354    quicklaunch_on = ql_on;
 355 }
 356
 357 EAPI Eina_Bool
 358 elm_quicklaunch_mode_get(void)
 359 {
 360    return quicklaunch_on;
 361 }
 362
 363 EAPI int
 364 elm_quicklaunch_init(int    argc,
 365                      char **argv)
 366 {
 367    _elm_ql_init_count++;
 368    if (_elm_ql_init_count > 1) return _elm_ql_init_count;
 369    eina_init();
 370    _elm_log_dom = eina_log_domain_register("elementary", EINA_COLOR_LIGHTBLUE);
 371    if (!_elm_log_dom)
 372      {
 373         EINA_LOG_ERR("could not register elementary log domain.");
 374         _elm_log_dom = EINA_LOG_DOMAIN_GLOBAL;
 375      }
 376
 377    eet_init();
 378    ecore_init();
 379
 380 #ifdef HAVE_ELEMENTARY_EMAP
 381    emap_init();
 382 #endif
 383    ecore_app_args_set(argc, (const char **)argv);
 384
 385    memset(_elm_policies, 0, sizeof(_elm_policies));
 386    if (!ELM_EVENT_POLICY_CHANGED)
 387      ELM_EVENT_POLICY_CHANGED = ecore_event_type_new();
 388
 389    ecore_file_init();
 390
 391    _elm_exit_handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _elm_signal_exit, NULL);
 392
 393    if (argv) _elm_appname = strdup(ecore_file_file_get(argv[0]));
 394
 395    pfx = eina_prefix_new(argv ? argv[0] : NULL, elm_quicklaunch_init,
 396                          "ELM", "elementary", "config/profile.cfg",
 397                          PACKAGE_LIB_DIR, /* don't have a bin dir currently */
 398                          PACKAGE_LIB_DIR,
 399                          PACKAGE_DATA_DIR,
 400                          LOCALE_DIR);
 401    if (pfx)
 402      {
 403         _elm_data_dir = eina_stringshare_add(eina_prefix_data_get(pfx));
 404         _elm_lib_dir = eina_stringshare_add(eina_prefix_lib_get(pfx));
 405      }
 406    if (!_elm_data_dir) _elm_data_dir = eina_stringshare_add("/");
 407    if (!_elm_lib_dir) _elm_lib_dir = eina_stringshare_add("/");
 408
 409    return _elm_ql_init_count;
 410 }
 411
 412 EAPI int
 413 elm_quicklaunch_sub_init(int    argc,
 414                          char **argv)
 415 {
 416    _elm_sub_init_count++;
 417    if (_elm_sub_init_count > 1) return _elm_sub_init_count;
 418    if (quicklaunch_on)
 419      {
 420         _elm_config_init();
 421 #ifdef SEMI_BROKEN_QUICKLAUNCH
 422         return _elm_sub_init_count;
 423 #endif
 424      }
 425    if (!quicklaunch_on)
 426      {
 427         ecore_app_args_set(argc, (const char **)argv);
 428         evas_init();
 429         edje_init();
 430         _elm_module_init();
 431         _elm_config_init();
 432         _elm_config_sub_init();
 433         ecore_evas_init(); // FIXME: check errors
 434 #ifdef HAVE_ELEMENTARY_ECORE_IMF
 435         ecore_imf_init();
 436 #endif
 437 #ifdef HAVE_ELEMENTARY_ECORE_CON
 438         ecore_con_init();
 439         ecore_con_url_init();
 440 #endif
 441         _elm_ews_wm_init();
 442      }
 443    return _elm_sub_init_count;
 444 }
 445
 446 EAPI int
 447 elm_quicklaunch_sub_shutdown(void)
 448 {
 449    _elm_sub_init_count--;
 450    if (_elm_sub_init_count > 0) return _elm_sub_init_count;
 451    if (quicklaunch_on)
 452      {
 453 #ifdef SEMI_BROKEN_QUICKLAUNCH
 454         return _elm_sub_init_count;
 455 #endif
 456      }
 457    if (!quicklaunch_on)
 458      {
 459         _elm_win_shutdown();
 460         _elm_module_shutdown();
 461         _elm_ews_wm_shutdown();
 462 #ifdef HAVE_ELEMENTARY_ECORE_CON
 463         ecore_con_url_shutdown();
 464         ecore_con_shutdown();
 465 #endif
 466 #ifdef HAVE_ELEMENTARY_ECORE_IMF
 467         ecore_imf_shutdown();
 468 #endif
 469         ecore_evas_shutdown();
 470         _elm_config_sub_shutdown();
 471 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 472         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 473             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 474             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 475             ENGINE_COMPARE(ELM_OPENGL_X11) ||
 476             ENGINE_COMPARE(ELM_SOFTWARE_SDL) ||
 477             ENGINE_COMPARE(ELM_SOFTWARE_16_SDL) ||
 478             ENGINE_COMPARE(ELM_OPENGL_SDL) ||
 479             ENGINE_COMPARE(ELM_OPENGL_COCOA) ||
 480             ENGINE_COMPARE(ELM_SOFTWARE_WIN32) ||
 481             ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE) ||
 482             ENGINE_COMPARE(ELM_EWS))
 483 #undef ENGINE_COMPARE
 484           evas_cserve_disconnect();
 485         edje_shutdown();
 486         evas_shutdown();
 487      }
 488    return _elm_sub_init_count;
 489 }
 490
 491 EAPI int
 492 elm_quicklaunch_shutdown(void)
 493 {
 494    _elm_ql_init_count--;
 495    if (_elm_ql_init_count > 0) return _elm_ql_init_count;
 496    if (pfx) eina_prefix_free(pfx);
 497    pfx = NULL;
 498    eina_stringshare_del(_elm_data_dir);
 499    _elm_data_dir = NULL;
 500    eina_stringshare_del(_elm_lib_dir);
 501    _elm_lib_dir = NULL;
 502
 503    free(_elm_appname);
 504    _elm_appname = NULL;
 505
 506    _elm_config_shutdown();
 507
 508    ecore_event_handler_del(_elm_exit_handler);
 509    _elm_exit_handler = NULL;
 510
 511    _elm_theme_shutdown();
 512    _elm_unneed_efreet();
 513    _elm_unneed_e_dbus();
 514    _elm_unneed_ethumb();
 515    _elm_unneed_web();
 516    ecore_file_shutdown();
 517
 518 #ifdef HAVE_ELEMENTARY_EMAP
 519    emap_shutdown();
 520 #endif
 521
 522    ecore_shutdown();
 523    eet_shutdown();
 524
 525    if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
 526      {
 527         eina_log_domain_unregister(_elm_log_dom);
 528         _elm_log_dom = -1;
 529      }
 530
 531    _elm_widget_type_clear();
 532
 533    eina_shutdown();
 534    return _elm_ql_init_count;
 535 }
 536
 537 EAPI void
 538 elm_quicklaunch_seed(void)
 539 {
 540 #ifndef SEMI_BROKEN_QUICKLAUNCH
 541    if (quicklaunch_on)
 542      {
 543         Evas_Object *win, *bg, *bt;
 544
 545         win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
 546         bg = elm_bg_add(win);
 547         elm_win_resize_object_add(win, bg);
 548         evas_object_show(bg);
 549         bt = elm_button_add(win);
 550         elm_object_text_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
 551         elm_win_resize_object_add(win, bt);
 552         ecore_main_loop_iterate();
 553         evas_object_del(win);
 554         ecore_main_loop_iterate();
 555 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 556         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 557             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 558             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 559             ENGINE_COMPARE(ELM_OPENGL_X11))
 560 #undef ENGINE_COMPARE
 561           {
 562 # ifdef HAVE_ELEMENTARY_X
 563              ecore_x_sync();
 564 # endif
 565           }
 566         ecore_main_loop_iterate();
 567      }
 568 #endif
 569 }
 570
 571 #ifdef HAVE_FORK
 572 static void *qr_handle = NULL;
 573 #endif
 574 static int (*qr_main)(int    argc,
 575                       char **argv) = NULL;
 576
 577 EAPI Eina_Bool
 578 elm_quicklaunch_prepare(int argc __UNUSED__,
 579                         char   **argv)
 580 {
 581 #ifdef HAVE_FORK
 582    char *exe = elm_quicklaunch_exe_path_get(argv[0]);
 583    if (!exe)
 584      {
 585         ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
 586         return EINA_FALSE;
 587      }
 588    else
 589      {
 590         char *exe2, *p;
 591         char *exename;
 592
 593         exe2 = malloc(strlen(exe) + 1 + 10);
 594         strcpy(exe2, exe);
 595         p = strrchr(exe2, '/');
 596         if (p) p++;
 597         else p = exe2;
 598         exename = alloca(strlen(p) + 1);
 599         strcpy(exename, p);
 600         *p = 0;
 601         strcat(p, "../lib/");
 602         strcat(p, exename);
 603         strcat(p, ".so");
 604         if (!access(exe2, R_OK | X_OK))
 605           {
 606              free(exe);
 607              exe = exe2;
 608           }
 609         else
 610           free(exe2);
 611      }
 612    qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
 613    if (!qr_handle)
 614      {
 615         fprintf(stderr, "dlerr: %s\n", dlerror());
 616         WRN("dlopen('%s') failed: %s", exe, dlerror());
 617         free(exe);
 618         return EINA_FALSE;
 619      }
 620    INF("dlopen('%s') = %p", exe, qr_handle);
 621    qr_main = dlsym(qr_handle, "elm_main");
 622    INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
 623    if (!qr_main)
 624      {
 625         WRN("not quicklauncher capable: no elm_main in '%s'", exe);
 626         dlclose(qr_handle);
 627         qr_handle = NULL;
 628         free(exe);
 629         return EINA_FALSE;
 630      }
 631    free(exe);
 632    return EINA_TRUE;
 633 #else
 634    return EINA_FALSE;
 635    (void)argv;
 636 #endif
 637 }
 638
 639 #ifdef HAVE_FORK
 640 static void
 641 save_env(void)
 642 {
 643    int i, size;
 644    extern char **environ;
 645    char **oldenv, **p;
 646
 647    oldenv = environ;
 648
 649    for (i = 0, size = 0; environ[i]; i++)
 650      size += strlen(environ[i]) + 1;
 651
 652    p = malloc((i + 1) * sizeof(char *));
 653    if (!p) return;
 654
 655    environ = p;
 656
 657    for (i = 0; oldenv[i]; i++)
 658      environ[i] = strdup(oldenv[i]);
 659    environ[i] = NULL;
 660 }
 661
 662 #endif
 663
 664 EAPI Eina_Bool
 665 elm_quicklaunch_fork(int    argc,
 666                      char **argv,
 667                      char  *cwd,
 668                      void (postfork_func) (void *data),
 669                      void  *postfork_data)
 670 {
 671 #ifdef HAVE_FORK
 672    pid_t child;
 673    int ret;
 674    int real_argc;
 675    char **real_argv;
 676
 677    // FIXME:
 678    // need to accept current environment from elementary_run
 679    if (!qr_main)
 680      {
 681         int i;
 682         char **args;
 683
 684         child = fork();
 685         if (child > 0) return EINA_TRUE;
 686         else if (child < 0)
 687           {
 688              perror("could not fork");
 689              return EINA_FALSE;
 690           }
 691         setsid();
 692         if (chdir(cwd) != 0)
 693           perror("could not chdir");
 694         args = alloca((argc + 1) * sizeof(char *));
 695         for (i = 0; i < argc; i++) args[i] = argv[i];
 696         args[argc] = NULL;
 697         WRN("%s not quicklaunch capable, fallback...", argv[0]);
 698         execvp(argv[0], args);
 699         ERR("failed to execute '%s': %s", argv[0], strerror(errno));
 700         exit(-1);
 701      }
 702    child = fork();
 703    if (child > 0) return EINA_TRUE;
 704    else if (child < 0)
 705      {
 706         perror("could not fork");
 707         return EINA_FALSE;
 708      }
 709    if (postfork_func) postfork_func(postfork_data);
 710
 711    if (quicklaunch_on)
 712      {
 713 #ifdef SEMI_BROKEN_QUICKLAUNCH
 714         ecore_app_args_set(argc, (const char **)argv);
 715         evas_init();
 716         edje_init();
 717         _elm_config_sub_init();
 718 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 719         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 720             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 721             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 722             ENGINE_COMPARE(ELM_OPENGL_X11))
 723 #undef ENGINE_COMPARE
 724           {
 725 # ifdef HAVE_ELEMENTARY_X
 726              ecore_x_init(NULL);
 727 # endif
 728           }
 729         ecore_evas_init(); // FIXME: check errors
 730 # ifdef HAVE_ELEMENTARY_ECORE_IMF
 731         ecore_imf_init();
 732 # endif
 733         _elm_module_init();
 734 #endif
 735      }
 736
 737    setsid();
 738    if (chdir(cwd) != 0)
 739      perror("could not chdir");
 740    // FIXME: this is very linux specific. it changes argv[0] of the process
 741    // so ps etc. report what you'd expect. for other unixes and os's this
 742    // may just not work
 743    save_env();
 744    if (argv)
 745      {
 746         char *lastarg, *p;
 747
 748         ecore_app_args_get(&real_argc, &real_argv);
 749         lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
 750         for (p = real_argv[0]; p < lastarg; p++) *p = 0;
 751         strcpy(real_argv[0], argv[0]);
 752      }
 753    ecore_app_args_set(argc, (const char **)argv);
 754    ret = qr_main(argc, argv);
 755    exit(ret);
 756    return EINA_TRUE;
 757 #else
 758    return EINA_FALSE;
 759    (void)argc;
 760    (void)argv;
 761    (void)cwd;
 762    (void)postfork_func;
 763    (void)postfork_data;
 764 #endif
 765 }
 766
 767 EAPI void
 768 elm_quicklaunch_cleanup(void)
 769 {
 770 #ifdef HAVE_FORK
 771    if (qr_handle)
 772      {
 773         dlclose(qr_handle);
 774         qr_handle = NULL;
 775         qr_main = NULL;
 776      }
 777 #endif
 778 }
 779
 780 EAPI int
 781 elm_quicklaunch_fallback(int    argc,
 782                          char **argv)
 783 {
 784    int ret;
 785    elm_quicklaunch_init(argc, argv);
 786    elm_quicklaunch_sub_init(argc, argv);
 787    elm_quicklaunch_prepare(argc, argv);
 788    ret = qr_main(argc, argv);
 789    exit(ret);
 790    return ret;
 791 }
 792
 793 EAPI char *
 794 elm_quicklaunch_exe_path_get(const char *exe)
 795 {
 796    static char *path = NULL;
 797    static Eina_List *pathlist = NULL;
 798    const char *pathitr;
 799    const Eina_List *l;
 800    char buf[PATH_MAX];
 801    if (exe[0] == '/') return strdup(exe);
 802    if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
 803    if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
 804    if (!path)
 805      {
 806         const char *p, *pp;
 807         char *buf2;
 808         path = getenv("PATH");
 809         buf2 = alloca(strlen(path) + 1);
 810         p = path;
 811         pp = p;
 812         for (;; )
 813           {
 814              if ((*p == ':') || (!*p))
 815                {
 816                   int len;
 817
 818                   len = p - pp;
 819                   strncpy(buf2, pp, len);
 820                   buf2[len] = 0;
 821                   pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
 822                   if (!*p) break;
 823                   p++;
 824                   pp = p;
 825                }
 826              else
 827                {
 828                   if (!*p) break;
 829                   p++;
 830                }
 831           }
 832      }
 833    EINA_LIST_FOREACH(pathlist, l, pathitr)
 834      {
 835         snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
 836         if (!access(buf, R_OK | X_OK)) return strdup(buf);
 837      }
 838    return NULL;
 839 }
 840
 841 EAPI void
 842 elm_run(void)
 843 {
 844    ecore_main_loop_begin();
 845 }
 846
 847 EAPI void
 848 elm_exit(void)
 849 {
 850    ecore_main_loop_quit();
 851 }
 852
 853 EAPI Eina_Bool
 854 elm_policy_set(unsigned int policy,
 855                int          value)
 856 {
 857    Elm_Event_Policy_Changed *ev;
 858
 859    if (policy >= ELM_POLICY_LAST)
 860      return EINA_FALSE;
 861
 862    if (value == _elm_policies[policy])
 863      return EINA_TRUE;
 864
 865    /* TODO: validade policy? */
 866
 867    ev = malloc(sizeof(*ev));
 868    ev->policy = policy;
 869    ev->new_value = value;
 870    ev->old_value = _elm_policies[policy];
 871
 872    _elm_policies[policy] = value;
 873
 874    ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
 875
 876    return EINA_TRUE;
 877 }
 878
 879 EAPI int
 880 elm_policy_get(unsigned int policy)
 881 {
 882    if (policy >= ELM_POLICY_LAST)
 883      return 0;
 884    return _elm_policies[policy];
 885 }
 886
 887 EAPI void
 888 elm_language_set(const char *lang)
 889 {
 890    setlocale(LC_ALL, lang);
 891    _elm_win_translate();
 892 }
 893
 894 EAPI Eina_Bool
 895 elm_object_mirrored_get(const Evas_Object *obj)
 896 {
 897    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 898    return elm_widget_mirrored_get(obj);
 899 }
 900
 901 EAPI void
 902 elm_object_mirrored_set(Evas_Object *obj, Eina_Bool mirrored)
 903 {
 904    EINA_SAFETY_ON_NULL_RETURN(obj);
 905    elm_widget_mirrored_set(obj, mirrored);
 906 }
 907
 908 EAPI Eina_Bool
 909 elm_object_mirrored_automatic_get(const Evas_Object *obj)
 910 {
 911    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 912    return elm_widget_mirrored_automatic_get(obj);
 913 }
 914
 915 EAPI void
 916 elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic)
 917 {
 918    EINA_SAFETY_ON_NULL_RETURN(obj);
 919    elm_widget_mirrored_automatic_set(obj, automatic);
 920 }
 921
 922 /**
 923  * @}
 924  */
 925
 926 EAPI void
 927 elm_object_scale_set(Evas_Object *obj,
 928                      double       scale)
 929 {
 930    EINA_SAFETY_ON_NULL_RETURN(obj);
 931    elm_widget_scale_set(obj, scale);
 932 }
 933
 934 EAPI double
 935 elm_object_scale_get(const Evas_Object *obj)
 936 {
 937    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0.0);
 938    return elm_widget_scale_get(obj);
 939 }
 940
 941 EAPI void
 942 elm_object_part_text_set(Evas_Object *obj, const char *part, const char *label)
 943 {
 944    EINA_SAFETY_ON_NULL_RETURN(obj);
 945    elm_widget_text_part_set(obj, part, label);
 946 }
 947
 948 EAPI const char *
 949 elm_object_part_text_get(const Evas_Object *obj, const char *part)
 950 {
 951    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 952    return elm_widget_text_part_get(obj, part);
 953 }
 954
 955 EAPI void
 956 elm_object_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *text)
 957 {
 958    EINA_SAFETY_ON_NULL_RETURN(obj);
 959    elm_widget_domain_translatable_text_part_set(obj, part, domain, text);
 960 }
 961
 962 EAPI const char *
 963 elm_object_translatable_text_part_get(const Evas_Object *obj, const char *part)
 964 {
 965    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 966    return elm_widget_translatable_text_part_get(obj, part);
 967 }
 968
 969 EAPI void
 970 elm_object_part_content_set(Evas_Object *obj, const char *part, Evas_Object *content)
 971 {
 972    EINA_SAFETY_ON_NULL_RETURN(obj);
 973    elm_widget_content_part_set(obj, part, content);
 974 }
 975
 976 EAPI Evas_Object *
 977 elm_object_part_content_get(const Evas_Object *obj, const char *part)
 978 {
 979    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 980    return elm_widget_content_part_get(obj, part);
 981 }
 982
 983 EAPI Evas_Object *
 984 elm_object_part_content_unset(Evas_Object *obj, const char *part)
 985 {
 986    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 987    return elm_widget_content_part_unset(obj, part);
 988 }
 989
 990 EAPI Eina_Bool
 991 elm_object_style_set(Evas_Object *obj,
 992                      const char  *style)
 993 {
 994    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 995    return elm_widget_style_set(obj, style);
 996 }
 997
 998 EAPI const char *
 999 elm_object_style_get(const Evas_Object *obj)
1000 {
1001    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1002    return elm_widget_style_get(obj);
1003 }
1004
1005 EAPI void
1006 elm_object_disabled_set(Evas_Object *obj,
1007                         Eina_Bool    disabled)
1008 {
1009    EINA_SAFETY_ON_NULL_RETURN(obj);
1010    elm_widget_disabled_set(obj, disabled);
1011 }
1012
1013 EAPI Eina_Bool
1014 elm_object_disabled_get(const Evas_Object *obj)
1015 {
1016    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1017    return elm_widget_disabled_get(obj);
1018 }
1019
1020 EAPI void
1021 elm_cache_all_flush(void)
1022 {
1023    const Eina_List *l;
1024    Evas_Object *obj;
1025
1026    edje_file_cache_flush();
1027    edje_collection_cache_flush();
1028    eet_clearcache();
1029    EINA_LIST_FOREACH(_elm_win_list, l, obj)
1030      {
1031         Evas *e = evas_object_evas_get(obj);
1032         evas_image_cache_flush(e);
1033         evas_font_cache_flush(e);
1034         evas_render_dump(e);
1035      }
1036 }
1037
1038 EAPI Eina_Bool
1039 elm_object_focus_get(const Evas_Object *obj)
1040 {
1041    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1042    return elm_widget_focus_get(obj);
1043 }
1044
1045 EAPI void
1046 elm_object_focus_set(Evas_Object *obj,
1047                      Eina_Bool    focus)
1048 {
1049    EINA_SAFETY_ON_NULL_RETURN(obj);
1050
1051    if (focus == elm_widget_focus_get(obj)) return;
1052
1053    if (focus)
1054      elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
1055    else
1056      elm_widget_focused_object_clear(obj);
1057 }
1058
1059 EAPI void
1060 elm_object_focus_allow_set(Evas_Object *obj,
1061                            Eina_Bool    enable)
1062 {
1063    EINA_SAFETY_ON_NULL_RETURN(obj);
1064    elm_widget_can_focus_set(obj, enable);
1065 /*FIXME: According to the elm_object_focus_allow_get(), child_can_focus field
1066 of the parent should be updated. Otherwise, the checking of it's child focus allow states should not be in elm_object_focus_allow_get() */
1067 }
1068
1069 EAPI Eina_Bool
1070 elm_object_focus_allow_get(const Evas_Object *obj)
1071 {
1072    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1073    return (elm_widget_can_focus_get(obj)) || (elm_widget_child_can_focus_get(obj));
1074 }
1075
1076 EAPI void
1077 elm_object_focus_custom_chain_set(Evas_Object *obj,
1078                                   Eina_List   *objs)
1079 {
1080    EINA_SAFETY_ON_NULL_RETURN(obj);
1081    elm_widget_focus_custom_chain_set(obj, objs);
1082 }
1083
1084 EAPI void
1085 elm_object_focus_custom_chain_unset(Evas_Object *obj)
1086 {
1087    EINA_SAFETY_ON_NULL_RETURN(obj);
1088    elm_widget_focus_custom_chain_unset(obj);
1089 }
1090
1091 EAPI const Eina_List *
1092 elm_object_focus_custom_chain_get(const Evas_Object *obj)
1093 {
1094    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1095    return elm_widget_focus_custom_chain_get(obj);
1096 }
1097
1098 EAPI void
1099 elm_object_focus_custom_chain_append(Evas_Object *obj,
1100                                      Evas_Object *child,
1101                                      Evas_Object *relative_child)
1102 {
1103    EINA_SAFETY_ON_NULL_RETURN(obj);
1104    elm_widget_focus_custom_chain_append(obj, child, relative_child);
1105 }
1106
1107 EAPI void
1108 elm_object_focus_custom_chain_prepend(Evas_Object *obj,
1109                                       Evas_Object *child,
1110                                       Evas_Object *relative_child)
1111 {
1112    EINA_SAFETY_ON_NULL_RETURN(obj);
1113    elm_widget_focus_custom_chain_prepend(obj, child, relative_child);
1114 }
1115
1116 EINA_DEPRECATED EAPI void
1117 elm_object_focus_cycle(Evas_Object        *obj,
1118                        Elm_Focus_Direction dir)
1119 {
1120    elm_object_focus_next(obj, dir);
1121 }
1122
1123 EAPI void
1124 elm_object_focus_next(Evas_Object        *obj,
1125                       Elm_Focus_Direction dir)
1126 {
1127    EINA_SAFETY_ON_NULL_RETURN(obj);
1128    elm_widget_focus_cycle(obj, dir);
1129 }
1130
1131 EAPI void
1132 elm_object_tree_focus_allow_set(Evas_Object *obj,
1133                                 Eina_Bool    tree_focusable)
1134 {
1135    EINA_SAFETY_ON_NULL_RETURN(obj);
1136    elm_widget_tree_unfocusable_set(obj, !tree_focusable);
1137 }
1138
1139 EAPI Eina_Bool
1140 elm_object_tree_focus_allow_get(const Evas_Object *obj)
1141 {
1142    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1143    return !elm_widget_tree_unfocusable_get(obj);
1144 }
1145
1146 EAPI void
1147 elm_object_scroll_hold_push(Evas_Object *obj)
1148 {
1149    EINA_SAFETY_ON_NULL_RETURN(obj);
1150    elm_widget_scroll_hold_push(obj);
1151 }
1152
1153 EAPI void
1154 elm_object_scroll_hold_pop(Evas_Object *obj)
1155 {
1156    EINA_SAFETY_ON_NULL_RETURN(obj);
1157    elm_widget_scroll_hold_pop(obj);
1158 }
1159
1160 EAPI void
1161 elm_object_scroll_freeze_push(Evas_Object *obj)
1162 {
1163    EINA_SAFETY_ON_NULL_RETURN(obj);
1164    elm_widget_scroll_freeze_push(obj);
1165 }
1166
1167 EAPI void
1168 elm_object_scroll_lock_x_set(Evas_Object *obj,
1169                              Eina_Bool    lock)
1170 {
1171    EINA_SAFETY_ON_NULL_RETURN(obj);
1172    elm_widget_drag_lock_x_set(obj, lock);
1173 }
1174
1175 EAPI void
1176 elm_object_scroll_lock_y_set(Evas_Object *obj,
1177                              Eina_Bool    lock)
1178 {
1179    EINA_SAFETY_ON_NULL_RETURN(obj);
1180    elm_widget_drag_lock_y_set(obj, lock);
1181 }
1182
1183 EAPI Eina_Bool
1184 elm_object_scroll_lock_x_get(const Evas_Object *obj)
1185 {
1186    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1187    return elm_widget_drag_lock_x_get(obj);
1188 }
1189
1190 EAPI Eina_Bool
1191 elm_object_scroll_lock_y_get(const Evas_Object *obj)
1192 {
1193    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1194    return elm_widget_drag_lock_y_get(obj);
1195 }
1196
1197 EAPI void
1198 elm_object_scroll_freeze_pop(Evas_Object *obj)
1199 {
1200    EINA_SAFETY_ON_NULL_RETURN(obj);
1201    elm_widget_scroll_freeze_pop(obj);
1202 }
1203
1204 EAPI Eina_Bool
1205 elm_object_widget_check(const Evas_Object *obj)
1206 {
1207    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1208    return elm_widget_is(obj);
1209 }
1210
1211 EAPI Evas_Object *
1212 elm_object_parent_widget_get(const Evas_Object *obj)
1213 {
1214    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1215    return elm_widget_parent_widget_get(obj);
1216 }
1217
1218 EAPI Evas_Object *
1219 elm_object_top_widget_get(const Evas_Object *obj)
1220 {
1221    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1222    return elm_widget_top_get(obj);
1223 }
1224
1225 EAPI const char *
1226 elm_object_widget_type_get(const Evas_Object *obj)
1227 {
1228    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1229    return elm_widget_type_get(obj);
1230 }
1231
1232 EAPI void
1233 elm_object_signal_emit(Evas_Object *obj,
1234                        const char  *emission,
1235                        const char  *source)
1236 {
1237    EINA_SAFETY_ON_NULL_RETURN(obj);
1238    elm_widget_signal_emit(obj, emission, source);
1239 }
1240
1241 EAPI void
1242 elm_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
1243 {
1244     EINA_SAFETY_ON_NULL_RETURN(obj);
1245     EINA_SAFETY_ON_NULL_RETURN(func);
1246     elm_widget_signal_callback_add(obj, emission, source, func, data);
1247 }
1248
1249 EAPI void *
1250 elm_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func)
1251 {
1252     EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1253     EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
1254     return elm_widget_signal_callback_del(obj, emission, source, func);
1255 }
1256
1257 EAPI void
1258 elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data)
1259 {
1260    EINA_SAFETY_ON_NULL_RETURN(obj);
1261    EINA_SAFETY_ON_NULL_RETURN(func);
1262    elm_widget_event_callback_add(obj, func, data);
1263 }
1264
1265 EAPI void *
1266 elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data)
1267 {
1268    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1269    EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
1270    return elm_widget_event_callback_del(obj, func, data);
1271 }
1272
1273 EAPI void
1274 elm_object_tree_dump(const Evas_Object *top)
1275 {
1276 #ifdef ELM_DEBUG
1277    elm_widget_tree_dump(top);
1278 #else
1279    return;
1280    (void)top;
1281 #endif
1282 }
1283
1284 EAPI void
1285 elm_object_tree_dot_dump(const Evas_Object *top,
1286                          const char        *file)
1287 {
1288 #ifdef ELM_DEBUG
1289    FILE *f = fopen(file, "wb");
1290    elm_widget_tree_dot_dump(top, f);
1291    fclose(f);
1292 #else
1293    return;
1294    (void)top;
1295    (void)file;
1296 #endif
1297 }
1298
1299 EAPI void
1300 elm_coords_finger_size_adjust(int         times_w,
1301                               Evas_Coord *w,
1302                               int         times_h,
1303                               Evas_Coord *h)
1304 {
1305    if ((w) && (*w < (_elm_config->finger_size * times_w)))
1306      *w = _elm_config->finger_size * times_w;
1307    if ((h) && (*h < (_elm_config->finger_size * times_h)))
1308      *h = _elm_config->finger_size * times_h;
1309 }
1310
1311 EAPI Evas_Object *
1312 elm_object_item_widget_get(const Elm_Object_Item *it)
1313 {
1314    return WIDGET(it);
1315 }
1316
1317 EAPI void
1318 elm_object_item_part_content_set(Elm_Object_Item *it,
1319                                  const char *part,
1320                                  Evas_Object *content)
1321 {
1322    _elm_widget_item_part_content_set((Elm_Widget_Item *)it, part, content);
1323 }
1324
1325 EAPI Evas_Object *
1326 elm_object_item_part_content_get(const Elm_Object_Item *it,
1327                                  const char *part)
1328 {
1329    return _elm_widget_item_part_content_get((Elm_Widget_Item *)it, part);
1330 }
1331
1332 EAPI Evas_Object *
1333 elm_object_item_part_content_unset(Elm_Object_Item *it, const char *part)
1334 {
1335    return _elm_widget_item_part_content_unset((Elm_Widget_Item *)it, part);
1336 }
1337
1338 EAPI void
1339 elm_object_item_part_text_set(Elm_Object_Item *it,
1340                               const char *part,
1341                               const char *label)
1342 {
1343    _elm_widget_item_part_text_set((Elm_Widget_Item *)it, part, label);
1344 }
1345
1346 EAPI const char *
1347 elm_object_item_part_text_get(const Elm_Object_Item *it, const char *part)
1348 {
1349    return _elm_widget_item_part_text_get((Elm_Widget_Item *)it, part);
1350 }
1351
1352 EAPI void
1353 elm_object_access_info_set(Evas_Object *obj, const char *txt)
1354 {
1355    elm_widget_access_info_set(obj, txt);
1356 }
1357
1358 EAPI Evas_Object *
1359 elm_object_name_find(const Evas_Object *obj, const char *name, int recurse)
1360 {
1361    return elm_widget_name_find(obj, name, recurse);
1362 }
1363
1364 EAPI void
1365 elm_object_item_access_info_set(Elm_Object_Item *it, const char *txt)
1366 {
1367    _elm_widget_item_access_info_set((Elm_Widget_Item *)it, txt);
1368 }
1369
1370 EAPI void *
1371 elm_object_item_data_get(const Elm_Object_Item *it)
1372 {
1373    return elm_widget_item_data_get(it);
1374 }
1375
1376 EAPI void
1377 elm_object_item_data_set(Elm_Object_Item *it, void *data)
1378 {
1379    elm_widget_item_data_set(it, data);
1380 }
1381
1382 EAPI void
1383 elm_object_item_signal_emit(Elm_Object_Item *it, const char *emission, const char *source)
1384 {
1385    _elm_widget_item_signal_emit((Elm_Widget_Item *)it, emission, source);
1386 }
1387
1388 EAPI void elm_object_item_disabled_set(Elm_Object_Item *it, Eina_Bool disabled)
1389 {
1390    _elm_widget_item_disabled_set((Elm_Widget_Item *)it, disabled);
1391 }
1392
1393 EAPI Eina_Bool elm_object_item_disabled_get(const Elm_Object_Item *it)
1394 {
1395    return _elm_widget_item_disabled_get((Elm_Widget_Item *)it);
1396 }
1397
1398 EAPI void elm_object_item_del_cb_set(Elm_Object_Item *it, Evas_Smart_Cb del_cb)
1399 {
1400    _elm_widget_item_del_cb_set((Elm_Widget_Item *)it, del_cb);
1401 }
1402
1403 EAPI void elm_object_item_del(Elm_Object_Item *it)
1404 {
1405    _elm_widget_item_del((Elm_Widget_Item *)it);
1406 }
1407
1408 EAPI void
1409 elm_object_item_tooltip_text_set(Elm_Object_Item *it, const char *text)
1410 {
1411    elm_widget_item_tooltip_text_set(it, text);
1412 }
1413
1414 EAPI void
1415 elm_object_item_tooltip_content_cb_set(Elm_Object_Item *it, Elm_Tooltip_Item_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
1416 {
1417    elm_widget_item_tooltip_content_cb_set(it, func, data, del_cb);
1418 }
1419
1420 EAPI void
1421 elm_object_item_tooltip_unset(Elm_Object_Item *it)
1422 {
1423    elm_widget_item_tooltip_unset(it);
1424 }
1425
1426 EAPI Eina_Bool
1427 elm_object_item_tooltip_window_mode_set(Elm_Object_Item *it, Eina_Bool disable)
1428 {
1429    return elm_widget_item_tooltip_window_mode_set(it, disable);
1430 }
1431
1432 EAPI Eina_Bool
1433 elm_object_item_tooltip_window_mode_get(const Elm_Object_Item *it)
1434 {
1435    return elm_widget_item_tooltip_window_mode_get(it);
1436 }
1437
1438 EAPI void
1439 elm_object_item_tooltip_style_set(Elm_Object_Item *it, const char *style)
1440 {
1441    elm_widget_item_tooltip_style_set(it, style);
1442 }
1443
1444 EAPI const char *
1445 elm_object_item_tooltip_style_get(const Elm_Object_Item *it)
1446 {
1447    return elm_widget_item_tooltip_style_get(it);
1448 }
1449
1450 EAPI void
1451 elm_object_item_cursor_set(Elm_Object_Item *it, const char *cursor)
1452 {
1453    elm_widget_item_cursor_set(it, cursor);
1454 }
1455
1456 EAPI const char *
1457 elm_object_item_cursor_get(const Elm_Object_Item *it)
1458 {
1459    return elm_widget_item_cursor_get(it);
1460 }
1461
1462 EAPI void
1463 elm_object_item_cursor_unset(Elm_Object_Item *it)
1464 {
1465    elm_widget_item_cursor_unset(it);
1466 }
1467
1468 EAPI void
1469 elm_object_item_cursor_style_set(Elm_Object_Item *it, const char *style)
1470 {
1471    elm_widget_item_cursor_style_set(it, style);
1472 }
1473
1474 EAPI const char *
1475 elm_object_item_cursor_style_get(const Elm_Object_Item *it)
1476 {
1477    return elm_widget_item_cursor_style_get(it);
1478 }
1479
1480 EAPI void
1481 elm_object_item_cursor_engine_only_set(Elm_Object_Item *it, Eina_Bool engine_only)
1482 {
1483    elm_widget_item_cursor_engine_only_set(it, engine_only);
1484 }
1485
1486 EAPI Eina_Bool
1487 elm_object_item_cursor_engine_only_get(const Elm_Object_Item *it)
1488 {
1489    return elm_widget_item_cursor_engine_only_get(it);
1490 }