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