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 }
  85
  86 static void *app_mainfunc = NULL;
  87 static const char *app_domain = NULL;
  88 static const char *app_checkfile = NULL;
  89
  90 static const char *app_compile_bin_dir = NULL;
  91 static const char *app_compile_lib_dir = NULL;
  92 static const char *app_compile_data_dir = NULL;
  93 static const char *app_compile_locale_dir = NULL;
  94 static const char *app_prefix_dir = NULL;
  95 static const char *app_bin_dir = NULL;
  96 static const char *app_lib_dir = NULL;
  97 static const char *app_data_dir = NULL;
  98 static const char *app_locale_dir = NULL;
  99
 100 static Eina_Prefix *app_pfx = NULL;
 101
 102 static void
 103 _prefix_check(void)
 104 {
 105    int argc = 0;
 106    char **argv = NULL;
 107    const char *dirs[4] = { NULL, NULL, NULL, NULL };
 108    char *caps = NULL, *p1, *p2;
 109
 110    if (app_pfx) return;
 111    if (!app_domain) return;
 112
 113    ecore_app_args_get(&argc, &argv);
 114    if (argc < 1) return;
 115
 116    dirs[0] = app_compile_bin_dir;
 117    dirs[1] = app_compile_lib_dir;
 118    dirs[2] = app_compile_data_dir;
 119    dirs[3] = app_compile_locale_dir;
 120
 121    if (!dirs[1]) dirs[1] = dirs[0];
 122    if (!dirs[0]) dirs[0] = dirs[1];
 123    if (!dirs[3]) dirs[3] = dirs[2];
 124    if (!dirs[2]) dirs[2] = dirs[3];
 125
 126    if (app_domain)
 127      {
 128         caps = alloca(strlen(app_domain) + 1);
 129         for (p1 = (char *)app_domain, p2 = caps; *p1; p1++, p2++)
 130            *p2 = toupper(*p1);
 131         *p2 = 0;
 132      }
 133    app_pfx = eina_prefix_new(argv[0], app_mainfunc, caps, app_domain,
 134                              app_checkfile, dirs[0], dirs[1], dirs[2], dirs[3]);
 135 }
 136
 137 static void
 138 _prefix_shutdown(void)
 139 {
 140    if (app_pfx) eina_prefix_free(app_pfx);
 141    if (app_domain) eina_stringshare_del(app_domain);
 142    if (app_checkfile) eina_stringshare_del(app_checkfile);
 143    if (app_compile_bin_dir) eina_stringshare_del(app_compile_bin_dir);
 144    if (app_compile_lib_dir) eina_stringshare_del(app_compile_lib_dir);
 145    if (app_compile_data_dir) eina_stringshare_del(app_compile_data_dir);
 146    if (app_compile_locale_dir) eina_stringshare_del(app_compile_locale_dir);
 147    if (app_prefix_dir) eina_stringshare_del(app_prefix_dir);
 148    if (app_bin_dir) eina_stringshare_del(app_bin_dir);
 149    if (app_lib_dir) eina_stringshare_del(app_lib_dir);
 150    if (app_data_dir) eina_stringshare_del(app_data_dir);
 151    if (app_locale_dir) eina_stringshare_del(app_locale_dir);
 152    app_mainfunc = NULL;
 153    app_domain = NULL;
 154    app_checkfile = NULL;
 155    app_compile_bin_dir = NULL;
 156    app_compile_lib_dir = NULL;
 157    app_compile_data_dir = NULL;
 158    app_compile_locale_dir = NULL;
 159    app_prefix_dir = NULL;
 160    app_bin_dir = NULL;
 161    app_lib_dir = NULL;
 162    app_data_dir = NULL;
 163    app_locale_dir = NULL;
 164    app_pfx = NULL;
 165 }
 166
 167 EAPI int
 168 elm_init(int    argc,
 169          char **argv)
 170 {
 171    _elm_init_count++;
 172    if (_elm_init_count > 1) return _elm_init_count;
 173    elm_quicklaunch_init(argc, argv);
 174    elm_quicklaunch_sub_init(argc, argv);
 175    _prefix_shutdown();
 176    return _elm_init_count;
 177 }
 178
 179 EAPI int
 180 elm_shutdown(void)
 181 {
 182    _elm_init_count--;
 183    if (_elm_init_count > 0) return _elm_init_count;
 184    _elm_win_shutdown();
 185    while (_elm_win_deferred_free) ecore_main_loop_iterate();
 186 // wrningz :(
 187 //   _prefix_shutdown();
 188    elm_quicklaunch_sub_shutdown();
 189    elm_quicklaunch_shutdown();
 190    return _elm_init_count;
 191 }
 192
 193 EAPI void
 194 elm_app_info_set(void *mainfunc, const char *dom, const char *checkfile)
 195 {
 196    app_mainfunc = mainfunc;
 197    eina_stringshare_replace(&app_domain, dom);
 198    eina_stringshare_replace(&app_checkfile, checkfile);
 199 }
 200
 201 EAPI void
 202 elm_app_compile_bin_dir_set(const char *dir)
 203 {
 204    eina_stringshare_replace(&app_compile_bin_dir, dir);
 205 }
 206
 207 EAPI void
 208 elm_app_compile_lib_dir_set(const char *dir)
 209 {
 210    eina_stringshare_replace(&app_compile_lib_dir, dir);
 211 }
 212
 213 EAPI void
 214 elm_app_compile_data_dir_set(const char *dir)
 215 {
 216    eina_stringshare_replace(&app_compile_data_dir, dir);
 217 }
 218
 219 EAPI void
 220 elm_app_compile_locale_set(const char *dir)
 221 {
 222    eina_stringshare_replace(&app_compile_locale_dir, dir);
 223 }
 224
 225 EAPI const char *
 226 elm_app_prefix_dir_get(void)
 227 {
 228    if (app_prefix_dir) return app_prefix_dir;
 229    _prefix_check();
 230   if (!app_pfx) return "";
 231    app_prefix_dir = eina_prefix_get(app_pfx);
 232    return app_prefix_dir;
 233 }
 234
 235 EAPI const char *
 236 elm_app_bin_dir_get(void)
 237 {
 238    if (app_bin_dir) return app_bin_dir;
 239    _prefix_check();
 240    if (!app_pfx) return "";
 241    app_bin_dir = eina_prefix_bin_get(app_pfx);
 242    return app_bin_dir;
 243 }
 244
 245 EAPI const char *
 246 elm_app_lib_dir_get(void)
 247 {
 248    if (app_lib_dir) return app_lib_dir;
 249    _prefix_check();
 250    if (!app_pfx) return "";
 251    app_lib_dir = eina_prefix_lib_get(app_pfx);
 252    return app_lib_dir;
 253 }
 254
 255 EAPI const char *
 256 elm_app_data_dir_get(void)
 257 {
 258    if (app_data_dir) return app_data_dir;
 259    _prefix_check();
 260    if (!app_pfx) return "";
 261    app_data_dir = eina_prefix_data_get(app_pfx);
 262    return app_data_dir;
 263 }
 264
 265 EAPI const char *
 266 elm_app_locale_dir_get(void)
 267 {
 268    if (app_locale_dir) return app_locale_dir;
 269    _prefix_check();
 270    if (!app_pfx) return "";
 271    app_locale_dir = eina_prefix_locale_get(app_pfx);
 272    return app_locale_dir;
 273 }
 274
 275 #ifdef ELM_EDBUS
 276 static int _elm_need_e_dbus = 0;
 277 #endif
 278 EAPI Eina_Bool
 279 elm_need_e_dbus(void)
 280 {
 281 #ifdef ELM_EDBUS
 282    if (_elm_need_e_dbus++) return EINA_TRUE;
 283    e_dbus_init();
 284    return EINA_TRUE;
 285 #else
 286    return EINA_FALSE;
 287 #endif
 288 }
 289
 290 static void
 291 _elm_unneed_e_dbus(void)
 292 {
 293 #ifdef ELM_EDBUS
 294    if (--_elm_need_e_dbus) return;
 295
 296    _elm_need_e_dbus = 0;
 297    e_dbus_shutdown();
 298 #endif
 299 }
 300
 301 #ifdef ELM_EFREET
 302 static int _elm_need_efreet = 0;
 303 #endif
 304 EAPI Eina_Bool
 305 elm_need_efreet(void)
 306 {
 307 #ifdef ELM_EFREET
 308    if (_elm_need_efreet++) return EINA_TRUE;
 309    efreet_init();
 310    efreet_mime_init();
 311    efreet_trash_init();
 312     /*
 313      {
 314         Eina_List **list;
 315
 316         list = efreet_icon_extra_list_get();
 317         if (list)
 318           {
 319              e_user_dir_concat_static(buf, "icons");
 320              *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
 321              e_prefix_data_concat_static(buf, "data/icons");
 322              *list = eina_list_prepend(*list, (void *)eina_stringshare_add(buf));
 323           }
 324      }
 325    */
 326    return EINA_TRUE;
 327 #else
 328    return EINA_FALSE;
 329 #endif
 330 }
 331
 332 static void
 333 _elm_unneed_efreet(void)
 334 {
 335 #ifdef ELM_EFREET
 336    if (--_elm_need_efreet) return;
 337
 338    _elm_need_efreet = 0;
 339    efreet_trash_shutdown();
 340    efreet_mime_shutdown();
 341    efreet_shutdown();
 342 #endif
 343 }
 344
 345 EAPI void
 346 elm_quicklaunch_mode_set(Eina_Bool ql_on)
 347 {
 348    quicklaunch_on = ql_on;
 349 }
 350
 351 EAPI Eina_Bool
 352 elm_quicklaunch_mode_get(void)
 353 {
 354    return quicklaunch_on;
 355 }
 356
 357 EAPI int
 358 elm_quicklaunch_init(int    argc,
 359                      char **argv)
 360 {
 361    _elm_ql_init_count++;
 362    if (_elm_ql_init_count > 1) return _elm_ql_init_count;
 363    eina_init();
 364    _elm_log_dom = eina_log_domain_register("elementary", EINA_COLOR_LIGHTBLUE);
 365    if (!_elm_log_dom)
 366      {
 367         EINA_LOG_ERR("could not register elementary log domain.");
 368         _elm_log_dom = EINA_LOG_DOMAIN_GLOBAL;
 369      }
 370
 371    eet_init();
 372    ecore_init();
 373
 374 #ifdef HAVE_ELEMENTARY_EMAP
 375    emap_init();
 376 #endif
 377    ecore_app_args_set(argc, (const char **)argv);
 378
 379    memset(_elm_policies, 0, sizeof(_elm_policies));
 380    if (!ELM_EVENT_POLICY_CHANGED)
 381      ELM_EVENT_POLICY_CHANGED = ecore_event_type_new();
 382
 383    ecore_file_init();
 384
 385    _elm_exit_handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _elm_signal_exit, NULL);
 386
 387    if (argv) _elm_appname = strdup(ecore_file_file_get(argv[0]));
 388
 389    pfx = eina_prefix_new(NULL, elm_quicklaunch_init,
 390                          "ELM", "elementary", "config/profile.cfg",
 391                          PACKAGE_LIB_DIR, /* don't have a bin dir currently */
 392                          PACKAGE_LIB_DIR,
 393                          PACKAGE_DATA_DIR,
 394                          LOCALE_DIR);
 395    if (pfx)
 396      {
 397         _elm_data_dir = eina_stringshare_add(eina_prefix_data_get(pfx));
 398         _elm_lib_dir = eina_stringshare_add(eina_prefix_lib_get(pfx));
 399      }
 400    if (!_elm_data_dir) _elm_data_dir = eina_stringshare_add("/");
 401    if (!_elm_lib_dir) _elm_lib_dir = eina_stringshare_add("/");
 402
 403    _elm_config_init();
 404    return _elm_ql_init_count;
 405 }
 406
 407 EAPI int
 408 elm_quicklaunch_sub_init(int    argc,
 409                          char **argv)
 410 {
 411    _elm_sub_init_count++;
 412    if (_elm_sub_init_count > 1) return _elm_sub_init_count;
 413    if (quicklaunch_on)
 414      {
 415 #ifdef SEMI_BROKEN_QUICKLAUNCH
 416         return _elm_sub_init_count;
 417 #endif
 418      }
 419    if (!quicklaunch_on)
 420      {
 421         ecore_app_args_set(argc, (const char **)argv);
 422         evas_init();
 423         edje_init();
 424         _elm_module_init();
 425         _elm_config_sub_init();
 426 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 427         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 428             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 429             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 430             ENGINE_COMPARE(ELM_OPENGL_X11))
 431 #undef ENGINE_COMPARE
 432           {
 433 #ifdef HAVE_ELEMENTARY_X
 434              ecore_x_init(NULL);
 435 #endif
 436           }
 437         ecore_evas_init(); // FIXME: check errors
 438         ecore_imf_init();
 439         ecore_con_init();
 440         ecore_con_url_init();
 441      }
 442    return _elm_sub_init_count;
 443 }
 444
 445 EAPI int
 446 elm_quicklaunch_sub_shutdown(void)
 447 {
 448    _elm_sub_init_count--;
 449    if (_elm_sub_init_count > 0) return _elm_sub_init_count;
 450    if (quicklaunch_on)
 451      {
 452 #ifdef SEMI_BROKEN_QUICKLAUNCH
 453         return _elm_sub_init_count;
 454 #endif
 455      }
 456    if (!quicklaunch_on)
 457      {
 458         _elm_win_shutdown();
 459         _elm_module_shutdown();
 460         ecore_con_url_shutdown();
 461         ecore_con_shutdown();
 462         ecore_imf_shutdown();
 463         ecore_evas_shutdown();
 464 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 465         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 466             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 467             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 468             ENGINE_COMPARE(ELM_OPENGL_X11))
 469 #undef ENGINE_COMPARE
 470           {
 471 #ifdef HAVE_ELEMENTARY_X
 472              ecore_x_disconnect();
 473 #endif
 474           }
 475 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 476         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 477             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 478             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 479             ENGINE_COMPARE(ELM_OPENGL_X11) ||
 480             ENGINE_COMPARE(ELM_SOFTWARE_SDL) ||
 481             ENGINE_COMPARE(ELM_SOFTWARE_16_SDL) ||
 482             ENGINE_COMPARE(ELM_OPENGL_SDL) ||
 483             ENGINE_COMPARE(ELM_OPENGL_COCOA) ||
 484             ENGINE_COMPARE(ELM_SOFTWARE_WIN32) ||
 485             ENGINE_COMPARE(ELM_SOFTWARE_16_WINCE))
 486 #undef ENGINE_COMPARE
 487           evas_cserve_disconnect();
 488         edje_shutdown();
 489         evas_shutdown();
 490      }
 491    return _elm_sub_init_count;
 492 }
 493
 494 EAPI int
 495 elm_quicklaunch_shutdown(void)
 496 {
 497    _elm_ql_init_count--;
 498    if (_elm_ql_init_count > 0) return _elm_ql_init_count;
 499    if (pfx) eina_prefix_free(pfx);
 500    pfx = NULL;
 501    eina_stringshare_del(_elm_data_dir);
 502    _elm_data_dir = NULL;
 503    eina_stringshare_del(_elm_lib_dir);
 504    _elm_lib_dir = NULL;
 505
 506    free(_elm_appname);
 507    _elm_appname = NULL;
 508
 509    _elm_config_shutdown();
 510
 511    ecore_event_handler_del(_elm_exit_handler);
 512    _elm_exit_handler = NULL;
 513
 514    _elm_theme_shutdown();
 515    _elm_unneed_efreet();
 516    _elm_unneed_e_dbus();
 517    _elm_unneed_ethumb();
 518    _elm_unneed_web();
 519    ecore_file_shutdown();
 520
 521 #ifdef HAVE_ELEMENTARY_EMAP
 522    emap_shutdown();
 523 #endif
 524
 525    ecore_shutdown();
 526    eet_shutdown();
 527
 528    if ((_elm_log_dom > -1) && (_elm_log_dom != EINA_LOG_DOMAIN_GLOBAL))
 529      {
 530         eina_log_domain_unregister(_elm_log_dom);
 531         _elm_log_dom = -1;
 532      }
 533
 534    _elm_widget_type_clear();
 535
 536    eina_shutdown();
 537    return _elm_ql_init_count;
 538 }
 539
 540 EAPI void
 541 elm_quicklaunch_seed(void)
 542 {
 543 #ifndef SEMI_BROKEN_QUICKLAUNCH
 544    if (quicklaunch_on)
 545      {
 546         Evas_Object *win, *bg, *bt;
 547
 548         win = elm_win_add(NULL, "seed", ELM_WIN_BASIC);
 549         bg = elm_bg_add(win);
 550         elm_win_resize_object_add(win, bg);
 551         evas_object_show(bg);
 552         bt = elm_button_add(win);
 553         elm_button_label_set(bt, " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~-_=+\\|]}[{;:'\",<.>/?");
 554         elm_win_resize_object_add(win, bt);
 555         ecore_main_loop_iterate();
 556         evas_object_del(win);
 557         ecore_main_loop_iterate();
 558 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 559         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 560             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 561             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 562             ENGINE_COMPARE(ELM_OPENGL_X11))
 563 #undef ENGINE_COMPARE
 564           {
 565 # ifdef HAVE_ELEMENTARY_X
 566              ecore_x_sync();
 567 # endif
 568           }
 569         ecore_main_loop_iterate();
 570      }
 571 #endif
 572 }
 573
 574 static void *qr_handle = NULL;
 575 static int (*qr_main)(int    argc,
 576                       char **argv) = NULL;
 577
 578 EAPI Eina_Bool
 579 elm_quicklaunch_prepare(int argc __UNUSED__,
 580                         char   **argv)
 581 {
 582 #ifdef HAVE_FORK
 583    char *exe = elm_quicklaunch_exe_path_get(argv[0]);
 584    if (!exe)
 585      {
 586         ERR("requested quicklaunch binary '%s' does not exist\n", argv[0]);
 587         return EINA_FALSE;
 588      }
 589    else
 590      {
 591         char *exe2, *p;
 592         char *exename;
 593
 594         exe2 = malloc(strlen(exe) + 1 + 10);
 595         strcpy(exe2, exe);
 596         p = strrchr(exe2, '/');
 597         if (p) p++;
 598         else p = exe2;
 599         exename = alloca(strlen(p) + 1);
 600         strcpy(exename, p);
 601         *p = 0;
 602         strcat(p, "../lib/");
 603         strcat(p, exename);
 604         strcat(p, ".so");
 605         if (!access(exe2, R_OK | X_OK))
 606           {
 607              free(exe);
 608              exe = exe2;
 609           }
 610         else
 611           free(exe2);
 612      }
 613    qr_handle = dlopen(exe, RTLD_NOW | RTLD_GLOBAL);
 614    if (!qr_handle)
 615      {
 616         fprintf(stderr, "dlerr: %s\n", dlerror());
 617         WRN("dlopen('%s') failed: %s", exe, dlerror());
 618         free(exe);
 619         return EINA_FALSE;
 620      }
 621    INF("dlopen('%s') = %p", exe, qr_handle);
 622    qr_main = dlsym(qr_handle, "elm_main");
 623    INF("dlsym(%p, 'elm_main') = %p", qr_handle, qr_main);
 624    if (!qr_main)
 625      {
 626         WRN("not quicklauncher capable: no elm_main in '%s'", exe);
 627         dlclose(qr_handle);
 628         qr_handle = NULL;
 629         free(exe);
 630         return EINA_FALSE;
 631      }
 632    free(exe);
 633    return EINA_TRUE;
 634 #else
 635    return EINA_FALSE;
 636    (void)argv;
 637 #endif
 638 }
 639
 640 #ifdef HAVE_FORK
 641 static void
 642 save_env(void)
 643 {
 644    int i, size;
 645    extern char **environ;
 646    char **oldenv, **p;
 647
 648    oldenv = environ;
 649
 650    for (i = 0, size = 0; environ[i]; i++)
 651      size += strlen(environ[i]) + 1;
 652
 653    p = malloc((i + 1) * sizeof(char *));
 654    if (!p) return;
 655
 656    environ = p;
 657
 658    for (i = 0; oldenv[i]; i++)
 659      environ[i] = strdup(oldenv[i]);
 660    environ[i] = NULL;
 661 }
 662
 663 #endif
 664
 665 EAPI Eina_Bool
 666 elm_quicklaunch_fork(int    argc,
 667                      char **argv,
 668                      char  *cwd,
 669                      void (postfork_func) (void *data),
 670                      void  *postfork_data)
 671 {
 672 #ifdef HAVE_FORK
 673    pid_t child;
 674    int ret;
 675    int real_argc;
 676    char **real_argv;
 677
 678    // FIXME:
 679    // need to accept current environment from elementary_run
 680    if (!qr_main)
 681      {
 682         int i;
 683         char **args;
 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         setsid();
 693         if (chdir(cwd) != 0)
 694           perror("could not chdir");
 695         args = alloca((argc + 1) * sizeof(char *));
 696         for (i = 0; i < argc; i++) args[i] = argv[i];
 697         args[argc] = NULL;
 698         WRN("%s not quicklaunch capable, fallback...", argv[0]);
 699         execvp(argv[0], args);
 700         ERR("failed to execute '%s': %s", argv[0], strerror(errno));
 701         exit(-1);
 702      }
 703    child = fork();
 704    if (child > 0) return EINA_TRUE;
 705    else if (child < 0)
 706      {
 707         perror("could not fork");
 708         return EINA_FALSE;
 709      }
 710    if (postfork_func) postfork_func(postfork_data);
 711
 712    if (quicklaunch_on)
 713      {
 714 #ifdef SEMI_BROKEN_QUICKLAUNCH
 715         ecore_app_args_set(argc, (const char **)argv);
 716         evas_init();
 717         edje_init();
 718         _elm_config_sub_init();
 719 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
 720         if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
 721             ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
 722             ENGINE_COMPARE(ELM_XRENDER_X11) ||
 723             ENGINE_COMPARE(ELM_OPENGL_X11))
 724 #undef ENGINE_COMPARE
 725           {
 726 # ifdef HAVE_ELEMENTARY_X
 727              ecore_x_init(NULL);
 728 # endif
 729           }
 730         ecore_evas_init(); // FIXME: check errors
 731         ecore_imf_init();
 732         _elm_module_init();
 733 #endif
 734      }
 735
 736    setsid();
 737    if (chdir(cwd) != 0)
 738      perror("could not chdir");
 739    // FIXME: this is very linux specific. it changes argv[0] of the process
 740    // so ps etc. report what you'd expect. for other unixes and os's this
 741    // may just not work
 742    save_env();
 743    if (argv)
 744      {
 745         char *lastarg, *p;
 746
 747         ecore_app_args_get(&real_argc, &real_argv);
 748         lastarg = real_argv[real_argc - 1] + strlen(real_argv[real_argc - 1]);
 749         for (p = real_argv[0]; p < lastarg; p++) *p = 0;
 750         strcpy(real_argv[0], argv[0]);
 751      }
 752    ecore_app_args_set(argc, (const char **)argv);
 753    ret = qr_main(argc, argv);
 754    exit(ret);
 755    return EINA_TRUE;
 756 #else
 757    return EINA_FALSE;
 758    (void)argc;
 759    (void)argv;
 760    (void)cwd;
 761    (void)postfork_func;
 762    (void)postfork_data;
 763 #endif
 764 }
 765
 766 EAPI void
 767 elm_quicklaunch_cleanup(void)
 768 {
 769 #ifdef HAVE_FORK
 770    if (qr_handle)
 771      {
 772         dlclose(qr_handle);
 773         qr_handle = NULL;
 774         qr_main = NULL;
 775      }
 776 #endif
 777 }
 778
 779 EAPI int
 780 elm_quicklaunch_fallback(int    argc,
 781                          char **argv)
 782 {
 783    int ret;
 784    elm_quicklaunch_init(argc, argv);
 785    elm_quicklaunch_sub_init(argc, argv);
 786    elm_quicklaunch_prepare(argc, argv);
 787    ret = qr_main(argc, argv);
 788    exit(ret);
 789    return ret;
 790 }
 791
 792 EAPI char *
 793 elm_quicklaunch_exe_path_get(const char *exe)
 794 {
 795    static char *path = NULL;
 796    static Eina_List *pathlist = NULL;
 797    const char *pathitr;
 798    const Eina_List *l;
 799    char buf[PATH_MAX];
 800    if (exe[0] == '/') return strdup(exe);
 801    if ((exe[0] == '.') && (exe[1] == '/')) return strdup(exe);
 802    if ((exe[0] == '.') && (exe[1] == '.') && (exe[2] == '/')) return strdup(exe);
 803    if (!path)
 804      {
 805         const char *p, *pp;
 806         char *buf2;
 807         path = getenv("PATH");
 808         buf2 = alloca(strlen(path) + 1);
 809         p = path;
 810         pp = p;
 811         for (;; )
 812           {
 813              if ((*p == ':') || (!*p))
 814                {
 815                   int len;
 816
 817                   len = p - pp;
 818                   strncpy(buf2, pp, len);
 819                   buf2[len] = 0;
 820                   pathlist = eina_list_append(pathlist, eina_stringshare_add(buf2));
 821                   if (!*p) break;
 822                   p++;
 823                   pp = p;
 824                }
 825              else
 826                {
 827                   if (!*p) break;
 828                   p++;
 829                }
 830           }
 831      }
 832    EINA_LIST_FOREACH(pathlist, l, pathitr)
 833      {
 834         snprintf(buf, sizeof(buf), "%s/%s", pathitr, exe);
 835         if (!access(buf, R_OK | X_OK)) return strdup(buf);
 836      }
 837    return NULL;
 838 }
 839
 840 EAPI void
 841 elm_run(void)
 842 {
 843    ecore_main_loop_begin();
 844 }
 845
 846 EAPI void
 847 elm_exit(void)
 848 {
 849    ecore_main_loop_quit();
 850 }
 851
 852 EAPI Eina_Bool
 853 elm_policy_set(unsigned int policy,
 854                int          value)
 855 {
 856    Elm_Event_Policy_Changed *ev;
 857
 858    if (policy >= ELM_POLICY_LAST)
 859      return EINA_FALSE;
 860
 861    if (value == _elm_policies[policy])
 862      return EINA_TRUE;
 863
 864    /* TODO: validade policy? */
 865
 866    ev = malloc(sizeof(*ev));
 867    ev->policy = policy;
 868    ev->new_value = value;
 869    ev->old_value = _elm_policies[policy];
 870
 871    _elm_policies[policy] = value;
 872
 873    ecore_event_add(ELM_EVENT_POLICY_CHANGED, ev, NULL, NULL);
 874
 875    return EINA_TRUE;
 876 }
 877
 878 EAPI int
 879 elm_policy_get(unsigned int policy)
 880 {
 881    if (policy >= ELM_POLICY_LAST)
 882      return 0;
 883    return _elm_policies[policy];
 884 }
 885
 886 EAPI void
 887 elm_language_set(const char *lang)
 888 {
 889    setlocale(LC_ALL, lang);
 890    _elm_win_translate();
 891 }
 892
 893 EAPI Eina_Bool
 894 elm_object_mirrored_get(const Evas_Object *obj)
 895 {
 896    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 897    return elm_widget_mirrored_get(obj);
 898 }
 899
 900 EAPI void
 901 elm_object_mirrored_set(Evas_Object *obj, Eina_Bool mirrored)
 902 {
 903    EINA_SAFETY_ON_NULL_RETURN(obj);
 904    elm_widget_mirrored_set(obj, mirrored);
 905 }
 906
 907 EAPI Eina_Bool
 908 elm_object_mirrored_automatic_get(const Evas_Object *obj)
 909 {
 910    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
 911    return elm_widget_mirrored_automatic_get(obj);
 912 }
 913
 914 EAPI void
 915 elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic)
 916 {
 917    EINA_SAFETY_ON_NULL_RETURN(obj);
 918    elm_widget_mirrored_automatic_set(obj, automatic);
 919 }
 920
 921 EAPI void
 922 elm_object_scale_set(Evas_Object *obj,
 923                      double       scale)
 924 {
 925    EINA_SAFETY_ON_NULL_RETURN(obj);
 926    elm_widget_scale_set(obj, scale);
 927 }
 928
 929 EAPI double
 930 elm_object_scale_get(const Evas_Object *obj)
 931 {
 932    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, 0.0);
 933    return elm_widget_scale_get(obj);
 934 }
 935
 936 EAPI void
 937 elm_object_text_part_set(Evas_Object *obj, const char *part, const char *label)
 938 {
 939    EINA_SAFETY_ON_NULL_RETURN(obj);
 940    elm_widget_text_part_set(obj, part, label);
 941 }
 942
 943 EAPI const char *
 944 elm_object_text_part_get(const Evas_Object *obj, const char *part)
 945 {
 946    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 947    return elm_widget_text_part_get(obj, part);
 948 }
 949
 950 EAPI void
 951 elm_object_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *text)
 952 {
 953    EINA_SAFETY_ON_NULL_RETURN(obj);
 954    elm_widget_domain_translatable_text_part_set(obj, part, domain, text);
 955 }
 956
 957 EAPI const char *
 958 elm_object_translatable_text_part_get(const Evas_Object *obj, const char *part)
 959 {
 960    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 961    return elm_widget_translatable_text_part_get(obj, part);
 962 }
 963
 964 EAPI void
 965 elm_object_content_part_set(Evas_Object *obj, const char *part, Evas_Object *content)
 966 {
 967    EINA_SAFETY_ON_NULL_RETURN(obj);
 968    elm_widget_content_part_set(obj, part, content);
 969 }
 970
 971 EAPI Evas_Object *
 972 elm_object_content_part_get(const Evas_Object *obj, const char *part)
 973 {
 974    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 975    return elm_widget_content_part_get(obj, part);
 976 }
 977
 978 EAPI Evas_Object *
 979 elm_object_content_part_unset(Evas_Object *obj, const char *part)
 980 {
 981    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 982    return elm_widget_content_part_unset(obj, part);
 983 }
 984
 985 EAPI double
 986 elm_scale_get(void)
 987 {
 988    return _elm_config->scale;
 989 }
 990
 991 EAPI void
 992 elm_scale_set(double scale)
 993 {
 994    if (_elm_config->scale == scale) return;
 995    _elm_config->scale = scale;
 996    _elm_rescale();
 997 }
 998
 999 EAPI void
1000 elm_scale_all_set(double scale)
1001 {
1002 #ifdef HAVE_ELEMENTARY_X
1003    static Ecore_X_Atom atom = 0;
1004    unsigned int scale_i = (unsigned int)(scale * 1000.0);
1005
1006    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_SCALE");
1007    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1008                                   atom, &scale_i, 1);
1009 #endif
1010 }
1011
1012 EAPI Eina_Bool
1013 elm_password_show_last_get(void)
1014 {
1015    return _elm_config->password_show_last;
1016 }
1017
1018 EAPI void
1019 elm_password_show_last_set(Eina_Bool password_show_last)
1020 {
1021    if (_elm_config->password_show_last == password_show_last) return;
1022    _elm_config->password_show_last = password_show_last;
1023    edje_password_show_last_set(_elm_config->password_show_last);
1024 }
1025
1026 EAPI double
1027 elm_password_show_last_timeout_get(void)
1028 {
1029    return _elm_config->password_show_last_timeout;
1030 }
1031
1032 EAPI void
1033 elm_password_show_last_timeout_set(double password_show_last_timeout)
1034 {
1035    if (_elm_config->password_show_last_timeout == password_show_last_timeout) return;
1036    _elm_config->password_show_last_timeout = password_show_last_timeout;
1037    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
1038 }
1039
1040 EAPI void
1041 elm_object_style_set(Evas_Object *obj,
1042                      const char  *style)
1043 {
1044    EINA_SAFETY_ON_NULL_RETURN(obj);
1045    elm_widget_style_set(obj, style);
1046 }
1047
1048 EAPI const char *
1049 elm_object_style_get(const Evas_Object *obj)
1050 {
1051    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1052    return elm_widget_style_get(obj);
1053 }
1054
1055 EAPI void
1056 elm_object_disabled_set(Evas_Object *obj,
1057                         Eina_Bool    disabled)
1058 {
1059    EINA_SAFETY_ON_NULL_RETURN(obj);
1060    elm_widget_disabled_set(obj, disabled);
1061 }
1062
1063 EAPI Eina_Bool
1064 elm_object_disabled_get(const Evas_Object *obj)
1065 {
1066    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1067    return elm_widget_disabled_get(obj);
1068 }
1069
1070 EAPI Eina_Bool
1071 elm_config_save(void)
1072 {
1073    return _elm_config_save();
1074 }
1075
1076 EAPI void
1077 elm_config_reload(void)
1078 {
1079    _elm_config_reload();
1080 }
1081
1082 EAPI const char *
1083 elm_profile_current_get(void)
1084 {
1085    return _elm_config_current_profile_get();
1086 }
1087
1088 EAPI const char *
1089 elm_profile_dir_get(const char *profile,
1090                     Eina_Bool   is_user)
1091 {
1092    return _elm_config_profile_dir_get(profile, is_user);
1093 }
1094
1095 EAPI void
1096 elm_profile_dir_free(const char *p_dir)
1097 {
1098    free((void *)p_dir);
1099 }
1100
1101 EAPI Eina_List *
1102 elm_profile_list_get(void)
1103 {
1104    return _elm_config_profiles_list();
1105 }
1106
1107 EAPI void
1108 elm_profile_list_free(Eina_List *l)
1109 {
1110    const char *dir;
1111
1112    EINA_LIST_FREE(l, dir)
1113      eina_stringshare_del(dir);
1114 }
1115
1116 EAPI void
1117 elm_profile_set(const char *profile)
1118 {
1119    EINA_SAFETY_ON_NULL_RETURN(profile);
1120    _elm_config_profile_set(profile);
1121 }
1122
1123 EAPI void
1124 elm_profile_all_set(const char *profile)
1125 {
1126 #ifdef HAVE_ELEMENTARY_X
1127    static Ecore_X_Atom atom = 0;
1128
1129    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_PROFILE");
1130    ecore_x_window_prop_string_set(ecore_x_window_root_first_get(),
1131                                   atom, profile);
1132 #endif
1133 }
1134
1135 EAPI const char *
1136 elm_engine_current_get(void)
1137 {
1138    return _elm_config->engine;
1139 }
1140
1141 EAPI void
1142 elm_engine_set(const char *engine)
1143 {
1144    EINA_SAFETY_ON_NULL_RETURN(engine);
1145
1146    _elm_config_engine_set(engine);
1147 }
1148
1149 EAPI const Eina_List *
1150 elm_text_classes_list_get(void)
1151 {
1152    return _elm_config_text_classes_get();
1153 }
1154
1155 EAPI void
1156 elm_text_classes_list_free(const Eina_List *list)
1157 {
1158    _elm_config_text_classes_free((Eina_List *)list);
1159 }
1160
1161 EAPI const Eina_List *
1162 elm_font_overlay_list_get(void)
1163 {
1164    return _elm_config_font_overlays_list();
1165 }
1166
1167 EAPI void
1168 elm_font_overlay_set(const char    *text_class,
1169                      const char    *font,
1170                      Evas_Font_Size size)
1171 {
1172    _elm_config_font_overlay_set(text_class, font, size);
1173 }
1174
1175 EAPI void
1176 elm_font_overlay_unset(const char *text_class)
1177 {
1178    _elm_config_font_overlay_remove(text_class);
1179 }
1180
1181 EAPI void
1182 elm_font_overlay_apply(void)
1183 {
1184    _elm_config_font_overlay_apply();
1185 }
1186
1187 EAPI void
1188 elm_font_overlay_all_apply(void)
1189 {
1190 #ifdef HAVE_ELEMENTARY_X
1191    static Ecore_X_Atom atom = 0;
1192    unsigned int dummy = (unsigned int)(1 * 1000.0);
1193
1194    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FONT_OVERLAY");
1195    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(), atom, &dummy,
1196                                   1);
1197 #endif
1198 }
1199
1200 EAPI Elm_Font_Properties *
1201 elm_font_properties_get(const char *font)
1202 {
1203    EINA_SAFETY_ON_NULL_RETURN_VAL(font, NULL);
1204    return _elm_font_properties_get(NULL, font);
1205 }
1206
1207 EAPI void
1208 elm_font_properties_free(Elm_Font_Properties *efp)
1209 {
1210    const char *str;
1211
1212    EINA_SAFETY_ON_NULL_RETURN(efp);
1213    EINA_LIST_FREE(efp->styles, str)
1214      if (str) eina_stringshare_del(str);
1215    if (efp->name) eina_stringshare_del(efp->name);
1216    free(efp);
1217 }
1218
1219 EAPI const char *
1220 elm_font_fontconfig_name_get(const char *name,
1221                              const char *style)
1222 {
1223    char buf[256];
1224
1225    EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
1226    if (!style || style[0] == 0) return eina_stringshare_add(name);
1227    snprintf(buf, 256, "%s" ELM_FONT_TOKEN_STYLE "%s", name, style);
1228    return eina_stringshare_add(buf);
1229 }
1230
1231 EAPI void
1232 elm_font_fontconfig_name_free(const char *name)
1233 {
1234    eina_stringshare_del(name);
1235 }
1236
1237 EAPI Eina_Hash *
1238 elm_font_available_hash_add(Eina_List *list)
1239 {
1240    Eina_Hash *font_hash;
1241    Eina_List *l;
1242    void *key;
1243
1244    font_hash = NULL;
1245
1246    /* populate with default font families */
1247    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Regular");
1248    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Bold");
1249    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Oblique");
1250    font_hash = _elm_font_available_hash_add(font_hash,
1251                                             "Sans:style=Bold Oblique");
1252
1253    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Regular");
1254    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Bold");
1255    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Oblique");
1256    font_hash = _elm_font_available_hash_add(font_hash,
1257                                             "Serif:style=Bold Oblique");
1258
1259    font_hash = _elm_font_available_hash_add(font_hash,
1260                                             "Monospace:style=Regular");
1261    font_hash = _elm_font_available_hash_add(font_hash,
1262                                             "Monospace:style=Bold");
1263    font_hash = _elm_font_available_hash_add(font_hash,
1264                                             "Monospace:style=Oblique");
1265    font_hash = _elm_font_available_hash_add(font_hash,
1266                                             "Monospace:style=Bold Oblique");
1267
1268    EINA_LIST_FOREACH(list, l, key)
1269      font_hash = _elm_font_available_hash_add(font_hash, key);
1270
1271    return font_hash;
1272 }
1273
1274 EAPI void
1275 elm_font_available_hash_del(Eina_Hash *hash)
1276 {
1277    _elm_font_available_hash_del(hash);
1278 }
1279
1280 EAPI Evas_Coord
1281 elm_finger_size_get(void)
1282 {
1283    return _elm_config->finger_size;
1284 }
1285
1286 EAPI void
1287 elm_finger_size_set(Evas_Coord size)
1288 {
1289    if (_elm_config->finger_size == size) return;
1290    _elm_config->finger_size = size;
1291    _elm_rescale();
1292 }
1293
1294 EAPI void
1295 elm_finger_size_all_set(Evas_Coord size)
1296 {
1297 #ifdef HAVE_ELEMENTARY_X
1298    static Ecore_X_Atom atom = 0;
1299    unsigned int size_i = (unsigned int)size;
1300
1301    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FINGER_SIZE");
1302    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1303                                   atom, &size_i, 1);
1304 #endif
1305 }
1306
1307 EAPI void
1308 elm_autocapitalization_allow_all_set(Eina_Bool on)
1309 {
1310 #ifdef HAVE_ELEMENTARY_X
1311    static Ecore_X_Atom atom = 0;
1312    unsigned int on_i = (unsigned int)on;
1313
1314    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_AUTOCAPITAL_ALLOW");
1315    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1316                                   atom, &on_i, 1);
1317 #endif
1318 }
1319
1320 EAPI void
1321 elm_autoperiod_allow_all_set(Eina_Bool on)
1322 {
1323 #ifdef HAVE_ELEMENTARY_X
1324    static Ecore_X_Atom atom = 0;
1325    unsigned int on_i = (unsigned int)on;
1326
1327    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_AUTOPERIOD_ALLOW");
1328    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1329                                   atom, &on_i, 1);
1330 #endif
1331 }
1332
1333 EAPI void
1334 elm_coords_finger_size_adjust(int         times_w,
1335                               Evas_Coord *w,
1336                               int         times_h,
1337                               Evas_Coord *h)
1338 {
1339    if ((w) && (*w < (_elm_config->finger_size * times_w)))
1340      *w = _elm_config->finger_size * times_w;
1341    if ((h) && (*h < (_elm_config->finger_size * times_h)))
1342      *h = _elm_config->finger_size * times_h;
1343 }
1344
1345 EAPI void
1346 elm_all_flush(void)
1347 {
1348    const Eina_List *l;
1349    Evas_Object *obj;
1350
1351    edje_file_cache_flush();
1352    edje_collection_cache_flush();
1353    eet_clearcache();
1354    EINA_LIST_FOREACH(_elm_win_list, l, obj)
1355      {
1356         Evas *e = evas_object_evas_get(obj);
1357         evas_image_cache_flush(e);
1358         evas_font_cache_flush(e);
1359         evas_render_dump(e);
1360      }
1361 }
1362
1363 EAPI int
1364 elm_cache_flush_interval_get(void)
1365 {
1366    return _elm_config->cache_flush_poll_interval;
1367 }
1368
1369 EAPI void
1370 elm_cache_flush_interval_set(int size)
1371 {
1372    if (_elm_config->cache_flush_poll_interval == size) return;
1373    _elm_config->cache_flush_poll_interval = size;
1374
1375    _elm_recache();
1376 }
1377
1378 EAPI void
1379 elm_cache_flush_interval_all_set(int size)
1380 {
1381 #ifdef HAVE_ELEMENTARY_X
1382    static Ecore_X_Atom atom = 0;
1383    unsigned int size_i = (unsigned int)size;
1384
1385    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_CACHE_FLUSH_INTERVAL");
1386    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1387                                   atom, &size_i, 1);
1388 #endif
1389 }
1390
1391 EAPI Eina_Bool
1392 elm_cache_flush_enabled_get(void)
1393 {
1394    return _elm_config->cache_flush_enable;
1395 }
1396
1397 EAPI void
1398 elm_cache_flush_enabled_set(Eina_Bool enabled)
1399 {
1400    enabled = !!enabled;
1401    if (_elm_config->cache_flush_enable == enabled) return;
1402    _elm_config->cache_flush_enable = enabled;
1403
1404    _elm_recache();
1405 }
1406
1407 EAPI void
1408 elm_cache_flush_enabled_all_set(Eina_Bool enabled)
1409 {
1410 #ifdef HAVE_ELEMENTARY_X
1411    static Ecore_X_Atom atom = 0;
1412    unsigned int enabled_i = (unsigned int)enabled;
1413
1414    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_CACHE_FLUSH_ENABLE");
1415    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1416                                   atom, &enabled_i, 1);
1417 #endif
1418 }
1419
1420 EAPI int
1421 elm_font_cache_get(void)
1422 {
1423    return _elm_config->font_cache;
1424 }
1425
1426 EAPI void
1427 elm_font_cache_set(int size)
1428 {
1429    if (_elm_config->font_cache == size) return;
1430    _elm_config->font_cache = size;
1431
1432    _elm_recache();
1433 }
1434
1435 EAPI void
1436 elm_font_cache_all_set(int size)
1437 {
1438 #ifdef HAVE_ELEMENTARY_X
1439    static Ecore_X_Atom atom = 0;
1440    unsigned int size_i = (unsigned int)size;
1441
1442    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FONT_CACHE");
1443    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1444                                   atom, &size_i, 1);
1445 #endif
1446 }
1447
1448 EAPI int
1449 elm_image_cache_get(void)
1450 {
1451    return _elm_config->image_cache;
1452 }
1453
1454 EAPI void
1455 elm_image_cache_set(int size)
1456 {
1457    if (_elm_config->image_cache == size) return;
1458    _elm_config->image_cache = size;
1459
1460    _elm_recache();
1461 }
1462
1463 EAPI void
1464 elm_image_cache_all_set(int size)
1465 {
1466 #ifdef HAVE_ELEMENTARY_X
1467    static Ecore_X_Atom atom = 0;
1468    unsigned int size_i = (unsigned int)size;
1469
1470    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_IMAGE_CACHE");
1471    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1472                                   atom, &size_i, 1);
1473 #endif
1474 }
1475
1476 EAPI int
1477 elm_edje_file_cache_get(void)
1478 {
1479    return _elm_config->edje_cache;
1480 }
1481
1482 EAPI void
1483 elm_edje_file_cache_set(int size)
1484 {
1485    if (_elm_config->edje_cache == size) return;
1486    _elm_config->edje_cache = size;
1487
1488    _elm_recache();
1489 }
1490
1491 EAPI void
1492 elm_edje_file_cache_all_set(int size)
1493 {
1494 #ifdef HAVE_ELEMENTARY_X
1495    static Ecore_X_Atom atom = 0;
1496    unsigned int size_i = (unsigned int)size;
1497
1498    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_EDJE_FILE_CACHE");
1499    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1500                                   atom, &size_i, 1);
1501 #endif
1502 }
1503
1504 EAPI int
1505 elm_edje_collection_cache_get(void)
1506 {
1507    return _elm_config->edje_collection_cache;
1508 }
1509
1510 EAPI void
1511 elm_edje_collection_cache_set(int size)
1512 {
1513    if (_elm_config->edje_collection_cache == size) return;
1514    _elm_config->edje_collection_cache = size;
1515
1516    _elm_recache();
1517 }
1518
1519 EAPI void
1520 elm_edje_collection_cache_all_set(int size)
1521 {
1522 #ifdef HAVE_ELEMENTARY_X
1523    static Ecore_X_Atom atom = 0;
1524    unsigned int size_i = (unsigned int)size;
1525
1526    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_EDJE_COLLECTION_CACHE");
1527    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1528                                   atom, &size_i, 1);
1529 #endif
1530 }
1531
1532 EAPI Eina_Bool
1533 elm_object_focus_get(const Evas_Object *obj)
1534 {
1535    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1536    return elm_widget_focus_get(obj);
1537 }
1538
1539 EAPI void
1540 elm_object_focus_set(Evas_Object *obj,
1541                      Eina_Bool    focus)
1542 {
1543    EINA_SAFETY_ON_NULL_RETURN(obj);
1544    if (focus)
1545      {
1546         if (elm_widget_focus_get(obj)) return;
1547         elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
1548      }
1549    else
1550      {
1551         if (!elm_widget_can_focus_get(obj)) return;
1552         elm_widget_focused_object_clear(obj);
1553      }
1554 }
1555
1556 EAPI void
1557 elm_object_focus(Evas_Object *obj)
1558 {
1559    EINA_SAFETY_ON_NULL_RETURN(obj);
1560    elm_object_focus_set(obj, EINA_TRUE);
1561 }
1562
1563 EAPI void
1564 elm_object_unfocus(Evas_Object *obj)
1565 {
1566    EINA_SAFETY_ON_NULL_RETURN(obj);
1567    elm_object_focus_set(obj, EINA_FALSE);
1568 }
1569
1570 EAPI void
1571 elm_object_focus_allow_set(Evas_Object *obj,
1572                            Eina_Bool    enable)
1573 {
1574    EINA_SAFETY_ON_NULL_RETURN(obj);
1575    elm_widget_can_focus_set(obj, enable);
1576 }
1577
1578 EAPI Eina_Bool
1579 elm_object_focus_allow_get(const Evas_Object *obj)
1580 {
1581    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1582    return (elm_widget_can_focus_get(obj)) || (elm_widget_child_can_focus_get(obj));
1583 }
1584
1585 EAPI void
1586 elm_object_focus_custom_chain_set(Evas_Object *obj,
1587                                   Eina_List   *objs)
1588 {
1589    EINA_SAFETY_ON_NULL_RETURN(obj);
1590    elm_widget_focus_custom_chain_set(obj, objs);
1591 }
1592
1593 EAPI void
1594 elm_object_focus_custom_chain_unset(Evas_Object *obj)
1595 {
1596    EINA_SAFETY_ON_NULL_RETURN(obj);
1597    elm_widget_focus_custom_chain_unset(obj);
1598 }
1599
1600 EAPI const Eina_List *
1601 elm_object_focus_custom_chain_get(const Evas_Object *obj)
1602 {
1603    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1604    return elm_widget_focus_custom_chain_get(obj);
1605 }
1606
1607 EAPI void
1608 elm_object_focus_custom_chain_append(Evas_Object *obj,
1609                                      Evas_Object *child,
1610                                      Evas_Object *relative_child)
1611 {
1612    EINA_SAFETY_ON_NULL_RETURN(obj);
1613    EINA_SAFETY_ON_NULL_RETURN(child);
1614    elm_widget_focus_custom_chain_append(obj, child, relative_child);
1615 }
1616
1617 EAPI void
1618 elm_object_focus_custom_chain_prepend(Evas_Object *obj,
1619                                       Evas_Object *child,
1620                                       Evas_Object *relative_child)
1621 {
1622    EINA_SAFETY_ON_NULL_RETURN(obj);
1623    EINA_SAFETY_ON_NULL_RETURN(child);
1624    elm_widget_focus_custom_chain_prepend(obj, child, relative_child);
1625 }
1626
1627 EAPI void
1628 elm_object_focus_cycle(Evas_Object        *obj,
1629                        Elm_Focus_Direction dir)
1630 {
1631    EINA_SAFETY_ON_NULL_RETURN(obj);
1632    elm_widget_focus_cycle(obj, dir);
1633 }
1634
1635 EAPI void
1636 elm_object_focus_direction_go(Evas_Object *obj,
1637                               int          x,
1638                               int          y)
1639 {
1640    EINA_SAFETY_ON_NULL_RETURN(obj);
1641    elm_widget_focus_direction_go(obj, x, y);
1642 }
1643
1644 EAPI void
1645 elm_object_tree_unfocusable_set(Evas_Object *obj,
1646                                 Eina_Bool    tree_unfocusable)
1647 {
1648    EINA_SAFETY_ON_NULL_RETURN(obj);
1649    elm_widget_tree_unfocusable_set(obj, tree_unfocusable);
1650 }
1651
1652 EAPI Eina_Bool
1653 elm_object_tree_unfocusable_get(const Evas_Object *obj)
1654 {
1655    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1656    return elm_widget_tree_unfocusable_get(obj);
1657 }
1658
1659 EAPI Eina_Bool
1660 elm_focus_highlight_enabled_get(void)
1661 {
1662    return _elm_config->focus_highlight_enable;
1663 }
1664
1665 EAPI void
1666 elm_focus_highlight_enabled_set(Eina_Bool enable)
1667 {
1668    _elm_config->focus_highlight_enable = !!enable;
1669 }
1670
1671 EAPI Eina_Bool
1672 elm_focus_highlight_animate_get(void)
1673 {
1674    return _elm_config->focus_highlight_animate;
1675 }
1676
1677 EAPI void
1678 elm_focus_highlight_animate_set(Eina_Bool animate)
1679 {
1680    _elm_config->focus_highlight_animate = !!animate;
1681 }
1682
1683 EAPI Eina_Bool
1684 elm_scroll_bounce_enabled_get(void)
1685 {
1686    return _elm_config->thumbscroll_bounce_enable;
1687 }
1688
1689 EAPI void
1690 elm_scroll_bounce_enabled_set(Eina_Bool enabled)
1691 {
1692    _elm_config->thumbscroll_bounce_enable = enabled;
1693 }
1694
1695 EAPI void
1696 elm_scroll_bounce_enabled_all_set(Eina_Bool enabled)
1697 {
1698 #ifdef HAVE_ELEMENTARY_X
1699    static Ecore_X_Atom atom = 0;
1700    unsigned int bounce_enable_i = (unsigned int)enabled;
1701
1702    if (!atom)
1703      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BOUNCE_ENABLE");
1704    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1705                                   atom, &bounce_enable_i, 1);
1706 #endif
1707 }
1708
1709 EAPI double
1710 elm_scroll_bounce_friction_get(void)
1711 {
1712    return _elm_config->thumbscroll_bounce_friction;
1713 }
1714
1715 EAPI void
1716 elm_scroll_bounce_friction_set(double friction)
1717 {
1718    _elm_config->thumbscroll_bounce_friction = friction;
1719 }
1720
1721 EAPI void
1722 elm_scroll_bounce_friction_all_set(double friction)
1723 {
1724 #ifdef HAVE_ELEMENTARY_X
1725    static Ecore_X_Atom atom = 0;
1726    unsigned int bounce_friction_i = (unsigned int)(friction * 1000.0);
1727
1728    if (!atom)
1729      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BOUNCE_FRICTION");
1730    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1731                                   atom, &bounce_friction_i, 1);
1732 #endif
1733 }
1734
1735 EAPI double
1736 elm_scroll_page_scroll_friction_get(void)
1737 {
1738    return _elm_config->page_scroll_friction;
1739 }
1740
1741 EAPI void
1742 elm_scroll_page_scroll_friction_set(double friction)
1743 {
1744    _elm_config->page_scroll_friction = friction;
1745 }
1746
1747 EAPI void
1748 elm_scroll_page_scroll_friction_all_set(double friction)
1749 {
1750 #ifdef HAVE_ELEMENTARY_X
1751    static Ecore_X_Atom atom = 0;
1752    unsigned int page_scroll_friction_i = (unsigned int)(friction * 1000.0);
1753
1754    if (!atom)
1755      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_PAGE_SCROLL_FRICTION");
1756    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1757                                   atom, &page_scroll_friction_i, 1);
1758 #endif
1759 }
1760
1761 EAPI double
1762 elm_scroll_bring_in_scroll_friction_get(void)
1763 {
1764    return _elm_config->bring_in_scroll_friction;
1765 }
1766
1767 EAPI void
1768 elm_scroll_bring_in_scroll_friction_set(double friction)
1769 {
1770    _elm_config->bring_in_scroll_friction = friction;
1771 }
1772
1773 EAPI void
1774 elm_scroll_bring_in_scroll_friction_all_set(double friction)
1775 {
1776 #ifdef HAVE_ELEMENTARY_X
1777    static Ecore_X_Atom atom = 0;
1778    unsigned int bring_in_scroll_friction_i = (unsigned int)(friction * 1000.0);
1779
1780    if (!atom)
1781      atom =
1782        ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BRING_IN_SCROLL_FRICTION");
1783    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1784                                   atom, &bring_in_scroll_friction_i, 1);
1785 #endif
1786 }
1787
1788 EAPI double
1789 elm_scroll_zoom_friction_get(void)
1790 {
1791    return _elm_config->zoom_friction;
1792 }
1793
1794 EAPI void
1795 elm_scroll_zoom_friction_set(double friction)
1796 {
1797    _elm_config->zoom_friction = friction;
1798 }
1799
1800 EAPI void
1801 elm_scroll_zoom_friction_all_set(double friction)
1802 {
1803 #ifdef HAVE_ELEMENTARY_X
1804    static Ecore_X_Atom atom = 0;
1805    unsigned int zoom_friction_i = (unsigned int)(friction * 1000.0);
1806
1807    if (!atom)
1808      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_ZOOM_FRICTION");
1809    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1810                                   atom, &zoom_friction_i, 1);
1811 #endif
1812 }
1813
1814 EAPI Eina_Bool
1815 elm_scroll_thumbscroll_enabled_get(void)
1816 {
1817    return _elm_config->thumbscroll_enable;
1818 }
1819
1820 EAPI void
1821 elm_scroll_thumbscroll_enabled_set(Eina_Bool enabled)
1822 {
1823    _elm_config->thumbscroll_enable = enabled;
1824 }
1825
1826 EAPI void
1827 elm_scroll_thumbscroll_enabled_all_set(Eina_Bool enabled)
1828 {
1829 #ifdef HAVE_ELEMENTARY_X
1830    static Ecore_X_Atom atom = 0;
1831    unsigned int ts_enable_i = (unsigned int)enabled;
1832
1833    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_ENABLE");
1834    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1835                                   atom, &ts_enable_i, 1);
1836 #endif
1837 }
1838
1839 EAPI unsigned int
1840 elm_scroll_thumbscroll_threshold_get(void)
1841 {
1842    return _elm_config->thumbscroll_threshold;
1843 }
1844
1845 EAPI void
1846 elm_scroll_thumbscroll_threshold_set(unsigned int threshold)
1847 {
1848    _elm_config->thumbscroll_threshold = threshold;
1849 }
1850
1851 EAPI void
1852 elm_scroll_thumbscroll_threshold_all_set(unsigned int threshold)
1853 {
1854 #ifdef HAVE_ELEMENTARY_X
1855    static Ecore_X_Atom atom = 0;
1856    unsigned int ts_threshold_i = (unsigned int)threshold;
1857
1858    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_THRESHOLD");
1859    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1860                                   atom, &ts_threshold_i, 1);
1861 #endif
1862 }
1863
1864 EAPI double
1865 elm_scroll_thumbscroll_momentum_threshold_get(void)
1866 {
1867    return _elm_config->thumbscroll_momentum_threshold;
1868 }
1869
1870 EAPI void
1871 elm_scroll_thumbscroll_momentum_threshold_set(double threshold)
1872 {
1873    _elm_config->thumbscroll_momentum_threshold = threshold;
1874 }
1875
1876 EAPI void
1877 elm_scroll_thumbscroll_momentum_threshold_all_set(double threshold)
1878 {
1879 #ifdef HAVE_ELEMENTARY_X
1880    static Ecore_X_Atom atom = 0;
1881    unsigned int ts_momentum_threshold_i = (unsigned int)(threshold * 1000.0);
1882
1883    if (!atom)
1884      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_MOMENTUM_THRESHOLD");
1885    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1886                                   atom, &ts_momentum_threshold_i, 1);
1887 #endif
1888 }
1889
1890 EAPI double
1891 elm_scroll_thumbscroll_friction_get(void)
1892 {
1893    return _elm_config->thumbscroll_friction;
1894 }
1895
1896 EAPI void
1897 elm_scroll_thumbscroll_friction_set(double friction)
1898 {
1899    _elm_config->thumbscroll_friction = friction;
1900 }
1901
1902 EAPI void
1903 elm_scroll_thumbscroll_friction_all_set(double friction)
1904 {
1905 #ifdef HAVE_ELEMENTARY_X
1906    static Ecore_X_Atom atom = 0;
1907    unsigned int ts_friction_i = (unsigned int)(friction * 1000.0);
1908
1909    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_FRICTION");
1910    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1911                                   atom, &ts_friction_i, 1);
1912 #endif
1913 }
1914
1915 EAPI double
1916 elm_scroll_thumbscroll_border_friction_get(void)
1917 {
1918    return _elm_config->thumbscroll_border_friction;
1919 }
1920
1921 EAPI void
1922 elm_scroll_thumbscroll_border_friction_set(double friction)
1923 {
1924    if (friction < 0.0)
1925      friction = 0.0;
1926
1927    if (friction > 1.0)
1928      friction = 1.0;
1929
1930    _elm_config->thumbscroll_friction = friction;
1931 }
1932
1933 EAPI void
1934 elm_scroll_thumbscroll_border_friction_all_set(double friction)
1935 {
1936    if (friction < 0.0)
1937      friction = 0.0;
1938
1939    if (friction > 1.0)
1940      friction = 1.0;
1941
1942 #ifdef HAVE_ELEMENTARY_X
1943    static Ecore_X_Atom atom = 0;
1944    unsigned int border_friction_i = (unsigned int)(friction * 1000.0);
1945
1946    if (!atom)
1947      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BORDER_FRICTION");
1948    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1949                                   atom, &border_friction_i, 1);
1950 #endif
1951 }
1952
1953 EAPI double
1954 elm_scroll_thumbscroll_sensitivity_friction_get(void)
1955 {
1956    return _elm_config->thumbscroll_sensitivity_friction;
1957 }
1958
1959 EAPI void
1960 elm_scroll_thumbscroll_sensitivity_friction_set(double friction)
1961 {
1962    if (friction < 0.1)
1963      friction = 0.1;
1964
1965    if (friction > 1.0)
1966      friction = 1.0;
1967
1968    _elm_config->thumbscroll_friction = friction;
1969 }
1970
1971 EAPI void
1972 elm_scroll_thumbscroll_sensitivity_friction_all_set(double friction)
1973 {
1974    if (friction < 0.1)
1975      friction = 0.1;
1976
1977    if (friction > 1.0)
1978      friction = 1.0;
1979
1980 #ifdef HAVE_ELEMENTARY_X
1981    static Ecore_X_Atom atom = 0;
1982    unsigned int sensitivity_friction_i = (unsigned int)(friction * 1000.0);
1983
1984    if (!atom)
1985      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_SENSITIVITY_FRICTION");
1986    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1987                                   atom, &sensitivity_friction_i, 1);
1988 #endif
1989 }
1990
1991 EAPI void
1992 elm_object_scroll_hold_push(Evas_Object *obj)
1993 {
1994    EINA_SAFETY_ON_NULL_RETURN(obj);
1995    elm_widget_scroll_hold_push(obj);
1996 }
1997
1998 EAPI void
1999 elm_object_scroll_hold_pop(Evas_Object *obj)
2000 {
2001    EINA_SAFETY_ON_NULL_RETURN(obj);
2002    elm_widget_scroll_hold_pop(obj);
2003 }
2004
2005 EAPI void
2006 elm_object_scroll_freeze_push(Evas_Object *obj)
2007 {
2008    EINA_SAFETY_ON_NULL_RETURN(obj);
2009    elm_widget_scroll_freeze_push(obj);
2010 }
2011
2012 EAPI void
2013 elm_object_scroll_lock_x_set(Evas_Object *obj,
2014                              Eina_Bool    lock)
2015 {
2016    EINA_SAFETY_ON_NULL_RETURN(obj);
2017    elm_widget_drag_lock_x_set(obj, lock);
2018 }
2019
2020 EAPI void
2021 elm_object_scroll_lock_y_set(Evas_Object *obj,
2022                              Eina_Bool    lock)
2023 {
2024    EINA_SAFETY_ON_NULL_RETURN(obj);
2025    elm_widget_drag_lock_y_set(obj, lock);
2026 }
2027
2028 EAPI Eina_Bool
2029 elm_object_scroll_lock_x_get(const Evas_Object *obj)
2030 {
2031    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
2032    return elm_widget_drag_lock_x_get(obj);
2033 }
2034
2035 EAPI Eina_Bool
2036 elm_object_scroll_lock_y_get(const Evas_Object *obj)
2037 {
2038    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
2039    return elm_widget_drag_lock_y_get(obj);
2040 }
2041
2042 EAPI void
2043 elm_object_scroll_freeze_pop(Evas_Object *obj)
2044 {
2045    EINA_SAFETY_ON_NULL_RETURN(obj);
2046    elm_widget_scroll_freeze_pop(obj);
2047 }
2048
2049 EAPI Eina_Bool
2050 elm_object_widget_check(const Evas_Object *obj)
2051 {
2052    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
2053    return elm_widget_is(obj);
2054 }
2055
2056 EAPI Evas_Object *
2057 elm_object_parent_widget_get(const Evas_Object *obj)
2058 {
2059    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2060    return elm_widget_parent_widget_get(obj);
2061 }
2062
2063 EAPI Evas_Object *
2064 elm_object_top_widget_get(const Evas_Object *obj)
2065 {
2066    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2067    return elm_widget_top_get(obj);
2068 }
2069
2070 EAPI const char *
2071 elm_object_widget_type_get(const Evas_Object *obj)
2072 {
2073    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2074    return elm_widget_type_get(obj);
2075 }
2076
2077 EAPI void
2078 elm_object_signal_emit(Evas_Object *obj,
2079                        const char  *emission,
2080                        const char  *source)
2081 {
2082    EINA_SAFETY_ON_NULL_RETURN(obj);
2083    elm_widget_signal_emit(obj, emission, source);
2084 }
2085
2086 EAPI void
2087 elm_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
2088 {
2089     EINA_SAFETY_ON_NULL_RETURN(obj);
2090     EINA_SAFETY_ON_NULL_RETURN(func);
2091     elm_widget_signal_callback_add(obj, emission, source, func, data);
2092 }
2093
2094 EAPI void *
2095 elm_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source))
2096 {
2097     EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2098     EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
2099     return elm_widget_signal_callback_del(obj, emission, source, func);
2100 }
2101
2102 EAPI void
2103 elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data)
2104 {
2105    EINA_SAFETY_ON_NULL_RETURN(obj);
2106    EINA_SAFETY_ON_NULL_RETURN(func);
2107    elm_widget_event_callback_add(obj, func, data);
2108 }
2109
2110 EAPI void *
2111 elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data)
2112 {
2113    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2114    EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
2115    return elm_widget_event_callback_del(obj, func, data);
2116 }
2117
2118 EAPI void
2119 elm_object_tree_dump(const Evas_Object *top)
2120 {
2121 #ifdef ELM_DEBUG
2122    elm_widget_tree_dump(top);
2123 #else
2124    return;
2125    (void)top;
2126 #endif
2127 }
2128
2129 EAPI void
2130 elm_object_tree_dot_dump(const Evas_Object *top,
2131                          const char        *file)
2132 {
2133 #ifdef ELM_DEBUG
2134    FILE *f = fopen(file, "wb");
2135    elm_widget_tree_dot_dump(top, f);
2136    fclose(f);
2137 #else
2138    return;
2139    (void)top;
2140    (void)file;
2141 #endif
2142 }
2143
2144 EAPI void
2145 elm_longpress_timeout_set(double longpress_timeout)
2146 {
2147    _elm_config->longpress_timeout = longpress_timeout;
2148 }
2149
2150 EAPI double
2151 elm_longpress_timeout_get(void)
2152 {
2153    return _elm_config->longpress_timeout;
2154 }
2155
2156 EAPI Evas_Object *
2157 elm_object_item_object_get(const Elm_Object_Item *it)
2158 {
2159    return ((Elm_Widget_Item *) it)->widget;
2160 }
2161
2162 EAPI void
2163 elm_object_item_content_part_set(Elm_Object_Item *it,
2164                                  const char *part,
2165                                  Evas_Object *content)
2166 {
2167    elm_widget_item_content_part_set(it, part, content);
2168 }
2169
2170 EAPI Evas_Object *
2171 elm_object_item_content_part_get(const Elm_Object_Item *it,
2172                                  const char *part)
2173 {
2174    return elm_widget_item_content_part_get(it, part);
2175 }
2176
2177 EAPI Evas_Object *
2178 elm_object_item_content_part_unset(Elm_Object_Item *it, const char *part)
2179 {
2180    return elm_widget_item_content_part_unset(it, part);
2181 }
2182
2183 EAPI void
2184 elm_object_item_text_part_set(Elm_Object_Item *it,
2185                               const char *part,
2186                               const char *label)
2187 {
2188    elm_widget_item_text_part_set(it, part, label);
2189 }
2190
2191 EAPI const char *
2192 elm_object_item_text_part_get(const Elm_Object_Item *it, const char *part)
2193 {
2194    return elm_widget_item_text_part_get(it, part);
2195 }
2196
2197 EAPI void *
2198 elm_object_item_data_get(const Elm_Object_Item *it)
2199 {
2200    return elm_widget_item_data_get(it);
2201 }
2202
2203 EAPI void
2204 elm_object_item_data_set(Elm_Object_Item *it, void *data)
2205 {
2206    elm_widget_item_data_set(it, data);
2207 }
2208
2209 EAPI void
2210 elm_object_item_signal_emit(Elm_Object_Item *it, const char *emission, const char *source)
2211 {
2212    elm_widget_item_signal_emit(it, emission, source);
2213 }
2214
2215 EAPI void
2216 elm_object_access_info_set(Evas_Object *obj, const char *txt)
2217 {
2218    elm_widget_access_info_set(obj, txt);
2219 }
2220
2221 EAPI void
2222 elm_object_item_access_info_set(Elm_Object_Item *it, const char *txt)
2223 {
2224    _elm_widget_item_access_info_set((Elm_Widget_Item *)it, txt);
2225 }
2226