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,
 614                         char **argv)
 615 {
 616 #ifdef HAVE_FORK
 617    char *exe;
 618
 619    if (argc <= 0 || argv == NULL) return EINA_FALSE;
 620
 621    exe = elm_quicklaunch_exe_path_get(argv[0]);
 622    if (!exe)
 623      {
 624         ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
 625         return EINA_FALSE;
 626      }
 627    else
 628      {
 629         char *exe2, *p;
 630         char *exename;
 631
 632         exe2 = malloc(strlen(exe) + 1 + 10);
 633         strcpy(exe2, exe);
 634         p = strrchr(exe2, '/');
 635         if (p) p++;
 636         else p = exe2;
 637         exename = alloca(strlen(p) + 1);
 638         strcpy(exename, p);
 639         *p = 0;
 640         strcat(p, "../lib/");
 641         strcat(p, exename);
 642         strcat(p, ".so");
 643         if (!access(exe2, R_OK | X_OK))
 644           {
 645              free(exe);
 646              exe = exe2;
 647           }
 648         else
 649           free(exe2);
 650      }
 651    qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
 652    if (!qr_handle)
 653      {
 654         fprintf(stderr, "dlerr: %s\n", dlerror());
 655         WRN("dlopen('%s') failed: %s", exe, dlerror());
 656         free(exe);
 657         return EINA_FALSE;
 658      }
 659    INF("dlopen('%s') = %p", exe, qr_handle);
 660    qr_main = dlsym(qr_handle, "elm_main");
 661    INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
 662    if (!qr_main)
 663      {
 664         WRN("not quicklauncher capable: no elm_main in '%s'", exe);
 665         dlclose(qr_handle);
 666         qr_handle = NULL;
 667         free(exe);
 668         return EINA_FALSE;
 669      }
 670    free(exe);
 671    return EINA_TRUE;
 672 #else
 673    return EINA_FALSE;
 674    (void)argv;
 675 #endif
 676 }
 677
 678 EAPI Eina_Bool
 679 elm_quicklaunch_fork(int    argc,
 680                      char **argv,
 681                      char  *cwd,
 682                      void (postfork_func) (void *data),
 683                      void  *postfork_data)
 684 {
 685 #ifdef HAVE_FORK
 686    pid_t child;
 687    int ret;
 688
 689    if (!qr_main)
 690      {
 691         int i;
 692         char **args;
 693
 694         child = fork();
 695         if (child > 0) return EINA_TRUE;
 696         else if (child < 0)
 697           {
 698              perror("could not fork");
 699              return EINA_FALSE;
 700           }
 701         setsid();
 702         if (chdir(cwd) != 0) perror("could not chdir");
 703         args = alloca((argc + 1) * sizeof(char *));
 704         for (i = 0; i < argc; i++) args[i] = argv[i];
 705         args[argc] = NULL;
 706         WRN("%s not quicklaunch capable, fallback...", argv[0]);
 707         execvp(argv[0], args);
 708         ERR("failed to execute '%s': %s", argv[0], strerror(errno));
 709         exit(-1);
 710      }
 711    child = fork();
 712    if (child > 0) return EINA_TRUE;
 713    else if (child < 0)
 714      {
 715         perror("could not fork");
 716         return EINA_FALSE;
 717      }
 718    if (postfork_func) postfork_func(postfork_data);
 719
 720    ecore_fork_reset();
 721
 722    if (quicklaunch_on)
 723      {
 724         if (_elm_appname) free(_elm_appname);
 725         _elm_appname = NULL;
 726         if ((argv) && (argv[0]))
 727           _elm_appname = strdup(ecore_file_file_get(argv[0]));
 728
 729 #ifdef SEMI_BROKEN_QUICKLAUNCH
 730         ecore_app_args_set(argc, (const char **)argv);
 731         evas_init();
 732         edje_init();
 733         _elm_module_init();
 734         _elm_config_sub_init();
 735 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 736         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 737             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 738             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 739             ENGINE_COMPARE(ELM_OPENGL_X11))
 740 #undef ENGINE_COMPARE
 741           {
 742 # ifdef HAVE_ELEMENTARY_X
 743              ecore_x_init(NULL);
 744 # endif
 745           }
 746         ecore_evas_init(); // FIXME: check errors
 747 # ifdef HAVE_ELEMENTARY_ECORE_IMF
 748         ecore_imf_init();
 749 # endif
 750 #endif
 751      }
 752
 753    setsid();
 754    if (chdir(cwd) != 0) perror("could not chdir");
 755    ecore_app_args_set(argc, (const char **)argv);
 756    ret = qr_main(argc, argv);
 757    exit(ret);
 758    return EINA_TRUE;
 759 #else
 760    return EINA_FALSE;
 761    (void)argc;
 762    (void)argv;
 763    (void)cwd;
 764    (void)postfork_func;
 765    (void)postfork_data;
 766 #endif
 767 }
 768
 769 EAPI void
 770 elm_quicklaunch_cleanup(void)
 771 {
 772 #ifdef HAVE_FORK
 773    if (qr_handle)
 774      {
 775         dlclose(qr_handle);
 776         qr_handle = NULL;
 777         qr_main = NULL;
 778      }
 779 #endif
 780 }
 781
 782 EAPI int
 783 elm_quicklaunch_fallback(int    argc,
 784                          char **argv)
 785 {
 786    int ret;
 787    elm_quicklaunch_init(argc, argv);
 788    elm_quicklaunch_sub_init(argc, argv);
 789    elm_quicklaunch_prepare(argc, argv);
 790    ret = qr_main(argc, argv);
 791    exit(ret);
 792    return ret;
 793 }
 794
 795 EAPI char *
 796 elm_quicklaunch_exe_path_get(const char *exe)
 797 {
 798    static char *path = NULL;
 799    static Eina_List *pathlist = NULL;
 800    const char *pathitr;
 801    const Eina_List *l;
 802    char buf[PATH_MAX];
 803    if (exe[0] == '/') return strdup(exe);
 804    if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
 805    if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
 806    if (!path)
 807      {
 808         const char *p, *pp;
 809         char *buf2;
 810         path = getenv("PATH");
 811         buf2 = alloca(strlen(path) + 1);
 812         p = path;
 813         pp = p;
 814         for (;; )
 815           {
 816              if ((*p == ':') || (!*p))
 817                {
 818                   int len;
 819
 820                   len = p - pp;
 821                   strncpy(buf2, pp, len);
 822                   buf2[len] = 0;
 823                   pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
 824                   if (!*p) break;
 825                   p++;
 826                   pp = p;
 827                }
 828              else
 829                {
 830                   if (!*p) break;
 831                   p++;
 832                }
 833           }
 834      }
 835    EINA_LIST_FOREACH(pathlist, l, pathitr)
 836      {
 837         snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
 838         if (!access(buf, R_OK | X_OK)) return strdup(buf);
 839      }
 840    return NULL;
 841 }
 842
 843 EAPI void
 844 elm_run(void)
 845 {
 846    ecore_main_loop_begin();
 847 }
 848
 849 EAPI void
 850 elm_exit(void)
 851 {
 852    ecore_main_loop_quit();
 853
 854    if (elm_policy_get(ELM_POLICY_EXIT) == ELM_POLICY_EXIT_WINDOWS_DEL)
 855      {
 856         Eina_List *l, *l_next;
 857         Evas_Object *win;
 858
 859         EINA_LIST_FOREACH_SAFE(_elm_win_list, l, l_next, win)
 860            evas_object_del(win);
 861      }
 862 }
 863
 864 //FIXME: Use Elm_Policy Parameter when 2.0 is released.
 865 EAPI Eina_Bool
 866 elm_policy_set(unsigned int policy,
 867                int          value)
 868 {
 869    Elm_Event_Policy_Changed *ev;
 870
 871    if (policy >= ELM_POLICY_LAST)
 872      return EINA_FALSE;
 873
 874    if (value == _elm_policies[policy])
 875      return EINA_TRUE;
 876
 877    /* TODO: validate policy? */
 878
 879    ev = malloc(sizeof(*ev));
 880    ev->policy = policy;
 881    ev->new_value = value;
 882    ev->old_value = _elm_policies[policy];
 883
 884    _elm_policies[policy] = value;
 885
 886    ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
 887
 888    return EINA_TRUE;
 889 }
 890
 891 //FIXME: Use Elm_Policy Parameter when 2.0 is released.
 892 EAPI int
 893 elm_policy_get(unsigned int policy)
 894 {
 895    if (policy >= ELM_POLICY_LAST)
 896      return 0;
 897    return _elm_policies[policy];
 898 }
 899
 900 EAPI void
 901 elm_language_set(const char *lang)
 902 {
 903    setlocale(LC_ALL, lang);
 904    _elm_win_translate();
 905 }
 906
 907 EAPI Eina_Bool
 908 elm_object_mirrored_get(const Evas_Object *obj)
 909 {
 910    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 911    return elm_widget_mirrored_get(obj);
 912 }
 913
 914 EAPI void
 915 elm_object_mirrored_set(Evas_Object *obj, Eina_Bool mirrored)
 916 {
 917    EINA_SAFETY_ON_NULL_RETURN(obj);
 918    elm_widget_mirrored_set(obj, mirrored);
 919 }
 920
 921 EAPI Eina_Bool
 922 elm_object_mirrored_automatic_get(const Evas_Object *obj)
 923 {
 924    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 925    return elm_widget_mirrored_automatic_get(obj);
 926 }
 927
 928 EAPI void
 929 elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic)
 930 {
 931    EINA_SAFETY_ON_NULL_RETURN(obj);
 932    elm_widget_mirrored_automatic_set(obj, automatic);
 933 }
 934
 935 /**
 936  * @}
 937  */
 938
 939 EAPI void
 940 elm_object_scale_set(Evas_Object *obj,
 941                      double       scale)
 942 {
 943    EINA_SAFETY_ON_NULL_RETURN(obj);
 944    elm_widget_scale_set(obj, scale);
 945 }
 946
 947 EAPI double
 948 elm_object_scale_get(const Evas_Object *obj)
 949 {
 950    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0.0);
 951    return elm_widget_scale_get(obj);
 952 }
 953
 954 EAPI void
 955 elm_object_part_text_set(Evas_Object *obj, const char *part, const char *label)
 956 {
 957    EINA_SAFETY_ON_NULL_RETURN(obj);
 958    elm_widget_text_part_set(obj, part, label);
 959 }
 960
 961 EAPI const char *
 962 elm_object_part_text_get(const Evas_Object *obj, const char *part)
 963 {
 964    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 965    return elm_widget_text_part_get(obj, part);
 966 }
 967
 968 EAPI void
 969 elm_object_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *text)
 970 {
 971    EINA_SAFETY_ON_NULL_RETURN(obj);
 972    elm_widget_domain_translatable_text_part_set(obj, part, domain, text);
 973 }
 974
 975 EAPI const char *
 976 elm_object_translatable_text_part_get(const Evas_Object *obj, const char *part)
 977 {
 978    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 979    return elm_widget_translatable_text_part_get(obj, part);
 980 }
 981
 982 EAPI void
 983 elm_object_part_content_set(Evas_Object *obj, const char *part, Evas_Object *content)
 984 {
 985    EINA_SAFETY_ON_NULL_RETURN(obj);
 986    elm_widget_content_part_set(obj, part, content);
 987 }
 988
 989 EAPI Evas_Object *
 990 elm_object_part_content_get(const Evas_Object *obj, const char *part)
 991 {
 992    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 993    return elm_widget_content_part_get(obj, part);
 994 }
 995
 996 EAPI Evas_Object *
 997 elm_object_part_content_unset(Evas_Object *obj, const char *part)
 998 {
 999    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1000    return elm_widget_content_part_unset(obj, part);
1001 }
1002
1003 EAPI Eina_Bool
1004 elm_object_style_set(Evas_Object *obj,
1005                      const char  *style)
1006 {
1007    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1008    return elm_widget_style_set(obj, style);
1009 }
1010
1011 EAPI const char *
1012 elm_object_style_get(const Evas_Object *obj)
1013 {
1014    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1015    return elm_widget_style_get(obj);
1016 }
1017
1018 EAPI void
1019 elm_object_disabled_set(Evas_Object *obj,
1020                         Eina_Bool    disabled)
1021 {
1022    EINA_SAFETY_ON_NULL_RETURN(obj);
1023    elm_widget_disabled_set(obj, disabled);
1024 }
1025
1026 EAPI Eina_Bool
1027 elm_object_disabled_get(const Evas_Object *obj)
1028 {
1029    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1030    return elm_widget_disabled_get(obj);
1031 }
1032
1033 EAPI void
1034 elm_cache_all_flush(void)
1035 {
1036    const Eina_List *l;
1037    Evas_Object *obj;
1038
1039    edje_file_cache_flush();
1040    edje_collection_cache_flush();
1041    eet_clearcache();
1042    EINA_LIST_FOREACH(_elm_win_list, l, obj)
1043      {
1044         Evas *e = evas_object_evas_get(obj);
1045         evas_image_cache_flush(e);
1046         evas_font_cache_flush(e);
1047         evas_render_dump(e);
1048      }
1049 }
1050
1051 EAPI Eina_Bool
1052 elm_object_focus_get(const Evas_Object *obj)
1053 {
1054    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1055    return elm_widget_focus_get(obj);
1056 }
1057
1058 EAPI void
1059 elm_object_focus_set(Evas_Object *obj,
1060                      Eina_Bool    focus)
1061 {
1062    EINA_SAFETY_ON_NULL_RETURN(obj);
1063
1064    if (elm_widget_is(obj))
1065      {
1066         const char *type;
1067
1068         if (focus == elm_widget_focus_get(obj)) return;
1069
1070         // ugly, but, special case for inlined windows
1071         type = evas_object_type_get(obj);
1072         if ((type) && (!strcmp(type, "elm_win")))
1073           {
1074              Evas_Object *inlined = elm_win_inlined_image_object_get(obj);
1075
1076              if (inlined)
1077                {
1078                   evas_object_focus_set(inlined, focus);
1079                   return;
1080                }
1081           }
1082         if (focus)
1083           elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
1084         else
1085           elm_widget_focused_object_clear(obj);
1086      }
1087    else
1088      {
1089         evas_object_focus_set(obj, focus);
1090      }
1091 }
1092
1093 EAPI void
1094 elm_object_focus_allow_set(Evas_Object *obj,
1095                            Eina_Bool    enable)
1096 {
1097    EINA_SAFETY_ON_NULL_RETURN(obj);
1098    elm_widget_can_focus_set(obj, enable);
1099 /*FIXME: According to the elm_object_focus_allow_get(), child_can_focus field
1100 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() */
1101 }
1102
1103 EAPI Eina_Bool
1104 elm_object_focus_allow_get(const Evas_Object *obj)
1105 {
1106    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1107    return (elm_widget_can_focus_get(obj)) || (elm_widget_child_can_focus_get(obj));
1108 }
1109
1110 EAPI void
1111 elm_object_focus_custom_chain_set(Evas_Object *obj,
1112                                   Eina_List   *objs)
1113 {
1114    EINA_SAFETY_ON_NULL_RETURN(obj);
1115    elm_widget_focus_custom_chain_set(obj, objs);
1116 }
1117
1118 EAPI void
1119 elm_object_focus_custom_chain_unset(Evas_Object *obj)
1120 {
1121    EINA_SAFETY_ON_NULL_RETURN(obj);
1122    elm_widget_focus_custom_chain_unset(obj);
1123 }
1124
1125 EAPI const Eina_List *
1126 elm_object_focus_custom_chain_get(const Evas_Object *obj)
1127 {
1128    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1129    return elm_widget_focus_custom_chain_get(obj);
1130 }
1131
1132 EAPI void
1133 elm_object_focus_custom_chain_append(Evas_Object *obj,
1134                                      Evas_Object *child,
1135                                      Evas_Object *relative_child)
1136 {
1137    EINA_SAFETY_ON_NULL_RETURN(obj);
1138    elm_widget_focus_custom_chain_append(obj, child, relative_child);
1139 }
1140
1141 EAPI void
1142 elm_object_focus_custom_chain_prepend(Evas_Object *obj,
1143                                       Evas_Object *child,
1144                                       Evas_Object *relative_child)
1145 {
1146    EINA_SAFETY_ON_NULL_RETURN(obj);
1147    elm_widget_focus_custom_chain_prepend(obj, child, relative_child);
1148 }
1149
1150 EINA_DEPRECATED EAPI void
1151 elm_object_focus_cycle(Evas_Object        *obj,
1152                        Elm_Focus_Direction dir)
1153 {
1154    elm_object_focus_next(obj, dir);
1155 }
1156
1157 EAPI void
1158 elm_object_focus_next(Evas_Object        *obj,
1159                       Elm_Focus_Direction dir)
1160 {
1161    EINA_SAFETY_ON_NULL_RETURN(obj);
1162    elm_widget_focus_cycle(obj, dir);
1163 }
1164
1165 EAPI void
1166 elm_object_tree_focus_allow_set(Evas_Object *obj,
1167                                 Eina_Bool    tree_focusable)
1168 {
1169    EINA_SAFETY_ON_NULL_RETURN(obj);
1170    elm_widget_tree_unfocusable_set(obj, !tree_focusable);
1171 }
1172
1173 EAPI Eina_Bool
1174 elm_object_tree_focus_allow_get(const Evas_Object *obj)
1175 {
1176    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1177    return !elm_widget_tree_unfocusable_get(obj);
1178 }
1179
1180 EAPI void
1181 elm_object_scroll_hold_push(Evas_Object *obj)
1182 {
1183    EINA_SAFETY_ON_NULL_RETURN(obj);
1184    elm_widget_scroll_hold_push(obj);
1185 }
1186
1187 EAPI void
1188 elm_object_scroll_hold_pop(Evas_Object *obj)
1189 {
1190    EINA_SAFETY_ON_NULL_RETURN(obj);
1191    elm_widget_scroll_hold_pop(obj);
1192 }
1193
1194 EAPI int
1195 elm_object_scroll_hold_get(const Evas_Object *obj)
1196 {
1197    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0);
1198    return elm_widget_scroll_hold_get(obj);
1199 }
1200
1201 EAPI void
1202 elm_object_scroll_freeze_push(Evas_Object *obj)
1203 {
1204    EINA_SAFETY_ON_NULL_RETURN(obj);
1205    elm_widget_scroll_freeze_push(obj);
1206 }
1207
1208 EAPI void
1209 elm_object_scroll_freeze_pop(Evas_Object *obj)
1210 {
1211    EINA_SAFETY_ON_NULL_RETURN(obj);
1212    elm_widget_scroll_freeze_pop(obj);
1213 }
1214
1215 EAPI int
1216 elm_object_scroll_freeze_get(const Evas_Object *obj)
1217 {
1218    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0);
1219    return elm_widget_scroll_freeze_get(obj);
1220 }
1221
1222 EAPI void
1223 elm_object_scroll_lock_x_set(Evas_Object *obj,
1224                              Eina_Bool    lock)
1225 {
1226    EINA_SAFETY_ON_NULL_RETURN(obj);
1227    elm_widget_drag_lock_x_set(obj, lock);
1228 }
1229
1230 EAPI void
1231 elm_object_scroll_lock_y_set(Evas_Object *obj,
1232                              Eina_Bool    lock)
1233 {
1234    EINA_SAFETY_ON_NULL_RETURN(obj);
1235    elm_widget_drag_lock_y_set(obj, lock);
1236 }
1237
1238 EAPI Eina_Bool
1239 elm_object_scroll_lock_x_get(const Evas_Object *obj)
1240 {
1241    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1242    return elm_widget_drag_lock_x_get(obj);
1243 }
1244
1245 EAPI Eina_Bool
1246 elm_object_scroll_lock_y_get(const Evas_Object *obj)
1247 {
1248    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1249    return elm_widget_drag_lock_y_get(obj);
1250 }
1251
1252 EAPI Eina_Bool
1253 elm_object_widget_check(const Evas_Object *obj)
1254 {
1255    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1256    return elm_widget_is(obj);
1257 }
1258
1259 EAPI Evas_Object *
1260 elm_object_parent_widget_get(const Evas_Object *obj)
1261 {
1262    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1263    return elm_widget_parent_widget_get(obj);
1264 }
1265
1266 EAPI Evas_Object *
1267 elm_object_top_widget_get(const Evas_Object *obj)
1268 {
1269    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1270    return elm_widget_top_get(obj);
1271 }
1272
1273 EAPI const char *
1274 elm_object_widget_type_get(const Evas_Object *obj)
1275 {
1276    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1277    return elm_widget_type_get(obj);
1278 }
1279
1280 EAPI void
1281 elm_object_signal_emit(Evas_Object *obj,
1282                        const char  *emission,
1283                        const char  *source)
1284 {
1285    EINA_SAFETY_ON_NULL_RETURN(obj);
1286    elm_widget_signal_emit(obj, emission, source);
1287 }
1288
1289 EAPI void
1290 elm_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
1291 {
1292     EINA_SAFETY_ON_NULL_RETURN(obj);
1293     EINA_SAFETY_ON_NULL_RETURN(func);
1294     elm_widget_signal_callback_add(obj, emission, source, func, data);
1295 }
1296
1297 EAPI void *
1298 elm_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func)
1299 {
1300     EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1301     EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
1302     return elm_widget_signal_callback_del(obj, emission, source, func);
1303 }
1304
1305 EAPI void
1306 elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data)
1307 {
1308    EINA_SAFETY_ON_NULL_RETURN(obj);
1309    EINA_SAFETY_ON_NULL_RETURN(func);
1310    elm_widget_event_callback_add(obj, func, data);
1311 }
1312
1313 EAPI void *
1314 elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data)
1315 {
1316    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1317    EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
1318    return elm_widget_event_callback_del(obj, func, data);
1319 }
1320
1321 EAPI void
1322 elm_object_tree_dump(const Evas_Object *top)
1323 {
1324 #ifdef ELM_DEBUG
1325    elm_widget_tree_dump(top);
1326 #else
1327    (void)top;
1328    return;
1329 #endif
1330 }
1331
1332 EAPI void
1333 elm_object_tree_dot_dump(const Evas_Object *top,
1334                          const char        *file)
1335 {
1336 #ifdef ELM_DEBUG
1337    FILE *f = fopen(file, "wb");
1338    elm_widget_tree_dot_dump(top, f);
1339    fclose(f);
1340 #else
1341    (void)top;
1342    (void)file;
1343    return;
1344 #endif
1345 }
1346
1347 EAPI void
1348 elm_coords_finger_size_adjust(int times_w,
1349                               Evas_Coord *w,
1350                               int times_h,
1351                               Evas_Coord *h)
1352 {
1353    if ((w) && (*w < (elm_config_finger_size_get() * times_w)))
1354      *w = elm_config_finger_size_get() * times_w;
1355    if ((h) && (*h < (elm_config_finger_size_get() * times_h)))
1356      *h = elm_config_finger_size_get() * times_h;
1357 }
1358
1359 EAPI Evas_Object *
1360 elm_object_item_widget_get(const Elm_Object_Item *it)
1361 {
1362    return elm_widget_item_widget_get(it);
1363 }
1364
1365 EAPI void
1366 elm_object_item_part_content_set(Elm_Object_Item *it,
1367                                  const char *part,
1368                                  Evas_Object *content)
1369 {
1370    _elm_widget_item_part_content_set((Elm_Widget_Item *)it, part, content);
1371 }
1372
1373 EAPI Evas_Object *
1374 elm_object_item_part_content_get(const Elm_Object_Item *it,
1375                                  const char *part)
1376 {
1377    return _elm_widget_item_part_content_get((Elm_Widget_Item *)it, part);
1378 }
1379
1380 EAPI Evas_Object *
1381 elm_object_item_part_content_unset(Elm_Object_Item *it, const char *part)
1382 {
1383    return _elm_widget_item_part_content_unset((Elm_Widget_Item *)it, part);
1384 }
1385
1386 EAPI void
1387 elm_object_item_part_text_set(Elm_Object_Item *it,
1388                               const char *part,
1389                               const char *label)
1390 {
1391    _elm_widget_item_part_text_set((Elm_Widget_Item *)it, part, label);
1392 }
1393
1394 EAPI const char *
1395 elm_object_item_part_text_get(const Elm_Object_Item *it, const char *part)
1396 {
1397    return _elm_widget_item_part_text_get((Elm_Widget_Item *)it, part);
1398 }
1399
1400 EAPI void
1401 elm_object_access_info_set(Evas_Object *obj, const char *txt)
1402 {
1403    elm_widget_access_info_set(obj, txt);
1404 }
1405
1406 EAPI Evas_Object *
1407 elm_object_name_find(const Evas_Object *obj, const char *name, int recurse)
1408 {
1409    return elm_widget_name_find(obj, name, recurse);
1410 }
1411
1412 EAPI void
1413 elm_object_orientation_mode_disabled_set(Evas_Object *obj, Eina_Bool disabled)
1414 {
1415    elm_widget_orientation_mode_disabled_set(obj, disabled);
1416 }
1417
1418 EAPI Eina_Bool
1419 elm_object_orientation_mode_disabled_get(const Evas_Object *obj)
1420 {
1421    return elm_widget_orientation_mode_disabled_get(obj);
1422 }
1423
1424 EAPI void
1425 elm_object_item_access_info_set(Elm_Object_Item *it, const char *txt)
1426 {
1427    _elm_widget_item_access_info_set((Elm_Widget_Item *)it, txt);
1428 }
1429
1430 EAPI Evas_Object *
1431 elm_object_item_access_register(Elm_Object_Item *item)
1432 {
1433    Elm_Widget_Item *it;
1434
1435    it = (Elm_Widget_Item *)item;
1436
1437    _elm_access_widget_item_register(it);
1438
1439    if (it) return it->access_obj;
1440    return NULL;
1441 }
1442
1443 EAPI void
1444 elm_object_item_access_unregister(Elm_Object_Item *item)
1445 {
1446    _elm_access_widget_item_unregister((Elm_Widget_Item *)item);
1447 }
1448
1449 EAPI Evas_Object *
1450 elm_object_item_access_object_get(const Elm_Object_Item *item)
1451 {
1452    if (!item) return NULL;
1453    return ((Elm_Widget_Item *)item)->access_obj;
1454 }
1455
1456 EAPI void
1457 elm_object_item_access_order_set(Elm_Object_Item *item, Eina_List *objs)
1458 {
1459    _elm_access_widget_item_access_order_set((Elm_Widget_Item *)item, objs);
1460 }
1461
1462 EAPI const Eina_List *
1463 elm_object_item_access_order_get(const Elm_Object_Item *item)
1464 {
1465    return _elm_access_widget_item_access_order_get((Elm_Widget_Item *)item);
1466 }
1467
1468 EAPI void
1469 elm_object_item_access_order_unset(Elm_Object_Item *item)
1470 {
1471    _elm_access_widget_item_access_order_unset((Elm_Widget_Item *)item);
1472 }
1473
1474 EAPI void *
1475 elm_object_item_data_get(const Elm_Object_Item *it)
1476 {
1477    return elm_widget_item_data_get(it);
1478 }
1479
1480 EAPI void
1481 elm_object_item_data_set(Elm_Object_Item *it, void *data)
1482 {
1483    elm_widget_item_data_set(it, data);
1484 }
1485
1486 EAPI void
1487 elm_object_item_signal_emit(Elm_Object_Item *it, const char *emission, const char *source)
1488 {
1489    _elm_widget_item_signal_emit((Elm_Widget_Item *)it, emission, source);
1490 }
1491
1492 EAPI void elm_object_item_disabled_set(Elm_Object_Item *it, Eina_Bool disabled)
1493 {
1494    _elm_widget_item_disabled_set((Elm_Widget_Item *)it, disabled);
1495 }
1496
1497 EAPI Eina_Bool elm_object_item_disabled_get(const Elm_Object_Item *it)
1498 {
1499    return _elm_widget_item_disabled_get((Elm_Widget_Item *)it);
1500 }
1501
1502 EAPI void elm_object_item_del_cb_set(Elm_Object_Item *it, Evas_Smart_Cb del_cb)
1503 {
1504    _elm_widget_item_del_cb_set((Elm_Widget_Item *)it, del_cb);
1505 }
1506
1507 EAPI void elm_object_item_del(Elm_Object_Item *it)
1508 {
1509    _elm_widget_item_del((Elm_Widget_Item *)it);
1510 }
1511
1512 EAPI void
1513 elm_object_item_tooltip_text_set(Elm_Object_Item *it, const char *text)
1514 {
1515    elm_widget_item_tooltip_text_set(it, text);
1516 }
1517
1518 EAPI void
1519 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)
1520 {
1521    elm_widget_item_tooltip_content_cb_set(it, func, data, del_cb);
1522 }
1523
1524 EAPI void
1525 elm_object_item_tooltip_unset(Elm_Object_Item *it)
1526 {
1527    elm_widget_item_tooltip_unset(it);
1528 }
1529
1530 EAPI Eina_Bool
1531 elm_object_item_tooltip_window_mode_set(Elm_Object_Item *it, Eina_Bool disable)
1532 {
1533    return elm_widget_item_tooltip_window_mode_set(it, disable);
1534 }
1535
1536 EAPI Eina_Bool
1537 elm_object_item_tooltip_window_mode_get(const Elm_Object_Item *it)
1538 {
1539    return elm_widget_item_tooltip_window_mode_get(it);
1540 }
1541
1542 EAPI void
1543 elm_object_item_tooltip_style_set(Elm_Object_Item *it, const char *style)
1544 {
1545    elm_widget_item_tooltip_style_set(it, style);
1546 }
1547
1548 EAPI const char *
1549 elm_object_item_tooltip_style_get(const Elm_Object_Item *it)
1550 {
1551    return elm_widget_item_tooltip_style_get(it);
1552 }
1553
1554 EAPI void
1555 elm_object_item_cursor_set(Elm_Object_Item *it, const char *cursor)
1556 {
1557    elm_widget_item_cursor_set(it, cursor);
1558 }
1559
1560 EAPI const char *
1561 elm_object_item_cursor_get(const Elm_Object_Item *it)
1562 {
1563    return elm_widget_item_cursor_get(it);
1564 }
1565
1566 EAPI void
1567 elm_object_item_cursor_unset(Elm_Object_Item *it)
1568 {
1569    elm_widget_item_cursor_unset(it);
1570 }
1571
1572 EAPI void
1573 elm_object_item_cursor_style_set(Elm_Object_Item *it, const char *style)
1574 {
1575    elm_widget_item_cursor_style_set(it, style);
1576 }
1577
1578 EAPI const char *
1579 elm_object_item_cursor_style_get(const Elm_Object_Item *it)
1580 {
1581    return elm_widget_item_cursor_style_get(it);
1582 }
1583
1584 EAPI void
1585 elm_object_item_cursor_engine_only_set(Elm_Object_Item *it, Eina_Bool engine_only)
1586 {
1587    elm_widget_item_cursor_engine_only_set(it, engine_only);
1588 }
1589
1590 EAPI Eina_Bool
1591 elm_object_item_cursor_engine_only_get(const Elm_Object_Item *it)
1592 {
1593    return elm_widget_item_cursor_engine_only_get(it);
1594 }