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_part_text_set(Evas_Object *obj, const char *part, const char *label)
 952 {
 953    EINA_SAFETY_ON_NULL_RETURN(obj);
 954    elm_widget_text_part_set(obj, part, label);
 955 }
 956
 957 EAPI const char *
 958 elm_object_part_text_get(const Evas_Object *obj, const char *part)
 959 {
 960    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 961    return elm_widget_text_part_get(obj, part);
 962 }
 963
 964 EAPI void
 965 elm_object_domain_translatable_text_part_set(Evas_Object *obj, const char *part, const char *domain, const char *text)
 966 {
 967    EINA_SAFETY_ON_NULL_RETURN(obj);
 968    elm_widget_domain_translatable_text_part_set(obj, part, domain, text);
 969 }
 970
 971 EAPI const char *
 972 elm_object_translatable_text_part_get(const Evas_Object *obj, const char *part)
 973 {
 974    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 975    return elm_widget_translatable_text_part_get(obj, part);
 976 }
 977
 978 EAPI void
 979 elm_object_content_part_set(Evas_Object *obj, const char *part, Evas_Object *content)
 980 {
 981    EINA_SAFETY_ON_NULL_RETURN(obj);
 982    elm_widget_content_part_set(obj, part, content);
 983 }
 984
 985 EAPI Evas_Object *
 986 elm_object_content_part_get(const Evas_Object *obj, const char *part)
 987 {
 988    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 989    return elm_widget_content_part_get(obj, part);
 990 }
 991
 992 EAPI Evas_Object *
 993 elm_object_content_part_unset(Evas_Object *obj, const char *part)
 994 {
 995    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
 996    return elm_widget_content_part_unset(obj, part);
 997 }
 998
 999 EAPI double
1000 elm_scale_get(void)
1001 {
1002    return _elm_config->scale;
1003 }
1004
1005 EAPI void
1006 elm_scale_set(double scale)
1007 {
1008    if (_elm_config->scale == scale) return;
1009    _elm_config->scale = scale;
1010    _elm_rescale();
1011 }
1012
1013 EAPI void
1014 elm_scale_all_set(double scale)
1015 {
1016 #ifdef HAVE_ELEMENTARY_X
1017    static Ecore_X_Atom atom = 0;
1018    unsigned int scale_i = (unsigned int)(scale * 1000.0);
1019
1020    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_SCALE");
1021    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1022                                   atom, &scale_i, 1);
1023 #endif
1024 }
1025
1026 EAPI Eina_Bool
1027 elm_password_show_last_get(void)
1028 {
1029    return _elm_config->password_show_last;
1030 }
1031
1032 EAPI void
1033 elm_password_show_last_set(Eina_Bool password_show_last)
1034 {
1035    if (_elm_config->password_show_last == password_show_last) return;
1036    _elm_config->password_show_last = password_show_last;
1037    edje_password_show_last_set(_elm_config->password_show_last);
1038 }
1039
1040 EAPI double
1041 elm_password_show_last_timeout_get(void)
1042 {
1043    return _elm_config->password_show_last_timeout;
1044 }
1045
1046 EAPI void
1047 elm_password_show_last_timeout_set(double password_show_last_timeout)
1048 {
1049    if (_elm_config->password_show_last_timeout == password_show_last_timeout) return;
1050    _elm_config->password_show_last_timeout = password_show_last_timeout;
1051    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
1052 }
1053
1054 EAPI void
1055 elm_object_style_set(Evas_Object *obj,
1056                      const char  *style)
1057 {
1058    EINA_SAFETY_ON_NULL_RETURN(obj);
1059    elm_widget_style_set(obj, style);
1060 }
1061
1062 EAPI const char *
1063 elm_object_style_get(const Evas_Object *obj)
1064 {
1065    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1066    return elm_widget_style_get(obj);
1067 }
1068
1069 EAPI void
1070 elm_object_disabled_set(Evas_Object *obj,
1071                         Eina_Bool    disabled)
1072 {
1073    EINA_SAFETY_ON_NULL_RETURN(obj);
1074    elm_widget_disabled_set(obj, disabled);
1075 }
1076
1077 EAPI Eina_Bool
1078 elm_object_disabled_get(const Evas_Object *obj)
1079 {
1080    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1081    return elm_widget_disabled_get(obj);
1082 }
1083
1084 EAPI Eina_Bool
1085 elm_config_save(void)
1086 {
1087    return _elm_config_save();
1088 }
1089
1090 EAPI void
1091 elm_config_reload(void)
1092 {
1093    _elm_config_reload();
1094 }
1095
1096 EAPI const char *
1097 elm_profile_current_get(void)
1098 {
1099    return _elm_config_current_profile_get();
1100 }
1101
1102 EAPI const char *
1103 elm_profile_dir_get(const char *profile,
1104                     Eina_Bool   is_user)
1105 {
1106    return _elm_config_profile_dir_get(profile, is_user);
1107 }
1108
1109 EAPI void
1110 elm_profile_dir_free(const char *p_dir)
1111 {
1112    free((void *)p_dir);
1113 }
1114
1115 EAPI Eina_List *
1116 elm_profile_list_get(void)
1117 {
1118    return _elm_config_profiles_list();
1119 }
1120
1121 EAPI void
1122 elm_profile_list_free(Eina_List *l)
1123 {
1124    const char *dir;
1125
1126    EINA_LIST_FREE(l, dir)
1127      eina_stringshare_del(dir);
1128 }
1129
1130 EAPI void
1131 elm_profile_set(const char *profile)
1132 {
1133    EINA_SAFETY_ON_NULL_RETURN(profile);
1134    _elm_config_profile_set(profile);
1135 }
1136
1137 EAPI void
1138 elm_profile_all_set(const char *profile)
1139 {
1140 #ifdef HAVE_ELEMENTARY_X
1141    static Ecore_X_Atom atom = 0;
1142
1143    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_PROFILE");
1144    ecore_x_window_prop_string_set(ecore_x_window_root_first_get(),
1145                                   atom, profile);
1146 #endif
1147 }
1148
1149 EAPI const char *
1150 elm_engine_current_get(void)
1151 {
1152    return _elm_config->engine;
1153 }
1154
1155 EAPI void
1156 elm_engine_set(const char *engine)
1157 {
1158    EINA_SAFETY_ON_NULL_RETURN(engine);
1159
1160    _elm_config_engine_set(engine);
1161 }
1162
1163 EAPI const Eina_List *
1164 elm_text_classes_list_get(void)
1165 {
1166    return _elm_config_text_classes_get();
1167 }
1168
1169 EAPI void
1170 elm_text_classes_list_free(const Eina_List *list)
1171 {
1172    _elm_config_text_classes_free((Eina_List *)list);
1173 }
1174
1175 EAPI const Eina_List *
1176 elm_font_overlay_list_get(void)
1177 {
1178    return _elm_config_font_overlays_list();
1179 }
1180
1181 EAPI void
1182 elm_font_overlay_set(const char    *text_class,
1183                      const char    *font,
1184                      Evas_Font_Size size)
1185 {
1186    _elm_config_font_overlay_set(text_class, font, size);
1187 }
1188
1189 EAPI void
1190 elm_font_overlay_unset(const char *text_class)
1191 {
1192    _elm_config_font_overlay_remove(text_class);
1193 }
1194
1195 EAPI void
1196 elm_font_overlay_apply(void)
1197 {
1198    _elm_config_font_overlay_apply();
1199 }
1200
1201 EAPI void
1202 elm_font_overlay_all_apply(void)
1203 {
1204 #ifdef HAVE_ELEMENTARY_X
1205    static Ecore_X_Atom atom = 0;
1206    unsigned int dummy = (unsigned int)(1 * 1000.0);
1207
1208    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FONT_OVERLAY");
1209    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(), atom, &dummy,
1210                                   1);
1211 #endif
1212 }
1213
1214 EAPI Elm_Font_Properties *
1215 elm_font_properties_get(const char *font)
1216 {
1217    EINA_SAFETY_ON_NULL_RETURN_VAL(font, NULL);
1218    return _elm_font_properties_get(NULL, font);
1219 }
1220
1221 EAPI void
1222 elm_font_properties_free(Elm_Font_Properties *efp)
1223 {
1224    const char *str;
1225
1226    EINA_SAFETY_ON_NULL_RETURN(efp);
1227    EINA_LIST_FREE(efp->styles, str)
1228      if (str) eina_stringshare_del(str);
1229    if (efp->name) eina_stringshare_del(efp->name);
1230    free(efp);
1231 }
1232
1233 EAPI const char *
1234 elm_font_fontconfig_name_get(const char *name,
1235                              const char *style)
1236 {
1237    char buf[256];
1238
1239    EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
1240    if (!style || style[0] == 0) return eina_stringshare_add(name);
1241    snprintf(buf, 256, "%s" ELM_FONT_TOKEN_STYLE "%s", name, style);
1242    return eina_stringshare_add(buf);
1243 }
1244
1245 EAPI void
1246 elm_font_fontconfig_name_free(const char *name)
1247 {
1248    eina_stringshare_del(name);
1249 }
1250
1251 EAPI Eina_Hash *
1252 elm_font_available_hash_add(Eina_List *list)
1253 {
1254    Eina_Hash *font_hash;
1255    Eina_List *l;
1256    void *key;
1257
1258    font_hash = NULL;
1259
1260    /* populate with default font families */
1261    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Regular");
1262    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Bold");
1263    font_hash = _elm_font_available_hash_add(font_hash, "Sans:style=Oblique");
1264    font_hash = _elm_font_available_hash_add(font_hash,
1265                                             "Sans:style=Bold Oblique");
1266
1267    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Regular");
1268    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Bold");
1269    font_hash = _elm_font_available_hash_add(font_hash, "Serif:style=Oblique");
1270    font_hash = _elm_font_available_hash_add(font_hash,
1271                                             "Serif:style=Bold Oblique");
1272
1273    font_hash = _elm_font_available_hash_add(font_hash,
1274                                             "Monospace:style=Regular");
1275    font_hash = _elm_font_available_hash_add(font_hash,
1276                                             "Monospace:style=Bold");
1277    font_hash = _elm_font_available_hash_add(font_hash,
1278                                             "Monospace:style=Oblique");
1279    font_hash = _elm_font_available_hash_add(font_hash,
1280                                             "Monospace:style=Bold Oblique");
1281
1282    EINA_LIST_FOREACH(list, l, key)
1283      font_hash = _elm_font_available_hash_add(font_hash, key);
1284
1285    return font_hash;
1286 }
1287
1288 EAPI void
1289 elm_font_available_hash_del(Eina_Hash *hash)
1290 {
1291    _elm_font_available_hash_del(hash);
1292 }
1293
1294 EAPI Evas_Coord
1295 elm_finger_size_get(void)
1296 {
1297    return _elm_config->finger_size;
1298 }
1299
1300 EAPI void
1301 elm_finger_size_set(Evas_Coord size)
1302 {
1303    if (_elm_config->finger_size == size) return;
1304    _elm_config->finger_size = size;
1305    _elm_rescale();
1306 }
1307
1308 EAPI void
1309 elm_finger_size_all_set(Evas_Coord size)
1310 {
1311 #ifdef HAVE_ELEMENTARY_X
1312    static Ecore_X_Atom atom = 0;
1313    unsigned int size_i = (unsigned int)size;
1314
1315    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FINGER_SIZE");
1316    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1317                                   atom, &size_i, 1);
1318 #endif
1319 }
1320
1321 EAPI void
1322 elm_autocapitalization_allow_all_set(Eina_Bool on)
1323 {
1324 #ifdef HAVE_ELEMENTARY_X
1325    static Ecore_X_Atom atom = 0;
1326    unsigned int on_i = (unsigned int)on;
1327
1328    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_AUTOCAPITAL_ALLOW");
1329    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1330                                   atom, &on_i, 1);
1331 #endif
1332 }
1333
1334 EAPI void
1335 elm_autoperiod_allow_all_set(Eina_Bool on)
1336 {
1337 #ifdef HAVE_ELEMENTARY_X
1338    static Ecore_X_Atom atom = 0;
1339    unsigned int on_i = (unsigned int)on;
1340
1341    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_AUTOPERIOD_ALLOW");
1342    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1343                                   atom, &on_i, 1);
1344 #endif
1345 }
1346
1347 EAPI void
1348 elm_coords_finger_size_adjust(int         times_w,
1349                               Evas_Coord *w,
1350                               int         times_h,
1351                               Evas_Coord *h)
1352 {
1353    if ((w) && (*w < (_elm_config->finger_size * times_w)))
1354      *w = _elm_config->finger_size * times_w;
1355    if ((h) && (*h < (_elm_config->finger_size * times_h)))
1356      *h = _elm_config->finger_size * times_h;
1357 }
1358
1359 EAPI void
1360 elm_all_flush(void)
1361 {
1362    const Eina_List *l;
1363    Evas_Object *obj;
1364
1365    edje_file_cache_flush();
1366    edje_collection_cache_flush();
1367    eet_clearcache();
1368    EINA_LIST_FOREACH(_elm_win_list, l, obj)
1369      {
1370         Evas *e = evas_object_evas_get(obj);
1371         evas_image_cache_flush(e);
1372         evas_font_cache_flush(e);
1373         evas_render_dump(e);
1374      }
1375 }
1376
1377 EAPI int
1378 elm_cache_flush_interval_get(void)
1379 {
1380    return _elm_config->cache_flush_poll_interval;
1381 }
1382
1383 EAPI void
1384 elm_cache_flush_interval_set(int size)
1385 {
1386    if (_elm_config->cache_flush_poll_interval == size) return;
1387    _elm_config->cache_flush_poll_interval = size;
1388
1389    _elm_recache();
1390 }
1391
1392 EAPI void
1393 elm_cache_flush_interval_all_set(int size)
1394 {
1395 #ifdef HAVE_ELEMENTARY_X
1396    static Ecore_X_Atom atom = 0;
1397    unsigned int size_i = (unsigned int)size;
1398
1399    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_CACHE_FLUSH_INTERVAL");
1400    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1401                                   atom, &size_i, 1);
1402 #endif
1403 }
1404
1405 EAPI Eina_Bool
1406 elm_cache_flush_enabled_get(void)
1407 {
1408    return _elm_config->cache_flush_enable;
1409 }
1410
1411 EAPI void
1412 elm_cache_flush_enabled_set(Eina_Bool enabled)
1413 {
1414    enabled = !!enabled;
1415    if (_elm_config->cache_flush_enable == enabled) return;
1416    _elm_config->cache_flush_enable = enabled;
1417
1418    _elm_recache();
1419 }
1420
1421 EAPI void
1422 elm_cache_flush_enabled_all_set(Eina_Bool enabled)
1423 {
1424 #ifdef HAVE_ELEMENTARY_X
1425    static Ecore_X_Atom atom = 0;
1426    unsigned int enabled_i = (unsigned int)enabled;
1427
1428    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_CACHE_FLUSH_ENABLE");
1429    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1430                                   atom, &enabled_i, 1);
1431 #endif
1432 }
1433
1434 EAPI int
1435 elm_font_cache_get(void)
1436 {
1437    return _elm_config->font_cache;
1438 }
1439
1440 EAPI void
1441 elm_font_cache_set(int size)
1442 {
1443    if (_elm_config->font_cache == size) return;
1444    _elm_config->font_cache = size;
1445
1446    _elm_recache();
1447 }
1448
1449 EAPI void
1450 elm_font_cache_all_set(int size)
1451 {
1452 #ifdef HAVE_ELEMENTARY_X
1453    static Ecore_X_Atom atom = 0;
1454    unsigned int size_i = (unsigned int)size;
1455
1456    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_FONT_CACHE");
1457    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1458                                   atom, &size_i, 1);
1459 #endif
1460 }
1461
1462 EAPI int
1463 elm_image_cache_get(void)
1464 {
1465    return _elm_config->image_cache;
1466 }
1467
1468 EAPI void
1469 elm_image_cache_set(int size)
1470 {
1471    if (_elm_config->image_cache == size) return;
1472    _elm_config->image_cache = size;
1473
1474    _elm_recache();
1475 }
1476
1477 EAPI void
1478 elm_image_cache_all_set(int size)
1479 {
1480 #ifdef HAVE_ELEMENTARY_X
1481    static Ecore_X_Atom atom = 0;
1482    unsigned int size_i = (unsigned int)size;
1483
1484    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_IMAGE_CACHE");
1485    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1486                                   atom, &size_i, 1);
1487 #endif
1488 }
1489
1490 EAPI int
1491 elm_edje_file_cache_get(void)
1492 {
1493    return _elm_config->edje_cache;
1494 }
1495
1496 EAPI void
1497 elm_edje_file_cache_set(int size)
1498 {
1499    if (_elm_config->edje_cache == size) return;
1500    _elm_config->edje_cache = size;
1501
1502    _elm_recache();
1503 }
1504
1505 EAPI void
1506 elm_edje_file_cache_all_set(int size)
1507 {
1508 #ifdef HAVE_ELEMENTARY_X
1509    static Ecore_X_Atom atom = 0;
1510    unsigned int size_i = (unsigned int)size;
1511
1512    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_EDJE_FILE_CACHE");
1513    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1514                                   atom, &size_i, 1);
1515 #endif
1516 }
1517
1518 EAPI int
1519 elm_edje_collection_cache_get(void)
1520 {
1521    return _elm_config->edje_collection_cache;
1522 }
1523
1524 EAPI void
1525 elm_edje_collection_cache_set(int size)
1526 {
1527    if (_elm_config->edje_collection_cache == size) return;
1528    _elm_config->edje_collection_cache = size;
1529
1530    _elm_recache();
1531 }
1532
1533 EAPI void
1534 elm_edje_collection_cache_all_set(int size)
1535 {
1536 #ifdef HAVE_ELEMENTARY_X
1537    static Ecore_X_Atom atom = 0;
1538    unsigned int size_i = (unsigned int)size;
1539
1540    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_EDJE_COLLECTION_CACHE");
1541    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1542                                   atom, &size_i, 1);
1543 #endif
1544 }
1545
1546 EAPI Eina_Bool
1547 elm_object_focus_get(const Evas_Object *obj)
1548 {
1549    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1550    return elm_widget_focus_get(obj);
1551 }
1552
1553 EAPI void
1554 elm_object_focus_set(Evas_Object *obj,
1555                      Eina_Bool    focus)
1556 {
1557    EINA_SAFETY_ON_NULL_RETURN(obj);
1558    if (focus)
1559      {
1560         if (elm_widget_focus_get(obj)) return;
1561         elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
1562      }
1563    else
1564      {
1565         if (!elm_widget_can_focus_get(obj)) return;
1566         elm_widget_focused_object_clear(obj);
1567      }
1568 }
1569
1570 EAPI void
1571 elm_object_focus(Evas_Object *obj)
1572 {
1573    EINA_SAFETY_ON_NULL_RETURN(obj);
1574    elm_object_focus_set(obj, EINA_TRUE);
1575 }
1576
1577 EAPI void
1578 elm_object_unfocus(Evas_Object *obj)
1579 {
1580    EINA_SAFETY_ON_NULL_RETURN(obj);
1581    elm_object_focus_set(obj, EINA_FALSE);
1582 }
1583
1584 EAPI void
1585 elm_object_focus_allow_set(Evas_Object *obj,
1586                            Eina_Bool    enable)
1587 {
1588    EINA_SAFETY_ON_NULL_RETURN(obj);
1589    elm_widget_can_focus_set(obj, enable);
1590 }
1591
1592 EAPI Eina_Bool
1593 elm_object_focus_allow_get(const Evas_Object *obj)
1594 {
1595    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1596    return (elm_widget_can_focus_get(obj)) || (elm_widget_child_can_focus_get(obj));
1597 }
1598
1599 EAPI void
1600 elm_object_focus_custom_chain_set(Evas_Object *obj,
1601                                   Eina_List   *objs)
1602 {
1603    EINA_SAFETY_ON_NULL_RETURN(obj);
1604    elm_widget_focus_custom_chain_set(obj, objs);
1605 }
1606
1607 EAPI void
1608 elm_object_focus_custom_chain_unset(Evas_Object *obj)
1609 {
1610    EINA_SAFETY_ON_NULL_RETURN(obj);
1611    elm_widget_focus_custom_chain_unset(obj);
1612 }
1613
1614 EAPI const Eina_List *
1615 elm_object_focus_custom_chain_get(const Evas_Object *obj)
1616 {
1617    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
1618    return elm_widget_focus_custom_chain_get(obj);
1619 }
1620
1621 EAPI void
1622 elm_object_focus_custom_chain_append(Evas_Object *obj,
1623                                      Evas_Object *child,
1624                                      Evas_Object *relative_child)
1625 {
1626    EINA_SAFETY_ON_NULL_RETURN(obj);
1627    EINA_SAFETY_ON_NULL_RETURN(child);
1628    elm_widget_focus_custom_chain_append(obj, child, relative_child);
1629 }
1630
1631 EAPI void
1632 elm_object_focus_custom_chain_prepend(Evas_Object *obj,
1633                                       Evas_Object *child,
1634                                       Evas_Object *relative_child)
1635 {
1636    EINA_SAFETY_ON_NULL_RETURN(obj);
1637    EINA_SAFETY_ON_NULL_RETURN(child);
1638    elm_widget_focus_custom_chain_prepend(obj, child, relative_child);
1639 }
1640
1641 EAPI void
1642 elm_object_focus_cycle(Evas_Object        *obj,
1643                        Elm_Focus_Direction dir)
1644 {
1645    EINA_SAFETY_ON_NULL_RETURN(obj);
1646    elm_widget_focus_cycle(obj, dir);
1647 }
1648
1649 EAPI void
1650 elm_object_focus_direction_go(Evas_Object *obj,
1651                               int          x,
1652                               int          y)
1653 {
1654    EINA_SAFETY_ON_NULL_RETURN(obj);
1655    elm_widget_focus_direction_go(obj, x, y);
1656 }
1657
1658 EAPI void
1659 elm_object_tree_unfocusable_set(Evas_Object *obj,
1660                                 Eina_Bool    tree_unfocusable)
1661 {
1662    EINA_SAFETY_ON_NULL_RETURN(obj);
1663    elm_widget_tree_unfocusable_set(obj, tree_unfocusable);
1664 }
1665
1666 EAPI Eina_Bool
1667 elm_object_tree_unfocusable_get(const Evas_Object *obj)
1668 {
1669    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
1670    return elm_widget_tree_unfocusable_get(obj);
1671 }
1672
1673 EAPI Eina_Bool
1674 elm_focus_highlight_enabled_get(void)
1675 {
1676    return _elm_config->focus_highlight_enable;
1677 }
1678
1679 EAPI void
1680 elm_focus_highlight_enabled_set(Eina_Bool enable)
1681 {
1682    _elm_config->focus_highlight_enable = !!enable;
1683 }
1684
1685 EAPI Eina_Bool
1686 elm_focus_highlight_animate_get(void)
1687 {
1688    return _elm_config->focus_highlight_animate;
1689 }
1690
1691 EAPI void
1692 elm_focus_highlight_animate_set(Eina_Bool animate)
1693 {
1694    _elm_config->focus_highlight_animate = !!animate;
1695 }
1696
1697 EAPI Eina_Bool
1698 elm_scroll_bounce_enabled_get(void)
1699 {
1700    return _elm_config->thumbscroll_bounce_enable;
1701 }
1702
1703 EAPI void
1704 elm_scroll_bounce_enabled_set(Eina_Bool enabled)
1705 {
1706    _elm_config->thumbscroll_bounce_enable = enabled;
1707 }
1708
1709 EAPI void
1710 elm_scroll_bounce_enabled_all_set(Eina_Bool enabled)
1711 {
1712 #ifdef HAVE_ELEMENTARY_X
1713    static Ecore_X_Atom atom = 0;
1714    unsigned int bounce_enable_i = (unsigned int)enabled;
1715
1716    if (!atom)
1717      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BOUNCE_ENABLE");
1718    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1719                                   atom, &bounce_enable_i, 1);
1720 #endif
1721 }
1722
1723 EAPI double
1724 elm_scroll_bounce_friction_get(void)
1725 {
1726    return _elm_config->thumbscroll_bounce_friction;
1727 }
1728
1729 EAPI void
1730 elm_scroll_bounce_friction_set(double friction)
1731 {
1732    _elm_config->thumbscroll_bounce_friction = friction;
1733 }
1734
1735 EAPI void
1736 elm_scroll_bounce_friction_all_set(double friction)
1737 {
1738 #ifdef HAVE_ELEMENTARY_X
1739    static Ecore_X_Atom atom = 0;
1740    unsigned int bounce_friction_i = (unsigned int)(friction * 1000.0);
1741
1742    if (!atom)
1743      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BOUNCE_FRICTION");
1744    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1745                                   atom, &bounce_friction_i, 1);
1746 #endif
1747 }
1748
1749 EAPI double
1750 elm_scroll_page_scroll_friction_get(void)
1751 {
1752    return _elm_config->page_scroll_friction;
1753 }
1754
1755 EAPI void
1756 elm_scroll_page_scroll_friction_set(double friction)
1757 {
1758    _elm_config->page_scroll_friction = friction;
1759 }
1760
1761 EAPI void
1762 elm_scroll_page_scroll_friction_all_set(double friction)
1763 {
1764 #ifdef HAVE_ELEMENTARY_X
1765    static Ecore_X_Atom atom = 0;
1766    unsigned int page_scroll_friction_i = (unsigned int)(friction * 1000.0);
1767
1768    if (!atom)
1769      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_PAGE_SCROLL_FRICTION");
1770    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1771                                   atom, &page_scroll_friction_i, 1);
1772 #endif
1773 }
1774
1775 EAPI double
1776 elm_scroll_bring_in_scroll_friction_get(void)
1777 {
1778    return _elm_config->bring_in_scroll_friction;
1779 }
1780
1781 EAPI void
1782 elm_scroll_bring_in_scroll_friction_set(double friction)
1783 {
1784    _elm_config->bring_in_scroll_friction = friction;
1785 }
1786
1787 EAPI void
1788 elm_scroll_bring_in_scroll_friction_all_set(double friction)
1789 {
1790 #ifdef HAVE_ELEMENTARY_X
1791    static Ecore_X_Atom atom = 0;
1792    unsigned int bring_in_scroll_friction_i = (unsigned int)(friction * 1000.0);
1793
1794    if (!atom)
1795      atom =
1796        ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BRING_IN_SCROLL_FRICTION");
1797    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1798                                   atom, &bring_in_scroll_friction_i, 1);
1799 #endif
1800 }
1801
1802 EAPI double
1803 elm_scroll_zoom_friction_get(void)
1804 {
1805    return _elm_config->zoom_friction;
1806 }
1807
1808 EAPI void
1809 elm_scroll_zoom_friction_set(double friction)
1810 {
1811    _elm_config->zoom_friction = friction;
1812 }
1813
1814 EAPI void
1815 elm_scroll_zoom_friction_all_set(double friction)
1816 {
1817 #ifdef HAVE_ELEMENTARY_X
1818    static Ecore_X_Atom atom = 0;
1819    unsigned int zoom_friction_i = (unsigned int)(friction * 1000.0);
1820
1821    if (!atom)
1822      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_ZOOM_FRICTION");
1823    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1824                                   atom, &zoom_friction_i, 1);
1825 #endif
1826 }
1827
1828 EAPI Eina_Bool
1829 elm_scroll_thumbscroll_enabled_get(void)
1830 {
1831    return _elm_config->thumbscroll_enable;
1832 }
1833
1834 EAPI void
1835 elm_scroll_thumbscroll_enabled_set(Eina_Bool enabled)
1836 {
1837    _elm_config->thumbscroll_enable = enabled;
1838 }
1839
1840 EAPI void
1841 elm_scroll_thumbscroll_enabled_all_set(Eina_Bool enabled)
1842 {
1843 #ifdef HAVE_ELEMENTARY_X
1844    static Ecore_X_Atom atom = 0;
1845    unsigned int ts_enable_i = (unsigned int)enabled;
1846
1847    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_ENABLE");
1848    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1849                                   atom, &ts_enable_i, 1);
1850 #endif
1851 }
1852
1853 EAPI unsigned int
1854 elm_scroll_thumbscroll_threshold_get(void)
1855 {
1856    return _elm_config->thumbscroll_threshold;
1857 }
1858
1859 EAPI void
1860 elm_scroll_thumbscroll_threshold_set(unsigned int threshold)
1861 {
1862    _elm_config->thumbscroll_threshold = threshold;
1863 }
1864
1865 EAPI void
1866 elm_scroll_thumbscroll_threshold_all_set(unsigned int threshold)
1867 {
1868 #ifdef HAVE_ELEMENTARY_X
1869    static Ecore_X_Atom atom = 0;
1870    unsigned int ts_threshold_i = (unsigned int)threshold;
1871
1872    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_THRESHOLD");
1873    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1874                                   atom, &ts_threshold_i, 1);
1875 #endif
1876 }
1877
1878 EAPI double
1879 elm_scroll_thumbscroll_momentum_threshold_get(void)
1880 {
1881    return _elm_config->thumbscroll_momentum_threshold;
1882 }
1883
1884 EAPI void
1885 elm_scroll_thumbscroll_momentum_threshold_set(double threshold)
1886 {
1887    _elm_config->thumbscroll_momentum_threshold = threshold;
1888 }
1889
1890 EAPI void
1891 elm_scroll_thumbscroll_momentum_threshold_all_set(double threshold)
1892 {
1893 #ifdef HAVE_ELEMENTARY_X
1894    static Ecore_X_Atom atom = 0;
1895    unsigned int ts_momentum_threshold_i = (unsigned int)(threshold * 1000.0);
1896
1897    if (!atom)
1898      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_MOMENTUM_THRESHOLD");
1899    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1900                                   atom, &ts_momentum_threshold_i, 1);
1901 #endif
1902 }
1903
1904 EAPI double
1905 elm_scroll_thumbscroll_friction_get(void)
1906 {
1907    return _elm_config->thumbscroll_friction;
1908 }
1909
1910 EAPI void
1911 elm_scroll_thumbscroll_friction_set(double friction)
1912 {
1913    _elm_config->thumbscroll_friction = friction;
1914 }
1915
1916 EAPI void
1917 elm_scroll_thumbscroll_friction_all_set(double friction)
1918 {
1919 #ifdef HAVE_ELEMENTARY_X
1920    static Ecore_X_Atom atom = 0;
1921    unsigned int ts_friction_i = (unsigned int)(friction * 1000.0);
1922
1923    if (!atom) atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_FRICTION");
1924    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1925                                   atom, &ts_friction_i, 1);
1926 #endif
1927 }
1928
1929 EAPI double
1930 elm_scroll_thumbscroll_border_friction_get(void)
1931 {
1932    return _elm_config->thumbscroll_border_friction;
1933 }
1934
1935 EAPI void
1936 elm_scroll_thumbscroll_border_friction_set(double friction)
1937 {
1938    if (friction < 0.0)
1939      friction = 0.0;
1940
1941    if (friction > 1.0)
1942      friction = 1.0;
1943
1944    _elm_config->thumbscroll_friction = friction;
1945 }
1946
1947 EAPI void
1948 elm_scroll_thumbscroll_border_friction_all_set(double friction)
1949 {
1950    if (friction < 0.0)
1951      friction = 0.0;
1952
1953    if (friction > 1.0)
1954      friction = 1.0;
1955
1956 #ifdef HAVE_ELEMENTARY_X
1957    static Ecore_X_Atom atom = 0;
1958    unsigned int border_friction_i = (unsigned int)(friction * 1000.0);
1959
1960    if (!atom)
1961      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_BORDER_FRICTION");
1962    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
1963                                   atom, &border_friction_i, 1);
1964 #endif
1965 }
1966
1967 EAPI double
1968 elm_scroll_thumbscroll_sensitivity_friction_get(void)
1969 {
1970    return _elm_config->thumbscroll_sensitivity_friction;
1971 }
1972
1973 EAPI void
1974 elm_scroll_thumbscroll_sensitivity_friction_set(double friction)
1975 {
1976    if (friction < 0.1)
1977      friction = 0.1;
1978
1979    if (friction > 1.0)
1980      friction = 1.0;
1981
1982    _elm_config->thumbscroll_friction = friction;
1983 }
1984
1985 EAPI void
1986 elm_scroll_thumbscroll_sensitivity_friction_all_set(double friction)
1987 {
1988    if (friction < 0.1)
1989      friction = 0.1;
1990
1991    if (friction > 1.0)
1992      friction = 1.0;
1993
1994 #ifdef HAVE_ELEMENTARY_X
1995    static Ecore_X_Atom atom = 0;
1996    unsigned int sensitivity_friction_i = (unsigned int)(friction * 1000.0);
1997
1998    if (!atom)
1999      atom = ecore_x_atom_get("ENLIGHTENMENT_THUMBSCROLL_SENSITIVITY_FRICTION");
2000    ecore_x_window_prop_card32_set(ecore_x_window_root_first_get(),
2001                                   atom, &sensitivity_friction_i, 1);
2002 #endif
2003 }
2004
2005 EAPI void
2006 elm_object_scroll_hold_push(Evas_Object *obj)
2007 {
2008    EINA_SAFETY_ON_NULL_RETURN(obj);
2009    elm_widget_scroll_hold_push(obj);
2010 }
2011
2012 EAPI void
2013 elm_object_scroll_hold_pop(Evas_Object *obj)
2014 {
2015    EINA_SAFETY_ON_NULL_RETURN(obj);
2016    elm_widget_scroll_hold_pop(obj);
2017 }
2018
2019 EAPI void
2020 elm_object_scroll_freeze_push(Evas_Object *obj)
2021 {
2022    EINA_SAFETY_ON_NULL_RETURN(obj);
2023    elm_widget_scroll_freeze_push(obj);
2024 }
2025
2026 EAPI void
2027 elm_object_scroll_lock_x_set(Evas_Object *obj,
2028                              Eina_Bool    lock)
2029 {
2030    EINA_SAFETY_ON_NULL_RETURN(obj);
2031    elm_widget_drag_lock_x_set(obj, lock);
2032 }
2033
2034 EAPI void
2035 elm_object_scroll_lock_y_set(Evas_Object *obj,
2036                              Eina_Bool    lock)
2037 {
2038    EINA_SAFETY_ON_NULL_RETURN(obj);
2039    elm_widget_drag_lock_y_set(obj, lock);
2040 }
2041
2042 EAPI Eina_Bool
2043 elm_object_scroll_lock_x_get(const Evas_Object *obj)
2044 {
2045    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
2046    return elm_widget_drag_lock_x_get(obj);
2047 }
2048
2049 EAPI Eina_Bool
2050 elm_object_scroll_lock_y_get(const Evas_Object *obj)
2051 {
2052    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
2053    return elm_widget_drag_lock_y_get(obj);
2054 }
2055
2056 EAPI void
2057 elm_object_scroll_freeze_pop(Evas_Object *obj)
2058 {
2059    EINA_SAFETY_ON_NULL_RETURN(obj);
2060    elm_widget_scroll_freeze_pop(obj);
2061 }
2062
2063 EAPI Eina_Bool
2064 elm_object_widget_check(const Evas_Object *obj)
2065 {
2066    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
2067    return elm_widget_is(obj);
2068 }
2069
2070 EAPI Evas_Object *
2071 elm_object_parent_widget_get(const Evas_Object *obj)
2072 {
2073    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2074    return elm_widget_parent_widget_get(obj);
2075 }
2076
2077 EAPI Evas_Object *
2078 elm_object_top_widget_get(const Evas_Object *obj)
2079 {
2080    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2081    return elm_widget_top_get(obj);
2082 }
2083
2084 EAPI const char *
2085 elm_object_widget_type_get(const Evas_Object *obj)
2086 {
2087    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2088    return elm_widget_type_get(obj);
2089 }
2090
2091 EAPI void
2092 elm_object_signal_emit(Evas_Object *obj,
2093                        const char  *emission,
2094                        const char  *source)
2095 {
2096    EINA_SAFETY_ON_NULL_RETURN(obj);
2097    elm_widget_signal_emit(obj, emission, source);
2098 }
2099
2100 EAPI void
2101 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)
2102 {
2103     EINA_SAFETY_ON_NULL_RETURN(obj);
2104     EINA_SAFETY_ON_NULL_RETURN(func);
2105     elm_widget_signal_callback_add(obj, emission, source, func, data);
2106 }
2107
2108 EAPI void *
2109 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))
2110 {
2111     EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2112     EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
2113     return elm_widget_signal_callback_del(obj, emission, source, func);
2114 }
2115
2116 EAPI void
2117 elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data)
2118 {
2119    EINA_SAFETY_ON_NULL_RETURN(obj);
2120    EINA_SAFETY_ON_NULL_RETURN(func);
2121    elm_widget_event_callback_add(obj, func, data);
2122 }
2123
2124 EAPI void *
2125 elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data)
2126 {
2127    EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
2128    EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
2129    return elm_widget_event_callback_del(obj, func, data);
2130 }
2131
2132 EAPI void
2133 elm_object_tree_dump(const Evas_Object *top)
2134 {
2135 #ifdef ELM_DEBUG
2136    elm_widget_tree_dump(top);
2137 #else
2138    return;
2139    (void)top;
2140 #endif
2141 }
2142
2143 EAPI void
2144 elm_object_tree_dot_dump(const Evas_Object *top,
2145                          const char        *file)
2146 {
2147 #ifdef ELM_DEBUG
2148    FILE *f = fopen(file, "wb");
2149    elm_widget_tree_dot_dump(top, f);
2150    fclose(f);
2151 #else
2152    return;
2153    (void)top;
2154    (void)file;
2155 #endif
2156 }
2157
2158 EAPI void
2159 elm_longpress_timeout_set(double longpress_timeout)
2160 {
2161    _elm_config->longpress_timeout = longpress_timeout;
2162 }
2163
2164 EAPI double
2165 elm_longpress_timeout_get(void)
2166 {
2167    return _elm_config->longpress_timeout;
2168 }
2169
2170 EAPI Evas_Object *
2171 elm_object_item_object_get(const Elm_Object_Item *it)
2172 {
2173    return ((Elm_Widget_Item *) it)->widget;
2174 }
2175
2176 EAPI void
2177 elm_object_item_content_part_set(Elm_Object_Item *it,
2178                                  const char *part,
2179                                  Evas_Object *content)
2180 {
2181    elm_widget_item_content_part_set(it, part, content);
2182 }
2183
2184 EAPI Evas_Object *
2185 elm_object_item_content_part_get(const Elm_Object_Item *it,
2186                                  const char *part)
2187 {
2188    return elm_widget_item_content_part_get(it, part);
2189 }
2190
2191 EAPI Evas_Object *
2192 elm_object_item_content_part_unset(Elm_Object_Item *it, const char *part)
2193 {
2194    return elm_widget_item_content_part_unset(it, part);
2195 }
2196
2197 EAPI void
2198 elm_object_item_text_part_set(Elm_Object_Item *it,
2199                               const char *part,
2200                               const char *label)
2201 {
2202    elm_widget_item_text_part_set(it, part, label);
2203 }
2204
2205 EAPI const char *
2206 elm_object_item_text_part_get(const Elm_Object_Item *it, const char *part)
2207 {
2208    return elm_widget_item_text_part_get(it, part);
2209 }
2210
2211 EAPI void *
2212 elm_object_item_data_get(const Elm_Object_Item *it)
2213 {
2214    return elm_widget_item_data_get(it);
2215 }
2216
2217 EAPI void
2218 elm_object_item_data_set(Elm_Object_Item *it, void *data)
2219 {
2220    elm_widget_item_data_set(it, data);
2221 }
2222
2223 EAPI void
2224 elm_object_item_signal_emit(Elm_Object_Item *it, const char *emission, const char *source)
2225 {
2226    elm_widget_item_signal_emit(it, emission, source);
2227 }
2228
2229 EAPI void
2230 elm_object_access_info_set(Evas_Object *obj, const char *txt)
2231 {
2232    elm_widget_access_info_set(obj, txt);
2233 }
2234
2235 EAPI void
2236 elm_object_item_access_info_set(Elm_Object_Item *it, const char *txt)
2237 {
2238    _elm_widget_item_access_info_set((Elm_Widget_Item *)it, txt);
2239 }
2240