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