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