src/lib/elm_config.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #ifdef HAVE_EVIL
   6 # include <Evil.h>
   7 #endif
   8
   9 #include <Elementary.h>
  10 #include "elm_priv.h"
  11
  12 EAPI int ELM_EVENT_CONFIG_ALL_CHANGED = 0;
  13
  14 Elm_Config *_elm_config = NULL;
  15 char *_elm_profile = NULL;
  16 static Eet_Data_Descriptor *_config_edd = NULL;
  17 static Eet_Data_Descriptor *_config_font_overlay_edd = NULL;
  18 const char *_elm_preferred_engine = NULL;
  19
  20 static Ecore_Poller *_elm_cache_flush_poller = NULL;
  21
  22 const char *_elm_engines[] = {
  23    "software_x11",
  24    "fb",
  25    "directfb",
  26    "software_16_x11",
  27    "software_8_x11",
  28    "xrender_x11",
  29    "opengl_x11",
  30    "software_gdi",
  31    "software_16_wince_gdi",
  32    "sdl",
  33    "software_16_sdl",
  34    "opengl_sdl",
  35    "buffer",
  36    "ews",
  37    "opengl_cocoa",
  38    "psl1ght",
  39    "wayland_shm",
  40    "wayland_egl",
  41    NULL
  42 };
  43
  44 /* whenever you want to add a new text class support into Elementary,
  45    declare it both here and in the (default) theme */
  46 static const Elm_Text_Class _elm_text_classes[] = {
  47    {"button", "Button Labels"},
  48    {"label", "Text Labels"},
  49    {"entry", "Text Entries"},
  50    {"title_bar", "Title Bar"},
  51    {"list_item", "List Items"},
  52    {"grid_item", "Grid Items"},
  53    {"toolbar_item", "Toolbar Items"},
  54    {"menu_item", "Menu Items"},
  55    {NULL, NULL}
  56 };
  57
  58 static void        _desc_init(void);
  59 static void        _desc_shutdown(void);
  60 static void        _profile_fetch_from_conf(void);
  61 static void        _config_free(void);
  62 static void        _config_apply(void);
  63 static Elm_Config *_config_user_load(void);
  64 static Elm_Config *_config_system_load(void);
  65 static void        _config_load(void);
  66 static void        _config_update(void);
  67 static void        _env_get(void);
  68 static size_t      _elm_data_dir_snprintf(char       *dst,
  69                                           size_t      size,
  70                                           const char *fmt, ...)
  71                                           EINA_PRINTF(3, 4);
  72 static size_t _elm_user_dir_snprintf(char       *dst,
  73                                      size_t      size,
  74                                      const char *fmt, ...)
  75                                      EINA_PRINTF(3, 4);
  76
  77 #define ELM_CONFIG_VAL(edd, type, member, dtype) \
  78   EET_DATA_DESCRIPTOR_ADD_BASIC(edd, type, #member, member, dtype)
  79 #define ELM_CONFIG_LIST(edd, type, member, eddtype) \
  80   EET_DATA_DESCRIPTOR_ADD_LIST(edd, type, #member, member, eddtype)
  81
  82 #ifdef HAVE_ELEMENTARY_X
  83 static Ecore_Event_Handler *_prop_change_handler = NULL;
  84 static Ecore_Timer *_prop_all_update_timer = NULL;
  85 static Ecore_Timer *_prop_change_delay_timer = NULL;
  86 static Ecore_X_Window _root_1st = 0;
  87 #define ATOM_COUNT 2
  88 static Ecore_X_Atom _atom[ATOM_COUNT];
  89 static Ecore_X_Atom _atom_config = 0;
  90 static const char *_atom_names[ATOM_COUNT] =
  91 {
  92    "ELM_PROFILE",
  93    "ELM_CONFIG"
  94 };
  95 #define ATOM_E_PROFILE                              0
  96 #define ATOM_E_CONFIG                               1
  97
  98 static Eina_Bool _prop_all_update_cb(void *data __UNUSED__);
  99 static Eina_Bool _prop_config_get(void);
 100 static void      _prop_config_set(void);
 101 static Eina_Bool _prop_change(void *data  __UNUSED__,
 102                               int ev_type __UNUSED__,
 103                               void       *ev);
 104
 105 static Eina_Bool
 106 _prop_all_update_cb(void *data __UNUSED__)
 107 {
 108    _prop_config_set();
 109    ecore_x_window_prop_string_set(_root_1st, _atom[ATOM_E_PROFILE],
 110                                   _elm_profile);
 111    _prop_all_update_timer = NULL;
 112    return EINA_FALSE;
 113 }
 114
 115 static Eina_Bool
 116 _prop_config_get(void)
 117 {
 118    int size = 0;
 119    Ecore_X_Atom atom;
 120    char buf[512];
 121    unsigned char *data = NULL;
 122    Elm_Config *config_data;
 123
 124    snprintf(buf, sizeof(buf), "ELM_CONFIG_%s", _elm_profile);
 125    atom = ecore_x_atom_get(buf);
 126    _atom_config = atom;
 127    if (!ecore_x_window_prop_property_get(_root_1st,
 128                                          atom, _atom[ATOM_E_CONFIG],
 129                                          8, &data, &size))
 130      {
 131         if (!ecore_x_window_prop_property_get(_root_1st,
 132                                               _atom[ATOM_E_CONFIG],
 133                                               _atom[ATOM_E_CONFIG],
 134                                               8, &data, &size))
 135           return EINA_FALSE;
 136         else
 137           _atom_config = _atom[ATOM_E_CONFIG];
 138      }
 139    else
 140      _atom_config = atom;
 141    if (size < 1)
 142      {
 143         free(data);
 144         return EINA_FALSE;
 145      }
 146    config_data = eet_data_descriptor_decode(_config_edd, data, size);
 147    free(data);
 148    if (!config_data) return EINA_FALSE;
 149
 150    /* What do we do on version mismatch when someone changes the
 151     * config in the rootwindow? */
 152    /* Most obvious case, new version and we are still linked to
 153     * whatever was there before, we just ignore until user restarts us */
 154    if (config_data->config_version > ELM_CONFIG_VERSION)
 155      return EINA_TRUE;
 156    /* What in the case the version is older? Do we even support those
 157     * cases or we only check for equality above? */
 158
 159    _config_free();
 160    _elm_config = config_data;
 161    _config_apply();
 162    _elm_config_font_overlay_apply();
 163    _elm_rescale();
 164    _elm_recache();
 165    ecore_event_add(ELM_EVENT_CONFIG_ALL_CHANGED, NULL, NULL, NULL);
 166    return EINA_TRUE;
 167 }
 168
 169 static void
 170 _prop_config_set(void)
 171 {
 172    unsigned char *config_data = NULL;
 173    int size = 0;
 174
 175    config_data = eet_data_descriptor_encode(_config_edd, _elm_config, &size);
 176    if (config_data)
 177      {
 178         Ecore_X_Atom atom;
 179         char buf[512];
 180
 181         snprintf(buf, sizeof(buf), "ELM_CONFIG_%s", _elm_profile);
 182         atom = ecore_x_atom_get(buf);
 183         _atom_config = atom;
 184
 185         ecore_x_window_prop_property_set(_root_1st, _atom_config,
 186                                          _atom[ATOM_E_CONFIG], 8,
 187                                          config_data, size);
 188         free(config_data);
 189      }
 190 }
 191
 192 static Eina_Bool
 193 _prop_change_delay_cb(void *data __UNUSED__)
 194 {
 195    char *s;
 196
 197    s = ecore_x_window_prop_string_get(_root_1st, _atom[ATOM_E_PROFILE]);
 198    if (s)
 199      {
 200         if (_elm_profile) free(_elm_profile);
 201         _elm_profile = s;
 202      }
 203    _prop_config_get();
 204    _prop_change_delay_timer = NULL;
 205    return EINA_FALSE;
 206 }
 207
 208 static Eina_Bool
 209 _prop_change(void *data  __UNUSED__,
 210              int ev_type __UNUSED__,
 211              void       *ev)
 212 {
 213    Ecore_X_Event_Window_Property *event = ev;
 214
 215    if (event->win == _root_1st)
 216      {
 217         if (event->atom == _atom[ATOM_E_PROFILE])
 218           {
 219              if (_prop_change_delay_timer) ecore_timer_del(_prop_change_delay_timer);
 220              _prop_change_delay_timer = ecore_timer_add(0.1, _prop_change_delay_cb, NULL);
 221           }
 222         else if (((_atom_config > 0) && (event->atom == _atom_config)) ||
 223                  (event->atom == _atom[ATOM_E_CONFIG]))
 224           {
 225              if (_prop_change_delay_timer) ecore_timer_del(_prop_change_delay_timer);
 226              _prop_change_delay_timer = ecore_timer_add(0.1, _prop_change_delay_cb, NULL);
 227           }
 228      }
 229    return ECORE_CALLBACK_PASS_ON;
 230 }
 231
 232 #endif
 233
 234 static void
 235 _desc_init(void)
 236 {
 237    Eet_Data_Descriptor_Class eddc;
 238
 239    EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Config);
 240    eddc.func.str_direct_alloc = NULL;
 241    eddc.func.str_direct_free = NULL;
 242
 243    _config_edd = eet_data_descriptor_file_new(&eddc);
 244    if (!_config_edd)
 245      {
 246         printf("EEEK! eet_data_descriptor_file_new() failed\n");
 247         return;
 248      }
 249
 250    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 251    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Font_Overlay);
 252    eddc.func.str_direct_alloc = NULL;
 253    eddc.func.str_direct_free = NULL;
 254
 255    _config_font_overlay_edd = eet_data_descriptor_stream_new(&eddc);
 256    if (!_config_font_overlay_edd)
 257      {
 258         printf("EEEK! eet_data_descriptor_stream_new() failed\n");
 259         eet_data_descriptor_free(_config_edd);
 260         return;
 261      }
 262 #define T_INT    EET_T_INT
 263 #define T_DOUBLE EET_T_DOUBLE
 264 #define T_STRING EET_T_STRING
 265 #define T_UCHAR  EET_T_UCHAR
 266
 267 #define T        Elm_Font_Overlay
 268 #define D        _config_font_overlay_edd
 269    ELM_CONFIG_VAL(D, T, text_class, EET_T_STRING);
 270    ELM_CONFIG_VAL(D, T, font, EET_T_STRING);
 271    ELM_CONFIG_VAL(D, T, size, EET_T_INT);
 272 #undef T
 273 #undef D
 274
 275 #define T Elm_Config
 276 #define D _config_edd
 277    ELM_CONFIG_VAL(D, T, config_version, T_INT);
 278    ELM_CONFIG_VAL(D, T, engine, T_STRING);
 279    ELM_CONFIG_VAL(D, T, vsync, T_UCHAR);
 280    ELM_CONFIG_VAL(D, T, thumbscroll_enable, T_UCHAR);
 281    ELM_CONFIG_VAL(D, T, thumbscroll_threshold, T_INT);
 282    ELM_CONFIG_VAL(D, T, thumbscroll_momentum_threshold, T_DOUBLE);
 283    ELM_CONFIG_VAL(D, T, thumbscroll_friction, T_DOUBLE);
 284    ELM_CONFIG_VAL(D, T, thumbscroll_bounce_friction, T_DOUBLE);
 285    ELM_CONFIG_VAL(D, T, thumbscroll_border_friction, T_DOUBLE);
 286    ELM_CONFIG_VAL(D, T, thumbscroll_sensitivity_friction, T_DOUBLE);
 287    ELM_CONFIG_VAL(D, T, page_scroll_friction, T_DOUBLE);
 288    ELM_CONFIG_VAL(D, T, bring_in_scroll_friction, T_DOUBLE);
 289    ELM_CONFIG_VAL(D, T, zoom_friction, T_DOUBLE);
 290    ELM_CONFIG_VAL(D, T, thumbscroll_bounce_enable, T_UCHAR);
 291    ELM_CONFIG_VAL(D, T, scroll_smooth_amount, T_DOUBLE);
 292    ELM_CONFIG_VAL(D, T, scroll_smooth_history_weight, T_DOUBLE);
 293    ELM_CONFIG_VAL(D, T, scroll_smooth_future_time, T_DOUBLE);
 294    ELM_CONFIG_VAL(D, T, scroll_smooth_time_window, T_DOUBLE);
 295    ELM_CONFIG_VAL(D, T, scale, T_DOUBLE);
 296    ELM_CONFIG_VAL(D, T, bgpixmap, T_INT);
 297    ELM_CONFIG_VAL(D, T, compositing, T_INT);
 298    /* EET_DATA_DESCRIPTOR_ADD_LIST(D, T, "font_dirs", font_dirs, sub_edd); */
 299    ELM_CONFIG_LIST(D, T, font_overlays, _config_font_overlay_edd);
 300    ELM_CONFIG_VAL(D, T, font_hinting, T_INT);
 301    ELM_CONFIG_VAL(D, T, cache_flush_poll_interval, T_INT);
 302    ELM_CONFIG_VAL(D, T, cache_flush_enable, T_UCHAR);
 303    ELM_CONFIG_VAL(D, T, image_cache, T_INT);
 304    ELM_CONFIG_VAL(D, T, font_cache, T_INT);
 305    ELM_CONFIG_VAL(D, T, edje_cache, T_INT);
 306    ELM_CONFIG_VAL(D, T, edje_collection_cache, T_INT);
 307    ELM_CONFIG_VAL(D, T, finger_size, T_INT);
 308    ELM_CONFIG_VAL(D, T, fps, T_DOUBLE);
 309    ELM_CONFIG_VAL(D, T, theme, T_STRING);
 310    ELM_CONFIG_VAL(D, T, modules, T_STRING);
 311    ELM_CONFIG_VAL(D, T, tooltip_delay, T_DOUBLE);
 312    ELM_CONFIG_VAL(D, T, cursor_engine_only, T_UCHAR);
 313    ELM_CONFIG_VAL(D, T, focus_highlight_enable, T_UCHAR);
 314    ELM_CONFIG_VAL(D, T, focus_highlight_animate, T_UCHAR);
 315    ELM_CONFIG_VAL(D, T, toolbar_shrink_mode, T_INT);
 316    ELM_CONFIG_VAL(D, T, fileselector_expand_enable, T_UCHAR);
 317    ELM_CONFIG_VAL(D, T, inwin_dialogs_enable, T_UCHAR);
 318    ELM_CONFIG_VAL(D, T, icon_size, T_INT);
 319    ELM_CONFIG_VAL(D, T, longpress_timeout, T_DOUBLE);
 320    ELM_CONFIG_VAL(D, T, effect_enable, T_UCHAR);
 321    ELM_CONFIG_VAL(D, T, desktop_entry, T_UCHAR);
 322    ELM_CONFIG_VAL(D, T, password_show_last, T_UCHAR);
 323    ELM_CONFIG_VAL(D, T, password_show_last_timeout, T_DOUBLE);
 324    ELM_CONFIG_VAL(D, T, glayer_zoom_finger_enable, T_UCHAR);
 325    ELM_CONFIG_VAL(D, T, glayer_zoom_finger_factor, T_DOUBLE);
 326    ELM_CONFIG_VAL(D, T, glayer_zoom_wheel_factor, T_DOUBLE);
 327    ELM_CONFIG_VAL(D, T, glayer_zoom_distance_tolerance, T_DOUBLE);
 328    ELM_CONFIG_VAL(D, T, glayer_rotate_finger_enable, T_UCHAR);
 329    ELM_CONFIG_VAL(D, T, glayer_rotate_angular_tolerance, T_DOUBLE);
 330    ELM_CONFIG_VAL(D, T, glayer_line_min_length, T_DOUBLE);
 331    ELM_CONFIG_VAL(D, T, glayer_line_distance_tolerance, T_DOUBLE);
 332    ELM_CONFIG_VAL(D, T, glayer_line_angular_tolerance, T_DOUBLE);
 333    ELM_CONFIG_VAL(D, T, glayer_flick_time_limit_ms, T_INT);
 334    ELM_CONFIG_VAL(D, T, glayer_long_tap_start_timeout, T_DOUBLE);
 335    ELM_CONFIG_VAL(D, T, access_mode, T_INT);
 336    ELM_CONFIG_VAL(D, T, glayer_continues_enable, T_UCHAR);
 337    ELM_CONFIG_VAL(D, T, week_start, T_INT);
 338    ELM_CONFIG_VAL(D, T, weekend_start, T_INT);
 339    ELM_CONFIG_VAL(D, T, weekend_len, T_INT);
 340 #undef T
 341 #undef D
 342 #undef T_INT
 343 #undef T_DOUBLE
 344 #undef T_STRING
 345 #undef T_UCHAR
 346 }
 347
 348 static void
 349 _desc_shutdown(void)
 350 {
 351    if (_config_edd)
 352      {
 353         eet_data_descriptor_free(_config_edd);
 354         _config_edd = NULL;
 355      }
 356
 357    if (_config_font_overlay_edd)
 358      {
 359         eet_data_descriptor_free(_config_font_overlay_edd);
 360         _config_font_overlay_edd = NULL;
 361      }
 362 }
 363
 364 static int
 365 _sort_files_cb(const void *f1,
 366                const void *f2)
 367 {
 368    return strcmp(f1, f2);
 369 }
 370
 371 const char *
 372 _elm_config_current_profile_get(void)
 373 {
 374    return _elm_profile;
 375 }
 376
 377 static size_t
 378 _elm_data_dir_snprintf(char       *dst,
 379                        size_t      size,
 380                        const char *fmt,
 381                        ...)
 382 {
 383    size_t data_dir_len, off;
 384    va_list ap;
 385
 386    data_dir_len = eina_strlcpy(dst, _elm_data_dir, size);
 387
 388    off = data_dir_len + 1;
 389    if (off >= size)
 390      goto end;
 391
 392    va_start(ap, fmt);
 393    dst[data_dir_len] = '/';
 394
 395    off = off + vsnprintf(dst + off, size - off, fmt, ap);
 396    va_end(ap);
 397
 398 end:
 399    return off;
 400 }
 401
 402 static size_t
 403 _elm_user_dir_snprintf(char       *dst,
 404                        size_t      size,
 405                        const char *fmt,
 406                        ...)
 407 {
 408    const char *home;
 409    size_t user_dir_len, off;
 410    va_list ap;
 411
 412 #ifdef _WIN32
 413    home = evil_homedir_get();
 414 #else
 415    home = getenv("HOME");
 416 #endif
 417    if (!home)
 418      home = "/";
 419
 420    user_dir_len = eina_str_join_len(dst, size, '/', home, strlen(home),
 421                                     ELEMENTARY_BASE_DIR, sizeof(ELEMENTARY_BASE_DIR) - 1);
 422
 423    off = user_dir_len + 1;
 424    if (off >= size)
 425      goto end;
 426
 427    va_start(ap, fmt);
 428    dst[user_dir_len] = '/';
 429
 430    off = off + vsnprintf(dst + off, size - off, fmt, ap);
 431    va_end(ap);
 432
 433 end:
 434    return off;
 435 }
 436
 437 const char *
 438 _elm_config_profile_dir_get(const char *prof,
 439                             Eina_Bool   is_user)
 440 {
 441    char buf[PATH_MAX];
 442
 443    if (!is_user)
 444      goto not_user;
 445
 446    _elm_user_dir_snprintf(buf, sizeof(buf), "config/%s", prof);
 447
 448    if (ecore_file_is_dir(buf))
 449      return strdup(buf);
 450
 451    return NULL;
 452
 453 not_user:
 454    snprintf(buf, sizeof(buf), "%s/config/%s", _elm_data_dir, prof);
 455
 456    if (ecore_file_is_dir(buf))
 457      return strdup(buf);
 458
 459    return NULL;
 460 }
 461
 462 Eina_List *
 463 _elm_config_font_overlays_list(void)
 464 {
 465    return _elm_config->font_overlays;
 466 }
 467
 468 void
 469 _elm_config_font_overlay_set(const char    *text_class,
 470                              const char    *font,
 471                              Evas_Font_Size size)
 472 {
 473    Elm_Font_Overlay *efd;
 474    Eina_List *l;
 475
 476    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 477      {
 478         if (strcmp(efd->text_class, text_class))
 479           continue;
 480
 481         if (efd->font) eina_stringshare_del(efd->font);
 482         efd->font = eina_stringshare_add(font);
 483         efd->size = size;
 484         _elm_config->font_overlays =
 485           eina_list_promote_list(_elm_config->font_overlays, l);
 486         return;
 487      }
 488
 489    /* the text class doesn't exist */
 490    efd = calloc(1, sizeof(Elm_Font_Overlay));
 491    efd->text_class = eina_stringshare_add(text_class);
 492    efd->font = eina_stringshare_add(font);
 493    efd->size = size;
 494
 495    _elm_config->font_overlays = eina_list_prepend(_elm_config->font_overlays,
 496                                                   efd);
 497 }
 498
 499 void
 500 _elm_config_font_overlay_remove(const char *text_class)
 501 {
 502    Elm_Font_Overlay *efd;
 503    Eina_List *l;
 504
 505    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 506      {
 507         if (strcmp(efd->text_class, text_class))
 508           continue;
 509
 510         _elm_config->font_overlays =
 511           eina_list_remove_list(_elm_config->font_overlays, l);
 512         if (efd->text_class) eina_stringshare_del(efd->text_class);
 513         if (efd->font) eina_stringshare_del(efd->font);
 514         free(efd);
 515
 516         return;
 517      }
 518 }
 519
 520 void
 521 _elm_config_font_overlay_apply(void)
 522 {
 523    Elm_Font_Overlay *efd;
 524    Eina_List *l;
 525    int i;
 526
 527    for (i = 0; _elm_text_classes[i].desc; i++)
 528      edje_text_class_del(_elm_text_classes[i].name);
 529
 530    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 531      edje_text_class_set(efd->text_class, efd->font, efd->size);
 532 }
 533
 534 Eina_List *
 535 _elm_config_text_classes_get(void)
 536 {
 537    Eina_List *ret = NULL;
 538    int i;
 539
 540    for (i = 0; _elm_text_classes[i].desc; i++)
 541      {
 542         Elm_Text_Class *tc;
 543         tc = malloc(sizeof(*tc));
 544         if (!tc) continue;
 545
 546         *tc = _elm_text_classes[i];
 547
 548         ret = eina_list_append(ret, tc);
 549      }
 550
 551    return ret;
 552 }
 553
 554 void
 555 _elm_config_text_classes_free(Eina_List *l)
 556 {
 557    Elm_Text_Class *tc;
 558
 559    EINA_LIST_FREE(l, tc)
 560      free(tc);
 561 }
 562
 563 Eina_List *
 564 _elm_config_profiles_list(void)
 565 {
 566    Eina_File_Direct_Info *info;
 567    Eina_List *flist = NULL;
 568    Eina_Iterator *file_it;
 569    char buf[PATH_MAX];
 570    const char *dir;
 571    size_t len;
 572
 573    len = _elm_user_dir_snprintf(buf, sizeof(buf), "config");
 574
 575    file_it = eina_file_direct_ls(buf);
 576    if (!file_it)
 577      goto sys;
 578
 579    buf[len] = '/';
 580    len++;
 581
 582    len = sizeof(buf) - len;
 583
 584    EINA_ITERATOR_FOREACH(file_it, info)
 585      {
 586         Eina_Stat st;
 587
 588         if (eina_file_statat(eina_iterator_container_get(file_it), info, &st))
 589           {
 590              ERR("this is bad.");
 591              continue;
 592           }
 593         if (info->name_length >= len)
 594           continue;
 595
 596         if (info->type == EINA_FILE_DIR)
 597           {
 598              flist =
 599                eina_list_sorted_insert(flist, _sort_files_cb,
 600                                        eina_stringshare_add(info->path +
 601                                                             info->name_start));
 602           }
 603      }
 604
 605    eina_iterator_free(file_it);
 606
 607 sys:
 608    len = eina_str_join_len(buf, sizeof(buf), '/', _elm_data_dir,
 609                            strlen(_elm_data_dir), "config",
 610                            sizeof("config") - 1);
 611
 612    file_it = eina_file_direct_ls(buf);
 613    if (!file_it)
 614      goto list_free;
 615
 616    buf[len] = '/';
 617    len++;
 618
 619    len = sizeof(buf) - len;
 620    EINA_ITERATOR_FOREACH(file_it, info)
 621      {
 622         if (info->name_length >= len)
 623           continue;
 624
 625         switch (info->type)
 626           {
 627            case EINA_FILE_DIR:
 628            {
 629               const Eina_List *l;
 630               const char *tmp;
 631
 632               EINA_LIST_FOREACH(flist, l, tmp)
 633                 if (!strcmp(info->path + info->name_start, tmp))
 634                   break;
 635
 636               if (!l)
 637                 flist =
 638                   eina_list_sorted_insert(flist, _sort_files_cb,
 639                                           eina_stringshare_add(info->path +
 640                                                                info->name_start));
 641            }
 642            break;
 643
 644            default:
 645              continue;
 646           }
 647      }
 648    eina_iterator_free(file_it);
 649    return flist;
 650
 651 list_free:
 652    EINA_LIST_FREE(flist, dir)
 653      eina_stringshare_del(dir);
 654
 655    return NULL;
 656 }
 657
 658 static void
 659 _profile_fetch_from_conf(void)
 660 {
 661    char buf[PATH_MAX], *p, *s;
 662    Eet_File *ef = NULL;
 663    int len = 0;
 664
 665    _elm_profile = strdup("default");
 666
 667    // if env var - use profile without question
 668    s = getenv("ELM_PROFILE");
 669    if (s)
 670      {
 671         free(_elm_profile);
 672         _elm_profile = strdup(s);
 673         return;
 674      }
 675
 676    // user profile
 677    _elm_user_dir_snprintf(buf, sizeof(buf), "config/profile.cfg");
 678    ef = eet_open(buf, EET_FILE_MODE_READ);
 679    if (ef)
 680      {
 681         p = eet_read(ef, "config", &len);
 682         if (p)
 683           {
 684              free(_elm_profile);
 685              _elm_profile = malloc(len + 1);
 686              memcpy(_elm_profile, p, len);
 687              _elm_profile[len] = 0;
 688              free(p);
 689           }
 690         eet_close(ef);
 691         if (!p) ef = NULL;
 692      }
 693    if (ef) return;
 694
 695    // system profile
 696    _elm_data_dir_snprintf(buf, sizeof(buf), "config/profile.cfg");
 697    ef = eet_open(buf, EET_FILE_MODE_READ);
 698    if (ef)
 699      {
 700         p = eet_read(ef, "config", &len);
 701         if (p)
 702           {
 703              free(_elm_profile);
 704              _elm_profile = malloc(len + 1);
 705              memcpy(_elm_profile, p, len);
 706              _elm_profile[len] = 0;
 707              free(p);
 708           }
 709         eet_close(ef);
 710      }
 711 }
 712
 713 static void
 714 _config_free(void)
 715 {
 716    Elm_Font_Overlay *fo;
 717    const char *fontdir;
 718
 719    if (!_elm_config) return;
 720    EINA_LIST_FREE(_elm_config->font_dirs, fontdir)
 721      {
 722         eina_stringshare_del(fontdir);
 723      }
 724    if (_elm_config->engine) eina_stringshare_del(_elm_config->engine);
 725    EINA_LIST_FREE(_elm_config->font_overlays, fo)
 726      {
 727         if (fo->text_class) eina_stringshare_del(fo->text_class);
 728         if (fo->font) eina_stringshare_del(fo->font);
 729         free(fo);
 730      }
 731    if (_elm_config->theme) eina_stringshare_del(_elm_config->theme);
 732    if (_elm_config->modules) eina_stringshare_del(_elm_config->modules);
 733    free(_elm_config);
 734    _elm_config = NULL;
 735 }
 736
 737 static void
 738 _config_apply(void)
 739 {
 740    _elm_theme_parse(NULL, _elm_config->theme);
 741    ecore_animator_frametime_set(1.0 / _elm_config->fps);
 742 }
 743
 744 static void
 745 _config_sub_apply(void)
 746 {
 747    edje_frametime_set(1.0 / _elm_config->fps);
 748    edje_scale_set(_elm_config->scale);
 749    edje_password_show_last_set(_elm_config->password_show_last);
 750    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
 751    if (_elm_config->modules) _elm_module_parse(_elm_config->modules);
 752 }
 753
 754 static Eina_Bool
 755 _elm_cache_flush_cb(void *data __UNUSED__)
 756 {
 757    elm_cache_all_flush();
 758    return ECORE_CALLBACK_RENEW;
 759 }
 760
 761 /* kind of abusing this call right now -- shared between all of those
 762  * properties -- but they are not meant to be called that periodically
 763  * anyway */
 764 void
 765 _elm_recache(void)
 766 {
 767    Eina_List *l;
 768    Evas_Object *win;
 769
 770    elm_cache_all_flush();
 771
 772    EINA_LIST_FOREACH(_elm_win_list, l, win)
 773      {
 774         Evas *e = evas_object_evas_get(win);
 775         evas_image_cache_set(e, _elm_config->image_cache * 1024);
 776         evas_font_cache_set(e, _elm_config->font_cache * 1024);
 777      }
 778    edje_file_cache_set(_elm_config->edje_cache);
 779    edje_collection_cache_set(_elm_config->edje_collection_cache);
 780
 781    if (_elm_cache_flush_poller)
 782      {
 783         ecore_poller_del(_elm_cache_flush_poller);
 784         _elm_cache_flush_poller = NULL;
 785      }
 786    if (_elm_config->cache_flush_enable)
 787      {
 788         if (_elm_config->cache_flush_poll_interval > 0)
 789           {
 790              _elm_cache_flush_poller =
 791                 ecore_poller_add(ECORE_POLLER_CORE,
 792                                  _elm_config->cache_flush_poll_interval,
 793                                  _elm_cache_flush_cb, NULL);
 794           }
 795      }
 796 }
 797
 798 static Elm_Config *
 799 _config_user_load(void)
 800 {
 801    Elm_Config *cfg = NULL;
 802    Eet_File *ef;
 803    char buf[PATH_MAX];
 804
 805    _elm_user_dir_snprintf(buf, sizeof(buf), "config/%s/base.cfg",
 806                           _elm_profile);
 807
 808    ef = eet_open(buf, EET_FILE_MODE_READ);
 809    if (ef)
 810      {
 811         cfg = eet_data_read(ef, _config_edd, "config");
 812         eet_close(ef);
 813      }
 814    return cfg;
 815 }
 816
 817 static Elm_Config *
 818 _config_system_load(void)
 819 {
 820    Elm_Config *cfg = NULL;
 821    Eet_File *ef;
 822    char buf[PATH_MAX];
 823
 824    _elm_data_dir_snprintf(buf, sizeof(buf), "config/%s/base.cfg",
 825                           _elm_profile);
 826
 827    ef = eet_open(buf, EET_FILE_MODE_READ);
 828    if (ef)
 829      {
 830         cfg = eet_data_read(ef, _config_edd, "config");
 831         eet_close(ef);
 832      }
 833    return cfg;
 834 }
 835
 836 static void
 837 _config_load(void)
 838 {
 839    _elm_config = _config_user_load();
 840    if (_elm_config)
 841      {
 842         if (_elm_config->config_version < ELM_CONFIG_VERSION)
 843           _config_update();
 844         return;
 845      }
 846
 847    /* no user config, fallback for system. No need to check version for
 848     * this one, if it's not the right one, someone screwed up at the time
 849     * of installing it */
 850    _elm_config = _config_system_load();
 851    if (_elm_config) return;
 852    /* FIXME: config load could have failed because of a non-existent
 853     * profile. Fallback to default before moving on */
 854
 855    // config load fail - defaults
 856    // why are these here? well if they are, it means you can make a gui
 857    // config recovery app i guess...
 858    _elm_config = ELM_NEW(Elm_Config);
 859    _elm_config->config_version = ELM_CONFIG_VERSION;
 860    _elm_config->engine = eina_stringshare_add("software_x11");
 861    _elm_config->vsync = 0;
 862    _elm_config->thumbscroll_enable = EINA_TRUE;
 863    _elm_config->thumbscroll_threshold = 24;
 864    _elm_config->thumbscroll_momentum_threshold = 100.0;
 865    _elm_config->thumbscroll_friction = 1.0;
 866    _elm_config->thumbscroll_bounce_friction = 0.5;
 867    _elm_config->thumbscroll_bounce_enable = EINA_TRUE;
 868    _elm_config->page_scroll_friction = 0.5;
 869    _elm_config->bring_in_scroll_friction = 0.5;
 870    _elm_config->zoom_friction = 0.5;
 871    _elm_config->thumbscroll_border_friction = 0.5;
 872    _elm_config->thumbscroll_sensitivity_friction = 0.25; // magic number! just trial and error shows this makes it behave "nicer" and not run off at high speed all the time
 873    _elm_config->scroll_smooth_amount = 1.0;
 874    _elm_config->scroll_smooth_history_weight = 0.3;
 875    _elm_config->scroll_smooth_future_time = 0.0;
 876    _elm_config->scroll_smooth_time_window = 0.2;
 877    _elm_config->scale = 1.0;
 878    _elm_config->bgpixmap = 0;
 879    _elm_config->compositing = 1;
 880    _elm_config->font_hinting = 2;
 881    _elm_config->cache_flush_poll_interval = 512;
 882    _elm_config->cache_flush_enable = EINA_TRUE;
 883    _elm_config->font_dirs = NULL;
 884    _elm_config->image_cache = 4096;
 885    _elm_config->font_cache = 512;
 886    _elm_config->edje_cache = 32;
 887    _elm_config->edje_collection_cache = 64;
 888    _elm_config->finger_size = 40;
 889    _elm_config->fps = 60.0;
 890    _elm_config->theme = eina_stringshare_add("default");
 891    _elm_config->modules = NULL;
 892    _elm_config->tooltip_delay = 1.0;
 893    _elm_config->cursor_engine_only = EINA_TRUE;
 894    _elm_config->focus_highlight_enable = EINA_FALSE;
 895    _elm_config->focus_highlight_animate = EINA_TRUE;
 896    _elm_config->toolbar_shrink_mode = 2;
 897    _elm_config->fileselector_expand_enable = EINA_FALSE;
 898    _elm_config->inwin_dialogs_enable = EINA_FALSE;
 899    _elm_config->icon_size = 32;
 900    _elm_config->longpress_timeout = 1.0;
 901    _elm_config->effect_enable = EINA_TRUE;
 902    _elm_config->desktop_entry = EINA_FALSE;
 903    _elm_config->is_mirrored = EINA_FALSE; /* Read sys value in env_get() */
 904    _elm_config->password_show_last = EINA_FALSE;
 905    _elm_config->password_show_last_timeout = 2.0;
 906    _elm_config->glayer_zoom_finger_enable = EINA_TRUE;
 907    _elm_config->glayer_zoom_finger_factor = 1.0;
 908    _elm_config->glayer_zoom_wheel_factor = 0.05;
 909    _elm_config->glayer_zoom_distance_tolerance = 1.0; /* 1 times elm_finger_size_get() */
 910    _elm_config->glayer_rotate_finger_enable = EINA_TRUE;
 911    _elm_config->glayer_rotate_angular_tolerance = 2.0; /* 2 DEG */
 912    _elm_config->glayer_line_min_length = 1.0;         /* 1 times elm_finger_size_get() */
 913    _elm_config->glayer_line_distance_tolerance = 3.0; /* 3 times elm_finger_size_get() */
 914    _elm_config->glayer_line_angular_tolerance = 20.0; /* 20 DEG */
 915    _elm_config->glayer_flick_time_limit_ms = 120;              /* ms to finish flick */
 916    _elm_config->glayer_long_tap_start_timeout = 1.2;   /* 1.2 second to start long-tap */
 917    _elm_config->glayer_continues_enable = EINA_TRUE;      /* Continue gestures default */
 918    _elm_config->week_start = 1; /* monday */
 919    _elm_config->weekend_start = 6; /* saturday */
 920    _elm_config->weekend_len = 2;
 921 }
 922
 923 static const char *
 924 _elm_config_eet_close_error_get(Eet_File *ef,
 925                                 char     *file)
 926 {
 927    Eet_Error err;
 928    const char *erstr = NULL;
 929
 930    err = eet_close(ef);
 931    switch (err)
 932      {
 933       case EET_ERROR_WRITE_ERROR:
 934         erstr = "An error occurred while saving Elementary's "
 935                 "settings to disk. The error could not be "
 936                 "deterimined. The file where the error occurred was: "
 937                 "%s. This file has been deleted to avoid corrupt data.";
 938         break;
 939
 940       case EET_ERROR_WRITE_ERROR_FILE_TOO_BIG:
 941         erstr = "Elementary's settings files are too big "
 942                 "for the file system they are being saved to. "
 943                 "This error is very strange as the files should "
 944                 "be extremely small. Please check the settings "
 945                 "for your home directory. "
 946                 "The file where the error occurred was: %s ."
 947                 "This file has been deleted to avoid corrupt data.";
 948         break;
 949
 950       case EET_ERROR_WRITE_ERROR_IO_ERROR:
 951         erstr = "An output error occurred when writing the settings "
 952                 "files for Elementary. Your disk is having troubles "
 953                 "and possibly needs replacement. "
 954                 "The file where the error occurred was: %s ."
 955                 "This file has been deleted to avoid corrupt data.";
 956         break;
 957
 958       case EET_ERROR_WRITE_ERROR_OUT_OF_SPACE:
 959         erstr = "Elementary cannot write its settings file "
 960                 "because it ran out of space to write the file. "
 961                 "You have either run out of disk space or have "
 962                 "gone over your quota limit. "
 963                 "The file where the error occurred was: %s ."
 964                 "This file has been deleted to avoid corrupt data.";
 965         break;
 966
 967       case EET_ERROR_WRITE_ERROR_FILE_CLOSED:
 968         erstr = "Elementary unexpectedly had the settings file "
 969                 "it was writing closed on it. This is very unusual. "
 970                 "The file where the error occurred was: %s "
 971                 "This file has been deleted to avoid corrupt data.";
 972         break;
 973
 974       default:
 975         break;
 976      }
 977    if (erstr)
 978      {
 979         /* delete any partially-written file */
 980          ecore_file_unlink(file);
 981          return strdup(erstr);
 982      }
 983
 984    return NULL;
 985 }
 986
 987 static Eina_Bool
 988 _elm_config_profile_save(void)
 989 {
 990    char buf[4096], buf2[4096];
 991    int ok = 0, ret;
 992    const char *err;
 993    Eet_File *ef;
 994    size_t len;
 995
 996    len = _elm_user_dir_snprintf(buf, sizeof(buf), "config/profile.cfg");
 997    if (len + 1 >= sizeof(buf))
 998      return EINA_FALSE;
 999
1000    len = _elm_user_dir_snprintf(buf2, sizeof(buf2), "config/profile.cfg.tmp");
1001    if (len + 1 >= sizeof(buf2))
1002      return EINA_FALSE;
1003
1004    ef = eet_open(buf2, EET_FILE_MODE_WRITE);
1005    if (!ef)
1006      return EINA_FALSE;
1007
1008    ok = eet_write(ef, "config", _elm_profile, strlen(_elm_profile), 0);
1009    if (!ok)
1010      goto err;
1011
1012    err = _elm_config_eet_close_error_get(ef, buf2);
1013    if (err)
1014      {
1015         ERR("%s", err);
1016         free((void *)err);
1017         goto err;
1018      }
1019
1020    ret = ecore_file_mv(buf2, buf);
1021    if (!ret)
1022      {
1023         ERR("Error saving Elementary's configuration file");
1024         goto err;
1025      }
1026
1027    ecore_file_unlink(buf2);
1028    return EINA_TRUE;
1029
1030 err:
1031    ecore_file_unlink(buf2);
1032    return EINA_FALSE;
1033 }
1034
1035 Eina_Bool
1036 _elm_config_save(void)
1037 {
1038    char buf[4096], buf2[4096];
1039    int ok = 0, ret;
1040    const char *err;
1041    Eet_File *ef;
1042    size_t len;
1043
1044    len = _elm_user_dir_snprintf(buf, sizeof(buf), "config/%s", _elm_profile);
1045    if (len + 1 >= sizeof(buf))
1046      return EINA_FALSE;
1047
1048    ok = ecore_file_mkpath(buf);
1049    if (!ok)
1050      {
1051         ERR("Problem accessing Elementary's user configuration directory: %s",
1052             buf);
1053         return EINA_FALSE;
1054      }
1055
1056    if (!_elm_config_profile_save())
1057      return EINA_FALSE;
1058
1059    buf[len] = '/';
1060    len++;
1061
1062    if (len + sizeof("base.cfg") >= sizeof(buf) - len)
1063      return EINA_FALSE;
1064
1065    memcpy(buf + len, "base.cfg", sizeof("base.cfg"));
1066    len += sizeof("base.cfg") - 1;
1067
1068    if (len + sizeof(".tmp") >= sizeof(buf))
1069      return EINA_FALSE;
1070
1071    memcpy(buf2, buf, len);
1072    memcpy(buf2 + len, ".tmp", sizeof(".tmp"));
1073
1074    ef = eet_open(buf2, EET_FILE_MODE_WRITE);
1075    if (!ef)
1076      return EINA_FALSE;
1077
1078    ok = eet_data_write(ef, _config_edd, "config", _elm_config, 1);
1079    if (!ok)
1080      goto err;
1081
1082    err = _elm_config_eet_close_error_get(ef, buf2);
1083    if (err)
1084      {
1085         ERR("%s", err);
1086         free((void *)err);
1087         goto err;
1088      }
1089
1090    ret = ecore_file_mv(buf2, buf);
1091    if (!ret)
1092      {
1093         ERR("Error saving Elementary's configuration file");
1094         goto err;
1095      }
1096
1097    ecore_file_unlink(buf2);
1098    return EINA_TRUE;
1099
1100 err:
1101    ecore_file_unlink(buf2);
1102    return EINA_FALSE;
1103 }
1104
1105 static void
1106 _config_update(void)
1107 {
1108    Elm_Config *tcfg;
1109
1110    tcfg = _config_system_load();
1111    if (!tcfg)
1112      {
1113         /* weird profile or something? We should probably fill
1114          * with hardcoded defaults, or get from default previx */
1115           return;
1116      }
1117 #define IFCFG(v)   if ((_elm_config->config_version & 0xffff) < (v)) {
1118 #define IFCFGELSE } else {
1119 #define IFCFGEND  }
1120 #define COPYVAL(x) do {_elm_config->x = tcfg->x; } while(0)
1121 #define COPYPTR(x) do {_elm_config->x = tcfg->x; tcfg->x = NULL; } while(0)
1122 #define COPYSTR(x) COPYPTR(x)
1123
1124      /* we also need to update for property changes in the root window
1125       * if needed, but that will be dependent on new properties added
1126       * with each version */
1127
1128      IFCFG(0x0003);
1129      COPYVAL(longpress_timeout);
1130      IFCFGEND;
1131
1132 #undef COPYSTR
1133 #undef COPYPTR
1134 #undef COPYVAL
1135 #undef IFCFGEND
1136 #undef IFCFGELSE
1137 #undef IFCFG
1138
1139      /* after updating user config, we must save */
1140 }
1141
1142 static void
1143 _env_get(void)
1144 {
1145    char *s;
1146    double friction;
1147
1148    s = getenv("ELM_ENGINE");
1149    if (s)
1150      {
1151         if ((!strcasecmp(s, "x11")) ||
1152             (!strcasecmp(s, "x")) ||
1153             (!strcasecmp(s, "software-x11")) ||
1154             (!strcasecmp(s, "software_x11")))
1155           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_X11);
1156         else if ((!strcasecmp(s, "opengl")) ||
1157                  (!strcasecmp(s, "gl")) ||
1158                  (!strcasecmp(s, "opengl-x11")) ||
1159                  (!strcasecmp(s, "opengl_x11")))
1160           eina_stringshare_replace(&_elm_config->engine, ELM_OPENGL_X11);
1161         else if ((!strcasecmp(s, "x11-8")) ||
1162                  (!strcasecmp(s, "x8")) ||
1163                  (!strcasecmp(s, "software-8-x11")) ||
1164                  (!strcasecmp(s, "software_8_x11")))
1165           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_8_X11);
1166         else if ((!strcasecmp(s, "x11-16")) ||
1167                  (!strcasecmp(s, "x16")) ||
1168                  (!strcasecmp(s, "software-16-x11")) ||
1169                  (!strcasecmp(s, "software_16_x11")))
1170           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_16_X11);
1171 /*
1172         else if ((!strcasecmp(s, "xrender")) ||
1173                  (!strcasecmp(s, "xr")) ||
1174                  (!strcasecmp(s, "xrender-x11")) ||
1175                  (!strcasecmp(s, "xrender_x11")))
1176           eina_stringshare_replace(&_elm_config->engine, ELM_XRENDER_X11);
1177  */
1178         else if ((!strcasecmp(s, "fb")) ||
1179                  (!strcasecmp(s, "software-fb")) ||
1180                  (!strcasecmp(s, "software_fb")))
1181           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_FB);
1182         else if ((!strcasecmp(s, "directfb")) ||
1183                  (!strcasecmp(s, "dfb")))
1184           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_DIRECTFB);
1185         else if ((!strcasecmp(s, "psl1ght")))
1186           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_PSL1GHT);
1187         else if ((!strcasecmp(s, "sdl")) ||
1188                  (!strcasecmp(s, "software-sdl")) ||
1189                  (!strcasecmp(s, "software_sdl")))
1190           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_SDL);
1191         else if ((!strcasecmp(s, "sdl-16")) ||
1192                  (!strcasecmp(s, "software-16-sdl")) ||
1193                  (!strcasecmp(s, "software_16_sdl")))
1194           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_16_SDL);
1195         else if ((!strcasecmp(s, "opengl-sdl")) ||
1196                  (!strcasecmp(s, "opengl_sdl")) ||
1197                  (!strcasecmp(s, "gl-sdl")) ||
1198                  (!strcasecmp(s, "gl_sdl")))
1199           eina_stringshare_replace(&_elm_config->engine, ELM_OPENGL_SDL);
1200         else if ((!strcasecmp(s, "opengl-cocoa")) ||
1201                  (!strcasecmp(s, "opengl_cocoa")) ||
1202                  (!strcasecmp(s, "gl-cocoa")) ||
1203                  (!strcasecmp(s, "gl_cocoa")))
1204           eina_stringshare_replace(&_elm_config->engine, ELM_OPENGL_COCOA);
1205         else if ((!strcasecmp(s, "gdi")) ||
1206                  (!strcasecmp(s, "software-gdi")) ||
1207                  (!strcasecmp(s, "software_gdi")))
1208           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_WIN32);
1209         else if ((!strcasecmp(s, "wince-gdi")) ||
1210                  (!strcasecmp(s, "software-16-wince-gdi")) ||
1211                  (!strcasecmp(s, "software_16_wince_gdi")))
1212           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_16_WINCE);
1213         else if (!strcasecmp(s, "buffer"))
1214           eina_stringshare_replace(&_elm_config->engine, ELM_BUFFER);
1215         else if ((!strncmp(s, "shot:", 5)))
1216           eina_stringshare_replace(&_elm_config->engine, s);
1217         else if ((!strcasecmp(s, "ews")))
1218           eina_stringshare_replace(&_elm_config->engine, ELM_EWS);
1219         else if ((!strcasecmp(s, "wayland_shm")))
1220           eina_stringshare_replace(&_elm_config->engine, ELM_WAYLAND_SHM);
1221         else if ((!strcasecmp(s, "wayland_egl")))
1222           eina_stringshare_replace(&_elm_config->engine, ELM_WAYLAND_EGL);
1223         else
1224           ERR("Unknown engine '%s'.", s);
1225      }
1226
1227    s = getenv("ELM_VSYNC");
1228    if (s) _elm_config->vsync = !!atoi(s);
1229
1230    s = getenv("ELM_THUMBSCROLL_ENABLE");
1231    if (s) _elm_config->thumbscroll_enable = !!atoi(s);
1232    s = getenv("ELM_THUMBSCROLL_THRESHOLD");
1233    if (s) _elm_config->thumbscroll_threshold = atoi(s);
1234    // FIXME: floatformat locale issues here 1.0 vs 1,0 - should just be 1.0
1235    s = getenv("ELM_THUMBSCROLL_MOMENTUM_THRESHOLD");
1236    if (s) _elm_config->thumbscroll_momentum_threshold = atof(s);
1237    s = getenv("ELM_THUMBSCROLL_FRICTION");
1238    if (s) _elm_config->thumbscroll_friction = atof(s);
1239    s = getenv("ELM_THUMBSCROLL_BOUNCE_ENABLE");
1240    if (s) _elm_config->thumbscroll_bounce_enable = !!atoi(s);
1241    s = getenv("ELM_THUMBSCROLL_BOUNCE_FRICTION");
1242    if (s) _elm_config->thumbscroll_bounce_friction = atof(s);
1243    s = getenv("ELM_PAGE_SCROLL_FRICTION");
1244    if (s) _elm_config->page_scroll_friction = atof(s);
1245    s = getenv("ELM_BRING_IN_SCROLL_FRICTION");
1246    if (s) _elm_config->bring_in_scroll_friction = atof(s);
1247    s = getenv("ELM_ZOOM_FRICTION");
1248    if (s) _elm_config->zoom_friction = atof(s);
1249    s = getenv("ELM_THUMBSCROLL_BORDER_FRICTION");
1250    if (s)
1251      {
1252         friction = atof(s);
1253         if (friction < 0.0)
1254           friction = 0.0;
1255
1256         if (friction > 1.0)
1257           friction = 1.0;
1258
1259         _elm_config->thumbscroll_border_friction = friction;
1260      }
1261    s = getenv("ELM_THUMBSCROLL_SENSITIVITY_FRICTION");
1262    if (s)
1263      {
1264         friction = atof(s);
1265         if (friction < 0.1)
1266           friction = 0.1;
1267
1268         if (friction > 1.0)
1269           friction = 1.0;
1270
1271         _elm_config->thumbscroll_sensitivity_friction = friction;
1272      }
1273    s = getenv("ELM_SCROLL_SMOOTH_AMOUNT");
1274    if (s) _elm_config->scroll_smooth_amount = atof(s);
1275    s = getenv("ELM_SCROLL_SMOOTH_HISTORY_WEIGHT");
1276    if (s) _elm_config->scroll_smooth_history_weight = atof(s);
1277    s = getenv("ELM_SCROLL_SMOOTH_FUTURE_TIME");
1278    if (s) _elm_config->scroll_smooth_future_time = atof(s);
1279    s = getenv("ELM_SCROLL_SMOOTH_TIME_WINDOW");
1280    if (s) _elm_config->scroll_smooth_time_window = atof(s);
1281    s = getenv("ELM_THEME");
1282    if (s) eina_stringshare_replace(&_elm_config->theme, s);
1283
1284    s = getenv("ELM_FONT_HINTING");
1285    if (s)
1286      {
1287         if      (!strcasecmp(s, "none")) _elm_config->font_hinting = 0;
1288         else if (!strcasecmp(s, "auto"))
1289           _elm_config->font_hinting = 1;
1290         else if (!strcasecmp(s, "bytecode"))
1291           _elm_config->font_hinting = 2;
1292      }
1293
1294    s = getenv("ELM_FONT_PATH");
1295    if (s)
1296      {
1297         const char *p, *pp;
1298         char *buf2;
1299
1300         EINA_LIST_FREE(_elm_config->font_dirs, p)
1301           {
1302              eina_stringshare_del(p);
1303           }
1304
1305         buf2 = alloca(strlen(s) + 1);
1306         p = s;
1307         pp = p;
1308         for (;; )
1309           {
1310              if ((*p == ':') || (*p == 0))
1311                {
1312                   int len;
1313
1314                   len = p - pp;
1315                   strncpy(buf2, pp, len);
1316                   buf2[len] = 0;
1317                   _elm_config->font_dirs =
1318                     eina_list_append(_elm_config->font_dirs,
1319                                      eina_stringshare_add(buf2));
1320                   if (*p == 0) break;
1321                   p++;
1322                   pp = p;
1323                }
1324              else
1325                {
1326                   if (*p == 0) break;
1327                   p++;
1328                }
1329           }
1330      }
1331
1332    s = getenv("ELM_IMAGE_CACHE");
1333    if (s) _elm_config->image_cache = atoi(s);
1334
1335    s = getenv("ELM_FONT_CACHE");
1336    if (s) _elm_config->font_cache = atoi(s);
1337
1338    s = getenv("ELM_SCALE");
1339    if (s) _elm_config->scale = atof(s);
1340
1341    s = getenv("ELM_FINGER_SIZE");
1342    if (s) _elm_config->finger_size = atoi(s);
1343
1344    s = getenv("ELM_PASSWORD_SHOW_LAST");
1345    if (s) _elm_config->password_show_last = !!atoi(s);
1346
1347    s = getenv("ELM_PASSWORD_SHOW_LAST_TIMEOUT");
1348    if (s)
1349      {
1350         double pw_show_last_timeout = atof(s);
1351         if (pw_show_last_timeout >= 0.0)
1352           _elm_config->password_show_last_timeout = pw_show_last_timeout;
1353      }
1354
1355    s = getenv("ELM_FPS");
1356    if (s) _elm_config->fps = atof(s);
1357    if (_elm_config->fps < 1.0) _elm_config->fps = 1.0;
1358
1359    s = getenv("ELM_MODULES");
1360    if (s) eina_stringshare_replace(&_elm_config->modules, s);
1361
1362    /* Get RTL orientation from system */
1363    setlocale(LC_ALL, "");
1364    bindtextdomain(PACKAGE, LOCALE_DIR);
1365    _elm_config->is_mirrored = !strcmp(E_("default:LTR"), "default:RTL");
1366
1367    s = getenv("ELM_TOOLTIP_DELAY");
1368    if (s)
1369      {
1370         double delay = atof(s);
1371         if (delay >= 0.0)
1372           _elm_config->tooltip_delay = delay;
1373      }
1374
1375    s = getenv("ELM_CURSOR_ENGINE_ONLY");
1376    if (s) _elm_config->cursor_engine_only = !!atoi(s);
1377
1378    s = getenv("ELM_FOCUS_HIGHLIGHT_ENABLE");
1379    if (s) _elm_config->focus_highlight_enable = !!atoi(s);
1380
1381    s = getenv("ELM_FOCUS_HIGHLIGHT_ANIMATE");
1382    if (s) _elm_config->focus_highlight_animate = !!atoi(s);
1383
1384    s = getenv("ELM_TOOLBAR_SHRINK_MODE");
1385    if (s) _elm_config->toolbar_shrink_mode = atoi(s);
1386
1387    s = getenv("ELM_FILESELECTOR_EXPAND_ENABLE");
1388    if (s) _elm_config->fileselector_expand_enable = !!atoi(s);
1389
1390    s = getenv("ELM_INWIN_DIALOGS_ENABLE");
1391    if (s) _elm_config->inwin_dialogs_enable = !!atoi(s);
1392
1393    s = getenv("ELM_ICON_SIZE");
1394    if (s) _elm_config->icon_size = atoi(s);
1395
1396    s = getenv("ELM_LONGPRESS_TIMEOUT");
1397    if (s) _elm_config->longpress_timeout = atof(s);
1398    if (_elm_config->longpress_timeout < 0.0)
1399      _elm_config->longpress_timeout = 0.0;
1400
1401    s = getenv("ELM_EFFECT_ENABLE");
1402    if (s) _elm_config->effect_enable = !!atoi(s);
1403
1404    s = getenv("ELM_DESKTOP_ENTRY");
1405    if (s) _elm_config->desktop_entry = !!atoi(s);
1406    s = getenv("ELM_ACCESS_MODE");
1407    if (s) _elm_config->access_mode = ELM_ACCESS_MODE_ON;
1408 }
1409
1410 EAPI Eina_Bool
1411 elm_config_mirrored_get(void)
1412 {
1413    return _elm_config->is_mirrored;
1414 }
1415
1416 EAPI void
1417 elm_config_mirrored_set(Eina_Bool mirrored)
1418 {
1419    _elm_config->is_mirrored = mirrored;
1420    _elm_rescale();
1421 }
1422
1423 EAPI Eina_Bool
1424 elm_config_cursor_engine_only_get(void)
1425 {
1426    return _elm_config->cursor_engine_only;
1427 }
1428
1429 EAPI void
1430 elm_config_cursor_engine_only_set(Eina_Bool engine_only)
1431 {
1432    engine_only = !!engine_only;
1433    _elm_config->cursor_engine_only = engine_only;
1434 }
1435
1436 EINA_DEPRECATED EAPI double
1437 elm_tooltip_delay_get(void)
1438 {
1439    return elm_config_tooltip_delay_get();
1440 }
1441
1442 EINA_DEPRECATED EAPI Eina_Bool
1443 elm_tooltip_delay_set(double delay)
1444 {
1445    elm_config_tooltip_delay_set(delay);
1446    return EINA_TRUE;
1447 }
1448
1449 EAPI double
1450 elm_config_tooltip_delay_get(void)
1451 {
1452    return _elm_config->tooltip_delay;
1453 }
1454
1455 EAPI void
1456 elm_config_tooltip_delay_set(double delay)
1457 {
1458    if (delay < 0.0) return;
1459    _elm_config->tooltip_delay = delay;
1460 }
1461
1462 EAPI double
1463 elm_config_scale_get(void)
1464 {
1465    return _elm_config->scale;
1466 }
1467
1468 EAPI void
1469 elm_config_scale_set(double scale)
1470 {
1471    if (_elm_config->scale == scale) return;
1472    _elm_config->scale = scale;
1473    _elm_rescale();
1474 }
1475
1476 EAPI Eina_Bool
1477 elm_config_password_show_last_get(void)
1478 {
1479    return _elm_config->password_show_last;
1480 }
1481
1482 EAPI void
1483 elm_config_password_show_last_set(Eina_Bool password_show_last)
1484 {
1485    if (_elm_config->password_show_last == password_show_last) return;
1486    _elm_config->password_show_last = password_show_last;
1487    edje_password_show_last_set(_elm_config->password_show_last);
1488 }
1489
1490 EAPI double
1491 elm_config_password_show_last_timeout_get(void)
1492 {
1493    return _elm_config->password_show_last_timeout;
1494 }
1495
1496 EAPI void
1497 elm_config_password_show_last_timeout_set(double password_show_last_timeout)
1498 {
1499    if (_elm_config->password_show_last_timeout == password_show_last_timeout) return;
1500    _elm_config->password_show_last_timeout = password_show_last_timeout;
1501    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
1502 }
1503
1504 EAPI Eina_Bool
1505 elm_config_save(void)
1506 {
1507    return _elm_config_save();
1508 }
1509
1510 EAPI void
1511 elm_config_reload(void)
1512 {
1513    _elm_config_reload();
1514 }
1515
1516 EAPI const char *
1517 elm_config_profile_get(void)
1518 {
1519    return _elm_config_current_profile_get();
1520 }
1521
1522 EAPI const char *
1523 elm_config_profile_dir_get(const char *profile,
1524                     Eina_Bool   is_user)
1525 {
1526    return _elm_config_profile_dir_get(profile, is_user);
1527 }
1528
1529 EAPI void
1530 elm_config_profile_dir_free(const char *p_dir)
1531 {
1532    free((void *)p_dir);
1533 }
1534
1535 EAPI Eina_List *
1536 elm_config_profile_list_get(void)
1537 {
1538    return _elm_config_profiles_list();
1539 }
1540
1541 EAPI void
1542 elm_config_profile_list_free(Eina_List *l)
1543 {
1544    const char *dir;
1545
1546    EINA_LIST_FREE(l, dir)
1547      eina_stringshare_del(dir);
1548 }
1549
1550 EAPI void
1551 elm_config_profile_set(const char *profile)
1552 {
1553    EINA_SAFETY_ON_NULL_RETURN(profile);
1554    _elm_config_profile_set(profile);
1555 }
1556
1557 EAPI const char *
1558 elm_config_engine_get(void)
1559 {
1560    return _elm_config->engine;
1561 }
1562
1563 EAPI void
1564 elm_config_engine_set(const char *engine)
1565 {
1566    EINA_SAFETY_ON_NULL_RETURN(engine);
1567
1568    _elm_config_engine_set(engine);
1569 }
1570
1571 EAPI Eina_List *
1572 elm_config_text_classes_list_get(void)
1573 {
1574    return _elm_config_text_classes_get();
1575 }
1576
1577 EAPI void
1578 elm_config_text_classes_list_free(Eina_List *list)
1579 {
1580    _elm_config_text_classes_free(list);
1581 }
1582
1583 EAPI const Eina_List *
1584 elm_config_font_overlay_list_get(void)
1585 {
1586    return _elm_config_font_overlays_list();
1587 }
1588
1589 EAPI void
1590 elm_config_font_overlay_set(const char    *text_class,
1591                      const char    *font,
1592                      Evas_Font_Size size)
1593 {
1594    EINA_SAFETY_ON_NULL_RETURN(text_class);
1595    _elm_config_font_overlay_set(text_class, font, size);
1596 }
1597
1598 EAPI void
1599 elm_config_font_overlay_unset(const char *text_class)
1600 {
1601    EINA_SAFETY_ON_NULL_RETURN(text_class);
1602    _elm_config_font_overlay_remove(text_class);
1603 }
1604
1605 EAPI void
1606 elm_config_font_overlay_apply(void)
1607 {
1608    _elm_config_font_overlay_apply();
1609 }
1610
1611 EAPI Evas_Coord
1612 elm_config_finger_size_get(void)
1613 {
1614    return _elm_config->finger_size;
1615 }
1616
1617 EAPI void
1618 elm_config_finger_size_set(Evas_Coord size)
1619 {
1620    if (_elm_config->finger_size == size) return;
1621    _elm_config->finger_size = size;
1622    _elm_rescale();
1623 }
1624
1625 EAPI int
1626 elm_config_cache_flush_interval_get(void)
1627 {
1628    return _elm_config->cache_flush_poll_interval;
1629 }
1630
1631 EAPI void
1632 elm_config_cache_flush_interval_set(int size)
1633 {
1634    if (_elm_config->cache_flush_poll_interval == size) return;
1635    _elm_config->cache_flush_poll_interval = size;
1636
1637    _elm_recache();
1638 }
1639
1640 EAPI Eina_Bool
1641 elm_config_cache_flush_enabled_get(void)
1642 {
1643    return _elm_config->cache_flush_enable;
1644 }
1645
1646 EAPI void
1647 elm_config_cache_flush_enabled_set(Eina_Bool enabled)
1648 {
1649    enabled = !!enabled;
1650    if (_elm_config->cache_flush_enable == enabled) return;
1651    _elm_config->cache_flush_enable = enabled;
1652
1653    _elm_recache();
1654 }
1655
1656 EINA_DEPRECATED EAPI int
1657 elm_font_cache_get(void)
1658 {
1659    return elm_config_cache_font_cache_size_get();
1660 }
1661
1662 EAPI int
1663 elm_config_cache_font_cache_size_get(void)
1664 {
1665    return _elm_config->font_cache;
1666 }
1667
1668 EINA_DEPRECATED EAPI void
1669 elm_font_cache_set(int size)
1670 {
1671    elm_config_cache_font_cache_size_set(size);
1672 }
1673
1674 EAPI void
1675 elm_config_cache_font_cache_size_set(int size)
1676 {
1677    if (_elm_config->font_cache == size) return;
1678    _elm_config->font_cache = size;
1679
1680    _elm_recache();
1681 }
1682
1683 EINA_DEPRECATED EAPI int
1684 elm_image_cache_get(void)
1685 {
1686    return elm_config_cache_image_cache_size_get();
1687 }
1688
1689 EAPI int
1690 elm_config_cache_image_cache_size_get(void)
1691 {
1692    return _elm_config->image_cache;
1693 }
1694
1695 EINA_DEPRECATED EAPI void
1696 elm_image_cache_set(int size)
1697 {
1698    elm_config_cache_image_cache_size_set(size);
1699 }
1700
1701 EAPI void
1702 elm_config_cache_image_cache_size_set(int size)
1703 {
1704    if (_elm_config->image_cache == size) return;
1705    _elm_config->image_cache = size;
1706
1707    _elm_recache();
1708 }
1709
1710 EINA_DEPRECATED EAPI int
1711 elm_edje_file_cache_get(void)
1712 {
1713    return elm_config_cache_edje_file_cache_size_get();
1714 }
1715
1716 EAPI int
1717 elm_config_cache_edje_file_cache_size_get()
1718 {
1719    return _elm_config->edje_cache;
1720 }
1721
1722 EINA_DEPRECATED EAPI void
1723 elm_edje_file_cache_set(int size)
1724 {
1725    elm_config_cache_edje_file_cache_size_set(size);
1726 }
1727
1728 EAPI void
1729 elm_config_cache_edje_file_cache_size_set(int size)
1730 {
1731    if (_elm_config->edje_cache == size) return;
1732    _elm_config->edje_cache = size;
1733
1734    _elm_recache();
1735 }
1736
1737 EINA_DEPRECATED EAPI int
1738 elm_edje_collection_cache_get(void)
1739 {
1740    return elm_config_cache_edje_collection_cache_size_get();
1741 }
1742
1743 EAPI int
1744 elm_config_cache_edje_collection_cache_size_get(void)
1745 {
1746    return _elm_config->edje_collection_cache;
1747 }
1748
1749 EINA_DEPRECATED EAPI void
1750 elm_edje_collection_cache_set(int size)
1751 {
1752    elm_config_cache_edje_collection_cache_size_set(size);
1753 }
1754
1755 EAPI void
1756 elm_config_cache_edje_collection_cache_size_set(int size)
1757 {
1758    if (_elm_config->edje_collection_cache == size) return;
1759    _elm_config->edje_collection_cache = size;
1760
1761    _elm_recache();
1762 }
1763
1764 EAPI Eina_Bool
1765 elm_config_focus_highlight_enabled_get(void)
1766 {
1767    return _elm_config->focus_highlight_enable;
1768 }
1769
1770 EAPI void
1771 elm_config_focus_highlight_enabled_set(Eina_Bool enable)
1772 {
1773    _elm_config->focus_highlight_enable = !!enable;
1774 }
1775
1776 EAPI Eina_Bool
1777 elm_config_focus_highlight_animate_get(void)
1778 {
1779    return _elm_config->focus_highlight_animate;
1780 }
1781
1782 EAPI void
1783 elm_config_focus_highlight_animate_set(Eina_Bool animate)
1784 {
1785    _elm_config->focus_highlight_animate = !!animate;
1786 }
1787
1788 EAPI Eina_Bool
1789 elm_config_scroll_bounce_enabled_get(void)
1790 {
1791    return _elm_config->thumbscroll_bounce_enable;
1792 }
1793
1794 EAPI void
1795 elm_config_scroll_bounce_enabled_set(Eina_Bool enabled)
1796 {
1797    _elm_config->thumbscroll_bounce_enable = enabled;
1798 }
1799
1800 EAPI double
1801 elm_config_scroll_bounce_friction_get(void)
1802 {
1803    return _elm_config->thumbscroll_bounce_friction;
1804 }
1805
1806 EAPI void
1807 elm_config_scroll_bounce_friction_set(double friction)
1808 {
1809    _elm_config->thumbscroll_bounce_friction = friction;
1810 }
1811
1812 EAPI double
1813 elm_config_scroll_page_scroll_friction_get(void)
1814 {
1815    return _elm_config->page_scroll_friction;
1816 }
1817
1818 EAPI void
1819 elm_config_scroll_page_scroll_friction_set(double friction)
1820 {
1821    _elm_config->page_scroll_friction = friction;
1822 }
1823
1824 EAPI double
1825 elm_config_scroll_bring_in_scroll_friction_get(void)
1826 {
1827    return _elm_config->bring_in_scroll_friction;
1828 }
1829
1830 EAPI void
1831 elm_config_scroll_bring_in_scroll_friction_set(double friction)
1832 {
1833    _elm_config->bring_in_scroll_friction = friction;
1834 }
1835
1836 EAPI double
1837 elm_config_scroll_zoom_friction_get(void)
1838 {
1839    return _elm_config->zoom_friction;
1840 }
1841
1842 EAPI void
1843 elm_config_scroll_zoom_friction_set(double friction)
1844 {
1845    _elm_config->zoom_friction = friction;
1846 }
1847
1848 EAPI Eina_Bool
1849 elm_config_scroll_thumbscroll_enabled_get(void)
1850 {
1851    return _elm_config->thumbscroll_enable;
1852 }
1853
1854 EAPI void
1855 elm_config_scroll_thumbscroll_enabled_set(Eina_Bool enabled)
1856 {
1857    _elm_config->thumbscroll_enable = enabled;
1858 }
1859
1860 EAPI unsigned int
1861 elm_config_scroll_thumbscroll_threshold_get(void)
1862 {
1863    return _elm_config->thumbscroll_threshold;
1864 }
1865
1866 EAPI void
1867 elm_config_scroll_thumbscroll_threshold_set(unsigned int threshold)
1868 {
1869    _elm_config->thumbscroll_threshold = threshold;
1870 }
1871
1872 EAPI double
1873 elm_config_scroll_thumbscroll_momentum_threshold_get(void)
1874 {
1875    return _elm_config->thumbscroll_momentum_threshold;
1876 }
1877
1878 EAPI void
1879 elm_config_scroll_thumbscroll_momentum_threshold_set(double threshold)
1880 {
1881    _elm_config->thumbscroll_momentum_threshold = threshold;
1882 }
1883
1884 EAPI double
1885 elm_config_scroll_thumbscroll_friction_get(void)
1886 {
1887    return _elm_config->thumbscroll_friction;
1888 }
1889
1890 EAPI void
1891 elm_config_scroll_thumbscroll_friction_set(double friction)
1892 {
1893    _elm_config->thumbscroll_friction = friction;
1894 }
1895
1896 EAPI double
1897 elm_config_scroll_thumbscroll_border_friction_get(void)
1898 {
1899    return _elm_config->thumbscroll_border_friction;
1900 }
1901
1902 EAPI void
1903 elm_config_scroll_thumbscroll_border_friction_set(double friction)
1904 {
1905    if (friction < 0.0) friction = 0.0;
1906    if (friction > 1.0) friction = 1.0;
1907    _elm_config->thumbscroll_friction = friction;
1908 }
1909
1910 EAPI double
1911 elm_config_scroll_thumbscroll_sensitivity_friction_get(void)
1912 {
1913    return _elm_config->thumbscroll_sensitivity_friction;
1914 }
1915
1916 EAPI void
1917 elm_config_scroll_thumbscroll_sensitivity_friction_set(double friction)
1918 {
1919    if (friction < 0.1) friction = 0.1;
1920    if (friction > 1.0) friction = 1.0;
1921    _elm_config->thumbscroll_friction = friction;
1922 }
1923
1924 EAPI void
1925 elm_config_longpress_timeout_set(double longpress_timeout)
1926 {
1927    _elm_config->longpress_timeout = longpress_timeout;
1928 }
1929
1930 EAPI double
1931 elm_config_longpress_timeout_get(void)
1932 {
1933    return _elm_config->longpress_timeout;
1934 }
1935
1936 EAPI void
1937 elm_config_all_flush(void)
1938 {
1939 #ifdef HAVE_ELEMENTARY_X
1940    if (_prop_all_update_timer) ecore_timer_del(_prop_all_update_timer);
1941    _prop_all_update_timer = ecore_timer_add(0.1, _prop_all_update_cb, NULL);
1942 #endif
1943 }
1944
1945 static void
1946 _translation_init()
1947 {
1948 #ifdef ENABLE_NLS
1949    const char *cur_dom = textdomain(NULL);
1950    const char *trans_comment = gettext("");
1951    const char *msg_locale = setlocale(LC_MESSAGES, NULL);
1952
1953    /* Same concept as what glib does:
1954     * We shouldn't translate if there are no translations for the
1955     * application in the current locale + domain. (Unless locale is
1956     * en_/C where translating only parts of the interface make some
1957     * sense).
1958     */
1959    _elm_config->translate = !(strcmp (cur_dom, "messages") &&
1960          !*trans_comment && strncmp (msg_locale, "en_", 3) &&
1961          strcmp (msg_locale, "C"));
1962 #endif
1963 }
1964
1965 void
1966 _elm_config_init(void)
1967 {
1968    if (!ELM_EVENT_CONFIG_ALL_CHANGED)
1969       ELM_EVENT_CONFIG_ALL_CHANGED = ecore_event_type_new();
1970    _desc_init();
1971    _profile_fetch_from_conf();
1972    _config_load();
1973    if (_elm_preferred_engine) eina_stringshare_del(_elm_preferred_engine);
1974    if (_elm_config->engine)
1975      _elm_preferred_engine = eina_stringshare_add(_elm_config->engine);
1976    else
1977      _elm_preferred_engine = NULL;
1978    _translation_init();
1979    _env_get();
1980    _config_apply();
1981    _elm_config_font_overlay_apply();
1982    _elm_recache();
1983 }
1984
1985 void
1986 _elm_config_sub_shutdown(void)
1987 {
1988 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
1989    if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
1990        ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
1991        ENGINE_COMPARE(ELM_XRENDER_X11) ||
1992        ENGINE_COMPARE(ELM_OPENGL_X11) ||
1993        ENGINE_COMPARE(ELM_OPENGL_COCOA))
1994 #undef ENGINE_COMPARE
1995      {
1996 #ifdef HAVE_ELEMENTARY_X
1997         ecore_x_disconnect();
1998 #endif
1999      }
2000 }
2001
2002 void
2003 _elm_config_sub_init(void)
2004 {
2005 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
2006    if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
2007        ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
2008        ENGINE_COMPARE(ELM_XRENDER_X11) ||
2009        ENGINE_COMPARE(ELM_OPENGL_X11) ||
2010        ENGINE_COMPARE(ELM_OPENGL_COCOA))
2011 #undef ENGINE_COMPARE
2012      {
2013 #ifdef HAVE_ELEMENTARY_X
2014         if (!ecore_x_init(NULL))
2015           {
2016              ERR("Cannot connect to X11 display. check $DISPLAY variable");
2017              exit(1);
2018           }
2019         _root_1st = ecore_x_window_root_first_get();
2020
2021         if (!ecore_x_screen_is_composited(0))
2022           _elm_config->compositing = 0;
2023
2024         ecore_x_atoms_get(_atom_names, ATOM_COUNT, _atom);
2025         ecore_x_event_mask_set(_root_1st,
2026                                ECORE_X_EVENT_MASK_WINDOW_PROPERTY);
2027         _prop_change_handler = ecore_event_handler_add
2028             (ECORE_X_EVENT_WINDOW_PROPERTY, _prop_change, NULL);
2029         if (!getenv("ELM_PROFILE"))
2030           {
2031              char *s;
2032
2033              s = ecore_x_window_prop_string_get(_root_1st,
2034                                                 _atom[ATOM_E_PROFILE]);
2035              if (s)
2036                {
2037                   int changed = 0;
2038
2039                   if (_elm_profile)
2040                     {
2041                        if (strcmp(_elm_profile, s)) changed = 1;
2042                        free(_elm_profile);
2043                     }
2044                   _elm_profile = s;
2045                   if (changed) _prop_config_get();
2046                }
2047           }
2048 #endif
2049      }
2050    _config_sub_apply();
2051 }
2052
2053 void
2054 _elm_config_reload(void)
2055 {
2056    _config_free();
2057    _config_load();
2058    _config_apply();
2059    _elm_config_font_overlay_apply();
2060    _elm_rescale();
2061    _elm_recache();
2062 }
2063
2064 void
2065 _elm_config_engine_set(const char *engine)
2066 {
2067    if (_elm_config->engine && strcmp(_elm_config->engine, engine))
2068      eina_stringshare_del(_elm_config->engine);
2069
2070    _elm_config->engine = eina_stringshare_add(engine);
2071 }
2072
2073 EAPI const char *
2074 elm_config_preferred_engine_get(void)
2075 {
2076    return _elm_preferred_engine;
2077 }
2078
2079 EAPI void
2080 elm_config_preferred_engine_set(const char *engine)
2081 {
2082    if (engine)
2083      eina_stringshare_replace(&(_elm_preferred_engine), engine);
2084    else
2085      {
2086         if (_elm_preferred_engine) eina_stringshare_del(_elm_preferred_engine);
2087         _elm_preferred_engine = eina_stringshare_add(_elm_config->engine);
2088      }
2089 }
2090
2091 void
2092 _elm_config_profile_set(const char *profile)
2093 {
2094    Eina_Bool changed = EINA_FALSE;
2095
2096    if (_elm_profile)
2097      {
2098         if (strcmp(_elm_profile, profile))
2099           changed = 1;
2100         free(_elm_profile);
2101      }
2102
2103    _elm_profile = strdup(profile);
2104
2105    if (changed)
2106      {
2107         _config_free();
2108         _config_load();
2109         _config_apply();
2110         _elm_config_font_overlay_apply();
2111         _elm_rescale();
2112         _elm_recache();
2113      }
2114 }
2115
2116 void
2117 _elm_config_shutdown(void)
2118 {
2119 #ifdef HAVE_ELEMENTARY_X
2120    if (_prop_all_update_timer)
2121      {
2122         ecore_timer_del(_prop_all_update_timer);
2123         _prop_all_update_timer = NULL;
2124         _prop_all_update_cb(NULL);
2125      }
2126    if (_prop_change_delay_timer) ecore_timer_del(_prop_change_delay_timer);
2127    _prop_change_delay_timer = NULL;
2128 #endif
2129
2130 #define ENGINE_COMPARE(name) (!strcmp(_elm_config->engine, name))
2131    if (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
2132        ENGINE_COMPARE(ELM_SOFTWARE_16_X11) ||
2133        ENGINE_COMPARE(ELM_XRENDER_X11) ||
2134        ENGINE_COMPARE(ELM_OPENGL_X11))
2135 #undef ENGINE_COMPARE
2136      {
2137 #ifdef HAVE_ELEMENTARY_X
2138         ecore_event_handler_del(_prop_change_handler);
2139         _prop_change_handler = NULL;
2140 #endif
2141      }
2142    _config_free();
2143    if (_elm_preferred_engine)
2144      {
2145         eina_stringshare_del(_elm_preferred_engine);
2146         _elm_preferred_engine = NULL;
2147      }
2148    if (_elm_profile)
2149      {
2150         free(_elm_profile);
2151         _elm_profile = NULL;
2152      }
2153    _desc_shutdown();
2154 }
2155