src/lib/elm_config.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #include <Elementary.h>
   6 #include "elm_priv.h"
   7 #include <pwd.h>
   8
   9 EAPI int ELM_EVENT_CONFIG_ALL_CHANGED = 0;
  10
  11 Elm_Config *_elm_config = NULL;
  12 char *_elm_profile = NULL;
  13 static Eet_Data_Descriptor *_config_edd = NULL;
  14 static Eet_Data_Descriptor *_config_font_overlay_edd = NULL;
  15 static Eet_Data_Descriptor *_config_color_edd = NULL;
  16 static Eet_Data_Descriptor *_config_color_palette_edd = NULL;
  17 static Eet_Data_Descriptor *_config_color_overlay_edd = NULL;
  18 static Eet_Data_Descriptor *_config_bindings_widget_edd = NULL;
  19 static Eet_Data_Descriptor *_config_binding_key_edd = NULL;
  20 static Eet_Data_Descriptor *_config_binding_modifier_edd = NULL;
  21 const char *_elm_preferred_engine = NULL;
  22 const char *_elm_accel_preference = NULL;
  23 const char *_elm_gl_preference = NULL;
  24 Eina_List  *_font_overlays_del = NULL;
  25 Eina_List  *_color_overlays_del = NULL;
  26
  27 static Ecore_Poller *_elm_cache_flush_poller = NULL;
  28 static void _elm_config_key_binding_hash(void);
  29 static Ecore_Timer *_config_change_delay_timer = NULL;
  30 Eio_Monitor *_eio_monitor = NULL;
  31
  32 Eina_Hash *_elm_key_bindings = NULL;
  33
  34 const char *_elm_engines[] = {
  35    "software_x11",
  36    "fb",
  37    "opengl_x11",
  38    "software_gdi",
  39    "sdl",
  40    "opengl_sdl",
  41    "buffer",
  42    "ews",
  43    "opengl_cocoa",
  44    "psl1ght",
  45    "wayland_shm",
  46    "wayland_egl",
  47    "drm",
  48    "ddraw",
  49    NULL
  50 };
  51
  52 /* whenever you want to add a new text class support into Elementary,
  53    declare it both here and in the (default) theme */
  54 static const Elm_Text_Class _elm_text_classes[] = {
  55    {"button", "Button"},
  56    {"label", "Label"},
  57    {"entry", "Entry"},
  58    {"title_bar", "Title Bar"},
  59    {"list_item", "List Items"},
  60    {"grid_item", "Grid Items"},
  61    {"toolbar_item", "Toolbar Items"},
  62    {"menu_item", "Menu Items"},
  63    {NULL, NULL}
  64 };
  65
  66 /* whenever you want to add a new class class support into Elementary,
  67    declare it both here and in the (default) theme */
  68 static const Elm_Color_Class _elm_color_classes[] = {
  69    {"button_text", "Button Text"},
  70    {"button_text_disabled", "Button Disabled Text"},
  71    {"button_text_anchor", "Anchor Button Text"},
  72    {"button_text_anchor_disabled", "Anchor Button Disabled Text"},
  73    {"hoversel_item_active", "Hoversel Item Text"},
  74    {"hoversel_text_disabled", "Hoversel Item Disabled Text"},
  75    {"radio_text", "Radio Text"},
  76    {"frame", "Frame Text"},
  77    {"entry", "Entry Text"},
  78    {"check_text", "Check Text"},
  79    {"check_on_text", "Check On Text"},
  80    {"check_off_text", "Check Off Text"},
  81    {"list_item_base", "List Item Base"},
  82    {"list_item_base_odd", "List Odd Item Base"},
  83    {"list_item_disabled", "List Item Disabled Base"},
  84    {"list_item_selected", "List Item Selected Base"},
  85    {"grid_item", "Grid Item Text"},
  86    {"grid_item_disabled", "Grid Item Disabled Text"},
  87    {"grid_item_selected", "Grid Item Selected Text"},
  88    {"toolbar_item", "Toolbar Item Text"},
  89    {"toolbar_item_disabled", "Toolbar Item Disabled Text"},
  90    {"toolbar_item_selected", "Toolbar Item Selected Text"},
  91    {"toolbar_item_active", "Toolbar Item Active Text"},
  92    {"slider_text", "Slider Text"},
  93    {"slider_text_disabled", "Slider Disabled Text"},
  94    {"slider_indicator", "Slider Indicator Text"},
  95    {"progressbar_text", "Progressbar Text"},
  96    {"progressbar_text_disabled", "Progressbar Disabled Text"},
  97    {"progressbar_status", "Progressbar Status Text"},
  98    {"bubble_text", "Bubble Text"},
  99    {"bubble_info", "Bubble Info Text"},
 100    {"menu_item_active", "Menu Item Text"},
 101    {"menu_item_disabled", "Menu Item Disabled Text"},
 102    {"border_title", "Border Title Text"},
 103    {"border_title_active", "Border Title Active Text"},
 104    {"datetime_text", "Datetime Text"},
 105    {"multibuttonentry_label", "Multibuttonentry Text"},
 106    {"spinner", "Spinner Text"},
 107    {"spinner_disabled", "Spinner Disabled Text"},
 108    {NULL, NULL}
 109 };
 110
 111 static void        _config_free(Elm_Config *cfg);
 112 static void        _config_apply(void);
 113 static void        _config_sub_apply(void);
 114 static void        _config_update(void);
 115 static void        _env_get(void);
 116 static void        _color_overlays_cancel(void);
 117
 118 #define ELM_CONFIG_VAL(edd, type, member, dtype) \
 119   EET_DATA_DESCRIPTOR_ADD_BASIC(edd, type, #member, member, dtype)
 120 #define ELM_CONFIG_LIST(edd, type, member, eddtype) \
 121   EET_DATA_DESCRIPTOR_ADD_LIST(edd, type, #member, member, eddtype)
 122
 123 static void
 124 _elm_font_overlays_del_free(void)
 125 {
 126    char *text_class;
 127    Eina_List *l;
 128    EINA_LIST_FOREACH(_font_overlays_del, l, text_class)
 129      eina_stringshare_del(text_class);
 130    _font_overlays_del = eina_list_free(_font_overlays_del);
 131 }
 132
 133 static void
 134 _elm_config_font_overlays_cancel(void)
 135 {
 136    Elm_Font_Overlay *efd;
 137    Eina_List *l;
 138    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 139      edje_text_class_del(efd->text_class);
 140 }
 141
 142 static void
 143 _desc_init(void)
 144 {
 145    Eet_Data_Descriptor_Class eddc;
 146
 147    EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Config);
 148    eddc.func.str_direct_alloc = NULL;
 149    eddc.func.str_direct_free = NULL;
 150
 151    _config_edd = eet_data_descriptor_file_new(&eddc);
 152    if (!_config_edd)
 153      {
 154         ERR("EEEK! eet_data_descriptor_file_new() failed.");
 155         return;
 156      }
 157
 158    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 159    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Font_Overlay);
 160    eddc.func.str_direct_alloc = NULL;
 161    eddc.func.str_direct_free = NULL;
 162
 163    _config_font_overlay_edd = eet_data_descriptor_stream_new(&eddc);
 164    if (!_config_font_overlay_edd)
 165      {
 166         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 167         eet_data_descriptor_free(_config_edd);
 168         return;
 169      }
 170
 171    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 172    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Color_RGBA);
 173    eddc.func.str_direct_alloc = NULL;
 174    eddc.func.str_direct_free = NULL;
 175
 176    _config_color_edd = eet_data_descriptor_stream_new(&eddc);
 177    if (!_config_color_edd)
 178      {
 179         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 180         eet_data_descriptor_free(_config_edd);
 181         return;
 182      }
 183
 184    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 185    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Custom_Palette);
 186    eddc.func.str_direct_alloc = NULL;
 187    eddc.func.str_direct_free = NULL;
 188
 189    _config_color_palette_edd = eet_data_descriptor_stream_new(&eddc);
 190    if (!_config_color_palette_edd)
 191      {
 192         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 193         eet_data_descriptor_free(_config_edd);
 194         return;
 195      }
 196
 197    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 198    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Color_Overlay);
 199    eddc.func.str_direct_alloc = NULL;
 200    eddc.func.str_direct_free = NULL;
 201
 202    _config_color_overlay_edd = eet_data_descriptor_stream_new(&eddc);
 203    if (!_config_color_overlay_edd)
 204      {
 205         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 206         eet_data_descriptor_free(_config_edd);
 207         return;
 208      }
 209
 210    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 211    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Config_Bindings_Widget);
 212    eddc.func.str_direct_alloc = NULL;
 213    eddc.func.str_direct_free = NULL;
 214
 215    _config_bindings_widget_edd = eet_data_descriptor_stream_new(&eddc);
 216    if (!_config_bindings_widget_edd)
 217      {
 218         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 219         eet_data_descriptor_free(_config_edd);
 220         return;
 221      }
 222
 223    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 224    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Config_Binding_Key);
 225    eddc.func.str_direct_alloc = NULL;
 226    eddc.func.str_direct_free = NULL;
 227
 228    _config_binding_key_edd = eet_data_descriptor_stream_new(&eddc);
 229    if (!_config_binding_key_edd)
 230      {
 231         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 232         eet_data_descriptor_free(_config_edd);
 233         return;
 234      }
 235
 236    memset(&eddc, 0, sizeof(eddc)); /* just in case... */
 237    EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Elm_Config_Binding_Modifier);
 238    eddc.func.str_direct_alloc = NULL;
 239    eddc.func.str_direct_free = NULL;
 240
 241    _config_binding_modifier_edd = eet_data_descriptor_stream_new(&eddc);
 242    if (!_config_binding_modifier_edd)
 243      {
 244         ERR("EEEK! eet_data_descriptor_stream_new() failed.");
 245         eet_data_descriptor_free(_config_edd);
 246         return;
 247      }
 248
 249 #define T_INT    EET_T_INT
 250 #define T_DOUBLE EET_T_DOUBLE
 251 #define T_STRING EET_T_STRING
 252 #define T_UCHAR  EET_T_UCHAR
 253
 254 #define T        Elm_Font_Overlay
 255 #define D        _config_font_overlay_edd
 256    ELM_CONFIG_VAL(D, T, text_class, EET_T_STRING);
 257    ELM_CONFIG_VAL(D, T, font, EET_T_STRING);
 258    ELM_CONFIG_VAL(D, T, size, EET_T_INT);
 259 #undef T
 260 #undef D
 261
 262 #define T Elm_Color_RGBA
 263 #define D _config_color_edd
 264    ELM_CONFIG_VAL(D, T, r, EET_T_UINT);
 265    ELM_CONFIG_VAL(D, T, g, EET_T_UINT);
 266    ELM_CONFIG_VAL(D, T, b, EET_T_UINT);
 267    ELM_CONFIG_VAL(D, T, a, EET_T_UINT);
 268 #undef T
 269 #undef D
 270
 271 #define T Elm_Custom_Palette
 272 #define D _config_color_palette_edd
 273    ELM_CONFIG_VAL(D, T, palette_name, EET_T_STRING);
 274    ELM_CONFIG_LIST(D, T, color_list, _config_color_edd);
 275 #undef T
 276 #undef D
 277
 278 #define T Elm_Color_Overlay
 279 #define D _config_color_overlay_edd
 280    ELM_CONFIG_VAL(D, T, color_class, EET_T_STRING);
 281    ELM_CONFIG_VAL(D, T, color.r, EET_T_UCHAR);
 282    ELM_CONFIG_VAL(D, T, color.g, EET_T_UCHAR);
 283    ELM_CONFIG_VAL(D, T, color.b, EET_T_UCHAR);
 284    ELM_CONFIG_VAL(D, T, color.a, EET_T_UCHAR);
 285    ELM_CONFIG_VAL(D, T, outline.r, EET_T_UCHAR);
 286    ELM_CONFIG_VAL(D, T, outline.g, EET_T_UCHAR);
 287    ELM_CONFIG_VAL(D, T, outline.b, EET_T_UCHAR);
 288    ELM_CONFIG_VAL(D, T, outline.a, EET_T_UCHAR);
 289    ELM_CONFIG_VAL(D, T, shadow.r, EET_T_UCHAR);
 290    ELM_CONFIG_VAL(D, T, shadow.g, EET_T_UCHAR);
 291    ELM_CONFIG_VAL(D, T, shadow.b, EET_T_UCHAR);
 292    ELM_CONFIG_VAL(D, T, shadow.a, EET_T_UCHAR);
 293 #undef T
 294 #undef D
 295
 296 #define T        Elm_Config_Bindings_Widget
 297 #define D        _config_bindings_widget_edd
 298    ELM_CONFIG_VAL(D, T, name, EET_T_STRING);
 299    ELM_CONFIG_LIST(D, T, key_bindings, _config_binding_key_edd);
 300 #undef T
 301 #undef D
 302
 303 #define T        Elm_Config_Binding_Key
 304 #define D        _config_binding_key_edd
 305    ELM_CONFIG_VAL(D, T, context, EET_T_INT);
 306    ELM_CONFIG_VAL(D, T, key, EET_T_STRING);
 307    ELM_CONFIG_VAL(D, T, action, EET_T_STRING);
 308    ELM_CONFIG_VAL(D, T, params, EET_T_STRING);
 309    ELM_CONFIG_LIST(D, T, modifiers, _config_binding_modifier_edd);
 310 #undef T
 311 #undef D
 312
 313 #define T        Elm_Config_Binding_Modifier
 314 #define D        _config_binding_modifier_edd
 315    ELM_CONFIG_VAL(D, T, mod, EET_T_STRING);
 316    ELM_CONFIG_VAL(D, T, flag, EET_T_UCHAR);
 317 #undef T
 318 #undef D
 319
 320 #define T Elm_Config
 321 #define D _config_edd
 322    ELM_CONFIG_VAL(D, T, config_version, T_INT);
 323    ELM_CONFIG_VAL(D, T, engine, T_STRING);
 324    ELM_CONFIG_VAL(D, T, accel, T_STRING);
 325    ELM_CONFIG_VAL(D, T, accel_override, T_UCHAR);
 326    ELM_CONFIG_VAL(D, T, vsync, T_UCHAR);
 327    ELM_CONFIG_VAL(D, T, thumbscroll_enable, T_UCHAR);
 328    ELM_CONFIG_VAL(D, T, thumbscroll_threshold, T_INT);
 329    ELM_CONFIG_VAL(D, T, thumbscroll_hold_threshold, T_INT);
 330    ELM_CONFIG_VAL(D, T, thumbscroll_momentum_threshold, T_DOUBLE);
 331    ELM_CONFIG_VAL(D, T, thumbscroll_flick_distance_tolerance, T_INT);
 332    ELM_CONFIG_VAL(D, T, thumbscroll_friction, T_DOUBLE);
 333    ELM_CONFIG_VAL(D, T, thumbscroll_min_friction, T_DOUBLE);
 334    ELM_CONFIG_VAL(D, T, thumbscroll_friction_standard, T_DOUBLE);
 335    ELM_CONFIG_VAL(D, T, thumbscroll_bounce_friction, T_DOUBLE);
 336    ELM_CONFIG_VAL(D, T, thumbscroll_border_friction, T_DOUBLE);
 337    ELM_CONFIG_VAL(D, T, thumbscroll_sensitivity_friction, T_DOUBLE);
 338    ELM_CONFIG_VAL(D, T, thumbscroll_acceleration_threshold, T_DOUBLE);
 339    ELM_CONFIG_VAL(D, T, thumbscroll_acceleration_time_limit, T_DOUBLE);
 340    ELM_CONFIG_VAL(D, T, thumbscroll_acceleration_weight, T_DOUBLE);
 341    ELM_CONFIG_VAL(D, T, page_scroll_friction, T_DOUBLE);
 342    ELM_CONFIG_VAL(D, T, bring_in_scroll_friction, T_DOUBLE);
 343    ELM_CONFIG_VAL(D, T, zoom_friction, T_DOUBLE);
 344    ELM_CONFIG_VAL(D, T, thumbscroll_bounce_enable, T_UCHAR);
 345    ELM_CONFIG_VAL(D, T, scroll_smooth_start_enable, T_UCHAR);
 346 //   ELM_CONFIG_VAL(D, T, scroll_smooth_time_interval, T_DOUBLE); // not used anymore
 347    ELM_CONFIG_VAL(D, T, scroll_smooth_amount, T_DOUBLE);
 348 //   ELM_CONFIG_VAL(D, T, scroll_smooth_history_weight, T_DOUBLE); // not used anymore
 349 //   ELM_CONFIG_VAL(D, T, scroll_smooth_future_time, T_DOUBLE); // not used anymore
 350    ELM_CONFIG_VAL(D, T, scroll_smooth_time_window, T_DOUBLE);
 351    ELM_CONFIG_VAL(D, T, scale, T_DOUBLE);
 352    ELM_CONFIG_VAL(D, T, win_no_border, T_INT);
 353    ELM_CONFIG_VAL(D, T, bgpixmap, T_INT);
 354    ELM_CONFIG_VAL(D, T, compositing, T_INT);
 355    /* EET_DATA_DESCRIPTOR_ADD_LIST(D, T, "font_dirs", font_dirs, sub_edd); */
 356    ELM_CONFIG_LIST(D, T, font_overlays, _config_font_overlay_edd);
 357    ELM_CONFIG_VAL(D, T, font_hinting, T_INT);
 358    ELM_CONFIG_VAL(D, T, cache_flush_poll_interval, T_INT);
 359    ELM_CONFIG_VAL(D, T, cache_flush_enable, T_UCHAR);
 360    ELM_CONFIG_VAL(D, T, image_cache, T_INT);
 361    ELM_CONFIG_VAL(D, T, font_cache, T_INT);
 362    ELM_CONFIG_VAL(D, T, edje_cache, T_INT);
 363    ELM_CONFIG_VAL(D, T, edje_collection_cache, T_INT);
 364    ELM_CONFIG_VAL(D, T, finger_size, T_INT);
 365    ELM_CONFIG_VAL(D, T, fps, T_DOUBLE);
 366    ELM_CONFIG_VAL(D, T, theme, T_STRING);
 367    ELM_CONFIG_VAL(D, T, modules, T_STRING);
 368    ELM_CONFIG_VAL(D, T, tooltip_delay, T_DOUBLE);
 369    ELM_CONFIG_VAL(D, T, cursor_engine_only, T_UCHAR);
 370    ELM_CONFIG_VAL(D, T, focus_highlight_enable, T_UCHAR);
 371    ELM_CONFIG_VAL(D, T, focus_highlight_animate, T_UCHAR);
 372    ELM_CONFIG_VAL(D, T, focus_highlight_clip_disable, T_UCHAR);
 373    ELM_CONFIG_VAL(D, T, focus_move_policy, T_UCHAR);
 374    ELM_CONFIG_VAL(D, T, focus_autoscroll_mode, T_UCHAR);
 375    ELM_CONFIG_VAL(D, T, slider_indicator_visible_mode, T_INT);
 376    ELM_CONFIG_VAL(D, T, item_select_on_focus_disable, T_UCHAR);
 377    ELM_CONFIG_VAL(D, T, first_item_focus_on_first_focus_in, T_UCHAR);
 378    ELM_CONFIG_VAL(D, T, toolbar_shrink_mode, T_INT);
 379    ELM_CONFIG_VAL(D, T, fileselector_expand_enable, T_UCHAR);
 380    ELM_CONFIG_VAL(D, T, fileselector_double_tap_navigation_enable, T_UCHAR);
 381    ELM_CONFIG_VAL(D, T, inwin_dialogs_enable, T_UCHAR);
 382    ELM_CONFIG_VAL(D, T, icon_size, T_INT);
 383    ELM_CONFIG_VAL(D, T, longpress_timeout, T_DOUBLE);
 384    ELM_CONFIG_VAL(D, T, effect_enable, T_UCHAR);
 385    ELM_CONFIG_VAL(D, T, desktop_entry, T_UCHAR);
 386    ELM_CONFIG_VAL(D, T, password_show_last, T_UCHAR);
 387    ELM_CONFIG_VAL(D, T, password_show_last_timeout, T_DOUBLE);
 388    ELM_CONFIG_VAL(D, T, glayer_zoom_finger_enable, T_UCHAR);
 389    ELM_CONFIG_VAL(D, T, glayer_zoom_finger_factor, T_DOUBLE);
 390    ELM_CONFIG_VAL(D, T, glayer_zoom_wheel_factor, T_DOUBLE);
 391    ELM_CONFIG_VAL(D, T, glayer_zoom_distance_tolerance, T_DOUBLE);
 392    ELM_CONFIG_VAL(D, T, glayer_rotate_finger_enable, T_UCHAR);
 393    ELM_CONFIG_VAL(D, T, glayer_rotate_angular_tolerance, T_DOUBLE);
 394    ELM_CONFIG_VAL(D, T, glayer_line_min_length, T_DOUBLE);
 395    ELM_CONFIG_VAL(D, T, glayer_line_distance_tolerance, T_DOUBLE);
 396    ELM_CONFIG_VAL(D, T, glayer_line_angular_tolerance, T_DOUBLE);
 397    ELM_CONFIG_VAL(D, T, glayer_flick_time_limit_ms, T_INT);
 398    ELM_CONFIG_VAL(D, T, glayer_long_tap_start_timeout, T_DOUBLE);
 399    ELM_CONFIG_VAL(D, T, glayer_double_tap_timeout, T_DOUBLE);
 400    ELM_CONFIG_VAL(D, T, access_mode, T_UCHAR);
 401    ELM_CONFIG_VAL(D, T, selection_clear_enable, T_UCHAR);
 402    ELM_CONFIG_VAL(D, T, glayer_continues_enable, T_UCHAR);
 403    ELM_CONFIG_VAL(D, T, week_start, T_INT);
 404    ELM_CONFIG_VAL(D, T, weekend_start, T_INT);
 405    ELM_CONFIG_VAL(D, T, weekend_len, T_INT);
 406    ELM_CONFIG_VAL(D, T, year_min, T_INT);
 407    ELM_CONFIG_VAL(D, T, year_max, T_INT);
 408    ELM_CONFIG_LIST(D, T, color_overlays, _config_color_overlay_edd);
 409    ELM_CONFIG_LIST(D, T, color_palette, _config_color_palette_edd);
 410    ELM_CONFIG_VAL(D, T, softcursor_mode, T_UCHAR);
 411    ELM_CONFIG_VAL(D, T, auto_norender_withdrawn, T_UCHAR);
 412    ELM_CONFIG_VAL(D, T, auto_norender_iconified_same_as_withdrawn, T_UCHAR);
 413    ELM_CONFIG_VAL(D, T, auto_flush_withdrawn, T_UCHAR);
 414    ELM_CONFIG_VAL(D, T, auto_dump_withdrawn, T_UCHAR);
 415    ELM_CONFIG_VAL(D, T, auto_throttle, T_UCHAR);
 416    ELM_CONFIG_VAL(D, T, auto_throttle_amount, T_DOUBLE);
 417    ELM_CONFIG_VAL(D, T, indicator_service_0, T_STRING);
 418    ELM_CONFIG_VAL(D, T, indicator_service_90, T_STRING);
 419    ELM_CONFIG_VAL(D, T, indicator_service_180, T_STRING);
 420    ELM_CONFIG_VAL(D, T, indicator_service_270, T_STRING);
 421    ELM_CONFIG_VAL(D, T, disable_external_menu, T_UCHAR);
 422    ELM_CONFIG_VAL(D, T, clouseau_enable, T_UCHAR);
 423    ELM_CONFIG_VAL(D, T, magnifier_enable, T_UCHAR);
 424    ELM_CONFIG_VAL(D, T, magnifier_scale, T_DOUBLE);
 425    ELM_CONFIG_VAL(D, T, audio_mute_effect, T_UCHAR);
 426    ELM_CONFIG_VAL(D, T, audio_mute_background, T_UCHAR);
 427    ELM_CONFIG_VAL(D, T, audio_mute_music, T_UCHAR);
 428    ELM_CONFIG_VAL(D, T, audio_mute_foreground, T_UCHAR);
 429    ELM_CONFIG_VAL(D, T, audio_mute_interface, T_UCHAR);
 430    ELM_CONFIG_VAL(D, T, audio_mute_input, T_UCHAR);
 431    ELM_CONFIG_VAL(D, T, audio_mute_alert, T_UCHAR);
 432    ELM_CONFIG_VAL(D, T, audio_mute_all, T_UCHAR);
 433    ELM_CONFIG_LIST(D, T, bindings, _config_bindings_widget_edd);
 434    ELM_CONFIG_VAL(D, T, atspi_mode, T_UCHAR);
 435    ELM_CONFIG_VAL(D, T, win_auto_focus_enable, T_UCHAR);
 436    ELM_CONFIG_VAL(D, T, win_auto_focus_animate, T_UCHAR);
 437    ELM_CONFIG_VAL(D, T, transition_duration_factor, T_DOUBLE);
 438    ELM_CONFIG_VAL(D, T, naviframe_prev_btn_auto_pushed, T_UCHAR);
 439    ELM_CONFIG_VAL(D, T, popup_horizontal_align, T_DOUBLE);
 440    ELM_CONFIG_VAL(D, T, popup_vertical_align, T_DOUBLE);
 441 #undef T
 442 #undef D
 443 #undef T_INT
 444 #undef T_DOUBLE
 445 #undef T_STRING
 446 #undef T_UCHAR
 447 }
 448
 449 static void
 450 _desc_shutdown(void)
 451 {
 452    if (_config_edd)
 453      {
 454         eet_data_descriptor_free(_config_edd);
 455         _config_edd = NULL;
 456      }
 457
 458    if (_config_font_overlay_edd)
 459      {
 460         eet_data_descriptor_free(_config_font_overlay_edd);
 461         _config_font_overlay_edd = NULL;
 462      }
 463
 464    if (_config_color_edd)
 465      {
 466         eet_data_descriptor_free(_config_color_edd);
 467         _config_color_edd = NULL;
 468      }
 469
 470    if (_config_color_palette_edd)
 471      {
 472         eet_data_descriptor_free(_config_color_palette_edd);
 473         _config_color_palette_edd = NULL;
 474      }
 475
 476    if (_config_color_overlay_edd)
 477      {
 478         eet_data_descriptor_free(_config_color_overlay_edd);
 479         _config_color_overlay_edd = NULL;
 480      }
 481
 482    if (_config_bindings_widget_edd)
 483      {
 484         eet_data_descriptor_free(_config_bindings_widget_edd);
 485         _config_bindings_widget_edd = NULL;
 486      }
 487
 488    if (_config_binding_key_edd)
 489      {
 490         eet_data_descriptor_free(_config_binding_key_edd);
 491         _config_binding_key_edd = NULL;
 492      }
 493
 494    if (_config_binding_modifier_edd)
 495      {
 496         eet_data_descriptor_free(_config_binding_modifier_edd);
 497         _config_binding_modifier_edd = NULL;
 498      }
 499 }
 500
 501 static int
 502 _sort_files_cb(const void *f1,
 503                const void *f2)
 504 {
 505    return strcmp(f1, f2);
 506 }
 507
 508 const char *
 509 _elm_config_current_profile_get(void)
 510 {
 511    return _elm_profile;
 512 }
 513
 514 static size_t
 515 _elm_data_dir_snprintf(char       *dst,
 516                        size_t      size,
 517                        const char *fmt,
 518                        ...)
 519 {
 520    size_t data_dir_len, off;
 521    va_list ap;
 522
 523    data_dir_len = eina_strlcpy(dst, _elm_data_dir, size);
 524
 525    off = data_dir_len + 1;
 526    if (off >= size)
 527      goto end;
 528
 529    va_start(ap, fmt);
 530    dst[data_dir_len] = '/';
 531
 532    off = off + vsnprintf(dst + off, size - off, fmt, ap);
 533    va_end(ap);
 534
 535 end:
 536    return off;
 537 }
 538
 539 size_t
 540 _elm_config_user_dir_snprintf(char       *dst,
 541                               size_t      size,
 542                               const char *fmt,
 543                               ...)
 544 {
 545    const char *home = NULL;
 546    size_t user_dir_len = 0, off = 0;
 547    va_list ap;
 548
 549 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
 550    if (getuid() == geteuid())
 551 #endif
 552      {
 553 #ifdef DOXDG
 554         home = getenv("XDG_CONFIG_HOME");
 555         if (home)
 556           {
 557              user_dir_len = eina_str_join_len
 558              (dst, size, '/', home, strlen(home),
 559                  "elementary", sizeof("elementary") - 1);
 560           }
 561         else
 562 #endif
 563           {
 564              home = eina_environment_home_get();
 565              if (!home) home = "/";
 566 #ifdef DOXDG
 567              user_dir_len = eina_str_join_len
 568              (dst, size, '/', home, strlen(home),
 569                  ".config", sizeof(".config") - 1,
 570                  "elementary", sizeof("elementary") - 1);
 571 #else
 572              user_dir_len = eina_str_join_len
 573              (dst, size, '/', home, strlen(home),
 574                  ELEMENTARY_BASE_DIR, sizeof(ELEMENTARY_BASE_DIR) - 1);
 575 #endif
 576           }
 577         off = user_dir_len + 1;
 578         if (off >= size) return off;
 579         dst[user_dir_len] = '/';
 580         va_start(ap, fmt);
 581         off = off + vsnprintf(dst + off, size - off, fmt, ap);
 582         va_end(ap);
 583         return off;
 584      }
 585 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
 586    else
 587 #else
 588      {
 589 # if HAVE_GETPWENT
 590         struct passwd *pw = getpwent();
 591
 592         if ((!pw) || (!pw->pw_dir)) goto end;
 593 #  ifdef DOXDG
 594         user_dir_len = eina_str_join_len
 595           (dst, size, '/', pw->pw_dir, strlen(pw->pw_dir),
 596            ".config", sizeof(".config") - 1,
 597            "elementary", sizeof("elementary") - 1);
 598 #  else
 599         user_dir_len = eina_str_join_len
 600           (dst, size, '/', pw->pw_dir, strlen(pw->pw_dir),
 601            ELEMENTARY_BASE_DIR, sizeof(ELEMENTARY_BASE_DIR) - 1);
 602 #  endif
 603 # endif /* HAVE_GETPWENT */
 604         off = user_dir_len + 1;
 605         if (off >= size) return off;
 606         dst[user_dir_len] = '/';
 607         va_start(ap, fmt);
 608         off = off + vsnprintf(dst + off, size - off, fmt, ap);
 609         va_end(ap);
 610         return off;
 611      }
 612 #endif
 613    return 0;
 614 }
 615
 616 const char *
 617 _elm_config_profile_dir_get(const char *prof,
 618                             Eina_Bool   is_user)
 619 {
 620    char buf[PATH_MAX];
 621
 622    if (!is_user)
 623      goto not_user;
 624
 625    _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/%s", prof);
 626
 627    if (ecore_file_is_dir(buf))
 628      return strdup(buf);
 629
 630    return NULL;
 631
 632 not_user:
 633    snprintf(buf, sizeof(buf), "%s/config/%s", _elm_data_dir, prof);
 634
 635    if (ecore_file_is_dir(buf))
 636      return strdup(buf);
 637
 638    return NULL;
 639 }
 640
 641 Eina_List *
 642 _elm_config_font_overlays_list(void)
 643 {
 644    return _elm_config->font_overlays;
 645 }
 646
 647 Eina_Bool _elm_config_access_get(void)
 648 {
 649    return _elm_config->access_mode;
 650 }
 651
 652 void _elm_config_access_set(Eina_Bool is_access)
 653 {
 654    is_access = !!is_access;
 655    if (_elm_config->access_mode == is_access) return;
 656    _elm_config->access_mode = is_access;
 657    _elm_win_access(is_access);
 658
 659    if (!is_access) _elm_access_shutdown();
 660 }
 661
 662 Eina_Bool _elm_config_atspi_mode_get(void)
 663 {
 664    return _elm_config->atspi_mode;
 665 }
 666
 667 void _elm_config_atspi_mode_set(Eina_Bool is_enabled)
 668 {
 669    is_enabled = !!is_enabled;
 670    if (_elm_config->atspi_mode == is_enabled) return;
 671    _elm_config->atspi_mode = is_enabled;
 672
 673    if (!is_enabled) _elm_atspi_bridge_shutdown();
 674    else _elm_atspi_bridge_init();
 675 }
 676
 677 Eina_Bool _elm_config_selection_unfocused_clear_get(void)
 678 {
 679    return _elm_config->selection_clear_enable;
 680 }
 681
 682 void _elm_config_selection_unfocused_clear_set(Eina_Bool enabled)
 683 {
 684    enabled = !!enabled;
 685    if (_elm_config->selection_clear_enable == enabled) return;
 686    _elm_config->selection_clear_enable = enabled;
 687 }
 688
 689 void
 690 _elm_config_font_overlay_set(const char    *text_class,
 691                              const char    *font,
 692                              Evas_Font_Size size)
 693 {
 694    Elm_Font_Overlay *efd;
 695    Eina_List *l;
 696
 697    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 698      {
 699         if (strcmp(efd->text_class, text_class))
 700           continue;
 701
 702         eina_stringshare_del(efd->font);
 703         efd->font = eina_stringshare_add(font);
 704         efd->size = size;
 705         _elm_config->font_overlays =
 706           eina_list_promote_list(_elm_config->font_overlays, l);
 707         return;
 708      }
 709
 710    /* the text class doesn't exist */
 711    efd = calloc(1, sizeof(Elm_Font_Overlay));
 712    efd->text_class = eina_stringshare_add(text_class);
 713    efd->font = eina_stringshare_add(font);
 714    efd->size = size;
 715
 716    _elm_config->font_overlays = eina_list_prepend(_elm_config->font_overlays,
 717                                                   efd);
 718 }
 719
 720 void
 721 _elm_config_font_overlay_remove(const char *text_class)
 722 {
 723    Elm_Font_Overlay *efd;
 724    Eina_List *l;
 725
 726    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 727      {
 728         if (!efd->text_class) continue;
 729         if (strcmp(efd->text_class, text_class)) continue;
 730
 731         _font_overlays_del =
 732            eina_list_append(_font_overlays_del,
 733                             eina_stringshare_add(text_class));
 734         _elm_config->font_overlays =
 735           eina_list_remove_list(_elm_config->font_overlays, l);
 736         eina_stringshare_del(efd->text_class);
 737         eina_stringshare_del(efd->font);
 738         free(efd);
 739
 740         return;
 741      }
 742 }
 743
 744 void
 745 _elm_config_font_overlay_apply(void)
 746 {
 747    Elm_Font_Overlay *efd;
 748    Eina_List *l;
 749    char *text_class;
 750    EINA_LIST_FOREACH(_font_overlays_del, l, text_class)
 751      {
 752         edje_text_class_del(text_class);
 753         eina_stringshare_del(text_class);
 754      }
 755    _font_overlays_del = eina_list_free(_font_overlays_del);
 756
 757    EINA_LIST_FOREACH(_elm_config->font_overlays, l, efd)
 758      edje_text_class_set(efd->text_class, efd->font, efd->size);
 759 }
 760
 761 Eina_List *
 762 _elm_config_text_classes_get(void)
 763 {
 764    Eina_List *ret = NULL;
 765    int i;
 766
 767    for (i = 0; _elm_text_classes[i].desc; i++)
 768      {
 769         Elm_Text_Class *tc;
 770         tc = malloc(sizeof(*tc));
 771         if (!tc) continue;
 772
 773         *tc = _elm_text_classes[i];
 774
 775         ret = eina_list_append(ret, tc);
 776      }
 777
 778    return ret;
 779 }
 780
 781 void
 782 _elm_config_text_classes_free(Eina_List *l)
 783 {
 784    Elm_Text_Class *tc;
 785
 786    EINA_LIST_FREE(l, tc)
 787      free(tc);
 788 }
 789
 790 Eina_List *
 791 _elm_config_color_classes_get(void)
 792 {
 793    Eina_List *ret = NULL;
 794    int i;
 795
 796    for (i = 0; _elm_color_classes[i].desc; i++)
 797      {
 798         Elm_Color_Class *cc;
 799         cc = malloc(sizeof(*cc));
 800         if (!cc) continue;
 801
 802         *cc = _elm_color_classes[i];
 803
 804         ret = eina_list_append(ret, cc);
 805      }
 806
 807    return ret;
 808 }
 809
 810 void
 811 _elm_config_color_classes_free(Eina_List *l)
 812 {
 813    Elm_Color_Class *cc;
 814
 815    EINA_LIST_FREE(l, cc)
 816      free(cc);
 817 }
 818
 819 static void
 820 _color_overlays_cancel(void)
 821 {
 822    Elm_Color_Overlay *ecd;
 823    Eina_List *l;
 824    EINA_LIST_FOREACH(_elm_config->color_overlays, l, ecd)
 825      edje_color_class_del(ecd->color_class);
 826 }
 827
 828 Eina_List *
 829 _elm_config_color_overlays_list(void)
 830 {
 831    return _elm_config->color_overlays;
 832 }
 833
 834 void
 835 _elm_config_color_overlay_set(const char *color_class,
 836                               int r, int g, int b, int a,
 837                               int r2, int g2, int b2, int a2,
 838                               int r3, int g3, int b3, int a3)
 839 {
 840    Elm_Color_Overlay *ecd;
 841    Eina_List *l;
 842
 843 #define CHECK_COLOR_VAL(v) v = (v > 255)? 255 : (v < 0)? 0: v
 844    CHECK_COLOR_VAL(r);
 845    CHECK_COLOR_VAL(g);
 846    CHECK_COLOR_VAL(b);
 847    CHECK_COLOR_VAL(a);
 848    CHECK_COLOR_VAL(r2);
 849    CHECK_COLOR_VAL(g2);
 850    CHECK_COLOR_VAL(b2);
 851    CHECK_COLOR_VAL(a2);
 852    CHECK_COLOR_VAL(r3);
 853    CHECK_COLOR_VAL(g3);
 854    CHECK_COLOR_VAL(b3);
 855    CHECK_COLOR_VAL(a3);
 856 #undef CHECK_COLOR_VAL
 857
 858    EINA_LIST_FOREACH(_elm_config->color_overlays, l, ecd)
 859      {
 860         if (!eina_streq(ecd->color_class, color_class))
 861           continue;
 862
 863         ecd->color.r = r;
 864         ecd->color.g = g;
 865         ecd->color.b = b;
 866         ecd->color.a = a;
 867         ecd->outline.r = r2;
 868         ecd->outline.g = g2;
 869         ecd->outline.b = b2;
 870         ecd->outline.a = a2;
 871         ecd->shadow.r = r3;
 872         ecd->shadow.g = g3;
 873         ecd->shadow.b = b3;
 874         ecd->shadow.a = a3;
 875
 876         _elm_config->color_overlays =
 877            eina_list_promote_list(_elm_config->color_overlays, l);
 878         return;
 879      }
 880
 881    /* the color class doesn't exist */
 882    ecd = calloc(1, sizeof(Elm_Color_Overlay));
 883    if (!ecd) return;
 884
 885    ecd->color_class = eina_stringshare_add(color_class);
 886    ecd->color.r = r;
 887    ecd->color.g = g;
 888    ecd->color.b = b;
 889    ecd->color.a = a;
 890    ecd->outline.r = r2;
 891    ecd->outline.g = g2;
 892    ecd->outline.b = b2;
 893    ecd->outline.a = a2;
 894    ecd->shadow.r = r3;
 895    ecd->shadow.g = g3;
 896    ecd->shadow.b = b3;
 897    ecd->shadow.a = a3;
 898
 899    _elm_config->color_overlays =
 900       eina_list_prepend(_elm_config->color_overlays, ecd);
 901 }
 902
 903 void
 904 _elm_config_color_overlay_remove(const char *color_class)
 905 {
 906    Elm_Color_Overlay *ecd;
 907    Eina_List *l;
 908
 909    EINA_LIST_FOREACH(_elm_config->color_overlays, l, ecd)
 910      {
 911         if (!ecd->color_class) continue;
 912         if (!eina_streq(ecd->color_class, color_class)) continue;
 913
 914         _color_overlays_del =
 915            eina_list_append(_color_overlays_del,
 916                             eina_stringshare_add(color_class));
 917         _elm_config->color_overlays =
 918           eina_list_remove_list(_elm_config->color_overlays, l);
 919         eina_stringshare_del(ecd->color_class);
 920         free(ecd);
 921
 922         return;
 923      }
 924 }
 925
 926 void
 927 _elm_config_color_overlay_apply(void)
 928 {
 929    Elm_Color_Overlay *ecd;
 930    Eina_List *l;
 931    char *color_class;
 932
 933    EINA_LIST_FREE(_color_overlays_del, color_class)
 934      {
 935         edje_color_class_del(color_class);
 936         eina_stringshare_del(color_class);
 937      }
 938
 939    EINA_LIST_FOREACH(_elm_config->color_overlays, l, ecd)
 940      edje_color_class_set(ecd->color_class,
 941                 ecd->color.r, ecd->color.g, ecd->color.b, ecd->color.a,
 942                 ecd->outline.r, ecd->outline.g, ecd->outline.b, ecd->outline.a,
 943                 ecd->shadow.r, ecd->shadow.g, ecd->shadow.b, ecd->shadow.a);
 944 }
 945
 946 Eina_List *
 947 _elm_config_color_list_get(const char *palette_name)
 948 {
 949     Eina_List *plist;
 950     Elm_Custom_Palette *cpalette;
 951     EINA_LIST_FOREACH(_elm_config->color_palette, plist, cpalette)
 952       {
 953          if (strcmp(cpalette->palette_name, palette_name))
 954            continue;
 955          return cpalette->color_list;
 956       }
 957     return NULL;
 958 }
 959
 960 void
 961 _elm_config_color_set(const char *palette_name,
 962                       int r,
 963                       int g,
 964                       int b,
 965                       int a)
 966 {
 967    Eina_List *plist;
 968    Elm_Custom_Palette *cpalette;
 969    Elm_Color_RGBA *color;
 970    EINA_LIST_FOREACH(_elm_config->color_palette, plist, cpalette)
 971      {
 972         if (strcmp(cpalette->palette_name, palette_name))
 973           continue;
 974
 975         color = calloc(1, sizeof(Elm_Color_RGBA));
 976         color->r = r;
 977         color->g = g;
 978         color->b = b;
 979         color->a = a;
 980         cpalette->color_list = eina_list_prepend(cpalette->color_list,
 981                                                        color);
 982      }
 983 }
 984
 985 void
 986 _elm_config_colors_free(const char *palette_name)
 987 {
 988    Eina_List *plist;
 989    Elm_Custom_Palette *cpalette;
 990    Elm_Color_RGBA *color;
 991    EINA_LIST_FOREACH(_elm_config->color_palette, plist, cpalette)
 992      {
 993         if (strcmp(cpalette->palette_name, palette_name))
 994           continue;
 995
 996         EINA_LIST_FREE(cpalette->color_list, color)
 997           {
 998              free(color);
 999           }
1000      }
1001 }
1002
1003 Eina_List *
1004 _elm_config_profiles_list(void)
1005 {
1006    Eina_File_Direct_Info *info;
1007    Eina_List *flist = NULL;
1008    Eina_Iterator *file_it;
1009    char buf[PATH_MAX];
1010    const char *dir;
1011    size_t len;
1012
1013    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "config");
1014
1015    file_it = eina_file_stat_ls(buf);
1016    if (!file_it)
1017      goto sys;
1018
1019    buf[len] = '/';
1020    len++;
1021
1022    len = sizeof(buf) - len;
1023
1024    EINA_ITERATOR_FOREACH(file_it, info)
1025      {
1026         if (info->name_length >= len)
1027           continue;
1028
1029         if (info->type == EINA_FILE_DIR)
1030           {
1031              flist =
1032                eina_list_sorted_insert(flist, _sort_files_cb,
1033                                        eina_stringshare_add(info->path +
1034                                                             info->name_start));
1035           }
1036      }
1037
1038    eina_iterator_free(file_it);
1039
1040 sys:
1041    len = eina_str_join_len(buf, sizeof(buf), '/', _elm_data_dir,
1042                            strlen(_elm_data_dir), "config",
1043                            sizeof("config") - 1);
1044
1045    file_it = eina_file_stat_ls(buf);
1046    if (!file_it)
1047      goto list_free;
1048
1049    buf[len] = '/';
1050    len++;
1051
1052    len = sizeof(buf) - len;
1053    EINA_ITERATOR_FOREACH(file_it, info)
1054      {
1055         if (info->name_length >= len)
1056           continue;
1057
1058         switch (info->type)
1059           {
1060            case EINA_FILE_DIR:
1061            {
1062               const Eina_List *l;
1063               const char *tmp;
1064
1065               EINA_LIST_FOREACH(flist, l, tmp)
1066                 if (!strcmp(info->path + info->name_start, tmp))
1067                   break;
1068
1069               if (!l)
1070                 flist =
1071                   eina_list_sorted_insert(flist, _sort_files_cb,
1072                                           eina_stringshare_add(info->path +
1073                                                                info->name_start));
1074            }
1075            break;
1076
1077            default:
1078              continue;
1079           }
1080      }
1081    eina_iterator_free(file_it);
1082    return flist;
1083
1084 list_free:
1085    EINA_LIST_FREE(flist, dir)
1086      eina_stringshare_del(dir);
1087
1088    return NULL;
1089 }
1090
1091 static void
1092 _profile_fetch_from_conf(void)
1093 {
1094    char buf[PATH_MAX], *p, *s;
1095    Eet_File *ef = NULL;
1096    int len = 0, i;
1097
1098    // if env var - use profile without question
1099    s = getenv("ELM_PROFILE");
1100    if (s)
1101      {
1102         _elm_profile = strdup(s);
1103         if (_elm_profile)
1104           {
1105              p = strchr(_elm_profile, '/');
1106              if (p) *p = 0;
1107           }
1108         return;
1109      }
1110
1111    for (i = 0; i < 2; i++)
1112      {
1113         // user profile
1114         if (i == 0)
1115           _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/profile.cfg");
1116         // system profile
1117         else if (i == 1)
1118           _elm_data_dir_snprintf(buf, sizeof(buf), "config/profile.cfg");
1119         ef = eet_open(buf, EET_FILE_MODE_READ);
1120         if (ef)
1121           {
1122              p = eet_read(ef, "config", &len);
1123              if (p)
1124                {
1125                   _elm_profile = malloc(len + 1);
1126                   if (_elm_profile)
1127                     {
1128                        memcpy(_elm_profile, p, len);
1129                        _elm_profile[len] = 0;
1130                        free(p);
1131                     }
1132                   else free(p);
1133                   eet_close(ef);
1134                   p = strchr(_elm_profile, '/');
1135                   if (p) *p = 0;
1136                   return;
1137                }
1138              eet_close(ef);
1139           }
1140      }
1141
1142    _elm_profile = strdup("default");
1143 }
1144
1145 static void
1146 _config_free(Elm_Config *cfg)
1147 {
1148    Elm_Font_Overlay *fo;
1149    const char *fontdir;
1150    Elm_Color_Overlay *co;
1151    Elm_Custom_Palette *palette;
1152    Elm_Color_RGBA *color;
1153    char *color_class;
1154    Elm_Config_Bindings_Widget *wb;
1155    Elm_Config_Binding_Key *kb;
1156    Elm_Config_Binding_Modifier *mb;
1157
1158    if (!cfg) return;
1159    EINA_LIST_FREE(cfg->font_dirs, fontdir)
1160      {
1161         eina_stringshare_del(fontdir);
1162      }
1163    eina_stringshare_del(cfg->engine);
1164    eina_stringshare_del(cfg->accel);
1165    EINA_LIST_FREE(cfg->font_overlays, fo)
1166      {
1167         eina_stringshare_del(fo->text_class);
1168         eina_stringshare_del(fo->font);
1169         free(fo);
1170      }
1171    EINA_LIST_FREE(_color_overlays_del, color_class)
1172      eina_stringshare_del(color_class);
1173    EINA_LIST_FREE(cfg->color_overlays, co)
1174      {
1175         if (co->color_class) eina_stringshare_del(co->color_class);
1176         free(co);
1177      }
1178    EINA_LIST_FREE(cfg->color_palette, palette)
1179      {
1180         eina_stringshare_del(palette->palette_name);
1181         EINA_LIST_FREE(palette->color_list, color) free(color);
1182         free(palette);
1183      }
1184    EINA_LIST_FREE(cfg->bindings, wb)
1185      {
1186         eina_stringshare_del(wb->name);
1187         EINA_LIST_FREE(wb->key_bindings, kb)
1188           {
1189              eina_stringshare_del(kb->key);
1190              eina_stringshare_del(kb->action);
1191              eina_stringshare_del(kb->params);
1192              EINA_LIST_FREE(kb->modifiers, mb)
1193                {
1194                   eina_stringshare_del(mb->mod);
1195                   free(mb);
1196                }
1197              free(kb);
1198           }
1199         free(wb);
1200      }
1201    eina_stringshare_del(cfg->theme);
1202    eina_stringshare_del(cfg->modules);
1203    eina_stringshare_del(cfg->indicator_service_0);
1204    eina_stringshare_del(cfg->indicator_service_90);
1205    eina_stringshare_del(cfg->indicator_service_180);
1206    eina_stringshare_del(cfg->indicator_service_270);
1207    free(cfg);
1208 }
1209
1210 static void
1211 _config_apply(void)
1212 {
1213    _elm_theme_parse(NULL, _elm_config->theme);
1214    ecore_animator_frametime_set(1.0 / _elm_config->fps);
1215 }
1216
1217 static void
1218 _config_sub_apply(void)
1219 {
1220    edje_frametime_set(1.0 / _elm_config->fps);
1221    edje_scale_set(_elm_config->scale);
1222    edje_password_show_last_set(_elm_config->password_show_last);
1223    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
1224    edje_transition_duration_factor_set(_elm_config->transition_duration_factor);
1225    if (_elm_config->modules) _elm_module_parse(_elm_config->modules);
1226    edje_audio_channel_mute_set(EDJE_CHANNEL_EFFECT, _elm_config->audio_mute_effect);
1227    edje_audio_channel_mute_set(EDJE_CHANNEL_BACKGROUND, _elm_config->audio_mute_background);
1228    edje_audio_channel_mute_set(EDJE_CHANNEL_MUSIC, _elm_config->audio_mute_music);
1229    edje_audio_channel_mute_set(EDJE_CHANNEL_FOREGROUND, _elm_config->audio_mute_foreground);
1230    edje_audio_channel_mute_set(EDJE_CHANNEL_INTERFACE, _elm_config->audio_mute_interface);
1231    edje_audio_channel_mute_set(EDJE_CHANNEL_INPUT, _elm_config->audio_mute_input);
1232    edje_audio_channel_mute_set(EDJE_CHANNEL_ALERT, _elm_config->audio_mute_alert);
1233    edje_audio_channel_mute_set(EDJE_CHANNEL_ALL, _elm_config->audio_mute_all);
1234 }
1235
1236 static Eina_Bool
1237 _elm_cache_flush_cb(void *data EINA_UNUSED)
1238 {
1239    elm_cache_all_flush();
1240    return ECORE_CALLBACK_RENEW;
1241 }
1242
1243 /* kind of abusing this call right now -- shared between all of those
1244  * properties -- but they are not meant to be called that periodically
1245  * anyway */
1246 void
1247 _elm_recache(void)
1248 {
1249    Eina_List *l;
1250    Evas_Object *win;
1251
1252    elm_cache_all_flush();
1253
1254    EINA_LIST_FOREACH(_elm_win_list, l, win)
1255      {
1256         Evas *e = evas_object_evas_get(win);
1257         evas_image_cache_set(e, _elm_config->image_cache * 1024);
1258         evas_font_cache_set(e, _elm_config->font_cache * 1024);
1259      }
1260    edje_file_cache_set(_elm_config->edje_cache);
1261    edje_collection_cache_set(_elm_config->edje_collection_cache);
1262
1263    ELM_SAFE_FREE(_elm_cache_flush_poller, ecore_poller_del);
1264    if (_elm_config->cache_flush_enable)
1265      {
1266         if (_elm_config->cache_flush_poll_interval > 0)
1267           {
1268              _elm_cache_flush_poller =
1269                 ecore_poller_add(ECORE_POLLER_CORE,
1270                                  _elm_config->cache_flush_poll_interval,
1271                                  _elm_cache_flush_cb, NULL);
1272           }
1273      }
1274 }
1275
1276 static Elm_Config *
1277 _config_user_load(void)
1278 {
1279    Elm_Config *cfg = NULL;
1280    Eet_File *ef;
1281    char buf[PATH_MAX];
1282
1283    _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/%s/base.cfg",
1284                           _elm_profile);
1285
1286    ef = eet_open(buf, EET_FILE_MODE_READ);
1287    if (ef)
1288      {
1289         cfg = eet_data_read(ef, _config_edd, "config");
1290         eet_close(ef);
1291      }
1292
1293    if (cfg)
1294      {
1295         size_t len;
1296
1297         len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "themes/");
1298         if (len + 1 < sizeof(buf))
1299           ecore_file_mkpath(buf);
1300      }
1301
1302    return cfg;
1303 }
1304
1305 static Elm_Config *
1306 _config_system_load(void)
1307 {
1308    Elm_Config *cfg = NULL;
1309    Eet_File *ef;
1310    char buf[PATH_MAX];
1311
1312    _elm_data_dir_snprintf(buf, sizeof(buf), "config/%s/base.cfg",
1313                           _elm_profile);
1314
1315    ef = eet_open(buf, EET_FILE_MODE_READ);
1316    if (ef)
1317      {
1318         cfg = eet_data_read(ef, _config_edd, "config");
1319         eet_close(ef);
1320      }
1321    return cfg;
1322 }
1323
1324 static void
1325 _config_load(void)
1326 {
1327    _elm_config = _config_user_load();
1328    if (_elm_config)
1329      {
1330         if ((_elm_config->config_version >> ELM_CONFIG_VERSION_EPOCH_OFFSET) < ELM_CONFIG_EPOCH)
1331            {
1332               WRN("User's elementary config seems outdated and unusable. Fallback to load system config.");
1333               _config_free(_elm_config);
1334               _elm_config = NULL;
1335            }
1336         else
1337           {
1338              if (_elm_config->config_version < ELM_CONFIG_VERSION)
1339                _config_update();
1340              return;
1341           }
1342      }
1343
1344    /* no user config, fallback for system. No need to check version for
1345     * this one, if it's not the right one, someone screwed up at the time
1346     * of installing it */
1347    _elm_config = _config_system_load();
1348    if (_elm_config) return;
1349    /* FIXME: config load could have failed because of a non-existent
1350     * profile. Fallback to default before moving on */
1351
1352    // config load fail - defaults
1353    // why are these here? well if they are, it means you can make a gui
1354    // config recovery app i guess...
1355    _elm_config = ELM_NEW(Elm_Config);
1356    _elm_config->config_version = ELM_CONFIG_VERSION;
1357    _elm_config->engine = NULL;
1358    _elm_config->accel = NULL;
1359    _elm_config->accel_override = 0;
1360    _elm_config->vsync = 0;
1361    _elm_config->thumbscroll_enable = EINA_TRUE;
1362    _elm_config->thumbscroll_threshold = 24;
1363    _elm_config->thumbscroll_hold_threshold = 24;
1364    _elm_config->thumbscroll_momentum_threshold = 100.0;
1365    _elm_config->thumbscroll_flick_distance_tolerance = 1000;
1366    _elm_config->thumbscroll_friction = 1.0;
1367    _elm_config->thumbscroll_min_friction = 0.5;
1368    _elm_config->thumbscroll_friction_standard = 1000.0;
1369    _elm_config->thumbscroll_bounce_friction = 0.5;
1370    _elm_config->thumbscroll_bounce_enable = EINA_TRUE;
1371    _elm_config->thumbscroll_acceleration_threshold = 500.0;
1372    _elm_config->thumbscroll_acceleration_time_limit = 0.7;
1373    _elm_config->thumbscroll_acceleration_weight = 1.5;
1374    _elm_config->page_scroll_friction = 0.5;
1375    _elm_config->bring_in_scroll_friction = 0.5;
1376    _elm_config->zoom_friction = 0.5;
1377    _elm_config->thumbscroll_border_friction = 0.5;
1378    _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
1379    _elm_config->scroll_smooth_start_enable = EINA_TRUE;
1380 //   _elm_config->scroll_smooth_time_interval = 0.008; // not used anymore
1381    _elm_config->scroll_smooth_amount = 1.0;
1382 //   _elm_config->scroll_smooth_history_weight = 0.3; // not used anymore
1383 //   _elm_config->scroll_smooth_future_time = 0.0; // not used anymore
1384    _elm_config->scroll_smooth_time_window = 0.15;
1385    _elm_config->scale = 1.0;
1386    _elm_config->win_no_border = 0;
1387    _elm_config->bgpixmap = 0;
1388    _elm_config->compositing = 1;
1389    _elm_config->font_hinting = 2;
1390    _elm_config->cache_flush_poll_interval = 512;
1391    _elm_config->cache_flush_enable = EINA_TRUE;
1392    _elm_config->font_dirs = NULL;
1393    _elm_config->image_cache = 4096;
1394    _elm_config->font_cache = 512;
1395    _elm_config->edje_cache = 32;
1396    _elm_config->edje_collection_cache = 64;
1397    _elm_config->finger_size = 10;
1398    _elm_config->fps = 60.0;
1399    _elm_config->theme = eina_stringshare_add("default");
1400    _elm_config->modules = NULL;
1401    _elm_config->tooltip_delay = 1.0;
1402    _elm_config->cursor_engine_only = EINA_TRUE;
1403    _elm_config->focus_highlight_enable = EINA_FALSE;
1404    _elm_config->focus_highlight_animate = EINA_TRUE;
1405    _elm_config->focus_highlight_clip_disable = EINA_FALSE;
1406    _elm_config->focus_move_policy = ELM_FOCUS_MOVE_POLICY_CLICK;
1407    _elm_config->first_item_focus_on_first_focus_in = EINA_FALSE;
1408    _elm_config->item_select_on_focus_disable = EINA_TRUE;
1409    _elm_config->toolbar_shrink_mode = 2;
1410    _elm_config->fileselector_expand_enable = EINA_FALSE;
1411    _elm_config->fileselector_double_tap_navigation_enable = EINA_FALSE;
1412    _elm_config->inwin_dialogs_enable = EINA_FALSE;
1413    _elm_config->icon_size = 32;
1414    _elm_config->longpress_timeout = 1.0;
1415    _elm_config->effect_enable = EINA_TRUE;
1416    _elm_config->desktop_entry = EINA_FALSE;
1417    _elm_config->is_mirrored = EINA_FALSE; /* Read sys value in env_get() */
1418    _elm_config->password_show_last = EINA_FALSE;
1419    _elm_config->password_show_last_timeout = 2.0;
1420    _elm_config->glayer_zoom_finger_enable = EINA_TRUE;
1421    _elm_config->glayer_zoom_finger_factor = 1.0;
1422    _elm_config->glayer_zoom_wheel_factor = 0.05;
1423    _elm_config->glayer_zoom_distance_tolerance = 1.0; /* 1 times elm_config_finger_size_get() */
1424    _elm_config->glayer_rotate_finger_enable = EINA_TRUE;
1425    _elm_config->glayer_rotate_angular_tolerance = 2.0; /* 2 DEG */
1426    _elm_config->glayer_line_min_length = 1.0;         /* 1 times elm_config_finger_size_get() */
1427    _elm_config->glayer_line_distance_tolerance = 3.0; /* 3 times elm_config_finger_size_get() */
1428    _elm_config->glayer_line_angular_tolerance = 20.0; /* 20 DEG */
1429    _elm_config->glayer_flick_time_limit_ms = 120;              /* ms to finish flick */
1430    _elm_config->glayer_long_tap_start_timeout = 1.2;   /* 1.2 second to start long-tap */
1431    _elm_config->glayer_double_tap_timeout = 0.25;   /* 0.25 seconds between 2 mouse downs of a tap. */
1432    _elm_config->glayer_continues_enable = EINA_TRUE;      /* Continue gestures default */
1433    _elm_config->access_mode = ELM_ACCESS_MODE_OFF;
1434    _elm_config->selection_clear_enable = EINA_FALSE;
1435    _elm_config->week_start = 1; /* monday */
1436    _elm_config->weekend_start = 6; /* saturday */
1437    _elm_config->weekend_len = 2;
1438    _elm_config->year_min = 2;
1439    _elm_config->year_max = 137;
1440    _elm_config->softcursor_mode = 0; /* 0 = auto, 1 = on, 2 = off */
1441    _elm_config->color_palette = NULL;
1442    _elm_config->auto_norender_withdrawn = 0;
1443    _elm_config->auto_norender_iconified_same_as_withdrawn = 1;
1444    _elm_config->auto_flush_withdrawn = 0;
1445    _elm_config->auto_dump_withdrawn = 0;
1446    _elm_config->auto_throttle = 0;
1447    _elm_config->auto_throttle_amount = 0.1;
1448    _elm_config->indicator_service_0 = eina_stringshare_add("elm_indicator_portrait");
1449    _elm_config->indicator_service_90 = eina_stringshare_add("elm_indicator_landscape");
1450    _elm_config->indicator_service_180 = eina_stringshare_add("elm_indicator_portrait");
1451    _elm_config->indicator_service_270 = eina_stringshare_add("elm_indicator_landscape");
1452    _elm_config->disable_external_menu = EINA_FALSE;
1453    _elm_config->magnifier_enable = EINA_TRUE;
1454    _elm_config->magnifier_scale = 1.5;
1455    _elm_config->audio_mute_effect = 0;
1456    _elm_config->audio_mute_background = 0;
1457    _elm_config->audio_mute_music = 0;
1458    _elm_config->audio_mute_foreground = 0;
1459    _elm_config->audio_mute_interface = 0;
1460    _elm_config->audio_mute_input = 0;
1461    _elm_config->audio_mute_alert = 0;
1462    _elm_config->audio_mute_all = 0;
1463    _elm_config->win_auto_focus_enable = 1;
1464    _elm_config->win_auto_focus_animate = 1;
1465    _elm_config->atspi_mode = ELM_ATSPI_MODE_OFF;
1466    _elm_config->gl_depth = 0;
1467    _elm_config->gl_msaa = 0;
1468    _elm_config->gl_stencil = 0;
1469    _elm_config->transition_duration_factor = 1.0;
1470    _elm_config->naviframe_prev_btn_auto_pushed = EINA_TRUE;
1471    _elm_config->popup_horizontal_align = 0.5;
1472    _elm_config->popup_vertical_align = 0.5;
1473 }
1474
1475 static void
1476 _config_flush_load(void)
1477 {
1478    Elm_Config *cfg = NULL;
1479    Eet_File *ef;
1480    char buf[PATH_MAX];
1481
1482    _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/flush.cfg");
1483
1484    ef = eet_open(buf, EET_FILE_MODE_READ);
1485    if (ef)
1486      {
1487         cfg = eet_data_read(ef, _config_edd, "config");
1488         eet_close(ef);
1489      }
1490
1491    if (cfg)
1492      {
1493         size_t len;
1494
1495         len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "themes/");
1496         if (len + 1 < sizeof(buf))
1497           ecore_file_mkpath(buf);
1498
1499         _elm_config = cfg;
1500
1501         if ((_elm_config->config_version >> ELM_CONFIG_VERSION_EPOCH_OFFSET) < ELM_CONFIG_EPOCH)
1502            {
1503               WRN("User's elementary config seems outdated and unusable. Fallback to load system config.");
1504               _config_free(_elm_config);
1505               _elm_config = NULL;
1506            }
1507         else
1508           {
1509              if (_elm_config->config_version < ELM_CONFIG_VERSION)
1510                _config_update();
1511           }
1512      }
1513 }
1514
1515 static void
1516 _config_flush_get(void)
1517 {
1518    _elm_config_font_overlays_cancel();
1519    _color_overlays_cancel();
1520    _config_free(_elm_config);
1521    _elm_config = NULL;
1522    _config_flush_load();
1523    _env_get();
1524    _config_apply();
1525    _config_sub_apply();
1526    evas_font_reinit();
1527    _elm_config_font_overlay_apply();
1528    _elm_config_color_overlay_apply();
1529    _elm_rescale();
1530    _elm_recache();
1531    _elm_clouseau_reload();
1532    _elm_config_key_binding_hash();
1533    if (_elm_config) _elm_win_access(_elm_config->access_mode);
1534    ecore_event_add(ELM_EVENT_CONFIG_ALL_CHANGED, NULL, NULL, NULL);
1535 }
1536
1537 static const char *
1538 _elm_config_eet_close_error_get(Eet_File *ef,
1539                                 char     *file)
1540 {
1541    Eet_Error err;
1542    const char *erstr = NULL;
1543
1544    err = eet_close(ef);
1545    switch (err)
1546      {
1547       case EET_ERROR_WRITE_ERROR:
1548         erstr = "An error occurred while saving Elementary's "
1549                 "settings to disk. The error could not be "
1550                 "deterimined. The file where the error occurred was: "
1551                 "%s. This file has been deleted to avoid corrupt data.";
1552         break;
1553
1554       case EET_ERROR_WRITE_ERROR_FILE_TOO_BIG:
1555         erstr = "Elementary's settings files are too big "
1556                 "for the file system they are being saved to. "
1557                 "This error is very strange as the files should "
1558                 "be extremely small. Please check the settings "
1559                 "for your home directory. "
1560                 "The file where the error occurred was: %s ."
1561                 "This file has been deleted to avoid corrupt data.";
1562         break;
1563
1564       case EET_ERROR_WRITE_ERROR_IO_ERROR:
1565         erstr = "An output error occurred when writing the settings "
1566                 "files for Elementary. Your disk is having troubles "
1567                 "and possibly needs replacement. "
1568                 "The file where the error occurred was: %s ."
1569                 "This file has been deleted to avoid corrupt data.";
1570         break;
1571
1572       case EET_ERROR_WRITE_ERROR_OUT_OF_SPACE:
1573         erstr = "Elementary cannot write its settings file "
1574                 "because it ran out of space to write the file. "
1575                 "You have either run out of disk space or have "
1576                 "gone over your quota limit. "
1577                 "The file where the error occurred was: %s ."
1578                 "This file has been deleted to avoid corrupt data.";
1579         break;
1580
1581       case EET_ERROR_WRITE_ERROR_FILE_CLOSED:
1582         erstr = "Elementary unexpectedly had the settings file "
1583                 "it was writing closed on it. This is very unusual. "
1584                 "The file where the error occurred was: %s "
1585                 "This file has been deleted to avoid corrupt data.";
1586         break;
1587
1588       default:
1589         break;
1590      }
1591    if (erstr)
1592      {
1593         /* delete any partially-written file */
1594          ecore_file_unlink(file);
1595          return strdup(erstr);
1596      }
1597
1598    return NULL;
1599 }
1600
1601 static Eina_Bool
1602 _elm_config_profile_save(void)
1603 {
1604    char buf[4096], buf2[4096];
1605    int ok = 0, ret;
1606    const char *err;
1607    Eet_File *ef;
1608    size_t len;
1609
1610    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/profile.cfg");
1611    if (len + 1 >= sizeof(buf))
1612      return EINA_FALSE;
1613
1614    len = _elm_config_user_dir_snprintf(buf2, sizeof(buf2),
1615                                        "config/profile.cfg.tmp");
1616    if (len + 1 >= sizeof(buf2))
1617      return EINA_FALSE;
1618
1619    ef = eet_open(buf2, EET_FILE_MODE_WRITE);
1620    if (!ef)
1621      return EINA_FALSE;
1622
1623    ok = eet_write(ef, "config", _elm_profile, strlen(_elm_profile), 0);
1624    if (!ok)
1625      goto err;
1626
1627    err = _elm_config_eet_close_error_get(ef, buf2);
1628    if (err)
1629      {
1630         ERR("%s", err);
1631         free((void *)err);
1632         goto err;
1633      }
1634
1635    ret = ecore_file_mv(buf2, buf);
1636    if (!ret)
1637      {
1638         ERR("Error saving Elementary's configuration profile file");
1639         goto err;
1640      }
1641
1642    ecore_file_unlink(buf2);
1643    return EINA_TRUE;
1644
1645 err:
1646    ecore_file_unlink(buf2);
1647    return EINA_FALSE;
1648 }
1649
1650 Eina_Bool
1651 _elm_config_save(void)
1652 {
1653    char buf[4096], buf2[4096];
1654    int ok = 0, ret;
1655    const char *err;
1656    Eet_File *ef;
1657    size_t len;
1658
1659    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "themes/");
1660    if (len + 1 >= sizeof(buf))
1661      return EINA_FALSE;
1662
1663    ok = ecore_file_mkpath(buf);
1664    if (!ok)
1665      {
1666         ERR("Problem accessing Elementary's user configuration directory: %s",
1667             buf);
1668         return EINA_FALSE;
1669      }
1670
1671    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/%s",
1672                                        _elm_profile);
1673    if (len + 1 >= sizeof(buf))
1674      return EINA_FALSE;
1675
1676    ok = ecore_file_mkpath(buf);
1677    if (!ok)
1678      {
1679         ERR("Problem accessing Elementary's user configuration directory: %s",
1680             buf);
1681         return EINA_FALSE;
1682      }
1683
1684    if (!_elm_config_profile_save())
1685      return EINA_FALSE;
1686
1687    buf[len] = '/';
1688    len++;
1689
1690    if (len + sizeof("base.cfg") >= sizeof(buf) - len)
1691      return EINA_FALSE;
1692
1693    memcpy(buf + len, "base.cfg", sizeof("base.cfg"));
1694    len += sizeof("base.cfg") - 1;
1695
1696    if (len + sizeof(".tmp") >= sizeof(buf))
1697      return EINA_FALSE;
1698
1699    memcpy(buf2, buf, len);
1700    memcpy(buf2 + len, ".tmp", sizeof(".tmp"));
1701
1702    ef = eet_open(buf2, EET_FILE_MODE_WRITE);
1703    if (!ef)
1704      return EINA_FALSE;
1705
1706    ok = eet_data_write(ef, _config_edd, "config", _elm_config, 1);
1707    if (!ok)
1708      goto err;
1709
1710    err = _elm_config_eet_close_error_get(ef, buf2);
1711    if (err)
1712      {
1713         ERR("%s", err);
1714         free((void *)err);
1715         goto err;
1716      }
1717
1718    ret = ecore_file_mv(buf2, buf);
1719    if (!ret)
1720      {
1721         ERR("Error saving Elementary's configuration file");
1722         goto err;
1723      }
1724
1725    ecore_file_unlink(buf2);
1726    return EINA_TRUE;
1727
1728 err:
1729    ecore_file_unlink(buf2);
1730    return EINA_FALSE;
1731 }
1732
1733 static void
1734 _config_update(void)
1735 {
1736    Elm_Config *tcfg;
1737    tcfg = _config_system_load();
1738    if (!tcfg)
1739      {
1740         /* weird profile or something? We should probably fill
1741          * with hardcoded defaults, or get from default previx */
1742         return;
1743      }
1744 #define IFCFG(v)   if ((_elm_config->config_version & 0xffff) < (v)) {
1745 #define IFCFGELSE } else {
1746 #define IFCFGEND  }
1747 #define COPYVAL(x) do {_elm_config->x = tcfg->x; } while (0)
1748 #define COPYPTR(x) do {_elm_config->x = tcfg->x; tcfg->x = NULL; } while (0)
1749 #define COPYSTR(x) COPYPTR(x)
1750
1751    /* we also need to update for property changes in the root window
1752     * if needed, but that will be dependent on new properties added
1753     * with each version */
1754    IFCFG(0x0002)
1755    _elm_config->win_auto_focus_enable = tcfg->win_auto_focus_enable;;
1756    _elm_config->win_auto_focus_animate = tcfg->win_auto_focus_animate;
1757    IFCFGEND
1758
1759    IFCFG(0x0003)
1760    _elm_config->transition_duration_factor = tcfg->transition_duration_factor;
1761    IFCFGEND
1762
1763    IFCFG(0x0004)
1764    Elm_Config_Bindings_Widget *wb, *twb = NULL;
1765    Eina_List *l;
1766
1767    EINA_LIST_FOREACH(tcfg->bindings, l, wb)
1768      {
1769         if (wb->name && !strcmp(wb->name, "Elm_Hoversel"))
1770           {
1771              twb = wb;
1772              break;
1773           }
1774      }
1775    if (twb)
1776      {
1777         EINA_LIST_FOREACH(_elm_config->bindings, l, wb)
1778            {
1779               if (wb->name && !strcmp(wb->name, "Elm_Hoversel"))
1780                 {
1781                    // simply swap bindngs for Elm_Hoversel with system ones
1782                    Eina_List *tmp = wb->key_bindings;
1783                    wb->key_bindings = twb->key_bindings;
1784                    twb->key_bindings = tmp;
1785                    break;
1786                 }
1787            }
1788      }
1789    IFCFGEND
1790
1791    IFCFG(0x0005)
1792    _elm_config->naviframe_prev_btn_auto_pushed = tcfg->naviframe_prev_btn_auto_pushed;
1793    IFCFGEND
1794
1795    IFCFG(0x0006)
1796    _elm_config->cursor_engine_only = 0;
1797    IFCFGEND
1798
1799    /**
1800     * Fix user config for current ELM_CONFIG_EPOCH here.
1801     **/
1802
1803 #undef COPYSTR
1804 #undef COPYPTR
1805 #undef COPYVAL
1806 #undef IFCFGEND
1807 #undef IFCFGELSE
1808 #undef IFCFG
1809
1810    _elm_config->config_version = ELM_CONFIG_VERSION;
1811    /* after updating user config, we must save */
1812    _config_free(tcfg);
1813    _elm_config_save();
1814 }
1815
1816 static void
1817 _env_get(void)
1818 {
1819    char *s;
1820    double friction;
1821
1822    s = getenv("ELM_ENGINE");
1823    if (s)
1824      {
1825         if ((!strcasecmp(s, "x11")) ||
1826             (!strcasecmp(s, "x")) ||
1827             (!strcasecmp(s, "software-x11")) ||
1828             (!strcasecmp(s, "software_x11")))
1829           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_X11);
1830         else if ((!strcasecmp(s, "opengl")) ||
1831                  (!strcasecmp(s, "gl")) ||
1832                  (!strcasecmp(s, "opengl-x11")) ||
1833                  (!strcasecmp(s, "opengl_x11")))
1834           eina_stringshare_replace(&_elm_config->engine, ELM_OPENGL_X11);
1835         else if ((!strcasecmp(s, "fb")) ||
1836                  (!strcasecmp(s, "software-fb")) ||
1837                  (!strcasecmp(s, "software_fb")))
1838           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_FB);
1839         else if ((!strcasecmp(s, "psl1ght")))
1840           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_PSL1GHT);
1841         else if ((!strcasecmp(s, "sdl")) ||
1842                  (!strcasecmp(s, "software-sdl")) ||
1843                  (!strcasecmp(s, "software_sdl")))
1844           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_SDL);
1845         else if ((!strcasecmp(s, "opengl-sdl")) ||
1846                  (!strcasecmp(s, "opengl_sdl")) ||
1847                  (!strcasecmp(s, "gl-sdl")) ||
1848                  (!strcasecmp(s, "gl_sdl")))
1849           eina_stringshare_replace(&_elm_config->engine, ELM_OPENGL_SDL);
1850         else if ((!strcasecmp(s, "opengl-cocoa")) ||
1851                  (!strcasecmp(s, "opengl_cocoa")) ||
1852                  (!strcasecmp(s, "gl-cocoa")) ||
1853                  (!strcasecmp(s, "gl_cocoa")))
1854           eina_stringshare_replace(&_elm_config->engine, ELM_OPENGL_COCOA);
1855         else if ((!strcasecmp(s, "gdi")) ||
1856                  (!strcasecmp(s, "software-gdi")) ||
1857                  (!strcasecmp(s, "software_gdi")))
1858           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_WIN32);
1859         else if (!strcasecmp(s, "buffer"))
1860           eina_stringshare_replace(&_elm_config->engine, ELM_BUFFER);
1861         else if ((!strncmp(s, "shot:", 5)))
1862           eina_stringshare_replace(&_elm_config->engine, s);
1863         else if ((!strcasecmp(s, "ews")))
1864           eina_stringshare_replace(&_elm_config->engine, ELM_EWS);
1865         else if ((!strcasecmp(s, "wayland_shm")) ||
1866                  (!strcasecmp(s, "wayland-shm")))
1867           eina_stringshare_replace(&_elm_config->engine, ELM_WAYLAND_SHM);
1868         else if ((!strcasecmp(s, "wayland_egl")) ||
1869                  (!strcasecmp(s, "wayland-egl")))
1870           eina_stringshare_replace(&_elm_config->engine, ELM_WAYLAND_EGL);
1871         else if ((!strcasecmp(s, "drm")))
1872           eina_stringshare_replace(&_elm_config->engine, ELM_DRM);
1873         else if ((!strcasecmp(s, "ddraw")))
1874           eina_stringshare_replace(&_elm_config->engine, ELM_SOFTWARE_DDRAW);
1875         else
1876           ERR("Unknown engine '%s'.", s);
1877         if (_elm_config->engine)
1878           eina_stringshare_replace(&_elm_preferred_engine, _elm_config->engine);
1879      }
1880
1881    s = getenv("ELM_VSYNC");
1882    if (s) _elm_config->vsync = !!atoi(s);
1883
1884    s = getenv("ELM_THUMBSCROLL_ENABLE");
1885    if (s) _elm_config->thumbscroll_enable = !!atoi(s);
1886    s = getenv("ELM_THUMBSCROLL_THRESHOLD");
1887    if (s) _elm_config->thumbscroll_threshold = atoi(s);
1888    s = getenv("ELM_THUMBSCROLL_HOLD_THRESHOLD");
1889    if (s) _elm_config->thumbscroll_hold_threshold = atoi(s);
1890    // FIXME: floatformat locale issues here 1.0 vs 1,0 - should just be 1.0
1891    s = getenv("ELM_THUMBSCROLL_MOMENTUM_THRESHOLD");
1892    if (s) _elm_config->thumbscroll_momentum_threshold = _elm_atof(s);
1893    s = getenv("ELM_THUMBSCROLL_FLICK_DISTANCE_TOLERANCE");
1894    if (s) _elm_config->thumbscroll_flick_distance_tolerance = atoi(s);
1895    s = getenv("ELM_THUMBSCROLL_FRICTION");
1896    if (s) _elm_config->thumbscroll_friction = _elm_atof(s);
1897    s = getenv("ELM_THUMBSCROLL_MIN_FRICTION");
1898    if (s) _elm_config->thumbscroll_min_friction = _elm_atof(s);
1899    s = getenv("ELM_THUMBSCROLL_FRICTION_STANDARD");
1900    if (s) _elm_config->thumbscroll_friction_standard = _elm_atof(s);
1901    s = getenv("ELM_THUMBSCROLL_BOUNCE_ENABLE");
1902    if (s) _elm_config->thumbscroll_bounce_enable = !!atoi(s);
1903    s = getenv("ELM_THUMBSCROLL_BOUNCE_FRICTION");
1904    if (s) _elm_config->thumbscroll_bounce_friction = _elm_atof(s);
1905    s = getenv("ELM_THUMBSCROLL_ACCELERATION_THRESHOLD");
1906    if (s) _elm_config->thumbscroll_acceleration_threshold = _elm_atof(s);
1907    s = getenv("ELM_THUMBSCROLL_ACCELERATION_TIME_LIMIT");
1908    if (s) _elm_config->thumbscroll_acceleration_time_limit = _elm_atof(s);
1909    s = getenv("ELM_THUMBSCROLL_ACCELERATION_WEIGHT");
1910    if (s) _elm_config->thumbscroll_acceleration_weight = _elm_atof(s);
1911    s = getenv("ELM_PAGE_SCROLL_FRICTION");
1912    if (s) _elm_config->page_scroll_friction = _elm_atof(s);
1913    s = getenv("ELM_BRING_IN_SCROLL_FRICTION");
1914    if (s) _elm_config->bring_in_scroll_friction = _elm_atof(s);
1915    s = getenv("ELM_ZOOM_FRICTION");
1916    if (s) _elm_config->zoom_friction = _elm_atof(s);
1917    s = getenv("ELM_THUMBSCROLL_BORDER_FRICTION");
1918    if (s)
1919      {
1920         friction = _elm_atof(s);
1921         if (friction < 0.0)
1922           friction = 0.0;
1923
1924         if (friction > 1.0)
1925           friction = 1.0;
1926
1927         _elm_config->thumbscroll_border_friction = friction;
1928      }
1929    s = getenv("ELM_THUMBSCROLL_SENSITIVITY_FRICTION");
1930    if (s)
1931      {
1932         friction = _elm_atof(s);
1933         if (friction < 0.1)
1934           friction = 0.1;
1935
1936         if (friction > 1.0)
1937           friction = 1.0;
1938
1939         _elm_config->thumbscroll_sensitivity_friction = friction;
1940      }
1941    s = getenv("ELM_SCROLL_SMOOTH_START_ENABLE");
1942    if (s) _elm_config->scroll_smooth_start_enable = !!atoi(s);
1943 //   s = getenv("ELM_SCROLL_SMOOTH_TIME_INTERVAL"); // not used anymore
1944 //   if (s) _elm_config->scroll_smooth_time_interval = atof(s); // not used anymore
1945    s = getenv("ELM_SCROLL_SMOOTH_AMOUNT");
1946    if (s) _elm_config->scroll_smooth_amount = _elm_atof(s);
1947 //   s = getenv("ELM_SCROLL_SMOOTH_HISTORY_WEIGHT"); // not used anymore
1948 //   if (s) _elm_config->scroll_smooth_history_weight = _elm_atof(s); // not used anymore
1949 //   s = getenv("ELM_SCROLL_SMOOTH_FUTURE_TIME"); // not used anymore
1950 //   if (s) _elm_config->scroll_smooth_future_time = _elm_atof(s); // not used anymore
1951    s = getenv("ELM_SCROLL_SMOOTH_TIME_WINDOW");
1952    if (s) _elm_config->scroll_smooth_time_window = _elm_atof(s);
1953    s = getenv("ELM_FOCUS_AUTOSCROLL_MODE");
1954    if (s)
1955      {
1956         if (!strcmp(s, "ELM_FOCUS_AUTOSCROLL_MODE_NONE"))
1957           _elm_config->focus_autoscroll_mode = ELM_FOCUS_AUTOSCROLL_MODE_NONE;
1958         else if (!strcmp(s, "ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN"))
1959           _elm_config->focus_autoscroll_mode = ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN;
1960         else
1961           _elm_config->focus_autoscroll_mode = ELM_FOCUS_AUTOSCROLL_MODE_SHOW;
1962      }
1963    s = getenv("ELM_SLIDER_INDICATOR_VISIBLE_MODE");
1964    if (s)
1965      {
1966         if (!strcmp(s, "ELM_SLIDER_INDICATOR_VISIBLE_MODE_DEFAULT"))
1967           _elm_config->slider_indicator_visible_mode = ELM_SLIDER_INDICATOR_VISIBLE_MODE_DEFAULT;
1968         else if (!strcmp(s, "ELM_SLIDER_INDICATOR_VISIBLE_MODE_ALWAYS"))
1969           _elm_config->slider_indicator_visible_mode = ELM_SLIDER_INDICATOR_VISIBLE_MODE_ALWAYS;
1970         else if (!strcmp(s, "ELM_SLIDER_INDICATOR_VISIBLE_MODE_ON_FOCUS"))
1971           _elm_config->slider_indicator_visible_mode = ELM_SLIDER_INDICATOR_VISIBLE_MODE_ON_FOCUS;
1972         else
1973           _elm_config->slider_indicator_visible_mode = ELM_SLIDER_INDICATOR_VISIBLE_MODE_NONE;
1974      }
1975    s = getenv("ELM_THEME");
1976    if (s) eina_stringshare_replace(&_elm_config->theme, s);
1977
1978    s = getenv("ELM_FONT_HINTING");
1979    if (s)
1980      {
1981         if      (!strcasecmp(s, "none")) _elm_config->font_hinting = 0;
1982         else if (!strcasecmp(s, "auto"))
1983           _elm_config->font_hinting = 1;
1984         else if (!strcasecmp(s, "bytecode"))
1985           _elm_config->font_hinting = 2;
1986      }
1987
1988    s = getenv("ELM_FONT_PATH");
1989    if (s)
1990      {
1991         const char *p, *pp;
1992         char *buf2;
1993
1994         EINA_LIST_FREE(_elm_config->font_dirs, p)
1995           {
1996              eina_stringshare_del(p);
1997           }
1998
1999         buf2 = alloca(strlen(s) + 1);
2000         p = s;
2001         pp = p;
2002         for (;; )
2003           {
2004              if ((*p == ':') || (*p == 0))
2005                {
2006                   int len;
2007
2008                   len = p - pp;
2009                   strncpy(buf2, pp, len);
2010                   buf2[len] = 0;
2011                   _elm_config->font_dirs =
2012                     eina_list_append(_elm_config->font_dirs,
2013                                      eina_stringshare_add(buf2));
2014                   if (*p == 0) break;
2015                   p++;
2016                   pp = p;
2017                }
2018              else
2019                {
2020                   if (*p == 0) break;
2021                   p++;
2022                }
2023           }
2024      }
2025
2026    s = getenv("ELM_IMAGE_CACHE");
2027    if (s) _elm_config->image_cache = atoi(s);
2028
2029    s = getenv("ELM_FONT_CACHE");
2030    if (s) _elm_config->font_cache = atoi(s);
2031
2032    s = getenv("ELM_SCALE");
2033    if (s) _elm_config->scale = _elm_atof(s);
2034
2035    s = getenv("ELM_FINGER_SIZE");
2036    if (s) _elm_config->finger_size = atoi(s);
2037
2038    s = getenv("ELM_PASSWORD_SHOW_LAST");
2039    if (s) _elm_config->password_show_last = !!atoi(s);
2040
2041    s = getenv("ELM_PASSWORD_SHOW_LAST_TIMEOUT");
2042    if (s)
2043      {
2044         double pw_show_last_timeout = _elm_atof(s);
2045         if (pw_show_last_timeout >= 0.0)
2046           _elm_config->password_show_last_timeout = pw_show_last_timeout;
2047      }
2048
2049    s = getenv("ELM_FPS");
2050    if (s) _elm_config->fps = _elm_atof(s);
2051    if (_elm_config->fps < 1.0) _elm_config->fps = 1.0;
2052
2053    s = getenv("ELM_MODULES");
2054    if (s) eina_stringshare_replace(&_elm_config->modules, s);
2055
2056    s = getenv("ELM_TOOLTIP_DELAY");
2057    if (s)
2058      {
2059         double delay = _elm_atof(s);
2060         if (delay >= 0.0)
2061           _elm_config->tooltip_delay = delay;
2062      }
2063
2064    s = getenv("ELM_CURSOR_ENGINE_ONLY");
2065    if (s) _elm_config->cursor_engine_only = !!atoi(s);
2066
2067    s = getenv("ELM_FOCUS_HIGHLIGHT_ENABLE");
2068    if (s) _elm_config->focus_highlight_enable = !!atoi(s);
2069
2070    s = getenv("ELM_FOCUS_HIGHLIGHT_ANIMATE");
2071    if (s) _elm_config->focus_highlight_animate = !!atoi(s);
2072
2073    s = getenv("ELM_FOCUS_HIGHLIGHT_CLIP_DISABLE");
2074    if (s) _elm_config->focus_highlight_clip_disable = !!atoi(s);
2075
2076    s = getenv("ELM_FOCUS_MOVE_POLICY");
2077    if (s) _elm_config->focus_move_policy = !!atoi(s);
2078
2079    s = getenv("ELM_ITEM_SELECT_ON_FOCUS_DISABLE");
2080    if (s) _elm_config->item_select_on_focus_disable = !!atoi(s);
2081
2082    s = getenv("ELM_FIRST_ITEM_FOCUS_ON_FIRST_FOCUS_IN");
2083    if (s) _elm_config->first_item_focus_on_first_focus_in = !!atoi(s);
2084
2085    s = getenv("ELM_TOOLBAR_SHRINK_MODE");
2086    if (s) _elm_config->toolbar_shrink_mode = atoi(s);
2087
2088    s = getenv("ELM_FILESELECTOR_EXPAND_ENABLE");
2089    if (s) _elm_config->fileselector_expand_enable = !!atoi(s);
2090
2091    s = getenv("ELM_FILESELECTOR_DOUBLE_TAP_NAVIGATION_ENABLE");
2092    if (s) _elm_config->fileselector_double_tap_navigation_enable = !!atoi(s);
2093
2094    s = getenv("ELM_INWIN_DIALOGS_ENABLE");
2095    if (s) _elm_config->inwin_dialogs_enable = !!atoi(s);
2096
2097    s = getenv("ELM_ICON_SIZE");
2098    if (s) _elm_config->icon_size = atoi(s);
2099
2100    s = getenv("ELM_LONGPRESS_TIMEOUT");
2101    if (s) _elm_config->longpress_timeout = _elm_atof(s);
2102    if (_elm_config->longpress_timeout < 0.0)
2103      _elm_config->longpress_timeout = 0.0;
2104
2105    s = getenv("ELM_EFFECT_ENABLE");
2106    if (s) _elm_config->effect_enable = !!atoi(s);
2107
2108    s = getenv("ELM_DESKTOP_ENTRY");
2109    if (s) _elm_config->desktop_entry = !!atoi(s);
2110    s = getenv("ELM_ACCESS_MODE");
2111    if (s) _elm_config->access_mode = ELM_ACCESS_MODE_ON;
2112
2113    s = getenv("ELM_SELECTION_CLEAR_ENABLE");
2114    if (s) _elm_config->selection_clear_enable = !!atoi(s);
2115
2116    s = getenv("ELM_AUTO_THROTTLE");
2117    if (s) _elm_config->auto_throttle = EINA_TRUE;
2118    s = getenv("ELM_AUTO_THROTTLE_AMOUNT");
2119    if (s) _elm_config->auto_throttle_amount = _elm_atof(s);
2120    s = getenv("ELM_AUTO_NORENDER_WITHDRAWN");
2121    if (s) _elm_config->auto_norender_withdrawn = EINA_TRUE;
2122    s = getenv("ELM_AUTO_NORENDER_ICONIFIED_SAME_AS_WITHDRAWN");
2123    if (s) _elm_config->auto_norender_iconified_same_as_withdrawn = EINA_TRUE;
2124    s = getenv("ELM_AUTO_FLUSH_WITHDRAWN");
2125    if (s) _elm_config->auto_flush_withdrawn = EINA_TRUE;
2126    s = getenv("ELM_AUTO_DUMP_WIDTHDRAWN");
2127    if (s) _elm_config->auto_dump_withdrawn = EINA_TRUE;
2128
2129    s = getenv("ELM_INDICATOR_SERVICE_0");
2130    if (s) eina_stringshare_replace(&_elm_config->indicator_service_0, s);
2131    s = getenv("ELM_INDICATOR_SERVICE_90");
2132    if (s) eina_stringshare_replace(&_elm_config->indicator_service_90, s);
2133    s = getenv("ELM_INDICATOR_SERVICE_180");
2134    if (s) eina_stringshare_replace(&_elm_config->indicator_service_180, s);
2135    s = getenv("ELM_INDICATOR_SERVICE_270");
2136    if (s) eina_stringshare_replace(&_elm_config->indicator_service_270, s);
2137    s = getenv("ELM_DISABLE_EXTERNAL_MENU");
2138    if (s) _elm_config->disable_external_menu = !!atoi(s);
2139
2140    s = getenv("ELM_CLOUSEAU");
2141    if (s) _elm_config->clouseau_enable = atoi(s);
2142    s = getenv("ELM_MAGNIFIER_ENABLE");
2143    if (s) _elm_config->magnifier_enable = !!atoi(s);
2144    s = getenv("ELM_MAGNIFIER_SCALE");
2145    if (s) _elm_config->magnifier_scale = _elm_atof(s);
2146    s = getenv("ELM_ATSPI_MODE");
2147    if (s) _elm_config->atspi_mode = ELM_ATSPI_MODE_ON;
2148
2149    s = getenv("ELM_TRANSITION_DURATION_FACTOR");
2150    if (s) _elm_config->transition_duration_factor = atof(s);
2151
2152    s = getenv("ELM_POPUP_HORIZONTAL_ALIGN");
2153    if (s) _elm_config->popup_horizontal_align = _elm_atof(s);
2154    s = getenv("ELM_POPUP_VERTICAL_ALIGN");
2155    if (s) _elm_config->popup_vertical_align = _elm_atof(s);
2156 }
2157
2158 static void
2159 _elm_config_key_binding_hash(void)
2160 {
2161    Elm_Config_Bindings_Widget *wb;
2162    Eina_List *l;
2163
2164    if (_elm_key_bindings)
2165      eina_hash_free(_elm_key_bindings);
2166
2167    _elm_key_bindings = eina_hash_string_superfast_new(NULL);
2168    EINA_LIST_FOREACH(_elm_config->bindings, l, wb)
2169      {
2170         eina_hash_add(_elm_key_bindings, wb->name, wb->key_bindings);
2171      }
2172 }
2173
2174 Eina_Bool
2175 _elm_config_modifier_check(const Evas_Modifier *m,
2176                            Eina_List *mod_list)
2177 {
2178    Eina_List *l;
2179    Elm_Config_Binding_Modifier *mod;
2180    EINA_LIST_FOREACH(mod_list, l, mod)
2181      {
2182         if ((evas_key_modifier_is_set(m, mod->mod)) ^ (mod->flag))
2183           return EINA_FALSE;
2184      }
2185    return EINA_TRUE;
2186 }
2187
2188 Eina_Bool
2189 _elm_config_key_binding_call(Evas_Object *obj,
2190                              const Evas_Event_Key_Down *ev,
2191                              const Elm_Action *actions)
2192 {
2193    Elm_Config_Binding_Key *binding;
2194    Eina_List *binding_list, *l;
2195    int i = 0;
2196
2197    binding_list = eina_hash_find(_elm_key_bindings, elm_widget_type_get(obj));
2198
2199    if (binding_list)
2200      {
2201         EINA_LIST_FOREACH(binding_list, l, binding)
2202           {
2203              if (binding->key && (!strcmp(binding->key, ev->key))
2204                  && _elm_config_modifier_check(ev->modifiers, binding->modifiers))
2205                {
2206                   while (actions[i].name)
2207                     {
2208                        if (!strcmp(binding->action, actions[i].name))
2209                          return actions[i].func(obj, binding->params);
2210                        i++;
2211                     }
2212                   break;
2213                }
2214           }
2215      }
2216    return EINA_FALSE;
2217 }
2218
2219 EAPI Eina_Bool
2220 elm_config_mirrored_get(void)
2221 {
2222    return _elm_config->is_mirrored;
2223 }
2224
2225 EAPI void
2226 elm_config_mirrored_set(Eina_Bool mirrored)
2227 {
2228    mirrored = !!mirrored;
2229    if (_elm_config->is_mirrored == mirrored) return;
2230    _elm_config->is_mirrored = mirrored;
2231    _elm_rescale();
2232 }
2233
2234 EAPI Eina_Bool
2235 elm_config_cursor_engine_only_get(void)
2236 {
2237    return _elm_config->cursor_engine_only;
2238 }
2239
2240 EAPI void
2241 elm_config_cursor_engine_only_set(Eina_Bool engine_only)
2242 {
2243    engine_only = !!engine_only;
2244    _elm_config->cursor_engine_only = engine_only;
2245 }
2246
2247 EAPI double
2248 elm_config_tooltip_delay_get(void)
2249 {
2250    return _elm_config->tooltip_delay;
2251 }
2252
2253 EAPI void
2254 elm_config_tooltip_delay_set(double delay)
2255 {
2256    if (delay < 0.0) return;
2257    _elm_config->tooltip_delay = delay;
2258 }
2259
2260 EAPI double
2261 elm_config_scale_get(void)
2262 {
2263    return _elm_config->scale;
2264 }
2265
2266 EAPI void
2267 elm_config_scale_set(double scale)
2268 {
2269    if (scale < 0.0) return;
2270    if (_elm_config->scale == scale) return;
2271    _elm_config->scale = scale;
2272    _elm_rescale();
2273 }
2274
2275 EAPI Eina_Bool
2276 elm_config_password_show_last_get(void)
2277 {
2278    return _elm_config->password_show_last;
2279 }
2280
2281 EAPI void
2282 elm_config_password_show_last_set(Eina_Bool password_show_last)
2283 {
2284    if (_elm_config->password_show_last == password_show_last) return;
2285    _elm_config->password_show_last = password_show_last;
2286    edje_password_show_last_set(_elm_config->password_show_last);
2287 }
2288
2289 EAPI double
2290 elm_config_password_show_last_timeout_get(void)
2291 {
2292    return _elm_config->password_show_last_timeout;
2293 }
2294
2295 EAPI void
2296 elm_config_password_show_last_timeout_set(double password_show_last_timeout)
2297 {
2298    if (password_show_last_timeout < 0.0) return;
2299    if (_elm_config->password_show_last_timeout == password_show_last_timeout) return;
2300    _elm_config->password_show_last_timeout = password_show_last_timeout;
2301    edje_password_show_last_timeout_set(_elm_config->password_show_last_timeout);
2302 }
2303
2304 EAPI Eina_Bool
2305 elm_config_save(void)
2306 {
2307    return _elm_config_save();
2308 }
2309
2310 EAPI void
2311 elm_config_reload(void)
2312 {
2313    _elm_config_reload();
2314 }
2315
2316 EAPI const char *
2317 elm_config_profile_get(void)
2318 {
2319    return _elm_config_current_profile_get();
2320 }
2321
2322 EAPI const char *
2323 elm_config_profile_dir_get(const char *profile,
2324                     Eina_Bool   is_user)
2325 {
2326    return _elm_config_profile_dir_get(profile, is_user);
2327 }
2328
2329 EAPI void
2330 elm_config_profile_dir_free(const char *p_dir)
2331 {
2332    free((void *)p_dir);
2333 }
2334
2335 EAPI Eina_List *
2336 elm_config_profile_list_get(void)
2337 {
2338    return _elm_config_profiles_list();
2339 }
2340
2341 EAPI void
2342 elm_config_profile_list_free(Eina_List *l)
2343 {
2344    const char *dir;
2345
2346    EINA_LIST_FREE(l, dir)
2347      eina_stringshare_del(dir);
2348 }
2349
2350 EAPI void
2351 elm_config_profile_set(const char *profile)
2352 {
2353    EINA_SAFETY_ON_NULL_RETURN(profile);
2354    _elm_config_profile_set(profile);
2355 }
2356
2357 EAPI const char *
2358 elm_config_engine_get(void)
2359 {
2360    return _elm_config->engine;
2361 }
2362
2363 EAPI void
2364 elm_config_engine_set(const char *engine)
2365 {
2366    EINA_SAFETY_ON_NULL_RETURN(engine);
2367
2368    _elm_config_engine_set(engine);
2369 }
2370
2371 EAPI Eina_List *
2372 elm_config_text_classes_list_get(void)
2373 {
2374    return _elm_config_text_classes_get();
2375 }
2376
2377 EAPI void
2378 elm_config_text_classes_list_free(Eina_List *list)
2379 {
2380    _elm_config_text_classes_free(list);
2381 }
2382
2383 EAPI const Eina_List *
2384 elm_config_font_overlay_list_get(void)
2385 {
2386    return _elm_config_font_overlays_list();
2387 }
2388
2389 EAPI Eina_Bool
2390 elm_config_access_get(void)
2391 {
2392    return _elm_config_access_get();
2393 }
2394
2395 EAPI void
2396 elm_config_access_set(Eina_Bool is_access)
2397 {
2398    _elm_config_access_set(is_access);
2399 }
2400
2401 EAPI Eina_Bool
2402 elm_config_atspi_mode_get(void)
2403 {
2404    return _elm_config_atspi_mode_get();
2405 }
2406
2407 EAPI void
2408 elm_config_atspi_mode_set(Eina_Bool is_enable)
2409 {
2410    _elm_config_atspi_mode_set(is_enable);
2411 }
2412
2413 EAPI Eina_Bool
2414 elm_config_selection_unfocused_clear_get(void)
2415 {
2416    return _elm_config_selection_unfocused_clear_get();
2417 }
2418
2419 EAPI void
2420 elm_config_selection_unfocused_clear_set(Eina_Bool enabled)
2421 {
2422    _elm_config_selection_unfocused_clear_set(enabled);
2423 }
2424
2425 EAPI void
2426 elm_config_font_overlay_set(const char    *text_class,
2427                      const char    *font,
2428                      Evas_Font_Size size)
2429 {
2430    EINA_SAFETY_ON_NULL_RETURN(text_class);
2431    _elm_config_font_overlay_set(text_class, font, size);
2432 }
2433
2434 EAPI void
2435 elm_config_font_overlay_unset(const char *text_class)
2436 {
2437    EINA_SAFETY_ON_NULL_RETURN(text_class);
2438    _elm_config_font_overlay_remove(text_class);
2439 }
2440
2441 EAPI void
2442 elm_config_font_overlay_apply(void)
2443 {
2444    _elm_config_font_overlay_apply();
2445    _elm_rescale();
2446 }
2447
2448 EAPI Eina_List *
2449 elm_config_color_classes_list_get(void)
2450 {
2451    return _elm_config_color_classes_get();
2452 }
2453
2454 EAPI void
2455 elm_config_color_classes_list_free(Eina_List *list)
2456 {
2457    _elm_config_color_classes_free(list);
2458 }
2459
2460 EAPI const Eina_List *
2461 elm_config_color_overlay_list_get(void)
2462 {
2463    return _elm_config_color_overlays_list();
2464 }
2465
2466 EAPI void
2467 elm_config_color_overlay_set(const char *color_class,
2468                              int r, int g, int b, int a,
2469                              int r2, int g2, int b2, int a2,
2470                              int r3, int g3, int b3, int a3)
2471 {
2472    EINA_SAFETY_ON_NULL_RETURN(color_class);
2473    _elm_config_color_overlay_set(color_class,
2474                                  r, g, b, a,
2475                                  r2, g2, b2, a2,
2476                                  r3, g3, b3, a3);
2477 }
2478
2479 EAPI void
2480 elm_config_color_overlay_unset(const char *color_class)
2481 {
2482    EINA_SAFETY_ON_NULL_RETURN(color_class);
2483    _elm_config_color_overlay_remove(color_class);
2484 }
2485
2486 EAPI void
2487 elm_config_color_overlay_apply(void)
2488 {
2489    _elm_config_color_overlay_apply();
2490 }
2491
2492 EAPI Evas_Coord
2493 elm_config_finger_size_get(void)
2494 {
2495    return _elm_config->finger_size;
2496 }
2497
2498 EAPI void
2499 elm_config_finger_size_set(Evas_Coord size)
2500 {
2501    if (size < 0) return;
2502    if (_elm_config->finger_size == size) return;
2503    _elm_config->finger_size = size;
2504    _elm_rescale();
2505 }
2506
2507 EAPI int
2508 elm_config_cache_flush_interval_get(void)
2509 {
2510    return _elm_config->cache_flush_poll_interval;
2511 }
2512
2513 EAPI void
2514 elm_config_cache_flush_interval_set(int size)
2515 {
2516    EINA_SAFETY_ON_FALSE_RETURN(size > 0);
2517    if (_elm_config->cache_flush_poll_interval == size) return;
2518    _elm_config->cache_flush_poll_interval = size;
2519
2520    _elm_recache();
2521 }
2522
2523 EAPI Eina_Bool
2524 elm_config_cache_flush_enabled_get(void)
2525 {
2526    return _elm_config->cache_flush_enable;
2527 }
2528
2529 EAPI void
2530 elm_config_cache_flush_enabled_set(Eina_Bool enabled)
2531 {
2532    enabled = !!enabled;
2533    if (_elm_config->cache_flush_enable == enabled) return;
2534    _elm_config->cache_flush_enable = enabled;
2535
2536    _elm_recache();
2537 }
2538
2539 EAPI int
2540 elm_config_cache_font_cache_size_get(void)
2541 {
2542    return _elm_config->font_cache;
2543 }
2544
2545 EAPI void
2546 elm_config_cache_font_cache_size_set(int size)
2547 {
2548    if (size < 0) return;
2549    if (_elm_config->font_cache == size) return;
2550    _elm_config->font_cache = size;
2551
2552    _elm_recache();
2553 }
2554
2555 EAPI int
2556 elm_config_cache_image_cache_size_get(void)
2557 {
2558    return _elm_config->image_cache;
2559 }
2560
2561 EAPI void
2562 elm_config_cache_image_cache_size_set(int size)
2563 {
2564    if (size < 0) return;
2565    if (_elm_config->image_cache == size) return;
2566    _elm_config->image_cache = size;
2567
2568    _elm_recache();
2569 }
2570
2571 EAPI void
2572 elm_config_font_hint_type_set(int type)
2573 {
2574    Eina_List *l;
2575    Evas_Object *win;
2576
2577    if ((type < 0) || (type > 2)) return;
2578    _elm_config->font_hinting = type;
2579
2580    EINA_LIST_FOREACH(_elm_win_list, l, win)
2581      {
2582         Evas *e = evas_object_evas_get(win);
2583
2584         if (!_elm_config->font_hinting)
2585           evas_font_hinting_set(e, EVAS_FONT_HINTING_NONE);
2586         else if (_elm_config->font_hinting == 1)
2587           evas_font_hinting_set(e, EVAS_FONT_HINTING_AUTO);
2588         else if (_elm_config->font_hinting == 2)
2589           evas_font_hinting_set(e, EVAS_FONT_HINTING_BYTECODE);
2590      }
2591 }
2592
2593 EAPI int
2594 elm_config_cache_edje_file_cache_size_get()
2595 {
2596    return _elm_config->edje_cache;
2597 }
2598
2599 EAPI void
2600 elm_config_cache_edje_file_cache_size_set(int size)
2601 {
2602    if (size < 0) return;
2603    if (_elm_config->edje_cache == size) return;
2604    _elm_config->edje_cache = size;
2605
2606    _elm_recache();
2607 }
2608
2609 EAPI int
2610 elm_config_cache_edje_collection_cache_size_get(void)
2611 {
2612    return _elm_config->edje_collection_cache;
2613 }
2614
2615 EAPI void
2616 elm_config_cache_edje_collection_cache_size_set(int size)
2617 {
2618    if (_elm_config->edje_collection_cache == size) return;
2619    _elm_config->edje_collection_cache = size;
2620
2621    _elm_recache();
2622 }
2623
2624 EAPI Eina_Bool
2625 elm_config_vsync_get(void)
2626 {
2627    return _elm_config->vsync;
2628 }
2629
2630 EAPI void
2631 elm_config_vsync_set(Eina_Bool enabled)
2632 {
2633    _elm_config->vsync = enabled;
2634 }
2635
2636 EAPI Eina_Bool
2637 elm_config_accel_preference_override_get(void)
2638 {
2639    return _elm_config->accel_override;
2640 }
2641
2642 EAPI void
2643 elm_config_accel_preference_override_set(Eina_Bool enabled)
2644 {
2645    _elm_config->accel_override = enabled;
2646 }
2647
2648 EAPI Eina_Bool
2649 elm_config_focus_highlight_enabled_get(void)
2650 {
2651    return _elm_config->focus_highlight_enable;
2652 }
2653
2654 EAPI void
2655 elm_config_focus_highlight_enabled_set(Eina_Bool enable)
2656 {
2657    _elm_config->focus_highlight_enable = !!enable;
2658 }
2659
2660 EAPI Eina_Bool
2661 elm_config_focus_highlight_animate_get(void)
2662 {
2663    return _elm_config->focus_highlight_animate;
2664 }
2665
2666 EAPI void
2667 elm_config_focus_highlight_animate_set(Eina_Bool animate)
2668 {
2669    _elm_config->focus_highlight_animate = !!animate;
2670 }
2671
2672 EAPI Eina_Bool
2673 elm_config_focus_highlight_clip_disabled_get(void)
2674 {
2675    return _elm_config->focus_highlight_clip_disable;
2676 }
2677
2678 EAPI void
2679 elm_config_focus_highlight_clip_disabled_set(Eina_Bool disable)
2680 {
2681    _elm_config->focus_highlight_clip_disable = !!disable;
2682 }
2683
2684 EAPI Elm_Focus_Move_Policy
2685 elm_config_focus_move_policy_get(void)
2686 {
2687    return _elm_config->focus_move_policy;
2688 }
2689
2690 EAPI void
2691 elm_config_focus_move_policy_set(Elm_Focus_Move_Policy policy)
2692 {
2693    _elm_config->focus_move_policy = policy;
2694 }
2695
2696 EAPI Eina_Bool
2697 elm_config_item_select_on_focus_disabled_get(void)
2698 {
2699    return _elm_config->item_select_on_focus_disable;
2700 }
2701
2702 EAPI void
2703 elm_config_item_select_on_focus_disabled_set(Eina_Bool disable)
2704 {
2705    _elm_config->item_select_on_focus_disable = !!disable;
2706 }
2707
2708 EAPI Eina_Bool
2709 elm_config_first_item_focus_on_first_focusin_get(void)
2710 {
2711    return _elm_config->first_item_focus_on_first_focus_in;
2712 }
2713
2714 EAPI void
2715 elm_config_first_item_focus_on_first_focusin_set(Eina_Bool enable)
2716 {
2717    _elm_config->first_item_focus_on_first_focus_in = !!enable;
2718 }
2719
2720 EAPI Eina_Bool
2721 elm_config_scroll_bounce_enabled_get(void)
2722 {
2723    return _elm_config->thumbscroll_bounce_enable;
2724 }
2725
2726 EAPI void
2727 elm_config_scroll_bounce_enabled_set(Eina_Bool enabled)
2728 {
2729    _elm_config->thumbscroll_bounce_enable = enabled;
2730 }
2731
2732 EAPI double
2733 elm_config_scroll_bounce_friction_get(void)
2734 {
2735    return _elm_config->thumbscroll_bounce_friction;
2736 }
2737
2738 EAPI void
2739 elm_config_scroll_bounce_friction_set(double friction)
2740 {
2741    _elm_config->thumbscroll_bounce_friction = friction;
2742 }
2743
2744 EAPI double
2745 elm_config_scroll_page_scroll_friction_get(void)
2746 {
2747    return _elm_config->page_scroll_friction;
2748 }
2749
2750 EAPI void
2751 elm_config_scroll_page_scroll_friction_set(double friction)
2752 {
2753    _elm_config->page_scroll_friction = friction;
2754 }
2755
2756 EAPI double
2757 elm_config_scroll_bring_in_scroll_friction_get(void)
2758 {
2759    return _elm_config->bring_in_scroll_friction;
2760 }
2761
2762 EAPI void
2763 elm_config_scroll_bring_in_scroll_friction_set(double friction)
2764 {
2765    _elm_config->bring_in_scroll_friction = friction;
2766 }
2767
2768 EAPI double
2769 elm_config_scroll_zoom_friction_get(void)
2770 {
2771    return _elm_config->zoom_friction;
2772 }
2773
2774 EAPI void
2775 elm_config_scroll_zoom_friction_set(double friction)
2776 {
2777    _elm_config->zoom_friction = friction;
2778 }
2779
2780 EAPI Eina_Bool
2781 elm_config_scroll_thumbscroll_enabled_get(void)
2782 {
2783    return _elm_config->thumbscroll_enable;
2784 }
2785
2786 EAPI void
2787 elm_config_scroll_thumbscroll_enabled_set(Eina_Bool enabled)
2788 {
2789    _elm_config->thumbscroll_enable = enabled;
2790 }
2791
2792 EAPI unsigned int
2793 elm_config_scroll_thumbscroll_threshold_get(void)
2794 {
2795    return _elm_config->thumbscroll_threshold;
2796 }
2797
2798 EAPI void
2799 elm_config_scroll_thumbscroll_threshold_set(unsigned int threshold)
2800 {
2801    _elm_config->thumbscroll_threshold = threshold;
2802 }
2803
2804 EAPI unsigned int
2805 elm_config_scroll_thumbscroll_hold_threshold_get(void)
2806 {
2807    return _elm_config->thumbscroll_hold_threshold;
2808 }
2809
2810 EAPI void
2811 elm_config_scroll_thumbscroll_hold_threshold_set(unsigned int threshold)
2812 {
2813    _elm_config->thumbscroll_hold_threshold = threshold;
2814 }
2815
2816 EAPI double
2817 elm_config_scroll_thumbscroll_momentum_threshold_get(void)
2818 {
2819    return _elm_config->thumbscroll_momentum_threshold;
2820 }
2821
2822 EAPI void
2823 elm_config_scroll_thumbscroll_momentum_threshold_set(double threshold)
2824 {
2825    _elm_config->thumbscroll_momentum_threshold = threshold;
2826 }
2827
2828 EAPI unsigned int
2829 elm_config_scroll_thumbscroll_flick_distance_tolerance_get(void)
2830 {
2831    return _elm_config->thumbscroll_flick_distance_tolerance;
2832 }
2833
2834 EAPI void
2835 elm_config_scroll_thumbscroll_flick_distance_tolerance_set(unsigned int distance)
2836 {
2837    _elm_config->thumbscroll_flick_distance_tolerance = distance;
2838 }
2839
2840 EAPI double
2841 elm_config_scroll_thumbscroll_friction_get(void)
2842 {
2843    return _elm_config->thumbscroll_friction;
2844 }
2845
2846 EAPI void
2847 elm_config_scroll_thumbscroll_friction_set(double friction)
2848 {
2849    _elm_config->thumbscroll_friction = friction;
2850 }
2851
2852 EAPI double
2853 elm_config_scroll_thumbscroll_min_friction_get(void)
2854 {
2855    return _elm_config->thumbscroll_min_friction;
2856 }
2857
2858 EAPI void
2859 elm_config_scroll_thumbscroll_min_friction_set(double friction)
2860 {
2861    _elm_config->thumbscroll_min_friction = friction;
2862 }
2863
2864 EAPI double
2865 elm_config_scroll_thumbscroll_friction_standard_get(void)
2866 {
2867    return _elm_config->thumbscroll_friction_standard;
2868 }
2869
2870 EAPI void
2871 elm_config_scroll_thumbscroll_friction_standard_set(double standard)
2872 {
2873    _elm_config->thumbscroll_friction_standard = standard;
2874 }
2875
2876 EAPI double
2877 elm_config_scroll_thumbscroll_border_friction_get(void)
2878 {
2879    return _elm_config->thumbscroll_border_friction;
2880 }
2881
2882 EAPI void
2883 elm_config_scroll_thumbscroll_border_friction_set(double friction)
2884 {
2885    if (friction < 0.0) friction = 0.0;
2886    if (friction > 1.0) friction = 1.0;
2887    _elm_config->thumbscroll_border_friction = friction;
2888 }
2889
2890 EAPI double
2891 elm_config_scroll_thumbscroll_sensitivity_friction_get(void)
2892 {
2893    return _elm_config->thumbscroll_sensitivity_friction;
2894 }
2895
2896 EAPI void
2897 elm_config_scroll_thumbscroll_sensitivity_friction_set(double friction)
2898 {
2899    if (friction < 0.1) friction = 0.1;
2900    if (friction > 1.0) friction = 1.0;
2901    _elm_config->thumbscroll_sensitivity_friction = friction;
2902 }
2903
2904 EAPI Eina_Bool
2905 elm_config_scroll_thumbscroll_smooth_start_get(void)
2906 {
2907    return _elm_config->scroll_smooth_start_enable;
2908 }
2909
2910 EAPI void
2911 elm_config_scroll_thumbscroll_smooth_start_set(Eina_Bool enable)
2912 {
2913    _elm_config->scroll_smooth_start_enable = enable;
2914 }
2915
2916 EAPI void
2917 elm_config_scroll_thumbscroll_smooth_amount_set(double amount)
2918 {
2919    if (amount < 0.0) amount = 0.0;
2920    if (amount > 1.0) amount = 1.0;
2921    _elm_config->scroll_smooth_amount = amount;
2922 }
2923
2924 EAPI double
2925 elm_config_scroll_thumbscroll_smooth_amount_get(void)
2926 {
2927    return _elm_config->scroll_smooth_amount;
2928 }
2929
2930 EAPI void
2931 elm_config_scroll_thumbscroll_smooth_time_window_set(double amount)
2932 {
2933    if (amount < 0.0) amount = 0.0;
2934    if (amount > 1.0) amount = 1.0;
2935    _elm_config->scroll_smooth_time_window = amount;
2936 }
2937
2938 EAPI double
2939 elm_config_scroll_thumbscroll_smooth_time_window_get(void)
2940 {
2941    return _elm_config->scroll_smooth_time_window;
2942 }
2943
2944 EAPI double
2945 elm_config_scroll_thumbscroll_acceleration_threshold_get(void)
2946 {
2947    return _elm_config->thumbscroll_acceleration_threshold;
2948 }
2949
2950 EAPI void
2951 elm_config_scroll_thumbscroll_acceleration_threshold_set(double threshold)
2952 {
2953    _elm_config->thumbscroll_acceleration_threshold = threshold;
2954 }
2955
2956 EAPI double
2957 elm_config_scroll_thumbscroll_acceleration_time_limit_get(void)
2958 {
2959    return _elm_config->thumbscroll_acceleration_time_limit;
2960 }
2961
2962 EAPI void
2963 elm_config_scroll_thumbscroll_acceleration_time_limit_set(double time_limit)
2964 {
2965    _elm_config->thumbscroll_acceleration_time_limit = time_limit;
2966 }
2967
2968 EAPI double
2969 elm_config_scroll_thumbscroll_acceleration_weight_get(void)
2970 {
2971    return _elm_config->thumbscroll_acceleration_weight;
2972 }
2973
2974 EAPI void
2975 elm_config_scroll_thumbscroll_acceleration_weight_set(double weight)
2976 {
2977    _elm_config->thumbscroll_acceleration_weight = weight;
2978 }
2979
2980 EAPI Elm_Focus_Autoscroll_Mode
2981 elm_config_focus_autoscroll_mode_get(void)
2982 {
2983    return _elm_config->focus_autoscroll_mode;
2984 }
2985
2986 EAPI void
2987 elm_config_slider_indicator_visible_mode_set(Elm_Slider_Indicator_Visible_Mode mode)
2988 {
2989    _elm_config->slider_indicator_visible_mode = mode;
2990 }
2991
2992 EAPI Elm_Slider_Indicator_Visible_Mode
2993 elm_config_slider_indicator_visible_mode_get(void)
2994 {
2995     return _elm_config->slider_indicator_visible_mode;
2996 }
2997
2998 EAPI void
2999 elm_config_focus_autoscroll_mode_set(Elm_Focus_Autoscroll_Mode mode)
3000 {
3001    _elm_config->focus_autoscroll_mode = mode;
3002 }
3003
3004 EAPI void
3005 elm_config_longpress_timeout_set(double longpress_timeout)
3006 {
3007    _elm_config->longpress_timeout = longpress_timeout;
3008 }
3009
3010 EAPI double
3011 elm_config_longpress_timeout_get(void)
3012 {
3013    return _elm_config->longpress_timeout;
3014 }
3015
3016 EAPI void
3017 elm_config_softcursor_mode_set(Elm_Softcursor_Mode mode)
3018 {
3019    _elm_config->softcursor_mode = mode;
3020 }
3021
3022 EAPI Elm_Softcursor_Mode
3023 elm_config_softcursor_mode_get(void)
3024 {
3025    return _elm_config->softcursor_mode;
3026 }
3027
3028 EAPI Eina_Bool
3029 elm_config_disable_external_menu_get(void)
3030 {
3031    return _elm_config->disable_external_menu;
3032 }
3033
3034 EAPI void
3035 elm_config_disable_external_menu_set(Eina_Bool disable)
3036 {
3037    _elm_config->disable_external_menu = !!disable;
3038 }
3039
3040 EAPI Eina_Bool
3041 elm_config_clouseau_enabled_get(void)
3042 {
3043    return _elm_config->clouseau_enable;
3044 }
3045
3046 EAPI void
3047 elm_config_clouseau_enabled_set(Eina_Bool enable)
3048 {
3049    _elm_config->clouseau_enable = !!enable;
3050    _elm_clouseau_reload();
3051 }
3052
3053 EAPI double
3054 elm_config_glayer_long_tap_start_timeout_get(void)
3055 {
3056    return _elm_config->glayer_long_tap_start_timeout;
3057 }
3058
3059 EAPI void
3060 elm_config_glayer_long_tap_start_timeout_set(double long_tap_timeout)
3061 {
3062    _elm_config->glayer_long_tap_start_timeout = long_tap_timeout;
3063 }
3064
3065 EAPI double
3066 elm_config_glayer_double_tap_timeout_get(void)
3067 {
3068    return _elm_config->glayer_double_tap_timeout;
3069 }
3070
3071 EAPI void
3072 elm_config_glayer_double_tap_timeout_set(double double_tap_timeout)
3073 {
3074    _elm_config->glayer_double_tap_timeout = double_tap_timeout;
3075 }
3076
3077 EAPI Eina_Bool
3078 elm_config_magnifier_enable_get(void)
3079 {
3080    return _elm_config->magnifier_enable;
3081 }
3082
3083 EAPI void
3084 elm_config_magnifier_enable_set(Eina_Bool enable)
3085 {
3086    _elm_config->magnifier_enable = !!enable;
3087 }
3088
3089 EAPI double
3090 elm_config_magnifier_scale_get(void)
3091 {
3092    return _elm_config->magnifier_scale;
3093 }
3094
3095 EAPI void
3096 elm_config_magnifier_scale_set(double scale)
3097 {
3098    _elm_config->magnifier_scale = scale;
3099 }
3100
3101 EAPI Eina_Bool
3102 elm_config_audio_mute_get(Edje_Channel channel)
3103 {
3104    switch (channel)
3105      {
3106       case EDJE_CHANNEL_EFFECT:
3107         return _elm_config->audio_mute_effect;
3108         break;
3109       case EDJE_CHANNEL_BACKGROUND:
3110         return _elm_config->audio_mute_background;
3111         break;
3112       case EDJE_CHANNEL_MUSIC:
3113         return _elm_config->audio_mute_music;
3114         break;
3115       case EDJE_CHANNEL_FOREGROUND:
3116         return _elm_config->audio_mute_foreground;
3117         break;
3118       case EDJE_CHANNEL_INTERFACE:
3119         return _elm_config->audio_mute_interface;
3120         break;
3121       case EDJE_CHANNEL_INPUT:
3122         return _elm_config->audio_mute_input;
3123         break;
3124       case EDJE_CHANNEL_ALERT:
3125         return _elm_config->audio_mute_alert;
3126         break;
3127       case EDJE_CHANNEL_ALL:
3128         return _elm_config->audio_mute_all;
3129         break;
3130       default:
3131         break;
3132      }
3133    return EINA_FALSE;
3134 }
3135
3136 EAPI void
3137 elm_config_audio_mute_set(Edje_Channel channel, Eina_Bool mute)
3138 {
3139    switch (channel)
3140      {
3141       case EDJE_CHANNEL_EFFECT:
3142         _elm_config->audio_mute_effect = mute;
3143         break;
3144       case EDJE_CHANNEL_BACKGROUND:
3145         _elm_config->audio_mute_background = mute;
3146         break;
3147       case EDJE_CHANNEL_MUSIC:
3148         _elm_config->audio_mute_music = mute;
3149         break;
3150       case EDJE_CHANNEL_FOREGROUND:
3151         _elm_config->audio_mute_foreground = mute;
3152         break;
3153       case EDJE_CHANNEL_INTERFACE:
3154         _elm_config->audio_mute_interface = mute;
3155         break;
3156       case EDJE_CHANNEL_INPUT:
3157         _elm_config->audio_mute_input = mute;
3158         break;
3159       case EDJE_CHANNEL_ALERT:
3160         _elm_config->audio_mute_alert = mute;
3161         break;
3162       case EDJE_CHANNEL_ALL:
3163         _elm_config->audio_mute_all = mute;
3164         break;
3165       default:
3166         break;
3167      }
3168    edje_audio_channel_mute_set(channel, mute);
3169 }
3170
3171 EAPI Eina_Bool
3172 elm_config_window_auto_focus_enable_get(void)
3173 {
3174    return _elm_config->win_auto_focus_enable;
3175 }
3176
3177 EAPI void
3178 elm_config_window_auto_focus_enable_set(Eina_Bool enable)
3179 {
3180    _elm_config->win_auto_focus_enable = enable;
3181 }
3182
3183 EAPI Eina_Bool
3184 elm_config_window_auto_focus_animate_get(void)
3185 {
3186    return _elm_config->win_auto_focus_animate;
3187 }
3188
3189 EAPI void
3190 elm_config_window_auto_focus_animate_set(Eina_Bool enable)
3191 {
3192    _elm_config->win_auto_focus_animate = enable;
3193 }
3194
3195 EAPI void
3196 elm_config_all_flush(void)
3197 {
3198    char buf[4096], buf2[4096];
3199    int ok = 0, ret;
3200    const char *err;
3201    Eet_File *ef;
3202    size_t len;
3203
3204    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "themes/");
3205    if (len + 1 >= sizeof(buf))
3206      return;
3207
3208    ok = ecore_file_mkpath(buf);
3209    if (!ok)
3210      {
3211         ERR("Problem accessing Elementary's user configuration directory: %s",
3212             buf);
3213         return;
3214      }
3215
3216    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "config");
3217    if (len + 1 >= sizeof(buf))
3218      return;
3219
3220    ok = ecore_file_mkpath(buf);
3221    if (!ok)
3222      {
3223         ERR("Problem accessing Elementary's user configuration directory: %s",
3224             buf);
3225         return;
3226      }
3227
3228    if (!_elm_config_profile_save())
3229      return;
3230
3231    buf[len] = '/';
3232    len++;
3233
3234    if (len + sizeof("flush.cfg") >= sizeof(buf) - len)
3235      return;
3236
3237    memcpy(buf + len, "flush.cfg", sizeof("flush.cfg"));
3238    len += sizeof("flush.cfg") - 1;
3239
3240    if (len + sizeof(".tmp") >= sizeof(buf))
3241      return;
3242
3243    memcpy(buf2, buf, len);
3244    memcpy(buf2 + len, ".tmp", sizeof(".tmp"));
3245
3246    ef = eet_open(buf2, EET_FILE_MODE_WRITE);
3247    if (!ef)
3248      return;
3249
3250    ok = eet_data_write(ef, _config_edd, "config", _elm_config, 1);
3251    if (!ok)
3252      goto err;
3253
3254    err = _elm_config_eet_close_error_get(ef, buf2);
3255    if (err)
3256      {
3257         ERR("%s", err);
3258         free((void *)err);
3259         goto err;
3260      }
3261
3262    ret = ecore_file_mv(buf2, buf);
3263    if (!ret)
3264      {
3265         ERR("Error saving Elementary's configuration file");
3266         goto err;
3267      }
3268
3269    ecore_file_unlink(buf2);
3270    return;
3271
3272 err:
3273    ecore_file_unlink(buf2);
3274    return;
3275 }
3276
3277 static void
3278 _translation_init()
3279 {
3280 #ifdef ENABLE_NLS
3281    const char *cur_dom = textdomain(NULL);
3282    const char *trans_comment = gettext("");
3283    const char *msg_locale = setlocale(LC_MESSAGES, NULL);
3284
3285    /* Same concept as what glib does:
3286     * We shouldn't translate if there are no translations for the
3287     * application in the current locale + domain. (Unless locale is
3288     * en_/C where translating only parts of the interface make some
3289     * sense).
3290     */
3291    _elm_config->translate = !(strcmp (cur_dom, "messages") &&
3292          !*trans_comment && strncmp (msg_locale, "en_", 3) &&
3293          strcmp (msg_locale, "C"));
3294    /* Get RTL orientation from system */
3295    if (_elm_config->translate)
3296      {
3297         bindtextdomain(PACKAGE, LOCALE_DIR);
3298         _elm_config->is_mirrored = !strcmp(E_("default:LTR"), "default:RTL");
3299      }
3300
3301 #endif
3302 }
3303
3304 void
3305 _elm_config_init(void)
3306 {
3307    if (!ELM_EVENT_CONFIG_ALL_CHANGED)
3308       ELM_EVENT_CONFIG_ALL_CHANGED = ecore_event_type_new();
3309    _desc_init();
3310    _profile_fetch_from_conf();
3311    _config_load();
3312    _env_get();
3313    ELM_SAFE_FREE(_elm_accel_preference, eina_stringshare_del);
3314    ELM_SAFE_FREE(_elm_gl_preference, eina_stringshare_del);
3315    _translation_init();
3316    _config_apply();
3317    _elm_config_font_overlay_apply();
3318    _elm_config_color_overlay_apply();
3319    _elm_recache();
3320    _elm_clouseau_reload();
3321    _elm_config_key_binding_hash();
3322 }
3323
3324 void
3325 _elm_config_sub_shutdown(void)
3326 {
3327 #ifdef HAVE_ELEMENTARY_X
3328    if (ecore_x_display_get()) ecore_x_shutdown();
3329 #endif
3330    ELM_SAFE_FREE(_eio_monitor, eio_monitor_del);
3331    ELM_SAFE_FREE(_config_change_delay_timer, ecore_timer_del);
3332 }
3333
3334 static Eina_Bool
3335 _config_change_delay_cb(void *data EINA_UNUSED)
3336 {
3337    char buf[PATH_MAX];
3338
3339    _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/flush.cfg");
3340    if (ecore_file_exists(buf)) _config_flush_get();
3341    _config_change_delay_timer = NULL;
3342
3343    return ECORE_CALLBACK_CANCEL;
3344 }
3345
3346 static Eina_Bool
3347 _elm_config_file_monitor_cb(void *data EINA_UNUSED,
3348                             int type EINA_UNUSED,
3349                             void *event)
3350 {
3351    Eio_Monitor_Event *ev = event;
3352
3353    if (ev->monitor != _eio_monitor) return ECORE_CALLBACK_PASS_ON;
3354
3355    ecore_timer_del(_config_change_delay_timer);
3356    _config_change_delay_timer = ecore_timer_add(0.1, _config_change_delay_cb, NULL);
3357
3358    return ECORE_CALLBACK_PASS_ON;
3359 }
3360
3361 void
3362 _elm_config_sub_init(void)
3363 {
3364 #if defined(HAVE_ELEMENTARY_X) || defined(HAVE_ELEMENTARY_WAYLAND)
3365    const char *ev = getenv("ELM_DISPLAY");
3366 #endif
3367
3368 #ifdef HAVE_ELEMENTARY_X
3369    Eina_Bool init_x = EINA_FALSE;
3370    Eina_Bool have_display = !!getenv("DISPLAY");
3371
3372    if (ev) /* If ELM_DISPLAY is specified */
3373      {
3374         if (!strcmp(ev, "x11")) /* and it is X11 */
3375           {
3376              if (!have_display) /* if there is no $DISPLAY */
3377                {
3378                   ERR("$ELM_DISPLAY is set to x11 but $DISPLAY is not set");
3379                   init_x = EINA_FALSE;
3380                }
3381              else /* if there is */
3382                init_x = EINA_TRUE;
3383           }
3384         else /* not X11 */
3385           init_x = EINA_FALSE;
3386      }
3387    else /* ELM_DISPLAY not specified */
3388      {
3389         if (have_display) /* If there is a $DISPLAY */
3390           init_x = EINA_TRUE;
3391         else /* No $DISPLAY */
3392           init_x = EINA_FALSE;
3393      }
3394    if (init_x)
3395      {
3396         ecore_x_init(NULL);
3397      }
3398 #endif
3399 #ifdef HAVE_ELEMENTARY_WAYLAND
3400    Eina_Bool init_wl = EINA_FALSE;
3401    Eina_Bool have_wl_display = !!getenv("WAYLAND_DISPLAY");
3402
3403    if (ev) /* If ELM_DISPLAY is specified */
3404      {
3405         if (!strcmp(ev, "wl")) /* and it is X11 */
3406           {
3407              if (!have_wl_display) /* if there is no $DISPLAY */
3408                {
3409                   ERR("$ELM_DISPLAY is set to wl but $WAYLAND_DISPLAY is not set");
3410                   init_wl = EINA_FALSE;
3411                }
3412              else /* if there is */
3413                init_wl = EINA_TRUE;
3414           }
3415         else /* not wl */
3416           init_wl = EINA_FALSE;
3417      }
3418    else /* ELM_DISPLAY not specified */
3419      {
3420         if (have_wl_display) /* If there is a $WAYLAND_DISPLAY */
3421           init_wl = EINA_TRUE;
3422         else /* No $WAYLAND_DISPLAY */
3423           init_wl = EINA_FALSE;
3424      }
3425    if (init_wl)
3426      {
3427         ecore_wl_init(NULL);
3428      }
3429 #endif
3430    char buf[PATH_MAX];
3431    size_t len;
3432    int ok = 0;
3433
3434    len = _elm_config_user_dir_snprintf(buf, sizeof(buf), "config/");
3435    if (len + 10 >= sizeof(buf)) // the space to add "flush.cfg"
3436      goto end;
3437
3438    ok = ecore_file_mkpath(buf);
3439    if (!ok)
3440      {
3441         ERR("Problem accessing Elementary's user configuration directory: %s",
3442             buf);
3443         goto end;
3444      }
3445
3446    strcat(buf, "flush.cfg");
3447    if (!ecore_file_exists(buf)) elm_config_all_flush();
3448
3449    _eio_monitor = eio_monitor_add(buf);
3450    ecore_event_handler_add(EIO_MONITOR_FILE_MODIFIED, _elm_config_file_monitor_cb, NULL);
3451
3452 end:
3453    _config_sub_apply();
3454 }
3455
3456 void
3457 _elm_config_reload(void)
3458 {
3459    _config_free(_elm_config);
3460    _elm_config = NULL;
3461    _config_load();
3462    _config_apply();
3463    _elm_config_font_overlay_apply();
3464    _elm_config_color_overlay_apply();
3465    _elm_rescale();
3466    _elm_recache();
3467    _elm_clouseau_reload();
3468    _elm_config_key_binding_hash();
3469    ecore_event_add(ELM_EVENT_CONFIG_ALL_CHANGED, NULL, NULL, NULL);
3470 }
3471
3472 void
3473 _elm_config_engine_set(const char *engine)
3474 {
3475    eina_stringshare_replace(&(_elm_config->engine), engine);
3476 }
3477
3478 EAPI const char *
3479 elm_config_preferred_engine_get(void)
3480 {
3481    return _elm_preferred_engine;
3482 }
3483
3484 EAPI void
3485 elm_config_preferred_engine_set(const char *engine)
3486 {
3487    char *d;
3488    if (engine) {
3489 #define ENGINE_COMPARE(name) (!strcmp(name, engine))
3490      if (!(d = getenv("DISPLAY")) && (ENGINE_COMPARE(ELM_SOFTWARE_X11) ||
3491                                       ENGINE_COMPARE(ELM_OPENGL_X11)))
3492         eina_stringshare_replace(&(_elm_preferred_engine), ELM_WAYLAND_EGL);
3493      else
3494         eina_stringshare_replace(&(_elm_preferred_engine), engine);
3495 #undef ENGINE_COMPARE
3496    }
3497    else
3498      {
3499         ELM_SAFE_FREE(_elm_preferred_engine, eina_stringshare_del);
3500      }
3501 }
3502
3503 EAPI const char *
3504 elm_config_accel_preference_get(void)
3505 {
3506    if (_elm_gl_preference) return _elm_gl_preference;
3507    if (_elm_accel_preference) return _elm_accel_preference;
3508    return _elm_config->accel;
3509 }
3510
3511 EAPI void
3512 elm_config_accel_preference_set(const char *pref)
3513 {
3514    if (pref)
3515      {
3516         Eina_Bool is_hw_accel = EINA_FALSE;
3517         unsigned int tokens = 0, i;
3518         char **arr;
3519
3520         /* Accel preference's string has the window surface configuration as a hw accel, depth, stencil and msaa.
3521          * The string format is   "{HW Accel}:depth{value}:stencil{value}:msaa{msaa string}"
3522          * Especially, msaa string is related Evas GL MSAA enum value(low, mid, high)
3523          * so msaa string has four types as msaa, msaa_low, msaa_mid, msaa_high
3524          * For instance, "opengl:depth24:stencil8:msaa_high".
3525          * It means that using hw accelation, window surface depth buffer's size is 24, stencil buffer's size 8 and msaa bits is the highest.
3526          * The other use-case is  "opengl:depth24".
3527          * It measn that using hw accelation, depth buffer size is 24. stencil and msaa are not used.
3528          * The simple case is  "opengl:depth:stencil:msaa".
3529          * It means that depth, stencil and msaa are setted by pre-defined value(depth:24, stencil:8, msaa:low)
3530          */
3531
3532         DBG("accel preference's string: %s",pref);
3533         /* full string */
3534         eina_stringshare_replace(&(_elm_gl_preference), pref);
3535         ELM_SAFE_FREE(_elm_accel_preference, eina_stringshare_del);
3536         ELM_SAFE_FREE(_elm_config->accel, eina_stringshare_del);
3537
3538         /* split GL items (hw accel, gl depth, gl stencil, gl msaa */
3539         arr = eina_str_split_full(pref, ":", 0, &tokens);
3540         for (i = 0; arr && arr[i]; i++)
3541           {
3542              if ((!strcasecmp(arr[i], "gl")) ||
3543                  (!strcasecmp(arr[i], "opengl")) ||
3544                  (!strcasecmp(arr[i], "3d")) ||
3545                  (!strcasecmp(arr[i], "hw")) ||
3546                  (!strcasecmp(arr[i], "accel")) ||
3547                  (!strcasecmp(arr[i], "hardware"))
3548                  )
3549                {
3550                   eina_stringshare_replace(&(_elm_accel_preference), arr[i]);
3551                   eina_stringshare_replace(&(_elm_config->accel), arr[i]);
3552                   is_hw_accel = EINA_TRUE;
3553                }
3554              else if (!strncmp(arr[i], "depth", 5))
3555                {
3556                   char *value_str = arr[i] + 5;
3557                   if ((value_str) && (isdigit(*value_str)))
3558                     _elm_config->gl_depth = atoi(value_str);
3559                   else
3560                     _elm_config->gl_depth = 24;
3561                }
3562              else if (!strncmp(arr[i], "stencil", 7))
3563                {
3564                   char *value_str = arr[i] + 7;
3565                   if ((value_str) && (isdigit(*value_str)))
3566                     _elm_config->gl_stencil = atoi(value_str);
3567                   else
3568                     _elm_config->gl_stencil = 8;
3569                }
3570              else if (!strncmp(arr[i], "msaa_low", 8))
3571                _elm_config->gl_msaa = 1;             // 1 means msaa low
3572              else if (!strncmp(arr[i], "msaa_mid", 8))
3573                _elm_config->gl_msaa = 2;             // 2 means msaa mid
3574              else if (!strncmp(arr[i], "msaa_high", 9))
3575                _elm_config->gl_msaa = 4;             // 4 means msaa high
3576              else if (!strncmp(arr[i], "msaa", 4))
3577                _elm_config->gl_msaa = 1;            // 1 means msaa low
3578           }
3579
3580         DBG("accel: %s", _elm_accel_preference);
3581         DBG("gl depth: %d", _elm_config->gl_depth);
3582         DBG("gl stencil: %d", _elm_config->gl_stencil);
3583         DBG("gl msaa: %d", _elm_config->gl_msaa);
3584         free(arr[0]);
3585         free(arr);
3586
3587         if (is_hw_accel == EINA_FALSE)
3588           {
3589              ELM_SAFE_FREE(_elm_accel_preference, eina_stringshare_del);
3590              ELM_SAFE_FREE(_elm_config->accel, eina_stringshare_del);
3591           }
3592      }
3593    else
3594      {
3595         ELM_SAFE_FREE(_elm_gl_preference, eina_stringshare_del);
3596         ELM_SAFE_FREE(_elm_accel_preference, eina_stringshare_del);
3597         ELM_SAFE_FREE(_elm_config->accel, eina_stringshare_del);
3598      }
3599 }
3600
3601 EAPI const char *
3602 elm_config_indicator_service_get(int rotation)
3603 {
3604    switch (rotation)
3605      {
3606       case 0:
3607         return _elm_config->indicator_service_0;
3608       case 90:
3609         return _elm_config->indicator_service_90;
3610       case 180:
3611         return _elm_config->indicator_service_180;
3612       case 270:
3613         return _elm_config->indicator_service_270;
3614       default:
3615         return NULL;
3616      }
3617 }
3618
3619 EAPI void
3620 elm_config_transition_duration_factor_set(double factor)
3621 {
3622     if (factor < 0.0) return;
3623     if (_elm_config->transition_duration_factor == factor) return;
3624     _elm_config->transition_duration_factor = factor;
3625     edje_transition_duration_factor_set(_elm_config->transition_duration_factor);
3626 }
3627
3628
3629 EAPI double
3630 elm_config_transition_duration_factor_get(void)
3631 {
3632     return _elm_config->transition_duration_factor;
3633 }
3634
3635 void
3636 _elm_config_profile_set(const char *profile)
3637 {
3638    if (!profile) return;
3639
3640    if (_elm_profile)
3641      {
3642         if (!strcmp(_elm_profile, profile))
3643           return;
3644
3645         free(_elm_profile);
3646      }
3647
3648    _elm_profile = strdup(profile);
3649
3650    _color_overlays_cancel();
3651    _config_free(_elm_config);
3652    _elm_config = NULL;
3653    _config_load();
3654    _config_apply();
3655    _elm_config_font_overlay_apply();
3656    _elm_config_color_overlay_apply();
3657    _elm_rescale();
3658    _elm_recache();
3659    _elm_clouseau_reload();
3660    _elm_config_key_binding_hash();
3661 }
3662
3663 void
3664 _elm_config_shutdown(void)
3665 {
3666    ELM_SAFE_FREE(_elm_config, _config_free);
3667    ELM_SAFE_FREE(_elm_preferred_engine, eina_stringshare_del);
3668    ELM_SAFE_FREE(_elm_accel_preference, eina_stringshare_del);
3669    ELM_SAFE_FREE(_elm_profile, free);
3670    _elm_font_overlays_del_free();
3671
3672    _desc_shutdown();
3673
3674    ELM_SAFE_FREE(_elm_key_bindings, eina_hash_free);
3675 }
3676
3677 /*
3678  * Add backwards compatability implementation for elm_scale_get/set and elm_finger_size_get/set
3679  * to allow running unmodified Tizen applications on a new drop of elementary
3680  */
3681
3682 EAPI double
3683 elm_scale_get(void)
3684 {
3685    return elm_config_scale_get();
3686 }
3687
3688 EAPI void
3689 elm_scale_set(double scale)
3690 {
3691    elm_config_scale_set(scale);
3692 }
3693
3694 EAPI Evas_Coord
3695 elm_finger_size_get(void)
3696 {
3697    return elm_config_finger_size_get();
3698 }
3699
3700 EAPI void
3701 elm_finger_size_set(Evas_Coord size)
3702 {
3703    elm_config_finger_size_set(size);
3704 }