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    _elm_config_init();
 405    return _elm_ql_init_count;
 406 }
 407
 408 EAPI int
 409 elm_quicklaunch_sub_init(int    argc,
 410                          char **argv)
 411 {
 412    _elm_sub_init_count++;
 413    if (_elm_sub_init_count > 1) return _elm_sub_init_count;
 414    if (quicklaunch_on)
 415      {
 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_sub_init();
 427         ecore_evas_init(); // FIXME: check errors
 428 #ifdef HAVE_ELEMENTARY_ECORE_IMF
 429         ecore_imf_init();
 430 #endif
 431 #ifdef HAVE_ELEMENTARY_ECORE_CON
 432         ecore_con_init();
 433         ecore_con_url_init();
 434 #endif
 435         _elm_ews_wm_init();
 436      }
 437    return _elm_sub_init_count;
 438 }
 439
 440 EAPI int
 441 elm_quicklaunch_sub_shutdown(void)
 442 {
 443    _elm_sub_init_count--;
 444    if (_elm_sub_init_count > 0) return _elm_sub_init_count;
 445    if (quicklaunch_on)
 446      {
 447 #ifdef SEMI_BROKEN_QUICKLAUNCH
 448         return _elm_sub_init_count;
 449 #endif
 450      }
 451    if (!quicklaunch_on)
 452      {
 453         _elm_win_shutdown();
 454         _elm_module_shutdown();
 455         _elm_ews_wm_shutdown();
 456 #ifdef HAVE_ELEMENTARY_ECORE_CON
 457         ecore_con_url_shutdown();
 458         ecore_con_shutdown();
 459 #endif
 460 #ifdef HAVE_ELEMENTARY_ECORE_IMF
 461         ecore_imf_shutdown();
 462 #endif
 463         ecore_evas_shutdown();
 464         _elm_config_sub_shutdown();
 465 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 466         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 467             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 468             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 469             ENGINE_COMPARE(ELM_OPENGL_X11) ||
 470             ENGINE_COMPARE(ELM_SOFTWARE_SDL) ||
 471             ENGINE_COMPARE(ELM_SOFTWARE_16_SDL) ||
 472             ENGINE_COMPARE(ELM_OPENGL_SDL) ||
 473             ENGINE_COMPARE(ELM_OPENGL_COCOA) ||
 474             ENGINE_COMPARE(ELM_SOFTWARE_WIN32) ||
 475             ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE) ||
 476             ENGINE_COMPARE(ELM_EWS))
 477 #undef ENGINE_COMPARE
 478           evas_cserve_disconnect();
 479         edje_shutdown();
 480         evas_shutdown();
 481      }
 482    return _elm_sub_init_count;
 483 }
 484
 485 EAPI int
 486 elm_quicklaunch_shutdown(void)
 487 {
 488    _elm_ql_init_count--;
 489    if (_elm_ql_init_count > 0) return _elm_ql_init_count;
 490    if (pfx) eina_prefix_free(pfx);
 491    pfx = NULL;
 492    eina_stringshare_del(_elm_data_dir);
 493    _elm_data_dir = NULL;
 494    eina_stringshare_del(_elm_lib_dir);
 495    _elm_lib_dir = NULL;
 496
 497    free(_elm_appname);
 498    _elm_appname = NULL;
 499
 500    _elm_config_shutdown();
 501
 502    ecore_event_handler_del(_elm_exit_handler);
 503    _elm_exit_handler = NULL;
 504
 505    _elm_theme_shutdown();
 506    _elm_unneed_efreet();
 507    _elm_unneed_e_dbus();
 508    _elm_unneed_ethumb();
 509    _elm_unneed_web();
 510    ecore_file_shutdown();
 511
 512 #ifdef HAVE_ELEMENTARY_EMAP
 513    emap_shutdown();
 514 #endif
 515
 516    ecore_shutdown();
 517    eet_shutdown();
 518
 519    if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
 520      {
 521         eina_log_domain_unregister(_elm_log_dom);
 522         _elm_log_dom = -1;
 523      }
 524
 525    _elm_widget_type_clear();
 526
 527    eina_shutdown();
 528    return _elm_ql_init_count;
 529 }
 530
 531 EAPI void
 532 elm_quicklaunch_seed(void)
 533 {
 534 #ifndef SEMI_BROKEN_QUICKLAUNCH
 535    if (quicklaunch_on)
 536      {
 537         Evas_Object *win, *bg, *bt;
 538
 539         win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
 540         bg = elm_bg_add(win);
 541         elm_win_resize_object_add(win, bg);
 542         evas_object_show(bg);
 543         bt = elm_button_add(win);
 544         elm_button_label_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
 545         elm_win_resize_object_add(win, bt);
 546         ecore_main_loop_iterate();
 547         evas_object_del(win);
 548         ecore_main_loop_iterate();
 549 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 550         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 551             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 552             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 553             ENGINE_COMPARE(ELM_OPENGL_X11))
 554 #undef ENGINE_COMPARE
 555           {
 556 # ifdef HAVE_ELEMENTARY_X
 557              ecore_x_sync();
 558 # endif
 559           }
 560         ecore_main_loop_iterate();
 561      }
 562 #endif
 563 }
 564
 565 #ifdef HAVE_FORK
 566 static void *qr_handle = NULL;
 567 #endif
 568 static int (*qr_main)(int    argc,
 569                       char **argv) = NULL;
 570
 571 EAPI Eina_Bool
 572 elm_quicklaunch_prepare(int argc __UNUSED__,
 573                         char   **argv)
 574 {
 575 #ifdef HAVE_FORK
 576    char *exe = elm_quicklaunch_exe_path_get(argv[0]);
 577    if (!exe)
 578      {
 579         ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
 580         return EINA_FALSE;
 581      }
 582    else
 583      {
 584         char *exe2, *p;
 585         char *exename;
 586
 587         exe2 = malloc(strlen(exe) + 1 + 10);
 588         strcpy(exe2, exe);
 589         p = strrchr(exe2, '/');
 590         if (p) p++;
 591         else p = exe2;
 592         exename = alloca(strlen(p) + 1);
 593         strcpy(exename, p);
 594         *p = 0;
 595         strcat(p, "../lib/");
 596         strcat(p, exename);
 597         strcat(p, ".so");
 598         if (!access(exe2, R_OK | X_OK))
 599           {
 600              free(exe);
 601              exe = exe2;
 602           }
 603         else
 604           free(exe2);
 605      }
 606    qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
 607    if (!qr_handle)
 608      {
 609         fprintf(stderr, "dlerr: %s\n", dlerror());
 610         WRN("dlopen('%s') failed: %s", exe, dlerror());
 611         free(exe);
 612         return EINA_FALSE;
 613      }
 614    INF("dlopen('%s') = %p", exe, qr_handle);
 615    qr_main = dlsym(qr_handle, "elm_main");
 616    INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
 617    if (!qr_main)
 618      {
 619         WRN("not quicklauncher capable: no elm_main in '%s'", exe);
 620         dlclose(qr_handle);
 621         qr_handle = NULL;
 622         free(exe);
 623         return EINA_FALSE;
 624      }
 625    free(exe);
 626    return EINA_TRUE;
 627 #else
 628    return EINA_FALSE;
 629    (void)argv;
 630 #endif
 631 }
 632
 633 #ifdef HAVE_FORK
 634 static void
 635 save_env(void)
 636 {
 637    int i, size;
 638    extern char **environ;
 639    char **oldenv, **p;
 640
 641    oldenv = environ;
 642
 643    for (i = 0, size = 0; environ[i]; i++)
 644      size += strlen(environ[i]) + 1;
 645
 646    p = malloc((i + 1) * sizeof(char *));
 647    if (!p) return;
 648
 649    environ = p;
 650
 651    for (i = 0; oldenv[i]; i++)
 652      environ[i] = strdup(oldenv[i]);
 653    environ[i] = NULL;
 654 }
 655
 656 #endif
 657
 658 EAPI Eina_Bool
 659 elm_quicklaunch_fork(int    argc,
 660                      char **argv,
 661                      char  *cwd,
 662                      void (postfork_func) (void *data),
 663                      void  *postfork_data)
 664 {
 665 #ifdef HAVE_FORK
 666    pid_t child;
 667    int ret;
 668    int real_argc;
 669    char **real_argv;
 670
 671    // FIXME:
 672    // need to accept current environment from elementary_run
 673    if (!qr_main)
 674      {
 675         int i;
 676         char **args;
 677
 678         child = fork();
 679         if (child > 0) return EINA_TRUE;
 680         else if (child < 0)
 681           {
 682              perror("could not fork");
 683              return EINA_FALSE;
 684           }
 685         setsid();
 686         if (chdir(cwd) != 0)
 687           perror("could not chdir");
 688         args = alloca((argc + 1) * sizeof(char *));
 689         for (i = 0; i < argc; i++) args[i] = argv[i];
 690         args[argc] = NULL;
 691         WRN("%s not quicklaunch capable, fallback...", argv[0]);
 692         execvp(argv[0], args);
 693         ERR("failed to execute '%s': %s", argv[0], strerror(errno));
 694         exit(-1);
 695      }
 696    child = fork();
 697    if (child > 0) return EINA_TRUE;
 698    else if (child < 0)
 699      {
 700         perror("could not fork");
 701         return EINA_FALSE;
 702      }
 703    if (postfork_func) postfork_func(postfork_data);
 704
 705    if (quicklaunch_on)
 706      {
 707 #ifdef SEMI_BROKEN_QUICKLAUNCH
 708         ecore_app_args_set(argc, (const char **)argv);
 709         evas_init();
 710         edje_init();
 711         _elm_config_sub_init();
 712 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 713         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 714             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 715             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 716             ENGINE_COMPARE(ELM_OPENGL_X11))
 717 #undef ENGINE_COMPARE
 718           {
 719 # ifdef HAVE_ELEMENTARY_X
 720              ecore_x_init(NULL);
 721 # endif
 722           }
 723         ecore_evas_init(); // FIXME: check errors
 724         ecore_imf_init();
 725         _elm_module_init();
 726 #endif
 727      }
 728
 729    setsid();
 730    if (chdir(cwd) != 0)
 731      perror("could not chdir");
 732    // FIXME: this is very linux specific. it changes argv[0] of the process
 733    // so ps etc. report what you'd expect. for other unixes and os's this
 734    // may just not work
 735    save_env();
 736    if (argv)
 737      {
 738         char *lastarg, *p;
 739
 740         ecore_app_args_get(&real_argc, &real_argv);
 741         lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
 742         for (p = real_argv[0]; p < lastarg; p++) *p = 0;
 743         strcpy(real_argv[0], argv[0]);
 744      }
 745    ecore_app_args_set(argc, (const char **)argv);
 746    ret = qr_main(argc, argv);
 747    exit(ret);
 748    return EINA_TRUE;
 749 #else
 750    return EINA_FALSE;
 751    (void)argc;
 752    (void)argv;
 753    (void)cwd;
 754    (void)postfork_func;
 755    (void)postfork_data;
 756 #endif
 757 }
 758
 759 EAPI void
 760 elm_quicklaunch_cleanup(void)
 761 {
 762 #ifdef HAVE_FORK
 763    if (qr_handle)
 764      {
 765         dlclose(qr_handle);
 766         qr_handle = NULL;
 767         qr_main = NULL;
 768      }
 769 #endif
 770 }
 771
 772 EAPI int
 773 elm_quicklaunch_fallback(int    argc,
 774                          char **argv)
 775 {
 776    int ret;
 777    elm_quicklaunch_init(argc, argv);
 778    elm_quicklaunch_sub_init(argc, argv);
 779    elm_quicklaunch_prepare(argc, argv);
 780    ret = qr_main(argc, argv);
 781    exit(ret);
 782    return ret;
 783 }
 784
 785 EAPI char *
 786 elm_quicklaunch_exe_path_get(const char *exe)
 787 {
 788    static char *path = NULL;
 789    static Eina_List *pathlist = NULL;
 790    const char *pathitr;
 791    const Eina_List *l;
 792    char buf[PATH_MAX];
 793    if (exe[0] == '/') return strdup(exe);
 794    if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
 795    if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
 796    if (!path)
 797      {
 798         const char *p, *pp;
 799         char *buf2;
 800         path = getenv("PATH");
 801         buf2 = alloca(strlen(path) + 1);
 802         p = path;
 803         pp = p;
 804         for (;; )
 805           {
 806              if ((*p == ':') || (!*p))
 807                {
 808                   int len;
 809
 810                   len = p - pp;
 811                   strncpy(buf2, pp, len);
 812                   buf2[len] = 0;
 813                   pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
 814                   if (!*p) break;
 815                   p++;
 816                   pp = p;
 817                }
 818              else
 819                {
 820                   if (!*p) break;
 821                   p++;
 822                }
 823           }
 824      }
 825    EINA_LIST_FOREACH(pathlist, l, pathitr)
 826      {
 827         snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
 828         if (!access(buf, R_OK | X_OK)) return strdup(buf);
 829      }
 830    return NULL;
 831 }
 832
 833 EAPI void
 834 elm_run(void)
 835 {
 836    ecore_main_loop_begin();
 837 }
 838
 839 EAPI void
 840 elm_exit(void)
 841 {
 842    ecore_main_loop_quit();
 843 }
 844
 845 EAPI Eina_Bool
 846 elm_policy_set(unsigned int policy,
 847                int          value)
 848 {
 849    Elm_Event_Policy_Changed *ev;
 850
 851    if (policy >= ELM_POLICY_LAST)
 852      return EINA_FALSE;
 853
 854    if (value == _elm_policies[policy])
 855      return EINA_TRUE;
 856
 857    /* TODO: validade policy? */
 858
 859    ev = malloc(sizeof(*ev));
 860    ev->policy = policy;
 861    ev->new_value = value;
 862    ev->old_value = _elm_policies[policy];
 863
 864    _elm_policies[policy] = value;
 865
 866    ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
 867
 868    return EINA_TRUE;
 869 }
 870
 871 EAPI int
 872 elm_policy_get(unsigned int policy)
 873 {
 874    if (policy >= ELM_POLICY_LAST)
 875      return 0;
 876    return _elm_policies[policy];
 877 }
 878
 879 EAPI void
 880 elm_language_set(const char *lang)
 881 {
 882    setlocale(LC_ALL, lang);
 883    _elm_win_translate();
 884 }
 885
 886 EAPI Eina_Bool
 887 elm_object_mirrored_get(const Evas_Object *obj)
 888 {
 889    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 890    return elm_widget_mirrored_get(obj);
 891 }
 892
 893 EAPI void
 894 elm_object_mirrored_set(Evas_Object *obj, Eina_Bool mirrored)
 895 {
 896    EINA_SAFETY_ON_NULL_RETURN(obj);
 897    elm_widget_mirrored_set(obj, mirrored);
 898 }
 899
 900 EAPI Eina_Bool
 901 elm_object_mirrored_automatic_get(const Evas_Object *obj)
 902 {
 903    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 904    return elm_widget_mirrored_automatic_get(obj);
 905 }
 906
 907 EAPI void
 908 elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic)
 909 {
 910    EINA_SAFETY_ON_NULL_RETURN(obj);
 911    elm_widget_mirrored_automatic_set(obj, automatic);
 912 }
 913
 914 /**
 915  * @}
 916  */
 917
 918 EAPI void
 919 elm_object_scale_set(Evas_Object *obj,
 920                      double       scale)
 921 {
 922    EINA_SAFETY_ON_NULL_RETURN(obj);
 923    elm_widget_scale_set(obj, scale);
 924 }
 925
 926 EAPI double
 927 elm_object_scale_get(const Evas_Object *obj)
 928 {
 929    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0.0);
 930    return elm_widget_scale_get(obj);
 931 }
 932
 933 EAPI void
 934 elm_object_text_part_set(Evas_Object *obj, const char *part, const char *label)
 935 {
 936    EINA_SAFETY_ON_NULL_RETURN(obj);
 937    elm_widget_text_part_set(obj, part, label);
 938 }
 939
 940 EAPI const char *
 941 elm_object_text_part_get(const Evas_Object *obj, const char *part)
 942 {
 943    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 944    return elm_widget_text_part_get(obj, part);
 945 }
 946
 947 EAPI void
 948 elm_object_part_text_set(Evas_Object *obj, const char *part, const char *label)
 949 {
 950    EINA_SAFETY_ON_NULL_RETURN(obj);
 951    elm_widget_text_part_set(obj, part, label);
 952 }
 953
 954 EAPI const char *
 955 elm_object_part_text_get(const Evas_Object *obj, const char *part)
 956 {
 957    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 958    return elm_widget_text_part_get(obj, part);
 959 }
 960
 961 EAPI void
 962 elm_object_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *text)
 963 {
 964    EINA_SAFETY_ON_NULL_RETURN(obj);
 965    elm_widget_domain_translatable_text_part_set(obj, part, domain, text);
 966 }
 967
 968 EAPI const char *
 969 elm_object_translatable_text_part_get(const Evas_Object *obj, const char *part)
 970 {
 971    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 972    return elm_widget_translatable_text_part_get(obj, part);
 973 }
 974
 975 EAPI void
 976 elm_object_part_content_set(Evas_Object *obj, const char *part, Evas_Object *content)
 977 {
 978    EINA_SAFETY_ON_NULL_RETURN(obj);
 979    elm_widget_content_part_set(obj, part, content);
 980 }
 981
 982 EAPI void
 983 elm_object_content_part_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
 990 EAPI Evas_Object *
 991 elm_object_part_content_get(const Evas_Object *obj, const char *part)
 992 {
 993    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 994    return elm_widget_content_part_get(obj, part);
 995 }
 996
 997 EAPI Evas_Object *
 998 elm_object_content_part_get(const Evas_Object *obj, const char *part)
 999 {
1000    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1001    return elm_widget_content_part_get(obj, part);
1002 }
1003
1004 EAPI Evas_Object *
1005 elm_object_part_content_unset(Evas_Object *obj, const char *part)
1006 {
1007    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1008    return elm_widget_content_part_unset(obj, part);
1009 }
1010
1011
1012 EAPI Evas_Object *
1013 elm_object_content_part_unset(Evas_Object *obj, const char *part)
1014 {
1015    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1016    return elm_widget_content_part_unset(obj, part);
1017 }
1018
1019 EAPI double
1020 elm_scale_get(void)
1021 {
1022    return _elm_config->scale;
1023 }
1024
1025 EAPI void
1026 elm_scale_set(double scale)
1027 {
1028    if (_elm_config->scale == scale) return;
1029    _elm_config->scale = scale;
1030    _elm_rescale();
1031 }
1032
1033 EAPI Eina_Bool
1034 elm_password_show_last_get(void)
1035 {
1036    return _elm_config->password_show_last;
1037 }
1038
1039 EAPI void
1040 elm_password_show_last_set(Eina_Bool password_show_last)
1041 {
1042    if (_elm_config->password_show_last == password_show_last) return;
1043    _elm_config->password_show_last = password_show_last;
1044    edje_password_show_last_set(_elm_config->password_show_last);
1045 }
1046
1047 EAPI double
1048 elm_password_show_last_timeout_get(void)
1049 {
1050    return _elm_config->password_show_last_timeout;
1051 }
1052
1053 EAPI void
1054 elm_password_show_last_timeout_set(double password_show_last_timeout)
1055 {
1056    if (_elm_config->password_show_last_timeout == password_show_last_timeout) return;
1057    _elm_config->password_show_last_timeout = password_show_last_timeout;
1058    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
1059 }
1060
1061 EAPI void
1062 elm_object_style_set(Evas_Object *obj,
1063                      const char  *style)
1064 {
1065    EINA_SAFETY_ON_NULL_RETURN(obj);
1066    elm_widget_style_set(obj, style);
1067 }
1068
1069 EAPI const char *
1070 elm_object_style_get(const Evas_Object *obj)
1071 {
1072    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1073    return elm_widget_style_get(obj);
1074 }
1075
1076 EAPI void
1077 elm_object_disabled_set(Evas_Object *obj,
1078                         Eina_Bool    disabled)
1079 {
1080    EINA_SAFETY_ON_NULL_RETURN(obj);
1081    elm_widget_disabled_set(obj, disabled);
1082 }
1083
1084 EAPI Eina_Bool
1085 elm_object_disabled_get(const Evas_Object *obj)
1086 {
1087    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1088    return elm_widget_disabled_get(obj);
1089 }
1090
1091 EAPI Eina_Bool
1092 elm_config_save(void)
1093 {
1094    return _elm_config_save();
1095 }
1096
1097 EAPI void
1098 elm_config_reload(void)
1099 {
1100    _elm_config_reload();
1101 }
1102
1103 EAPI const char *
1104 elm_profile_current_get(void)
1105 {
1106    return _elm_config_current_profile_get();
1107 }
1108
1109 EAPI const char *
1110 elm_profile_dir_get(const char *profile,
1111                     Eina_Bool   is_user)
1112 {
1113    return _elm_config_profile_dir_get(profile, is_user);
1114 }
1115
1116 EAPI void
1117 elm_profile_dir_free(const char *p_dir)
1118 {
1119    free((void *)p_dir);
1120 }
1121
1122 EAPI Eina_List *
1123 elm_profile_list_get(void)
1124 {
1125    return _elm_config_profiles_list();
1126 }
1127
1128 EAPI void
1129 elm_profile_list_free(Eina_List *l)
1130 {
1131    const char *dir;
1132
1133    EINA_LIST_FREE(l, dir)
1134      eina_stringshare_del(dir);
1135 }
1136
1137 EAPI void
1138 elm_profile_set(const char *profile)
1139 {
1140    EINA_SAFETY_ON_NULL_RETURN(profile);
1141    _elm_config_profile_set(profile);
1142 }
1143
1144 EAPI const char *
1145 elm_engine_get(void)
1146 {
1147    return _elm_config->engine;
1148 }
1149
1150 EAPI void
1151 elm_engine_set(const char *engine)
1152 {
1153    EINA_SAFETY_ON_NULL_RETURN(engine);
1154
1155    _elm_config_engine_set(engine);
1156 }
1157
1158 EAPI Eina_List *
1159 elm_text_classes_list_get(void)
1160 {
1161    return _elm_config_text_classes_get();
1162 }
1163
1164 EAPI void
1165 elm_text_classes_list_free(Eina_List *list)
1166 {
1167    _elm_config_text_classes_free(list);
1168 }
1169
1170 EAPI const Eina_List *
1171 elm_font_overlay_list_get(void)
1172 {
1173    return _elm_config_font_overlays_list();
1174 }
1175
1176 EAPI void
1177 elm_font_overlay_set(const char    *text_class,
1178                      const char    *font,
1179                      Evas_Font_Size size)
1180 {
1181    EINA_SAFETY_ON_NULL_RETURN(text_class);
1182    _elm_config_font_overlay_set(text_class, font, size);
1183 }
1184
1185 EAPI void
1186 elm_font_overlay_unset(const char *text_class)
1187 {
1188    EINA_SAFETY_ON_NULL_RETURN(text_class);
1189    _elm_config_font_overlay_remove(text_class);
1190 }
1191
1192 EAPI void
1193 elm_font_overlay_apply(void)
1194 {
1195    _elm_config_font_overlay_apply();
1196 }
1197
1198 EAPI Elm_Font_Properties *
1199 elm_font_properties_get(const char *font)
1200 {
1201    EINA_SAFETY_ON_NULL_RETURN_VAL(font, NULL);
1202    return _elm_font_properties_get(NULL, font);
1203 }
1204
1205 EAPI void
1206 elm_font_properties_free(Elm_Font_Properties *efp)
1207 {
1208    const char *str;
1209
1210    EINA_SAFETY_ON_NULL_RETURN(efp);
1211    EINA_LIST_FREE(efp->styles, str)
1212      if (str) eina_stringshare_del(str);
1213    if (efp->name) eina_stringshare_del(efp->name);
1214    free(efp);
1215 }
1216
1217 EAPI char *
1218 elm_font_fontconfig_name_get(const char *name,
1219                              const char *style)
1220 {
1221    char buf[256];
1222
1223    EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
1224    if (!style || style[0] == 0) return (char *) eina_stringshare_add(name);
1225    snprintf(buf, 256, "%s" ELM_FONT_TOKEN_STYLE "%s", name, style);
1226    return (char *) eina_stringshare_add(buf);
1227 }
1228
1229 EAPI void
1230 elm_font_fontconfig_name_free(char *name)
1231 {
1232    eina_stringshare_del(name);
1233 }
1234
1235 EAPI Eina_Hash *
1236 elm_font_available_hash_add(Eina_List *list)
1237 {
1238    Eina_Hash *font_hash;
1239    Eina_List *l;
1240    void *key;
1241
1242    font_hash = NULL;
1243
1244    /* populate with default font families */
1245    //FIXME: Need to check whether fonts are being added multiple times.
1246    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Regular");
1247    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Bold");
1248    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Oblique");
1249    font_hash = _elm_font_available_hash_add(font_hash,
1250                                             "Sans:style=Bold Oblique");
1251
1252    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Regular");
1253    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Bold");
1254    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Oblique");
1255    font_hash = _elm_font_available_hash_add(font_hash,
1256                                             "Serif:style=Bold Oblique");
1257
1258    font_hash = _elm_font_available_hash_add(font_hash,
1259                                             "Monospace:style=Regular");
1260    font_hash = _elm_font_available_hash_add(font_hash,
1261                                             "Monospace:style=Bold");
1262    font_hash = _elm_font_available_hash_add(font_hash,
1263                                             "Monospace:style=Oblique");
1264    font_hash = _elm_font_available_hash_add(font_hash,
1265                                             "Monospace:style=Bold Oblique");
1266
1267    EINA_LIST_FOREACH(list, l, key)
1268      if (key) _elm_font_available_hash_add(font_hash, key);
1269
1270    return font_hash;
1271 }
1272
1273 EAPI void
1274 elm_font_available_hash_del(Eina_Hash *hash)
1275 {
1276    _elm_font_available_hash_del(hash);
1277 }
1278
1279 EAPI Evas_Coord
1280 elm_finger_size_get(void)
1281 {
1282    return _elm_config->finger_size;
1283 }
1284
1285 EAPI void
1286 elm_finger_size_set(Evas_Coord size)
1287 {
1288    if (_elm_config->finger_size == size) return;
1289    _elm_config->finger_size = size;
1290    _elm_rescale();
1291 }
1292
1293 EAPI void
1294 elm_coords_finger_size_adjust(int         times_w,
1295                               Evas_Coord *w,
1296                               int         times_h,
1297                               Evas_Coord *h)
1298 {
1299    if ((w) && (*w < (_elm_config->finger_size * times_w)))
1300      *w = _elm_config->finger_size * times_w;
1301    if ((h) && (*h < (_elm_config->finger_size * times_h)))
1302      *h = _elm_config->finger_size * times_h;
1303 }
1304
1305 EAPI void
1306 elm_cache_all_flush(void)
1307 {
1308    const Eina_List *l;
1309    Evas_Object *obj;
1310
1311    edje_file_cache_flush();
1312    edje_collection_cache_flush();
1313    eet_clearcache();
1314    EINA_LIST_FOREACH(_elm_win_list, l, obj)
1315      {
1316         Evas *e = evas_object_evas_get(obj);
1317         evas_image_cache_flush(e);
1318         evas_font_cache_flush(e);
1319         evas_render_dump(e);
1320      }
1321 }
1322
1323 EINA_DEPRECATED EAPI void
1324 elm_all_flush(void)
1325 {
1326    elm_cache_all_flush();
1327 }
1328
1329 EAPI int
1330 elm_cache_flush_interval_get(void)
1331 {
1332    return _elm_config->cache_flush_poll_interval;
1333 }
1334
1335 EAPI void
1336 elm_cache_flush_interval_set(int size)
1337 {
1338    if (_elm_config->cache_flush_poll_interval == size) return;
1339    _elm_config->cache_flush_poll_interval = size;
1340
1341    _elm_recache();
1342 }
1343
1344 EAPI Eina_Bool
1345 elm_cache_flush_enabled_get(void)
1346 {
1347    return _elm_config->cache_flush_enable;
1348 }
1349
1350 EAPI void
1351 elm_cache_flush_enabled_set(Eina_Bool enabled)
1352 {
1353    enabled = !!enabled;
1354    if (_elm_config->cache_flush_enable == enabled) return;
1355    _elm_config->cache_flush_enable = enabled;
1356
1357    _elm_recache();
1358 }
1359
1360 EAPI int
1361 elm_font_cache_get(void)
1362 {
1363    return _elm_config->font_cache;
1364 }
1365
1366 EAPI void
1367 elm_font_cache_set(int size)
1368 {
1369    if (_elm_config->font_cache == size) return;
1370    _elm_config->font_cache = size;
1371
1372    _elm_recache();
1373 }
1374
1375 EAPI int
1376 elm_image_cache_get(void)
1377 {
1378    return _elm_config->image_cache;
1379 }
1380
1381 EAPI void
1382 elm_image_cache_set(int size)
1383 {
1384    if (_elm_config->image_cache == size) return;
1385    _elm_config->image_cache = size;
1386
1387    _elm_recache();
1388 }
1389
1390 EAPI int
1391 elm_edje_file_cache_get(void)
1392 {
1393    return _elm_config->edje_cache;
1394 }
1395
1396 EAPI void
1397 elm_edje_file_cache_set(int size)
1398 {
1399    if (_elm_config->edje_cache == size) return;
1400    _elm_config->edje_cache = size;
1401
1402    _elm_recache();
1403 }
1404
1405 EAPI int
1406 elm_edje_collection_cache_get(void)
1407 {
1408    return _elm_config->edje_collection_cache;
1409 }
1410
1411 EAPI void
1412 elm_edje_collection_cache_set(int size)
1413 {
1414    if (_elm_config->edje_collection_cache == size) return;
1415    _elm_config->edje_collection_cache = size;
1416
1417    _elm_recache();
1418 }
1419
1420 EAPI Eina_Bool
1421 elm_object_focus_get(const Evas_Object *obj)
1422 {
1423    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1424    return elm_widget_focus_get(obj);
1425 }
1426
1427 EAPI void
1428 elm_object_focus_set(Evas_Object *obj,
1429                      Eina_Bool    focus)
1430 {
1431    EINA_SAFETY_ON_NULL_RETURN(obj);
1432
1433    if (focus == elm_widget_focus_get(obj)) return;
1434
1435    if (focus)
1436      elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
1437    else
1438      elm_widget_focused_object_clear(obj);
1439 }
1440
1441 EAPI void
1442 elm_object_focus(Evas_Object *obj)
1443 {
1444    EINA_SAFETY_ON_NULL_RETURN(obj);
1445    elm_object_focus_set(obj, EINA_TRUE);
1446 }
1447
1448 EAPI void
1449 elm_object_unfocus(Evas_Object *obj)
1450 {
1451    EINA_SAFETY_ON_NULL_RETURN(obj);
1452    elm_object_focus_set(obj, EINA_FALSE);
1453 }
1454
1455 EAPI void
1456 elm_object_focus_allow_set(Evas_Object *obj,
1457                            Eina_Bool    enable)
1458 {
1459    EINA_SAFETY_ON_NULL_RETURN(obj);
1460    elm_widget_can_focus_set(obj, enable);
1461 /*FIXME: According to the elm_object_focus_allow_get(), child_can_focus field
1462 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() */
1463 }
1464
1465 EAPI Eina_Bool
1466 elm_object_focus_allow_get(const Evas_Object *obj)
1467 {
1468    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1469    return (elm_widget_can_focus_get(obj)) || (elm_widget_child_can_focus_get(obj));
1470 }
1471
1472 EAPI void
1473 elm_object_focus_custom_chain_set(Evas_Object *obj,
1474                                   Eina_List   *objs)
1475 {
1476    EINA_SAFETY_ON_NULL_RETURN(obj);
1477    elm_widget_focus_custom_chain_set(obj, objs);
1478 }
1479
1480 EAPI void
1481 elm_object_focus_custom_chain_unset(Evas_Object *obj)
1482 {
1483    EINA_SAFETY_ON_NULL_RETURN(obj);
1484    elm_widget_focus_custom_chain_unset(obj);
1485 }
1486
1487 EAPI const Eina_List *
1488 elm_object_focus_custom_chain_get(const Evas_Object *obj)
1489 {
1490    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1491    return elm_widget_focus_custom_chain_get(obj);
1492 }
1493
1494 EAPI void
1495 elm_object_focus_custom_chain_append(Evas_Object *obj,
1496                                      Evas_Object *child,
1497                                      Evas_Object *relative_child)
1498 {
1499    EINA_SAFETY_ON_NULL_RETURN(obj);
1500    elm_widget_focus_custom_chain_append(obj, child, relative_child);
1501 }
1502
1503 EAPI void
1504 elm_object_focus_custom_chain_prepend(Evas_Object *obj,
1505                                       Evas_Object *child,
1506                                       Evas_Object *relative_child)
1507 {
1508    EINA_SAFETY_ON_NULL_RETURN(obj);
1509    elm_widget_focus_custom_chain_prepend(obj, child, relative_child);
1510 }
1511
1512 EAPI void
1513 elm_object_focus_cycle(Evas_Object        *obj,
1514                        Elm_Focus_Direction dir)
1515 {
1516    EINA_SAFETY_ON_NULL_RETURN(obj);
1517    elm_widget_focus_cycle(obj, dir);
1518 }
1519
1520 EAPI void
1521 elm_object_focus_direction_go(Evas_Object *obj,
1522                               int          x,
1523                               int          y)
1524 {
1525    EINA_SAFETY_ON_NULL_RETURN(obj);
1526    elm_widget_focus_direction_go(obj, x, y);
1527 }
1528
1529 EAPI void
1530 elm_object_tree_unfocusable_set(Evas_Object *obj,
1531                                 Eina_Bool    tree_unfocusable)
1532 {
1533    EINA_SAFETY_ON_NULL_RETURN(obj);
1534    elm_widget_tree_unfocusable_set(obj, tree_unfocusable);
1535 }
1536
1537 EAPI Eina_Bool
1538 elm_object_tree_unfocusable_get(const Evas_Object *obj)
1539 {
1540    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1541    return elm_widget_tree_unfocusable_get(obj);
1542 }
1543
1544 EAPI Eina_Bool
1545 elm_focus_highlight_enabled_get(void)
1546 {
1547    return _elm_config->focus_highlight_enable;
1548 }
1549
1550 EAPI void
1551 elm_focus_highlight_enabled_set(Eina_Bool enable)
1552 {
1553    _elm_config->focus_highlight_enable = !!enable;
1554 }
1555
1556 EAPI Eina_Bool
1557 elm_focus_highlight_animate_get(void)
1558 {
1559    return _elm_config->focus_highlight_animate;
1560 }
1561
1562 EAPI void
1563 elm_focus_highlight_animate_set(Eina_Bool animate)
1564 {
1565    _elm_config->focus_highlight_animate = !!animate;
1566 }
1567
1568 EAPI Eina_Bool
1569 elm_scroll_bounce_enabled_get(void)
1570 {
1571    return _elm_config->thumbscroll_bounce_enable;
1572 }
1573
1574 EAPI void
1575 elm_scroll_bounce_enabled_set(Eina_Bool enabled)
1576 {
1577    _elm_config->thumbscroll_bounce_enable = enabled;
1578 }
1579
1580 EAPI double
1581 elm_scroll_bounce_friction_get(void)
1582 {
1583    return _elm_config->thumbscroll_bounce_friction;
1584 }
1585
1586 EAPI void
1587 elm_scroll_bounce_friction_set(double friction)
1588 {
1589    _elm_config->thumbscroll_bounce_friction = friction;
1590 }
1591
1592 EAPI double
1593 elm_scroll_page_scroll_friction_get(void)
1594 {
1595    return _elm_config->page_scroll_friction;
1596 }
1597
1598 EAPI void
1599 elm_scroll_page_scroll_friction_set(double friction)
1600 {
1601    _elm_config->page_scroll_friction = friction;
1602 }
1603
1604 EAPI double
1605 elm_scroll_bring_in_scroll_friction_get(void)
1606 {
1607    return _elm_config->bring_in_scroll_friction;
1608 }
1609
1610 EAPI void
1611 elm_scroll_bring_in_scroll_friction_set(double friction)
1612 {
1613    _elm_config->bring_in_scroll_friction = friction;
1614 }
1615
1616 EAPI double
1617 elm_scroll_zoom_friction_get(void)
1618 {
1619    return _elm_config->zoom_friction;
1620 }
1621
1622 EAPI void
1623 elm_scroll_zoom_friction_set(double friction)
1624 {
1625    _elm_config->zoom_friction = friction;
1626 }
1627
1628 EAPI Eina_Bool
1629 elm_scroll_thumbscroll_enabled_get(void)
1630 {
1631    return _elm_config->thumbscroll_enable;
1632 }
1633
1634 EAPI void
1635 elm_scroll_thumbscroll_enabled_set(Eina_Bool enabled)
1636 {
1637    _elm_config->thumbscroll_enable = enabled;
1638 }
1639
1640 EAPI unsigned int
1641 elm_scroll_thumbscroll_threshold_get(void)
1642 {
1643    return _elm_config->thumbscroll_threshold;
1644 }
1645
1646 EAPI void
1647 elm_scroll_thumbscroll_threshold_set(unsigned int threshold)
1648 {
1649    _elm_config->thumbscroll_threshold = threshold;
1650 }
1651
1652 EAPI double
1653 elm_scroll_thumbscroll_momentum_threshold_get(void)
1654 {
1655    return _elm_config->thumbscroll_momentum_threshold;
1656 }
1657
1658 EAPI void
1659 elm_scroll_thumbscroll_momentum_threshold_set(double threshold)
1660 {
1661    _elm_config->thumbscroll_momentum_threshold = threshold;
1662 }
1663
1664 EAPI double
1665 elm_scroll_thumbscroll_friction_get(void)
1666 {
1667    return _elm_config->thumbscroll_friction;
1668 }
1669
1670 EAPI void
1671 elm_scroll_thumbscroll_friction_set(double friction)
1672 {
1673    _elm_config->thumbscroll_friction = friction;
1674 }
1675
1676 EAPI double
1677 elm_scroll_thumbscroll_border_friction_get(void)
1678 {
1679    return _elm_config->thumbscroll_border_friction;
1680 }
1681
1682 EAPI void
1683 elm_scroll_thumbscroll_border_friction_set(double friction)
1684 {
1685    if (friction < 0.0) friction = 0.0;
1686    if (friction > 1.0) friction = 1.0;
1687    _elm_config->thumbscroll_friction = friction;
1688 }
1689
1690 EAPI double
1691 elm_scroll_thumbscroll_sensitivity_friction_get(void)
1692 {
1693    return _elm_config->thumbscroll_sensitivity_friction;
1694 }
1695
1696 EAPI void
1697 elm_scroll_thumbscroll_sensitivity_friction_set(double friction)
1698 {
1699    if (friction < 0.1) friction = 0.1;
1700    if (friction > 1.0) friction = 1.0;
1701    _elm_config->thumbscroll_friction = friction;
1702 }
1703
1704 EAPI void
1705 elm_scroll_thumbscroll_sensitivity_friction_all_set(double friction)
1706 {
1707    elm_scroll_thumbscroll_sensitivity_friction_set(friction);
1708    elm_config_all_flush();
1709 }
1710
1711 EAPI void
1712 elm_object_scroll_hold_push(Evas_Object *obj)
1713 {
1714    EINA_SAFETY_ON_NULL_RETURN(obj);
1715    elm_widget_scroll_hold_push(obj);
1716 }
1717
1718 EAPI void
1719 elm_object_scroll_hold_pop(Evas_Object *obj)
1720 {
1721    EINA_SAFETY_ON_NULL_RETURN(obj);
1722    elm_widget_scroll_hold_pop(obj);
1723 }
1724
1725 EAPI void
1726 elm_object_scroll_freeze_push(Evas_Object *obj)
1727 {
1728    EINA_SAFETY_ON_NULL_RETURN(obj);
1729    elm_widget_scroll_freeze_push(obj);
1730 }
1731
1732 EAPI void
1733 elm_object_scroll_lock_x_set(Evas_Object *obj,
1734                              Eina_Bool    lock)
1735 {
1736    EINA_SAFETY_ON_NULL_RETURN(obj);
1737    elm_widget_drag_lock_x_set(obj, lock);
1738 }
1739
1740 EAPI void
1741 elm_object_scroll_lock_y_set(Evas_Object *obj,
1742                              Eina_Bool    lock)
1743 {
1744    EINA_SAFETY_ON_NULL_RETURN(obj);
1745    elm_widget_drag_lock_y_set(obj, lock);
1746 }
1747
1748 EAPI Eina_Bool
1749 elm_object_scroll_lock_x_get(const Evas_Object *obj)
1750 {
1751    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1752    return elm_widget_drag_lock_x_get(obj);
1753 }
1754
1755 EAPI Eina_Bool
1756 elm_object_scroll_lock_y_get(const Evas_Object *obj)
1757 {
1758    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1759    return elm_widget_drag_lock_y_get(obj);
1760 }
1761
1762 EAPI void
1763 elm_object_scroll_freeze_pop(Evas_Object *obj)
1764 {
1765    EINA_SAFETY_ON_NULL_RETURN(obj);
1766    elm_widget_scroll_freeze_pop(obj);
1767 }
1768
1769 EAPI Eina_Bool
1770 elm_object_widget_check(const Evas_Object *obj)
1771 {
1772    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1773    return elm_widget_is(obj);
1774 }
1775
1776 EAPI Evas_Object *
1777 elm_object_parent_widget_get(const Evas_Object *obj)
1778 {
1779    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1780    return elm_widget_parent_widget_get(obj);
1781 }
1782
1783 EAPI Evas_Object *
1784 elm_object_top_widget_get(const Evas_Object *obj)
1785 {
1786    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1787    return elm_widget_top_get(obj);
1788 }
1789
1790 EAPI const char *
1791 elm_object_widget_type_get(const Evas_Object *obj)
1792 {
1793    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1794    return elm_widget_type_get(obj);
1795 }
1796
1797 EAPI void
1798 elm_object_signal_emit(Evas_Object *obj,
1799                        const char  *emission,
1800                        const char  *source)
1801 {
1802    EINA_SAFETY_ON_NULL_RETURN(obj);
1803    elm_widget_signal_emit(obj, emission, source);
1804 }
1805
1806 EAPI void
1807 elm_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
1808 {
1809     EINA_SAFETY_ON_NULL_RETURN(obj);
1810     EINA_SAFETY_ON_NULL_RETURN(func);
1811     elm_widget_signal_callback_add(obj, emission, source, func, data);
1812 }
1813
1814 EAPI void *
1815 elm_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func)
1816 {
1817     EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1818     EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
1819     return elm_widget_signal_callback_del(obj, emission, source, func);
1820 }
1821
1822 EAPI void
1823 elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data)
1824 {
1825    EINA_SAFETY_ON_NULL_RETURN(obj);
1826    EINA_SAFETY_ON_NULL_RETURN(func);
1827    elm_widget_event_callback_add(obj, func, data);
1828 }
1829
1830 EAPI void *
1831 elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data)
1832 {
1833    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1834    EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
1835    return elm_widget_event_callback_del(obj, func, data);
1836 }
1837
1838 EAPI void
1839 elm_object_tree_dump(const Evas_Object *top)
1840 {
1841 #ifdef ELM_DEBUG
1842    elm_widget_tree_dump(top);
1843 #else
1844    return;
1845    (void)top;
1846 #endif
1847 }
1848
1849 EAPI void
1850 elm_object_tree_dot_dump(const Evas_Object *top,
1851                          const char        *file)
1852 {
1853 #ifdef ELM_DEBUG
1854    FILE *f = fopen(file, "wb");
1855    elm_widget_tree_dot_dump(top, f);
1856    fclose(f);
1857 #else
1858    return;
1859    (void)top;
1860    (void)file;
1861 #endif
1862 }
1863
1864 EAPI void
1865 elm_longpress_timeout_set(double longpress_timeout)
1866 {
1867    _elm_config->longpress_timeout = longpress_timeout;
1868 }
1869
1870 EAPI double
1871 elm_longpress_timeout_get(void)
1872 {
1873    return _elm_config->longpress_timeout;
1874 }
1875
1876 EAPI Evas_Object *
1877 elm_object_item_widget_get(const Elm_Object_Item *it)
1878 {
1879    return WIDGET(it);
1880 }
1881
1882 EAPI void
1883 elm_object_item_content_part_set(Elm_Object_Item *it,
1884                                  const char *part,
1885                                  Evas_Object *content)
1886 {
1887    _elm_widget_item_content_part_set((Elm_Widget_Item *) it, part, content);
1888 }
1889
1890 EAPI void
1891 elm_object_item_part_content_set(Elm_Object_Item *it,
1892                                  const char *part,
1893                                  Evas_Object *content)
1894 {
1895    _elm_widget_item_content_part_set((Elm_Widget_Item *) it, part, content);
1896 }
1897
1898 EAPI Evas_Object *
1899 elm_object_item_content_part_get(const Elm_Object_Item *it,
1900                                  const char *part)
1901 {
1902    return _elm_widget_item_content_part_get((Elm_Widget_Item *) it, part);
1903 }
1904
1905 EAPI Evas_Object *
1906 elm_object_item_part_content_get(const Elm_Object_Item *it,
1907                                  const char *part)
1908 {
1909    return _elm_widget_item_content_part_get((Elm_Widget_Item *) it, part);
1910 }
1911
1912 EAPI Evas_Object *
1913 elm_object_item_content_part_unset(Elm_Object_Item *it, const char *part)
1914 {
1915    return _elm_widget_item_content_part_unset((Elm_Widget_Item *) it, part);
1916 }
1917
1918 EAPI Evas_Object *
1919 elm_object_item_part_content_unset(Elm_Object_Item *it, const char *part)
1920 {
1921    return _elm_widget_item_content_part_unset((Elm_Widget_Item *) it, part);
1922 }
1923
1924 EAPI void
1925 elm_object_item_text_part_set(Elm_Object_Item *it,
1926                               const char *part,
1927                               const char *label)
1928 {
1929    _elm_widget_item_text_part_set((Elm_Widget_Item *) it, part, label);
1930 }
1931
1932 EAPI void
1933 elm_object_item_part_text_set(Elm_Object_Item *it,
1934                               const char *part,
1935                               const char *label)
1936 {
1937    _elm_widget_item_text_part_set((Elm_Widget_Item *) it, part, label);
1938 }
1939
1940 EAPI const char *
1941 elm_object_item_text_part_get(const Elm_Object_Item *it, const char *part)
1942 {
1943    return _elm_widget_item_text_part_get((Elm_Widget_Item *) it, part);
1944 }
1945
1946 EAPI const char *
1947 elm_object_item_part_text_get(const Elm_Object_Item *it, const char *part)
1948 {
1949    return _elm_widget_item_text_part_get((Elm_Widget_Item *) it, part);
1950 }
1951
1952 EAPI void
1953 elm_object_access_info_set(Evas_Object *obj, const char *txt)
1954 {
1955    elm_widget_access_info_set(obj, txt);
1956 }
1957
1958 EAPI Evas_Object *
1959 elm_object_name_find(const Evas_Object *obj, const char *name, int recurse)
1960 {
1961    return elm_widget_name_find(obj, name, recurse);
1962 }
1963
1964 EAPI void
1965 elm_object_item_access_info_set(Elm_Object_Item *it, const char *txt)
1966 {
1967    _elm_widget_item_access_info_set((Elm_Widget_Item *) it, txt);
1968 }
1969
1970 EAPI void *
1971 elm_object_item_data_get(const Elm_Object_Item *it)
1972 {
1973    return elm_widget_item_data_get(it);
1974 }
1975
1976 EAPI void
1977 elm_object_item_data_set(Elm_Object_Item *it, void *data)
1978 {
1979    elm_widget_item_data_set(it, data);
1980 }
1981
1982 EAPI void
1983 elm_object_item_signal_emit(Elm_Object_Item *it, const char *emission, const char *source)
1984 {
1985    _elm_widget_item_signal_emit((Elm_Widget_Item *) it, emission, source);
1986 }
1987
1988 EAPI void elm_object_item_disabled_set(Elm_Object_Item *it, Eina_Bool disabled)
1989 {
1990    _elm_widget_item_disabled_set((Elm_Widget_Item *) it, disabled);
1991 }
1992
1993 EAPI Eina_Bool elm_object_item_disabled_get(const Elm_Object_Item *it)
1994 {
1995    return _elm_widget_item_disabled_get((Elm_Widget_Item *) it);
1996 }
1997
1998 EAPI void elm_object_item_del_cb_set(Elm_Object_Item *it, Evas_Smart_Cb del_cb)
1999 {
2000    _elm_widget_item_del_cb_set((Elm_Widget_Item *) it, del_cb);
2001 }
2002
2003 EAPI void elm_object_item_del(Elm_Object_Item *it)
2004 {
2005    _elm_widget_item_del((Elm_Widget_Item *) it);
2006 }
2007
2008 EAPI void
2009 elm_object_item_tooltip_text_set(Elm_Object_Item *it, const char *text)
2010 {
2011    elm_widget_item_tooltip_text_set(it, text);
2012 }
2013
2014 EAPI void
2015 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)
2016 {
2017    elm_widget_item_tooltip_content_cb_set(it, func, data, del_cb);
2018 }
2019
2020 EAPI void
2021 elm_object_item_tooltip_unset(Elm_Object_Item *it)
2022 {
2023    elm_widget_item_tooltip_unset(it);
2024 }
2025
2026 EAPI Eina_Bool
2027 elm_object_item_tooltip_window_mode_set(Elm_Object_Item *it, Eina_Bool disable)
2028 {
2029    return elm_widget_item_tooltip_window_mode_set(it, disable);
2030 }
2031
2032 EAPI Eina_Bool
2033 elm_object_item_tooltip_window_mode_get(const Elm_Object_Item *it)
2034 {
2035    return elm_widget_item_tooltip_window_mode_get(it);
2036 }
2037
2038 EAPI void
2039 elm_object_item_tooltip_style_set(Elm_Object_Item *it, const char *style)
2040 {
2041    elm_widget_item_tooltip_style_set(it, style);
2042 }
2043
2044 EAPI const char *
2045 elm_object_item_tooltip_style_get(const Elm_Object_Item *it)
2046 {
2047    return elm_widget_item_tooltip_style_get(it);
2048 }
2049
2050 EINA_DEPRECATED EAPI Evas_Object *
2051 elm_object_item_object_get(const Elm_Object_Item *it)
2052 {
2053    return elm_object_item_widget_get(it);
2054 }
2055
2056 EAPI void
2057 elm_object_item_cursor_set(Elm_Object_Item *it, const char *cursor)
2058 {
2059    elm_widget_item_cursor_set(it, cursor);
2060 }
2061
2062 EAPI const char *
2063 elm_object_item_cursor_get(const Elm_Object_Item *it)
2064 {
2065    return elm_widget_item_cursor_get(it);
2066 }
2067
2068 EAPI void
2069 elm_object_item_cursor_unset(Elm_Object_Item *it)
2070 {
2071    elm_widget_item_cursor_unset(it);
2072 }
2073
2074 EAPI void
2075 elm_object_item_cursor_style_set(Elm_Object_Item *it, const char *style)
2076 {
2077    elm_widget_item_cursor_style_set(it, style);
2078 }
2079
2080 EAPI const char *
2081 elm_object_item_cursor_style_get(const Elm_Object_Item *it)
2082 {
2083    return elm_widget_item_cursor_style_get(it);
2084 }
2085
2086 EAPI void
2087 elm_object_item_cursor_engine_only_set(Elm_Object_Item *it, Eina_Bool engine_only)
2088 {
2089    elm_widget_item_cursor_engine_only_set(it, engine_only);
2090 }
2091
2092 EAPI Eina_Bool
2093 elm_object_item_cursor_engine_only_get(const Elm_Object_Item *it)
2094 {
2095    return elm_widget_item_cursor_engine_only_get(it);
2096 }