src/bin/config.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4 #include <Elementary.h>
   5
   6 typedef struct _Theme               Theme;
   7 typedef struct _Fonts_Data          Fonts_Data;
   8 typedef struct _Elm_Text_Class_Data Elm_Text_Class_Data;
   9 typedef struct _Elm_Font_Size_Data  Elm_Font_Size_Data;
  10
  11 struct _Theme
  12 {
  13    const char *label;
  14    const char *name;
  15    const char *path;
  16    Eina_Bool   in_search_path;
  17 };
  18
  19 static const Eina_List *tsel = NULL;
  20 static Eina_List *themes = NULL;
  21
  22 struct _Elm_Text_Class_Data
  23 {
  24    const char    *name;
  25    const char    *desc;
  26    const char    *font;
  27    const char    *style;
  28    Evas_Font_Size size;
  29 };
  30
  31 struct _Elm_Font_Size_Data
  32 {
  33    const char    *size_str;
  34    Evas_Font_Size size;
  35 };
  36
  37 struct _Fonts_Data
  38 {
  39    Eina_List  *text_classes;
  40
  41    Eina_Hash  *font_hash;
  42    Eina_List  *font_px_list;
  43    Eina_List  *font_scale_list;
  44
  45    const char *cur_font;
  46    const char *cur_style;
  47    double      cur_size;
  48 };
  49
  50 #define ELM_LIST_DISABLE(list)                         \
  51   do                                                   \
  52     {                                                  \
  53        const Eina_List *_l = elm_list_items_get(list); \
  54        if (_l)                                         \
  55          {                                             \
  56             elm_list_item_show(eina_list_data_get(_l));\
  57             elm_object_disabled_set(list, EINA_TRUE);  \
  58          }                                             \
  59     }                                                  \
  60   while (0)
  61
  62 #define ELM_LIST_ENABLE(list)                     \
  63   do                                              \
  64     {                                             \
  65        elm_object_disabled_set(list, EINA_FALSE); \
  66     }                                             \
  67   while (0)
  68
  69 #define LABEL_FRAME_ADD(label)                                      \
  70   do                                                                \
  71     {                                                               \
  72        pd = elm_frame_add(win);                                     \
  73        evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0); \
  74        evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, 0.5);    \
  75        elm_object_style_set(pd, "pad_medium");                      \
  76        elm_box_pack_end(bx, pd);                                    \
  77        evas_object_show(pd);                                        \
  78                                                                     \
  79        lb = elm_label_add(win);                                     \
  80        evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.0); \
  81        evas_object_size_hint_align_set(lb, EVAS_HINT_FILL, 0.5);    \
  82        elm_object_text_set(lb, label);                              \
  83        elm_object_content_set(pd, lb);                              \
  84        evas_object_show(lb);                                        \
  85     }                                                               \
  86   while (0)
  87
  88 static int quiet = 0;
  89 static int interactive = 1;
  90
  91 static const char *theme_set = NULL;
  92 static const char *finger_size_set = NULL;
  93 static const char *scale_set = NULL;
  94 static Fonts_Data fndata = {NULL, NULL, NULL, NULL, NULL, NULL, 0.0};
  95
  96 static void
  97 _font_styles_list_sel(void *data   EINA_UNUSED,
  98                       Evas_Object *obj,
  99                       void        *event_info);
 100
 101 static void
 102 config_exit(void *data       EINA_UNUSED,
 103             Evas_Object *obj EINA_UNUSED,
 104             void *event_info EINA_UNUSED)
 105 {
 106    Elm_Text_Class_Data *tc_data;
 107    Elm_Font_Size_Data *sd;
 108
 109    EINA_LIST_FREE(fndata.text_classes, tc_data)
 110      {
 111         eina_stringshare_del(tc_data->name);
 112         eina_stringshare_del(tc_data->desc);
 113         eina_stringshare_del(tc_data->font);
 114         eina_stringshare_del(tc_data->style);
 115         free(tc_data);
 116      }
 117
 118    elm_font_available_hash_del(fndata.font_hash);
 119    fndata.font_hash = NULL;
 120
 121    EINA_LIST_FREE(fndata.font_px_list, sd)
 122      {
 123         eina_stringshare_del(sd->size_str);
 124         free(sd);
 125      }
 126
 127    EINA_LIST_FREE(fndata.font_scale_list, sd)
 128      {
 129         eina_stringshare_del(sd->size_str);
 130         free(sd);
 131      }
 132
 133    if (fndata.cur_font) eina_stringshare_del(fndata.cur_font);
 134    fndata.cur_font = NULL;
 135
 136    if (fndata.cur_style) eina_stringshare_del(fndata.cur_style);
 137    fndata.cur_style = NULL;
 138
 139    elm_config_save();
 140    elm_exit(); /* exit the program's main loop that runs in elm_run() */
 141 }
 142
 143 static void
 144 sb_change(void *data       EINA_UNUSED,
 145           Evas_Object     *obj,
 146           void *event_info EINA_UNUSED)
 147 {
 148    Eina_Bool val = elm_check_state_get(obj);
 149    Eina_Bool sb = elm_config_scroll_bounce_enabled_get();
 150
 151    if (val == sb) return;
 152    elm_config_scroll_bounce_enabled_set(val);
 153    elm_config_all_flush();
 154
 155    /*TODO: enable/disable subordinate sliders (make 'em support it 1st)*/
 156 }
 157
 158 static void
 159 bf_round(void *data       EINA_UNUSED,
 160          Evas_Object     *obj,
 161          void *event_info EINA_UNUSED)
 162 {
 163    double val = elm_slider_value_get(obj);
 164    double v;
 165
 166    v = ((double)((int)(val * 10.0))) / 10.0;
 167    if (v != val) elm_slider_value_set(obj, v);
 168 }
 169
 170 static void
 171 bf_change(void *data       EINA_UNUSED,
 172           Evas_Object     *obj,
 173           void *event_info EINA_UNUSED)
 174 {
 175    double bf = elm_config_scroll_bounce_friction_get();
 176    double val = elm_slider_value_get(obj);
 177
 178    if (bf == val) return;
 179    elm_config_scroll_bounce_friction_set(val);
 180    elm_config_all_flush();
 181 }
 182
 183 static void
 184 ps_round(void *data       EINA_UNUSED,
 185          Evas_Object     *obj,
 186          void *event_info EINA_UNUSED)
 187 {
 188    double val = elm_slider_value_get(obj);
 189    double v;
 190
 191    v = ((double)((int)(val * 10.0))) / 10.0;
 192    if (v != val) elm_slider_value_set(obj, v);
 193 }
 194
 195 static void
 196 ps_change(void *data       EINA_UNUSED,
 197           Evas_Object     *obj,
 198           void *event_info EINA_UNUSED)
 199 {
 200    double ps = elm_config_scroll_page_scroll_friction_get();
 201    double val = elm_slider_value_get(obj);
 202
 203    if (ps == val) return;
 204    elm_config_scroll_page_scroll_friction_set(val);
 205    elm_config_all_flush();
 206 }
 207
 208 static void
 209 bis_round(void *data       EINA_UNUSED,
 210           Evas_Object     *obj,
 211           void *event_info EINA_UNUSED)
 212 {
 213    double val = elm_slider_value_get(obj);
 214    double v;
 215
 216    v = ((double)((int)(val * 10.0))) / 10.0;
 217    if (v != val) elm_slider_value_set(obj, v);
 218 }
 219
 220 static void
 221 bis_change(void *data       EINA_UNUSED,
 222            Evas_Object     *obj,
 223            void *event_info EINA_UNUSED)
 224 {
 225    double bis = elm_config_scroll_bring_in_scroll_friction_get();
 226    double val = elm_slider_value_get(obj);
 227
 228    if (bis == val) return;
 229    elm_config_scroll_bring_in_scroll_friction_set(val);
 230    elm_config_all_flush();
 231 }
 232
 233 static void
 234 zf_round(void *data       EINA_UNUSED,
 235          Evas_Object     *obj,
 236          void *event_info EINA_UNUSED)
 237 {
 238    double val = elm_slider_value_get(obj);
 239    double v;
 240
 241    v = ((double)((int)(val * 10.0))) / 10.0;
 242    if (v != val) elm_slider_value_set(obj, v);
 243 }
 244
 245 static void
 246 zf_change(void *data       EINA_UNUSED,
 247           Evas_Object     *obj,
 248           void *event_info EINA_UNUSED)
 249 {
 250    double zf = elm_config_scroll_zoom_friction_get();
 251    double val = elm_slider_value_get(obj);
 252
 253    if (zf == val) return;
 254    elm_config_scroll_zoom_friction_set(val);
 255    elm_config_all_flush();
 256 }
 257
 258 static void
 259 ts_change(void *data       EINA_UNUSED,
 260           Evas_Object     *obj,
 261           void *event_info EINA_UNUSED)
 262 {
 263    Eina_Bool val = elm_check_state_get(obj);
 264    Eina_Bool sb = elm_config_scroll_thumbscroll_enabled_get();
 265
 266    if (val == sb) return;
 267    elm_config_scroll_thumbscroll_enabled_set(val);
 268    elm_config_all_flush();
 269
 270    /*TODO: enable/disable subordinate sliders (make 'em support it 1st)*/
 271 }
 272
 273 static void
 274 tst_round(void *data       EINA_UNUSED,
 275           Evas_Object     *obj,
 276           void *event_info EINA_UNUSED)
 277 {
 278    double val = elm_slider_value_get(obj);
 279    double v;
 280
 281    v = ((double)((int)(val * 10.0))) / 10.0;
 282    if (v != val) elm_slider_value_set(obj, v);
 283 }
 284
 285 static void
 286 tst_change(void *data       EINA_UNUSED,
 287            Evas_Object     *obj,
 288            void *event_info EINA_UNUSED)
 289 {
 290    double tst = elm_config_scroll_thumbscroll_threshold_get();
 291    double val = elm_slider_value_get(obj);
 292
 293    if (tst == val) return;
 294    elm_config_scroll_thumbscroll_threshold_set(val);
 295    elm_config_all_flush();
 296 }
 297
 298 static void
 299 tsht_round(void *data       EINA_UNUSED,
 300           Evas_Object     *obj,
 301           void *event_info EINA_UNUSED)
 302 {
 303    double val = elm_slider_value_get(obj);
 304    double v;
 305
 306    v = ((double)((int)(val * 10.0))) / 10.0;
 307    if (v != val) elm_slider_value_set(obj, v);
 308 }
 309
 310 static void
 311 tsht_change(void *data       EINA_UNUSED,
 312            Evas_Object     *obj,
 313            void *event_info EINA_UNUSED)
 314 {
 315    double tst = elm_config_scroll_thumbscroll_hold_threshold_get();
 316    double val = elm_slider_value_get(obj);
 317
 318    if (tst == val) return;
 319    elm_config_scroll_thumbscroll_hold_threshold_set(val);
 320    elm_config_all_flush();
 321 }
 322
 323 static void
 324 tsmt_round(void *data       EINA_UNUSED,
 325            Evas_Object     *obj,
 326            void *event_info EINA_UNUSED)
 327 {
 328    double val = elm_slider_value_get(obj);
 329    double v;
 330
 331    v = ((double)((int)(val * 10.0))) / 10.0;
 332    if (v != val) elm_slider_value_set(obj, v);
 333 }
 334
 335 static void
 336 tsmt_change(void *data       EINA_UNUSED,
 337             Evas_Object     *obj,
 338             void *event_info EINA_UNUSED)
 339 {
 340    double tsmt = elm_config_scroll_thumbscroll_momentum_threshold_get();
 341    double val = elm_slider_value_get(obj);
 342
 343    if (tsmt == val) return;
 344    elm_config_scroll_thumbscroll_momentum_threshold_set(val);
 345    elm_config_all_flush();
 346 }
 347
 348 static void
 349 tsfdt_round(void *data       EINA_UNUSED,
 350             Evas_Object     *obj,
 351             void *event_info EINA_UNUSED)
 352 {
 353    double val = elm_slider_value_get(obj);
 354    double v;
 355
 356    v = ((double)((int)(val * 10.0))) / 10.0;
 357    if (v != val) elm_slider_value_set(obj, v);
 358 }
 359
 360 static void
 361 tsfdt_change(void *data       EINA_UNUSED,
 362              Evas_Object     *obj,
 363              void *event_info EINA_UNUSED)
 364 {
 365    double tsfdt = elm_config_scroll_thumbscroll_flick_distance_tolerance_get();
 366    double val = elm_slider_value_get(obj);
 367
 368    if (tsfdt == val) return;
 369    elm_config_scroll_thumbscroll_flick_distance_tolerance_set(val);
 370    elm_config_all_flush();
 371 }
 372
 373 static void
 374 tsf_round(void *data       EINA_UNUSED,
 375           Evas_Object     *obj,
 376           void *event_info EINA_UNUSED)
 377 {
 378    double val = elm_slider_value_get(obj);
 379    double v;
 380
 381    v = ((double)((int)(val * 10.0))) / 10.0;
 382    if (v != val) elm_slider_value_set(obj, v);
 383 }
 384
 385 static void
 386 tsf_change(void *data       EINA_UNUSED,
 387            Evas_Object     *obj,
 388            void *event_info EINA_UNUSED)
 389 {
 390    double tsf = elm_config_scroll_thumbscroll_friction_get();
 391    double val = elm_slider_value_get(obj);
 392
 393    if (tsf == val) return;
 394    elm_config_scroll_thumbscroll_friction_set(val);
 395    elm_config_all_flush();
 396 }
 397
 398 static void
 399 tsmf_round(void *data       EINA_UNUSED,
 400            Evas_Object     *obj,
 401            void *event_info EINA_UNUSED)
 402 {
 403    double val = elm_slider_value_get(obj);
 404    double v;
 405
 406    v = ((double)((int)(val * 10.0))) / 10.0;
 407    if (v != val) elm_slider_value_set(obj, v);
 408 }
 409
 410 static void
 411 tsmf_change(void *data       EINA_UNUSED,
 412             Evas_Object     *obj,
 413             void *event_info EINA_UNUSED)
 414 {
 415    double tsmf = elm_config_scroll_thumbscroll_min_friction_get();
 416    double val = elm_slider_value_get(obj);
 417
 418    if (tsmf == val) return;
 419    elm_config_scroll_thumbscroll_min_friction_set(val);
 420    elm_config_all_flush();
 421 }
 422
 423 static void
 424 tsfs_round(void *data       EINA_UNUSED,
 425            Evas_Object     *obj,
 426            void *event_info EINA_UNUSED)
 427 {
 428    double val = elm_slider_value_get(obj);
 429    double v;
 430
 431    v = ((double)((int)(val * 10.0))) / 10.0;
 432    if (v != val) elm_slider_value_set(obj, v);
 433 }
 434
 435 static void
 436 tsfs_change(void *data       EINA_UNUSED,
 437             Evas_Object     *obj,
 438             void *event_info EINA_UNUSED)
 439 {
 440    double tsfs = elm_config_scroll_thumbscroll_friction_standard_get();
 441    double val = elm_slider_value_get(obj);
 442
 443    if (tsfs == val) return;
 444    elm_config_scroll_thumbscroll_friction_standard_set(val);
 445    elm_config_all_flush();
 446 }
 447
 448 static void
 449 tsbf_round(void *data       EINA_UNUSED,
 450            Evas_Object     *obj,
 451            void *event_info EINA_UNUSED)
 452 {
 453    double val = elm_slider_value_get(obj);
 454    double v;
 455
 456    v = ((double)((int)(val * 10.0))) / 10.0;
 457    if (v != val) elm_slider_value_set(obj, v);
 458 }
 459
 460 static void
 461 tsbf_change(void *data       EINA_UNUSED,
 462             Evas_Object     *obj,
 463             void *event_info EINA_UNUSED)
 464 {
 465    double tsbf = elm_config_scroll_thumbscroll_border_friction_get();
 466    double val = elm_slider_value_get(obj);
 467
 468    if (tsbf == val) return;
 469    elm_config_scroll_thumbscroll_border_friction_set(val);
 470    elm_config_all_flush();
 471 }
 472
 473 static void
 474 tssf_round(void *data       EINA_UNUSED,
 475            Evas_Object     *obj,
 476            void *event_info EINA_UNUSED)
 477 {
 478    double val = elm_slider_value_get(obj);
 479    double v;
 480
 481    v = ((double)((int)(val * 20.0))) / 20.0;
 482    if (v != val) elm_slider_value_set(obj, v);
 483 }
 484
 485 static void
 486 tssf_change(void *data       EINA_UNUSED,
 487             Evas_Object     *obj,
 488             void *event_info EINA_UNUSED)
 489 {
 490    double tssf = elm_config_scroll_thumbscroll_sensitivity_friction_get();
 491    double val = elm_slider_value_get(obj);
 492
 493    if (tssf == val) return;
 494    elm_config_scroll_thumbscroll_sensitivity_friction_set(val);
 495    elm_config_all_flush();
 496 }
 497
 498 static void
 499 tsat_round(void *data       EINA_UNUSED,
 500            Evas_Object     *obj,
 501            void *event_info EINA_UNUSED)
 502 {
 503    double val = elm_slider_value_get(obj);
 504    double v;
 505
 506    v = ((double)((int)(val * 10.0))) / 10.0;
 507    if (v != val) elm_slider_value_set(obj, v);
 508 }
 509
 510 static void
 511 tsat_change(void *data       EINA_UNUSED,
 512             Evas_Object     *obj,
 513             void *event_info EINA_UNUSED)
 514 {
 515    double tsat = elm_config_scroll_thumbscroll_acceleration_threshold_get();
 516    double val = elm_slider_value_get(obj);
 517
 518    if (tsat == val) return;
 519    elm_config_scroll_thumbscroll_acceleration_threshold_set(val);
 520    elm_config_all_flush();
 521 }
 522
 523 static void
 524 tsatl_round(void *data       EINA_UNUSED,
 525            Evas_Object     *obj,
 526            void *event_info EINA_UNUSED)
 527 {
 528    double val = elm_slider_value_get(obj);
 529    double v;
 530
 531    v = ((double)((int)(val * 10.0))) / 10.0;
 532    if (v != val) elm_slider_value_set(obj, v);
 533 }
 534
 535 static void
 536 tsatl_change(void *data       EINA_UNUSED,
 537             Evas_Object     *obj,
 538             void *event_info EINA_UNUSED)
 539 {
 540    double tsatl = elm_config_scroll_thumbscroll_acceleration_time_limit_get();
 541    double val = elm_slider_value_get(obj);
 542
 543    if (tsatl == val) return;
 544    elm_config_scroll_thumbscroll_acceleration_time_limit_set(val);
 545    elm_config_all_flush();
 546 }
 547
 548 static void
 549 tsaw_round(void *data       EINA_UNUSED,
 550            Evas_Object     *obj,
 551            void *event_info EINA_UNUSED)
 552 {
 553    double val = elm_slider_value_get(obj);
 554    double v;
 555
 556    v = ((double)((int)(val * 10.0))) / 10.0;
 557    if (v != val) elm_slider_value_set(obj, v);
 558 }
 559
 560 static void
 561 tsaw_change(void *data       EINA_UNUSED,
 562             Evas_Object     *obj,
 563             void *event_info EINA_UNUSED)
 564 {
 565    double tsaw = elm_config_scroll_thumbscroll_acceleration_weight_get();
 566    double val = elm_slider_value_get(obj);
 567
 568    if (tsaw == val) return;
 569    elm_config_scroll_thumbscroll_acceleration_weight_set(val);
 570    elm_config_all_flush();
 571 }
 572
 573 static void
 574 cf_enable(void *data,
 575           Evas_Object     *obj,
 576           void *event_info EINA_UNUSED)
 577 {
 578    Eina_Bool cf = elm_config_cache_flush_enabled_get();
 579    Eina_Bool val = elm_check_state_get(obj);
 580
 581    if (cf == val) return;
 582    elm_object_disabled_set((Evas_Object *)data, !val);
 583    elm_config_cache_flush_enabled_set(val);
 584    elm_config_all_flush();
 585 }
 586
 587 static void
 588 cf_round(void *data       EINA_UNUSED,
 589          Evas_Object     *obj,
 590          void *event_info EINA_UNUSED)
 591 {
 592    double val = elm_slider_value_get(obj);
 593    double v;
 594
 595    v = ((double)((int)(val * 5.0))) / 5.0;
 596    if (v != val) elm_slider_value_set(obj, v);
 597 }
 598
 599 static void
 600 cf_change(void *data       EINA_UNUSED,
 601           Evas_Object     *obj,
 602           void *event_info EINA_UNUSED)
 603 {
 604    double cf = elm_config_cache_flush_interval_get();
 605    double val = elm_slider_value_get(obj);
 606
 607    if (cf == val) return;
 608    elm_config_cache_flush_interval_set(val);
 609    elm_config_all_flush();
 610 }
 611
 612 static void
 613 fc_round(void *data       EINA_UNUSED,
 614          Evas_Object     *obj,
 615          void *event_info EINA_UNUSED)
 616 {
 617    double val = elm_slider_value_get(obj);
 618    double v;
 619
 620    v = ((double)((int)(val * 10.0))) / 10.0;
 621    if (v != val) elm_slider_value_set(obj, v);
 622 }
 623
 624 static void
 625 fc_change(void *data       EINA_UNUSED,
 626           Evas_Object     *obj,
 627           void *event_info EINA_UNUSED)
 628 {
 629    double font_cache = elm_config_cache_font_cache_size_get();
 630    double val = elm_slider_value_get(obj);
 631
 632    if (font_cache == val) return;
 633    elm_config_cache_font_cache_size_set(val * 1024);
 634    elm_config_all_flush();
 635 }
 636
 637 static void
 638 ic_round(void *data       EINA_UNUSED,
 639          Evas_Object     *obj,
 640          void *event_info EINA_UNUSED)
 641 {
 642    double val = elm_slider_value_get(obj);
 643    double v;
 644
 645    v = ((double)((int)(val * 10.0))) / 10.0;
 646    if (v != val) elm_slider_value_set(obj, v);
 647 }
 648
 649 static void
 650 ic_change(void *data       EINA_UNUSED,
 651           Evas_Object     *obj,
 652           void *event_info EINA_UNUSED)
 653 {
 654    double image_cache = elm_config_cache_image_cache_size_get();
 655    double val = elm_slider_value_get(obj);
 656
 657    if (image_cache == val) return;
 658    elm_config_cache_image_cache_size_set(val * 1024);
 659    elm_config_all_flush();
 660 }
 661
 662 static void
 663 sc_round(void *data       EINA_UNUSED,
 664          Evas_Object     *obj,
 665          void *event_info EINA_UNUSED)
 666 {
 667    double val = elm_slider_value_get(obj);
 668    double v;
 669
 670    v = ((double)((int)(val * 10.0))) / 10.0;
 671    if (v != val) elm_slider_value_set(obj, v);
 672 }
 673
 674 static void
 675 sc_change(void *data       EINA_UNUSED,
 676           Evas_Object     *obj,
 677           void *event_info EINA_UNUSED)
 678 {
 679    double scale = elm_config_scale_get();
 680    double val = elm_slider_value_get(obj);
 681
 682    if (scale == val) return;
 683    elm_config_scale_set(val);
 684    elm_config_all_flush();
 685 }
 686
 687 static void
 688 fs_round(void *data       EINA_UNUSED,
 689          Evas_Object     *obj,
 690          void *event_info EINA_UNUSED)
 691 {
 692    double val = elm_slider_value_get(obj);
 693    double v;
 694
 695    v = ((double)((int)(val * 5.0))) / 5.0;
 696    if (v != val) elm_slider_value_set(obj, v);
 697 }
 698
 699 static void
 700 fs_change(void *data       EINA_UNUSED,
 701           Evas_Object     *obj,
 702           void *event_info EINA_UNUSED)
 703 {
 704    double fs = elm_config_finger_size_get();
 705    double val = elm_slider_value_get(obj);
 706
 707    if (fs == val) return;
 708    elm_config_finger_size_set(val);
 709    elm_config_all_flush();
 710 }
 711
 712 static void
 713 efc_round(void *data       EINA_UNUSED,
 714           Evas_Object     *obj,
 715           void *event_info EINA_UNUSED)
 716 {
 717    double val = elm_slider_value_get(obj);
 718    double v;
 719
 720    v = ((double)((int)(val * 5.0))) / 5.0;
 721    if (v != val) elm_slider_value_set(obj, v);
 722 }
 723
 724 static void
 725 efc_change(void *data       EINA_UNUSED,
 726            Evas_Object     *obj,
 727            void *event_info EINA_UNUSED)
 728 {
 729    double efc = elm_config_cache_edje_file_cache_size_get();
 730    double val = elm_slider_value_get(obj);
 731
 732    if (efc == val) return;
 733    elm_config_cache_edje_file_cache_size_set(val);
 734    elm_config_all_flush();
 735 }
 736
 737 static void
 738 ecc_round(void *data       EINA_UNUSED,
 739           Evas_Object     *obj,
 740           void *event_info EINA_UNUSED)
 741 {
 742    double val = elm_slider_value_get(obj);
 743    double v;
 744
 745    v = ((double)((int)(val * 5.0))) / 5.0;
 746    if (v != val) elm_slider_value_set(obj, v);
 747 }
 748
 749 static void
 750 ecc_change(void *data       EINA_UNUSED,
 751            Evas_Object     *obj,
 752            void *event_info EINA_UNUSED)
 753 {
 754    double ecc = elm_config_cache_edje_collection_cache_size_get();
 755    double val = elm_slider_value_get(obj);
 756
 757    if (ecc == val) return;
 758    elm_config_cache_edje_collection_cache_size_set(val);
 759    elm_config_all_flush();
 760 }
 761
 762 static void
 763 ac_change(void *data       EINA_UNUSED,
 764           Evas_Object     *obj,
 765           void *event_info EINA_UNUSED)
 766 {
 767    Eina_Bool val = elm_check_state_get(obj);
 768    Eina_Bool ac = elm_config_access_get();
 769
 770    if (val == ac) return;
 771    elm_config_access_set(val);
 772    elm_config_all_flush();
 773 }
 774
 775 static void
 776 sel_change(void *data       EINA_UNUSED,
 777           Evas_Object     *obj,
 778           void *event_info EINA_UNUSED)
 779 {
 780    Eina_Bool val = elm_check_state_get(obj);
 781    Eina_Bool sel = elm_config_selection_unfocused_clear_get();
 782
 783    if (val == sel) return;
 784    elm_config_selection_unfocused_clear_set(val);
 785    elm_config_all_flush();
 786    elm_config_save();
 787 }
 788
 789 static void
 790 dbg_change(void *data       EINA_UNUSED,
 791           Evas_Object     *obj,
 792           void *event_info EINA_UNUSED)
 793 {
 794    Eina_Bool val = elm_check_state_get(obj);
 795    Eina_Bool sel = elm_config_clouseau_enabled_get();
 796
 797    if (val == sel) return;
 798    elm_config_clouseau_enabled_set(val);
 799    elm_config_all_flush();
 800    elm_config_save();
 801 }
 802
 803 static void
 804 _status_basic(Evas_Object *win,
 805               Evas_Object *bx0)
 806 {
 807    Evas_Object *lb, *fr;
 808
 809    fr = elm_frame_add(win);
 810    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 811    elm_object_text_set(fr, "Information");
 812    elm_box_pack_end(bx0, fr);
 813    evas_object_show(fr);
 814
 815    lb = elm_label_add(win);
 816    elm_object_text_set(lb,
 817                        "Applying configuration change"
 818                        );
 819    elm_object_content_set(fr, lb);
 820    evas_object_show(lb);
 821 }
 822
 823 static void
 824 _status_config(Evas_Object *win,
 825                Evas_Object *bx0)
 826 {
 827    Evas_Object *lb, *pd, *bx, *fr, *sl, *sp;
 828
 829    fr = elm_frame_add(win);
 830    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 831    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
 832    elm_object_text_set(fr, "Sizing");
 833    elm_box_pack_end(bx0, fr);
 834    evas_object_show(fr);
 835
 836    bx = elm_box_add(win);
 837    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
 838    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
 839
 840    LABEL_FRAME_ADD("<hilight>Scale</>");
 841
 842    sl = elm_slider_add(win);
 843    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
 844    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
 845    elm_slider_span_size_set(sl, 120);
 846    elm_slider_unit_format_set(sl, "%1.2f");
 847    elm_slider_indicator_format_set(sl, "%1.2f");
 848    elm_slider_min_max_set(sl, 0.25, 5.0);
 849    elm_slider_value_set(sl, elm_config_scale_get());
 850    elm_box_pack_end(bx, sl);
 851    evas_object_show(sl);
 852
 853    evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
 854    evas_object_smart_callback_add(sl, "delay,changed", sc_change, NULL);
 855
 856    sp = elm_separator_add(win);
 857    elm_separator_horizontal_set(sp, EINA_TRUE);
 858    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
 859    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
 860    elm_box_pack_end(bx, sp);
 861    evas_object_show(sp);
 862
 863    LABEL_FRAME_ADD("<hilight>Finger Size</><br/>");
 864
 865    sl = elm_slider_add(win);
 866    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
 867    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
 868    elm_slider_span_size_set(sl, 120);
 869    elm_slider_unit_format_set(sl, "%1.0f");
 870    elm_slider_indicator_format_set(sl, "%1.0f");
 871    elm_slider_min_max_set(sl, 5, 200);
 872    elm_slider_value_set(sl, elm_config_finger_size_get());
 873    elm_box_pack_end(bx, sl);
 874    evas_object_show(sl);
 875
 876    evas_object_smart_callback_add(sl, "changed", fs_round, NULL);
 877    evas_object_smart_callback_add(sl, "delay,changed", fs_change, NULL);
 878
 879    // FIXME: add theme selector (basic mode and advanced for fallbacks)
 880    // FIXME: save config
 881    // FIXME: profile selector / creator etc.
 882    elm_object_content_set(fr, bx);
 883    evas_object_show(bx);
 884 }
 885
 886 static void
 887 _flip_to(Evas_Object *win,
 888          const char  *name)
 889 {
 890    Evas_Object *wid, *naviframe;
 891    wid = evas_object_data_get(win, name);
 892    naviframe = evas_object_data_get(win, "naviframe");
 893    if (!naviframe) return;
 894    elm_naviframe_item_simple_promote(naviframe, wid);
 895 }
 896
 897 static void
 898 _cf_sizing(void            *data,
 899            Evas_Object *obj EINA_UNUSED,
 900            void *event_info EINA_UNUSED)
 901 {
 902    _flip_to(data, "sizing");
 903 }
 904
 905 static void
 906 _cf_themes(void            *data,
 907            Evas_Object *obj EINA_UNUSED,
 908            void *event_info EINA_UNUSED)
 909 {
 910    _flip_to(data, "themes");
 911 }
 912
 913 static void
 914 _cf_fonts(void            *data,
 915           Evas_Object *obj EINA_UNUSED,
 916           void *event_info EINA_UNUSED)
 917 {
 918    _flip_to(data, "fonts");
 919 }
 920
 921 static void
 922 _cf_profiles(void            *data,
 923              Evas_Object *obj EINA_UNUSED,
 924              void *event_info EINA_UNUSED)
 925 {
 926    _flip_to(data, "profiles");
 927 }
 928
 929 static void
 930 _cf_scrolling(void            *data,
 931               Evas_Object *obj EINA_UNUSED,
 932               void *event_info EINA_UNUSED)
 933 {
 934    _flip_to(data, "scrolling");
 935 }
 936
 937 static void
 938 _cf_rendering(void            *data,
 939               Evas_Object *obj EINA_UNUSED,
 940               void *event_info EINA_UNUSED)
 941 {
 942    _flip_to(data, "rendering");
 943 }
 944
 945 static void
 946 _cf_caches(void            *data,
 947            Evas_Object *obj EINA_UNUSED,
 948            void *event_info EINA_UNUSED)
 949 {
 950    _flip_to(data, "caches");
 951 }
 952
 953 static void
 954 _cf_etc(void *data,
 955         Evas_Object *obj EINA_UNUSED,
 956         void *event_info EINA_UNUSED)
 957 {
 958    _flip_to(data,"etc");
 959 }
 960
 961 const char *
 962 _elm_theme_current_get(const char *theme_search_order)
 963 {
 964    const char *ret;
 965    const char *p;
 966
 967    if (!theme_search_order)
 968      return NULL;
 969
 970    for (p = theme_search_order;; p++)
 971      {
 972         if ((*p == ':') || (!*p))
 973           {
 974              if (p > theme_search_order)
 975                {
 976                   char *n = malloc(p - theme_search_order + 1);
 977                   if (!n)
 978                     return NULL;
 979
 980                   strncpy(n, theme_search_order, p - theme_search_order);
 981                   n[p - theme_search_order] = 0;
 982                   ret = eina_stringshare_add(n);
 983                   free(n);
 984                   break;
 985                }
 986           }
 987      }
 988
 989    return ret;
 990 }
 991
 992 static void
 993 _font_overlay_set_all(void            *data,
 994                       Evas_Object *obj EINA_UNUSED,
 995                       void *event_info EINA_UNUSED)
 996 {
 997    Evas_Object *win, *fclasses;
 998    Elm_Text_Class_Data *tc_data, *tc;
 999    Elm_Object_Item *list_it;
1000    Eina_List *l;
1001
1002    win = data;
1003
1004    fclasses = evas_object_data_get(win, "font_classes_list");
1005    list_it = elm_list_selected_item_get(fclasses);
1006    if (!list_it) return;
1007    tc_data = elm_object_item_data_get(list_it);
1008
1009    EINA_LIST_FOREACH(fndata.text_classes, l, tc)
1010      {
1011         eina_stringshare_replace(&tc->font, tc_data->font);
1012         eina_stringshare_replace(&tc->style, tc_data->style);
1013         tc->size = tc_data->size;
1014      }
1015
1016    elm_config_all_flush();
1017    elm_config_save();
1018 }
1019
1020 static void
1021 _font_overlay_reset(void            *data,
1022                     Evas_Object *obj EINA_UNUSED,
1023                     void *event_info EINA_UNUSED)
1024 {
1025    Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
1026    Elm_Text_Class_Data *tc_data;
1027    Elm_Object_Item *list_it;
1028
1029    win = data;
1030
1031    fclasses = evas_object_data_get(win, "font_classes_list");
1032    list_it = elm_list_selected_item_get(fclasses);
1033    if (!list_it) return;
1034    tc_data = elm_object_item_data_get(list_it);
1035
1036    fnames = evas_object_data_get(win, "font_names_list");
1037    fstyles = evas_object_data_get(win, "font_styles_list");
1038    fsizes = evas_object_data_get(win, "font_sizes_list");
1039
1040    elm_config_font_overlay_unset(tc_data->name);
1041
1042    eina_stringshare_replace(&fndata.cur_font, NULL);
1043    eina_stringshare_replace(&tc_data->font, NULL);
1044    eina_stringshare_replace(&fndata.cur_style, NULL);
1045    eina_stringshare_replace(&tc_data->style, NULL);
1046    fndata.cur_size = 0.0;
1047    tc_data->size = 0.0;
1048
1049    ELM_LIST_DISABLE(fnames);
1050    ELM_LIST_DISABLE(fstyles);
1051    ELM_LIST_DISABLE(fsizes);
1052
1053    elm_config_all_flush();
1054    elm_config_save();
1055 }
1056
1057 static void
1058 _font_overlay_reset_all(void            *data,
1059                         Evas_Object *obj EINA_UNUSED,
1060                         void *event_info EINA_UNUSED)
1061 {
1062    Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
1063    Elm_Text_Class_Data *tc_data;
1064    Elm_Object_Item *list_it;
1065    Eina_List *l;
1066
1067    win = data;
1068    eina_stringshare_replace(&fndata.cur_font, NULL);
1069    eina_stringshare_replace(&fndata.cur_style, NULL);
1070    fndata.cur_size = 0.0;
1071
1072    EINA_LIST_FOREACH(fndata.text_classes, l, tc_data)
1073      {
1074         elm_config_font_overlay_unset(tc_data->name);
1075
1076         eina_stringshare_replace(&tc_data->font, NULL);
1077         eina_stringshare_replace(&tc_data->style, NULL);
1078         tc_data->size = 0.0;
1079      }
1080
1081    fclasses = evas_object_data_get(win, "font_classes_list");
1082    fnames = evas_object_data_get(win, "font_names_list");
1083    fstyles = evas_object_data_get(win, "font_styles_list");
1084    fsizes = evas_object_data_get(win, "font_sizes_list");
1085
1086    list_it = elm_list_selected_item_get(fclasses);
1087    if (list_it) elm_list_item_selected_set(list_it, EINA_FALSE);
1088
1089    ELM_LIST_DISABLE(fnames);
1090    ELM_LIST_DISABLE(fstyles);
1091    ELM_LIST_DISABLE(fsizes);
1092
1093    elm_config_all_flush();
1094    elm_config_save();
1095 }
1096
1097 static void
1098 _font_overlay_change(void *data       EINA_UNUSED,
1099                      Evas_Object *obj EINA_UNUSED,
1100                      void *event_info EINA_UNUSED)
1101 {
1102    Elm_Text_Class_Data *tc_data;
1103    Eina_List *l;
1104
1105    EINA_LIST_FOREACH(fndata.text_classes, l, tc_data)
1106      {
1107         if (tc_data->font)
1108           {
1109              char *name;
1110
1111              name = elm_font_fontconfig_name_get(tc_data->font,
1112                                                  tc_data->style);
1113              elm_config_font_overlay_set(tc_data->name, name,
1114                                          tc_data->size ? tc_data->size : -100);
1115              elm_font_fontconfig_name_free(name);
1116           }
1117         else
1118           elm_config_font_overlay_unset(tc_data->name);
1119      }
1120
1121    elm_config_font_overlay_apply();
1122    elm_config_all_flush();
1123    elm_config_save();
1124
1125    /* TODO: apply hinting */
1126 }
1127
1128 static void
1129 _config_display_update(Evas_Object *win)
1130 {
1131    int flush_interval, font_c, image_c, edje_file_c, edje_col_c, ts_threshould,
1132        ts_hold_threshold;
1133    double scale, s_bounce_friction, ts_momentum_threshold,
1134           ts_flick_distance_tolerance, ts_friction,
1135           ts_min_friction, ts_friction_standard, ts_border_friction,
1136           ts_sensitivity_friction, ts_acceleration_threshold,
1137           ts_acceleration_time_limit, ts_acceleration_weight, page_friction,
1138           bring_in_friction, zoom_friction;
1139    const char *curr_theme, *curr_engine;
1140    const Eina_List *l_items, *l;
1141    Eina_Bool s_bounce, ts;
1142    Elm_Object_Item *list_it;
1143    Elm_Theme *th;
1144    int fs;
1145
1146    scale = elm_config_scale_get();
1147    fs = elm_config_finger_size_get();
1148    flush_interval = elm_config_cache_flush_interval_get();
1149    font_c = elm_config_cache_font_cache_size_get();
1150    image_c = elm_config_cache_image_cache_size_get();
1151    edje_file_c = elm_config_cache_edje_file_cache_size_get();
1152    edje_col_c = elm_config_cache_edje_collection_cache_size_get();
1153
1154    s_bounce = elm_config_scroll_bounce_enabled_get();
1155    s_bounce_friction = elm_config_scroll_bounce_friction_get();
1156    ts = elm_config_scroll_thumbscroll_enabled_get();
1157    ts_threshould = elm_config_scroll_thumbscroll_threshold_get();
1158    ts_hold_threshold = elm_config_scroll_thumbscroll_hold_threshold_get();
1159    ts_momentum_threshold = elm_config_scroll_thumbscroll_momentum_threshold_get();
1160    ts_flick_distance_tolerance = elm_config_scroll_thumbscroll_flick_distance_tolerance_get();
1161    ts_friction = elm_config_scroll_thumbscroll_friction_get();
1162    ts_min_friction = elm_config_scroll_thumbscroll_min_friction_get();
1163    ts_friction_standard = elm_config_scroll_thumbscroll_friction_standard_get();
1164    ts_border_friction = elm_config_scroll_thumbscroll_border_friction_get();
1165    ts_sensitivity_friction = elm_config_scroll_thumbscroll_sensitivity_friction_get();
1166    ts_acceleration_threshold = elm_config_scroll_thumbscroll_acceleration_threshold_get();
1167    ts_acceleration_time_limit = elm_config_scroll_thumbscroll_acceleration_time_limit_get();
1168    ts_acceleration_weight = elm_config_scroll_thumbscroll_acceleration_weight_get();
1169    page_friction = elm_config_scroll_page_scroll_friction_get();
1170    bring_in_friction = elm_config_scroll_bring_in_scroll_friction_get();
1171    zoom_friction = elm_config_scroll_zoom_friction_get();
1172
1173    /* gotta update root windows' atoms */
1174    elm_slider_value_set(evas_object_data_get(win, "scale_slider"), scale);
1175    elm_slider_value_set(evas_object_data_get(win, "fs_slider"), fs);
1176
1177    elm_slider_value_set(evas_object_data_get(win,
1178                                              "cache_flush_interval_slider"),
1179                         flush_interval);
1180    elm_slider_value_set(evas_object_data_get(win, "font_cache_slider"),
1181                         font_c / 1024.0);
1182    elm_slider_value_set(evas_object_data_get(win, "image_cache_slider"),
1183                         image_c / 1024.0);
1184    elm_slider_value_set(evas_object_data_get(win, "edje_file_cache_slider"),
1185                         edje_file_c);
1186    elm_slider_value_set(evas_object_data_get(win,
1187                                              "edje_collection_cache_slider"),
1188                         edje_col_c);
1189
1190    elm_check_state_set(evas_object_data_get(win, "scroll_bounce_check"),
1191                        s_bounce);
1192    elm_slider_value_set(evas_object_data_get(win, "bounce_friction_slider"),
1193                         s_bounce_friction);
1194    elm_check_state_set(evas_object_data_get(win, "thumbscroll_check"), ts);
1195    elm_slider_value_set(evas_object_data_get(win,
1196                                              "ts_threshold_slider"),
1197                         ts_threshould);
1198    elm_slider_value_set(evas_object_data_get(win,
1199                                              "ts_hold_threshold_slider"),
1200                         ts_hold_threshold);
1201    elm_slider_value_set(evas_object_data_get(win,
1202                                              "ts_momentum_threshold_slider"),
1203                         ts_momentum_threshold);
1204    elm_slider_value_set(evas_object_data_get(win,
1205                                              "ts_flick_distance_tolerance_slider"),
1206                         ts_flick_distance_tolerance);
1207    elm_slider_value_set(evas_object_data_get(win,
1208                                              "ts_friction_slider"),
1209                         ts_friction);
1210    elm_slider_value_set(evas_object_data_get(win,
1211                                              "ts_min_friction_slider"),
1212                         ts_min_friction);
1213    elm_slider_value_set(evas_object_data_get(win,
1214                                              "ts_friction_standard_slider"),
1215                         ts_friction_standard);
1216    elm_slider_value_set(evas_object_data_get(win, "ts_border_friction_slider"),
1217                         ts_border_friction);
1218    elm_slider_value_set(evas_object_data_get(win, "ts_sensitivity_friction_slider"),
1219                         ts_sensitivity_friction);
1220    elm_slider_value_set(evas_object_data_get(win, "ts_acceleration_threshold_slider"),
1221                         ts_acceleration_threshold);
1222    elm_slider_value_set(evas_object_data_get(win, "ts_acceleration_time_limit_slider"),
1223                         ts_acceleration_time_limit);
1224    elm_slider_value_set(evas_object_data_get(win, "ts_acceleration_weight_slider"),
1225                         ts_acceleration_weight);
1226    elm_slider_value_set(evas_object_data_get(win,
1227                                              "page_scroll_friction_slider"),
1228                         page_friction);
1229    elm_slider_value_set(evas_object_data_get(win,
1230                                              "bring_in_scroll_friction_slider"),
1231                         bring_in_friction);
1232    elm_slider_value_set(evas_object_data_get(win,
1233                                              "zoom_scroll_friction_slider"),
1234                         zoom_friction);
1235
1236    curr_theme = _elm_theme_current_get(elm_theme_get(NULL));
1237
1238    th = elm_theme_new();
1239    elm_theme_set(th, curr_theme);
1240    elm_object_theme_set(evas_object_data_get(win, "theme_preview"), th);
1241    elm_theme_free(th);
1242    eina_stringshare_del(curr_theme);
1243
1244    curr_engine = elm_config_engine_get();
1245    l_items = elm_list_items_get(evas_object_data_get(win, "engines_list"));
1246    EINA_LIST_FOREACH(l_items, l, list_it)
1247      {
1248         if (!strcmp(elm_object_item_data_get(list_it), curr_engine))
1249           {
1250              elm_list_item_selected_set(list_it, EINA_TRUE);
1251              break;
1252           }
1253      }
1254 }
1255
1256 static Eina_Bool
1257 _config_all_changed(void *data,
1258                     int ev_type EINA_UNUSED,
1259                     void *ev EINA_UNUSED)
1260 {
1261    Evas_Object *win = data;
1262    _config_display_update(win);
1263    return ECORE_CALLBACK_PASS_ON;
1264 }
1265
1266 static void
1267 _engine_use(void            *data,
1268             Evas_Object *obj EINA_UNUSED,
1269             void *event_info EINA_UNUSED)
1270 {
1271    Evas_Object *li;
1272    const char *selection;
1273
1274    li = data;
1275    selection = elm_object_item_data_get(elm_list_selected_item_get(li));
1276
1277    if (!strcmp(elm_config_engine_get(), selection))
1278      return;
1279
1280    elm_config_engine_set(selection);
1281    elm_config_all_flush();
1282    elm_config_save(); /* make sure new engine has its data dir */
1283 }
1284
1285 static void
1286 _profile_use(void            *data,
1287              Evas_Object *obj EINA_UNUSED,
1288              void *event_info EINA_UNUSED)
1289 {
1290    Evas_Object *li;
1291    const char *selection;
1292    const char *profile;
1293
1294    li = data;
1295    selection = elm_object_item_data_get(elm_list_selected_item_get(li));
1296    profile = elm_config_profile_get();
1297
1298    if (!profile)
1299      {
1300         fprintf(stderr, "No profile currently set!\n"); /* FIXME: log domain */
1301         return;
1302      }
1303
1304    if (!strcmp(profile, selection))
1305      return;
1306
1307    elm_config_profile_set(selection); /* just here to update info for getters below */
1308
1309    _config_display_update(elm_object_top_widget_get(li));
1310    elm_config_all_flush();
1311    elm_config_save(); /* make sure new profile has its data dir */
1312 }
1313
1314 static void
1315 _btn_todo(void *data       EINA_UNUSED,
1316           Evas_Object *obj EINA_UNUSED,
1317           void *event_info EINA_UNUSED)
1318 {
1319    printf("To be done!\n");
1320 }
1321
1322 static void
1323 _profile_reset(void            *data,
1324                Evas_Object *obj EINA_UNUSED,
1325                void *event_info EINA_UNUSED)
1326 {
1327    const char *selection;
1328    const char *pdir;
1329    Evas_Object *li;
1330
1331    li = data;
1332    selection = elm_object_item_data_get(elm_list_selected_item_get(li));
1333
1334    elm_config_all_flush();
1335    elm_config_save(); /* dump config into old profile's data dir */
1336
1337    pdir = elm_config_profile_dir_get(selection, EINA_TRUE);
1338    if (!pdir)
1339      return;
1340
1341    ecore_file_recursive_rm(pdir);
1342    elm_config_profile_dir_free(pdir);
1343
1344    elm_config_reload();
1345
1346    elm_config_all_flush();
1347    _config_display_update(elm_object_top_widget_get(li));
1348    elm_config_save(); /* make sure new profile has its data dir */
1349 }
1350
1351 static void
1352 _theme_use(void *data       EINA_UNUSED,
1353            Evas_Object *obj EINA_UNUSED,
1354            void *event_info EINA_UNUSED)
1355 {
1356    const char *defth;
1357    Elm_Theme *th;
1358    Evas_Object *win = elm_object_top_widget_get(obj);
1359    Evas_Object *sample = evas_object_data_get(win, "theme_preview");
1360
1361    th = elm_object_theme_get(sample);
1362    defth = elm_theme_get(th);
1363    elm_theme_set(NULL, defth);
1364    elm_config_all_flush();
1365    elm_config_save();
1366 }
1367
1368 static void
1369 _theme_sel(void            *data EINA_UNUSED,
1370            Evas_Object     *obj,
1371            void *event_info EINA_UNUSED)
1372 {
1373    Evas_Object *win = elm_object_top_widget_get(obj);
1374    Evas_Object *sample = evas_object_data_get(win, "theme_preview");
1375    Elm_Theme *th;
1376    Elm_Object_Item *list_it;
1377    Eina_Strbuf *newth;
1378    Eina_List *l;
1379
1380    if (!sample) return;
1381    tsel = elm_list_selected_items_get(obj);
1382    newth = eina_strbuf_new();
1383    EINA_SAFETY_ON_NULL_RETURN(newth);
1384    th = elm_theme_new();
1385    if (!th)
1386      {
1387         eina_strbuf_free(newth);
1388         return;
1389      }
1390    EINA_LIST_REVERSE_FOREACH((Eina_List*)tsel, l, list_it)
1391      {
1392         Theme *t = elm_object_item_data_get(list_it);
1393         eina_strbuf_append_printf(newth, "%s:", t->name);
1394         if ((!l->prev) && strcmp(t->name, "default"))
1395           /* ensure default theme is always there for fallback */
1396           eina_strbuf_append(newth, "default");
1397      }
1398    elm_theme_set(th, eina_strbuf_string_get(newth));
1399    eina_strbuf_free(newth);
1400    elm_object_theme_set(sample, th);
1401    elm_theme_free(th);
1402 }
1403
1404 /*static void
1405    _theme_browse(void *data, Evas_Object *obj, void *event_info)
1406    {
1407    printf("not implemented\n");
1408    }*/
1409
1410 static void
1411 _status_config_sizing(Evas_Object *win,
1412                       Evas_Object *naviframe)
1413 {
1414    Evas_Object *lb, *pd, *bx, *sl, *sp;
1415
1416    bx = elm_box_add(win);
1417    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
1418    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
1419
1420    LABEL_FRAME_ADD("<hilight>Scale</>");
1421
1422    sl = elm_slider_add(win);
1423    evas_object_data_set(win, "scale_slider", sl);
1424    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1425    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1426    elm_slider_span_size_set(sl, 120);
1427    elm_slider_unit_format_set(sl, "%1.2f");
1428    elm_slider_indicator_format_set(sl, "%1.2f");
1429    elm_slider_min_max_set(sl, 0.25, 5.0);
1430    elm_slider_value_set(sl, elm_config_scale_get());
1431    elm_box_pack_end(bx, sl);
1432    evas_object_show(sl);
1433
1434    evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
1435    evas_object_smart_callback_add(sl, "delay,changed", sc_change, NULL);
1436
1437    sp = elm_separator_add(win);
1438    elm_separator_horizontal_set(sp, EINA_TRUE);
1439    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1440    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1441    elm_box_pack_end(bx, sp);
1442    evas_object_show(sp);
1443
1444    LABEL_FRAME_ADD("<hilight>Finger Size</><br/>");
1445
1446    sl = elm_slider_add(win);
1447    evas_object_data_set(win, "fs_slider", sl);
1448    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1449    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1450    elm_slider_span_size_set(sl, 120);
1451    elm_slider_unit_format_set(sl, "%1.0f");
1452    elm_slider_indicator_format_set(sl, "%1.0f");
1453    elm_slider_min_max_set(sl, 5, 200);
1454    elm_slider_value_set(sl, elm_config_finger_size_get());
1455    elm_box_pack_end(bx, sl);
1456    evas_object_show(sl);
1457
1458    evas_object_smart_callback_add(sl, "changed", fs_round, NULL);
1459    evas_object_smart_callback_add(sl, "delay,changed", fs_change, NULL);
1460
1461    evas_object_data_set(win, "sizing", bx);
1462
1463    elm_naviframe_item_simple_push(naviframe, bx);
1464 }
1465
1466 static void
1467 _status_config_etc(Evas_Object *win,
1468                    Evas_Object *naviframe)
1469 {
1470    Evas_Object *bx, *ck;
1471
1472    bx = elm_box_add(win);
1473    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
1474    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
1475
1476    // access
1477    ck = elm_check_add(win);
1478    elm_object_tooltip_text_set(ck, "Set access mode");
1479    elm_object_text_set(ck, "Enable Access Mode");
1480    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
1481    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
1482    elm_check_state_set(ck, elm_config_access_get());
1483    elm_box_pack_end(bx, ck);
1484    evas_object_show(ck);
1485
1486    evas_object_smart_callback_add(ck, "changed", ac_change, NULL);
1487
1488    // selection
1489    ck = elm_check_add(win);
1490    elm_object_tooltip_text_set(ck, "Set selection mode");
1491    elm_object_text_set(ck, "Enable clear selection when unfocus");
1492    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
1493    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
1494    elm_check_state_set(ck, elm_config_selection_unfocused_clear_get());
1495    elm_box_pack_end(bx, ck);
1496    evas_object_show(ck);
1497
1498    evas_object_smart_callback_add(ck, "changed", sel_change, NULL);
1499
1500    // clouseau
1501    ck = elm_check_add(win);
1502    elm_object_tooltip_text_set(ck, "Set clouseau mode");
1503    elm_object_text_set(ck, "Enable clouseau");
1504    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
1505    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
1506    elm_check_state_set(ck, elm_config_clouseau_enabled_get());
1507    elm_box_pack_end(bx, ck);
1508    evas_object_show(ck);
1509
1510    evas_object_smart_callback_add(ck, "changed", dbg_change, NULL);
1511
1512    evas_object_data_set(win, "etc", bx);
1513
1514    elm_naviframe_item_simple_push(naviframe, bx);
1515 }
1516
1517 static Evas_Object *
1518 _sample_theme_new(Evas_Object *win)
1519 {
1520    Evas_Object *base, *bg, *bt, *ck, *rd, *rdg, *sl, *fr, *li, *rc, *sp;
1521
1522    base = elm_table_add(win);
1523    evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1524    evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
1525
1526    bg = elm_bg_add(win);
1527    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1528    evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
1529    elm_table_pack(base, bg, 0, 0, 2, 5);
1530    evas_object_show(bg);
1531
1532    bt = elm_button_add(win);
1533    evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
1534    elm_object_text_set(bt, "Button");
1535    elm_table_pack(base, bt, 0, 0, 1, 1);
1536    evas_object_show(bt);
1537
1538    ck = elm_check_add(win);
1539    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
1540    elm_object_text_set(ck, "Check");
1541    elm_table_pack(base, ck, 0, 1, 1, 1);
1542    evas_object_show(ck);
1543
1544    rd = elm_radio_add(win);
1545    evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
1546    elm_radio_state_value_set(rd, 0);
1547    elm_object_text_set(rd, "Radio 1");
1548    elm_table_pack(base, rd, 1, 0, 1, 1);
1549    evas_object_show(rd);
1550    rdg = rd;
1551
1552    rd = elm_radio_add(win);
1553    evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
1554    elm_radio_state_value_set(rd, 1);
1555    elm_object_text_set(rd, "Radio 2");
1556    elm_radio_group_add(rd, rdg);
1557    elm_table_pack(base, rd, 1, 1, 1, 1);
1558    evas_object_show(rd);
1559
1560    sp = elm_separator_add(win);
1561    elm_separator_horizontal_set(sp, EINA_TRUE);
1562    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1563    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1564    elm_table_pack(base, sp, 0, 2, 2, 1);
1565    evas_object_show(sp);
1566
1567    sl = elm_slider_add(win);
1568    elm_object_text_set(sl, "Slider");
1569    elm_slider_span_size_set(sl, 120);
1570    elm_slider_min_max_set(sl, 1, 10);
1571    elm_slider_value_set(sl, 4);
1572    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1573    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, EVAS_HINT_FILL);
1574    elm_table_pack(base, sl, 0, 3, 2, 1);
1575    evas_object_show(sl);
1576
1577    fr = elm_frame_add(win);
1578    elm_object_text_set(fr, "Frame");
1579    elm_table_pack(base, fr, 0, 4, 2, 1);
1580    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1581    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1582    evas_object_show(fr);
1583
1584    li = elm_list_add(win);
1585    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1586    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1587    elm_object_content_set(fr, li);
1588    evas_object_show(li);
1589
1590    elm_list_item_append(li, "List Item 1", NULL, NULL, NULL, NULL);
1591    elm_list_item_append(li, "Second Item", NULL, NULL, NULL, NULL);
1592    elm_list_item_append(li, "Third Item", NULL, NULL, NULL, NULL);
1593    elm_list_go(li);
1594
1595    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1596    evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1597    evas_object_size_hint_min_set(rc, 160, 120);
1598    elm_table_pack(base, rc, 0, 4, 2, 1);
1599
1600    return base;
1601 }
1602
1603 static void
1604 _status_config_themes(Evas_Object *win,
1605                       Evas_Object *naviframe)
1606 {
1607    Evas_Object *tb, *rc, *sc, *sp, *li, *pd, *fr, *bt, *sample;
1608    Eina_List *list, *l;
1609    char *th, *s, *ext;
1610    Elm_Theme *d;
1611    Elm_Object_Item *list_it, *def_it = NULL;
1612    const char *theme_name, *sep[20];
1613    unsigned int x;
1614
1615    tb = elm_table_add(win);
1616    evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1617    evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
1618
1619    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1620    evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1621    evas_object_size_hint_min_set(rc, 0, 130);
1622    elm_table_pack(tb, rc, 0, 0, 1, 1);
1623
1624    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1625    evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1626    evas_object_size_hint_min_set(rc, 0, 200);
1627    elm_table_pack(tb, rc, 0, 1, 1, 1);
1628
1629    /////////////////////////////////////////////
1630
1631    pd = elm_frame_add(win);
1632    elm_object_style_set(pd, "pad_medium");
1633    evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1634    evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
1635    elm_table_pack(tb, pd, 0, 0, 1, 1);
1636    evas_object_show(pd);
1637
1638    li = elm_list_add(win);
1639    elm_list_multi_select_set(li, EINA_TRUE);
1640    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1641    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1642    elm_object_content_set(pd, li);
1643    evas_object_show(li);
1644
1645    list = elm_theme_name_available_list_new();
1646    d = elm_theme_default_get();
1647    theme_name = elm_theme_get(d);
1648    for (x = 1, sep[0] = theme_name; x < sizeof(sep) / sizeof(sep[0]); x++)
1649      {
1650         sep[x] = strchr(sep[x - 1] + 1, ':');
1651         if (!sep[x]) break;
1652      }
1653    EINA_LIST_FOREACH(list, l, th)
1654      {
1655         Theme *t;
1656         int y;
1657
1658         t = calloc(1, sizeof(Theme));
1659         t->name = eina_stringshare_add(th);
1660         s = elm_theme_list_item_path_get(th, &(t->in_search_path));
1661         if (s)
1662           {
1663              t->path = eina_stringshare_add(s);
1664              free(s);
1665           }
1666         if (t->in_search_path)
1667           {
1668              s = strdup(th);
1669              if (s)
1670                {
1671                   s[0] = toupper(s[0]);
1672                   t->label = eina_stringshare_add(s);
1673                   free(s);
1674                }
1675              else
1676                t->label = eina_stringshare_add(s);
1677           }
1678         else
1679           {
1680              s = strdup(ecore_file_file_get(th));
1681              if (s)
1682                {
1683                   s[0] = toupper(s[0]);
1684                   ext = strrchr(s, '.');
1685                   if (ext) *ext = 0;
1686                   t->label = eina_stringshare_add(s);
1687                   free(s);
1688                }
1689              else
1690                t->label = eina_stringshare_add(s);
1691           }
1692         themes = eina_list_append(themes, t);
1693         list_it = elm_list_item_append(li, t->label, NULL, NULL, NULL, t);
1694         if (!strcmp(t->name, "default")) def_it = list_it;
1695         for (y = x - 1 /* ignore default e theme */; y > 0; y--)
1696           {
1697              const char *start = (sep[y - 1][0] == ':') ? sep[y - 1] + 1 : sep[y - 1];
1698              unsigned int len = (unsigned int)(sep[y] - start);
1699              if (strncmp(start , t->name, len) || (strlen(t->name) != len)) continue;
1700
1701              if (!elm_list_item_selected_get(list_it))
1702                elm_list_item_selected_set(list_it, EINA_TRUE);
1703              break;
1704           }
1705      }
1706    if (!elm_list_selected_items_get(li))
1707      elm_list_item_selected_set(def_it, EINA_TRUE);
1708    evas_object_smart_callback_add(li, "selected", _theme_sel, NULL);
1709    evas_object_smart_callback_add(li, "unselected", _theme_sel, NULL);
1710    elm_theme_name_available_list_free(list);
1711
1712    elm_list_go(li);
1713
1714    pd = elm_frame_add(win);
1715    elm_object_style_set(pd, "pad_medium");
1716    evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1717    evas_object_size_hint_align_set(pd, 0.9, 0.9);
1718    elm_table_pack(tb, pd, 0, 0, 1, 1);
1719    evas_object_show(pd);
1720
1721    /* FIXME: not implemented yet
1722       bt = elm_button_add(win);
1723       evas_object_smart_callback_add(bt, "clicked", _theme_browse, win);
1724       elm_object_text_set(bt, "Browse...");
1725       evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1726       evas_object_size_hint_align_set(bt, 0.9, 0.9);
1727       elm_object_content_set(pd, bt);
1728       evas_object_show(bt);
1729     */
1730    pd = elm_frame_add(win);
1731    elm_object_style_set(pd, "pad_medium");
1732    evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
1733    evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
1734    elm_table_pack(tb, pd, 0, 1, 1, 1);
1735    evas_object_show(pd);
1736
1737    fr = elm_frame_add(win);
1738    elm_object_text_set(fr, "Preview");
1739    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1740    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1741    elm_object_content_set(pd, fr);
1742    evas_object_show(fr);
1743
1744    sc = elm_scroller_add(win);
1745    elm_scroller_bounce_set(sc, EINA_FALSE, EINA_FALSE);
1746    evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1747    evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
1748    elm_object_content_set(fr, sc);
1749    evas_object_show(sc);
1750
1751    sample = _sample_theme_new(win);
1752    elm_object_content_set(sc, sample);
1753    evas_object_show(sample);
1754    evas_object_data_set(win, "theme_preview", sample);
1755
1756    /////////////////////////////////////////////
1757    sp = elm_separator_add(win);
1758    elm_separator_horizontal_set(sp, EINA_TRUE);
1759    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1760    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1761    elm_table_pack(tb, sp, 0, 2, 1, 1);
1762    evas_object_show(sp);
1763
1764    pd = elm_frame_add(win);
1765    elm_object_style_set(pd, "pad_medium");
1766    evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
1767    evas_object_size_hint_align_set(pd, 0.5, 0.5);
1768    elm_table_pack(tb, pd, 0, 3, 1, 1);
1769    evas_object_show(pd);
1770
1771    bt = elm_button_add(win);
1772    evas_object_smart_callback_add(bt, "clicked", _theme_use, win);
1773    elm_object_text_set(bt, "Use Theme");
1774    evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
1775    evas_object_size_hint_align_set(bt, 0.5, 0.5);
1776    elm_object_content_set(pd, bt);
1777    evas_object_show(bt);
1778
1779    evas_object_data_set(win, "themes", tb);
1780    elm_naviframe_item_simple_push(naviframe, tb);
1781 }
1782
1783 static void
1784 _font_preview_update(Evas_Object *win)
1785 {
1786    Evas_Font_Size sz;
1787    char *name;
1788
1789    if (!fndata.cur_font)
1790      return;
1791
1792    name = elm_font_fontconfig_name_get(fndata.cur_font, fndata.cur_style);
1793    sz = fndata.cur_size;
1794
1795    if (sz < 0)
1796      sz = (-sz * 10) / 100;
1797    if (sz == 0)
1798      sz = 10;
1799
1800    edje_object_text_class_set(evas_object_data_get(win, "font_preview"),
1801                               "font_preview", name, sz);
1802
1803    elm_font_fontconfig_name_free(name);
1804 }
1805
1806 static void
1807 _font_classes_list_sel(void *data   EINA_UNUSED,
1808                        Evas_Object *obj,
1809                        void        *event_info)
1810 {
1811    const Eina_List *f_names_items, *l;
1812    Elm_Text_Class_Data *tc_data;
1813    Evas_Object *f_names_list;
1814    Elm_Object_Item *list_it;
1815
1816    tc_data = elm_object_item_data_get(event_info);
1817
1818    f_names_list = evas_object_data_get(elm_object_top_widget_get(obj),
1819                                        "font_names_list");
1820    ELM_LIST_ENABLE(f_names_list);
1821
1822    f_names_items = elm_list_items_get(f_names_list);
1823
1824    EINA_LIST_FOREACH(f_names_items, l, list_it)
1825      {
1826         const char *s;
1827
1828         s = elm_object_item_text_get(list_it);
1829
1830         if (tc_data->font && !strcmp(s, tc_data->font))
1831           {
1832              elm_list_item_selected_set(list_it, EINA_TRUE);
1833              elm_list_item_show(list_it);
1834              break;
1835           }
1836      }
1837 }
1838
1839 static void
1840 _font_names_list_sel(void *data   EINA_UNUSED,
1841                      Evas_Object *obj,
1842                      void        *event_info)
1843 {
1844    Evas_Object *style_list, *cls_list, *win;
1845    const char *style, *sel_font;
1846    Elm_Text_Class_Data *tc_data;
1847    Elm_Object_Item *list_it, *fc_list_it;
1848    Elm_Font_Properties *efp;
1849    const Eina_List *l;
1850
1851    list_it = event_info;
1852    sel_font = elm_object_item_text_get(list_it);
1853
1854    win = elm_object_top_widget_get(obj);
1855    style_list = evas_object_data_get(win, "font_styles_list");
1856    cls_list = evas_object_data_get(win, "font_classes_list");
1857
1858    fc_list_it = elm_list_selected_item_get(cls_list);
1859    if (!fc_list_it) return;  /* should not happen, fonts list disabled in
1860                          * this case */
1861
1862    eina_stringshare_replace(&fndata.cur_font, sel_font);
1863
1864    tc_data = elm_object_item_data_get(fc_list_it);
1865    if (tc_data->font) eina_stringshare_del(tc_data->font);
1866    if (fndata.cur_font) tc_data->font = eina_stringshare_ref(fndata.cur_font);
1867
1868    /* load styles list */
1869    efp = eina_hash_find(fndata.font_hash, sel_font);
1870
1871    ELM_LIST_ENABLE(style_list);
1872    elm_list_clear(style_list);
1873
1874    evas_event_freeze(evas_object_evas_get(style_list));
1875    edje_freeze();
1876
1877    list_it = NULL;
1878
1879    EINA_LIST_FOREACH(efp->styles, l, style)
1880      {
1881         Elm_Object_Item *i;
1882
1883         i = elm_list_item_append(style_list, style, NULL, NULL,
1884                                  _font_styles_list_sel, NULL);
1885
1886         if (tc_data->style && (!strcmp(style, tc_data->style)))
1887           list_it = i;
1888      }
1889
1890    elm_list_go(style_list);
1891
1892    edje_thaw();
1893    evas_event_thaw(evas_object_evas_get(style_list));
1894
1895    if (list_it)
1896      elm_list_item_selected_set(list_it, EINA_TRUE);
1897
1898    _font_preview_update(win);
1899 }
1900
1901 static void
1902 _font_styles_list_sel(void *data   EINA_UNUSED,
1903                       Evas_Object *obj,
1904                       void        *event_info)
1905 {
1906    Evas_Object *fc_list, *fs_list, *win;
1907    Elm_Text_Class_Data *tc_data;
1908    const Eina_List *l;
1909    Elm_Object_Item *list_it;
1910
1911    win = elm_object_top_widget_get(obj);
1912    fc_list = evas_object_data_get(win, "font_classes_list");
1913    fs_list = evas_object_data_get(win, "font_sizes_list");
1914
1915    list_it = elm_list_selected_item_get(fc_list);
1916    if (!list_it) return;  /* should not happen */
1917
1918    eina_stringshare_replace(&fndata.cur_style,
1919                             elm_object_item_text_get(event_info));
1920    ELM_LIST_ENABLE(fs_list);
1921
1922    tc_data = elm_object_item_data_get(list_it);
1923    eina_stringshare_del(tc_data->style);
1924    tc_data->style = eina_stringshare_ref(fndata.cur_style);
1925
1926    evas_event_freeze(evas_object_evas_get(fs_list));
1927    edje_freeze();
1928
1929    EINA_LIST_FOREACH(elm_list_items_get(fs_list), l, list_it)
1930      {
1931         Elm_Font_Size_Data *sdata;
1932
1933         sdata = elm_object_item_data_get(list_it);
1934         elm_list_item_selected_set(l->data, EINA_FALSE);
1935
1936         if (tc_data->size == sdata->size)
1937           {
1938              elm_list_item_selected_set(list_it, EINA_TRUE);
1939              elm_list_item_show(list_it);
1940              break;
1941           }
1942      }
1943
1944    edje_thaw();
1945    evas_event_thaw(evas_object_evas_get(fs_list));
1946
1947    _font_preview_update(win);
1948 }
1949
1950 static void
1951 _font_sizes_list_sel(void *data       EINA_UNUSED,
1952                      Evas_Object *obj EINA_UNUSED,
1953                      void *event_info EINA_UNUSED)
1954 {
1955    Elm_Text_Class_Data *tc_data;
1956    Evas_Object *fc_list, *win;
1957    Elm_Font_Size_Data *sd;
1958    Elm_Object_Item *list_it;
1959
1960    win = elm_object_top_widget_get(obj);
1961    fc_list = evas_object_data_get(win, "font_classes_list");
1962
1963    list_it = elm_list_selected_item_get(fc_list);
1964    if (!list_it) return;  /* should not happen */
1965
1966    sd = elm_object_item_data_get(event_info);
1967    fndata.cur_size = sd->size;
1968
1969    tc_data = elm_object_item_data_get(list_it);
1970    tc_data->size = fndata.cur_size;
1971
1972    _font_preview_update(win);
1973 }
1974
1975 static void
1976 _fstyle_list_unselect_cb(void *data       EINA_UNUSED,
1977                          Evas_Object     *obj,
1978                          void *event_info EINA_UNUSED)
1979 {
1980    Evas_Object *sizes_list, *win;
1981
1982    if (elm_list_selected_item_get(obj)) return;
1983
1984    win = elm_object_top_widget_get(obj);
1985
1986    sizes_list = evas_object_data_get(win, "font_sizes_list");
1987    ELM_LIST_DISABLE(sizes_list);
1988 }
1989
1990 static void
1991 _fc_list_unselect_cb(void *data       EINA_UNUSED,
1992                      Evas_Object     *obj,
1993                      void *event_info EINA_UNUSED)
1994 {
1995    Evas_Object *font_names_list, *styles_list, *sizes_list, *win;
1996
1997    if (elm_list_selected_item_get(obj)) return;
1998
1999    win = elm_object_top_widget_get(obj);
2000
2001    font_names_list = evas_object_data_get(win, "font_names_list");
2002    ELM_LIST_DISABLE(font_names_list);
2003
2004    styles_list = evas_object_data_get(win, "font_styles_list");
2005    ELM_LIST_DISABLE(styles_list);
2006
2007    sizes_list = evas_object_data_get(win, "font_sizes_list");
2008    ELM_LIST_DISABLE(sizes_list);
2009 }
2010
2011 static void
2012 _font_classes_list_load(Evas_Object *li)
2013 {
2014    Elm_Text_Class_Data *tc_data;
2015    Eina_List *l;
2016    Evas *evas;
2017
2018    evas = evas_object_evas_get(li);
2019    evas_event_freeze(evas);
2020    edje_freeze();
2021
2022    EINA_LIST_FOREACH(fndata.text_classes, l, tc_data)
2023      elm_list_item_append(li, tc_data->desc, NULL, NULL,
2024                           _font_classes_list_sel, tc_data);
2025
2026    evas_object_smart_callback_add(li, "unselected", _fc_list_unselect_cb,
2027                                   NULL);
2028
2029    elm_list_go(li);
2030    edje_thaw();
2031    evas_event_thaw(evas);
2032 }
2033
2034 static void
2035 _fonts_data_fill(Evas *evas)
2036 {
2037    const Eina_List *fo_list, *l;
2038    Eina_List *text_classes;
2039    Elm_Text_Class_Data *tc_data;
2040    Elm_Font_Size_Data *sd;
2041    Elm_Font_Overlay *efo;
2042    Eina_List *evas_fonts;
2043    Elm_Text_Class *etc;
2044    int i;
2045
2046    evas_fonts = evas_font_available_list(evas);
2047    fndata.font_hash = elm_font_available_hash_add(evas_fonts);
2048    evas_font_available_list_free(evas, evas_fonts);
2049
2050    text_classes = elm_config_text_classes_list_get();
2051    fo_list = elm_config_font_overlay_list_get();
2052
2053    EINA_LIST_FOREACH(text_classes, l, etc)
2054      {
2055         const Eina_List *ll;
2056
2057         tc_data = calloc(1, sizeof(*tc_data));
2058         if (!tc_data) continue;
2059
2060         tc_data->name = eina_stringshare_add(etc->name);
2061         tc_data->desc = eina_stringshare_add(etc->desc);
2062
2063         EINA_LIST_FOREACH(fo_list, ll, efo)
2064           {
2065              if (strcmp(tc_data->name, efo->text_class))
2066                continue;
2067
2068              if (efo->font)
2069                {
2070                   Elm_Font_Properties *efp;
2071
2072                   efp = elm_font_properties_get(efo->font);
2073                   if (efp)
2074                     {
2075                        tc_data->font = eina_stringshare_add(efp->name);
2076                        /* we're sure we recorded with only 1 style selected */
2077                        tc_data->style = eina_stringshare_add(efp->styles->data);
2078                        elm_font_properties_free(efp);
2079                     }
2080                }
2081              tc_data->size = efo->size;
2082           }
2083
2084         fndata.text_classes = eina_list_append(fndata.text_classes, tc_data);
2085      }
2086
2087    elm_config_text_classes_list_free(text_classes);
2088
2089    /* FIXME: hinting later */
2090    /* fndata.hinting = e_config->font_hinting; */
2091
2092    sd = calloc(1, sizeof(Elm_Font_Size_Data));
2093    sd->size_str = eina_stringshare_add("Tiny");
2094    sd->size = -50;
2095    fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2096
2097    sd = calloc(1, sizeof(Elm_Font_Size_Data));
2098    sd->size_str = eina_stringshare_add("Small");
2099    sd->size = -80;
2100    fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2101
2102    sd = calloc(1, sizeof(Elm_Font_Size_Data));
2103    sd->size_str = eina_stringshare_add("Normal");
2104    sd->size = -100;
2105    fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2106
2107    sd = calloc(1, sizeof(Elm_Font_Size_Data));
2108    sd->size_str = eina_stringshare_add("Big");
2109    sd->size = -150;
2110    fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2111
2112    sd = calloc(1, sizeof(Elm_Font_Size_Data));
2113    sd->size_str = eina_stringshare_add("Really Big");
2114    sd->size = -190;
2115    fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2116
2117    sd = calloc(1, sizeof(Elm_Font_Size_Data));
2118    sd->size_str = eina_stringshare_add("Huge");
2119    sd->size = -250;
2120    fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2121
2122    for (i = 5; i < 51; i++)
2123      {
2124         char str[16];
2125
2126         str[0] = 0;
2127         snprintf(str, sizeof(str), "%d pixels", i);
2128
2129         sd = calloc(1, sizeof(Elm_Font_Size_Data));
2130         sd->size_str = eina_stringshare_add(str);
2131         sd->size = i;
2132         fndata.font_px_list = eina_list_append(fndata.font_px_list, sd);
2133      }
2134 }
2135
2136 static int
2137 _font_sort_cb(const void *data1,
2138               const void *data2)
2139 {
2140    if (!data1) return 1;
2141    if (!data2) return -1;
2142    return strcmp(data1, data2);
2143 }
2144
2145 static void
2146 _font_sizes_list_load(Evas_Object *size_list)
2147 {
2148    Elm_Font_Size_Data *size_data;
2149    Eina_List *l;
2150    Evas *evas;
2151
2152    evas = evas_object_evas_get(size_list);
2153    evas_event_freeze(evas);
2154    edje_freeze();
2155
2156    EINA_LIST_FOREACH(fndata.font_scale_list, l, size_data)
2157      elm_list_item_append(size_list, size_data->size_str, NULL, NULL,
2158                           _font_sizes_list_sel, size_data);
2159
2160    EINA_LIST_FOREACH(fndata.font_px_list, l, size_data)
2161      elm_list_item_append(size_list, size_data->size_str, NULL, NULL,
2162                           _font_sizes_list_sel, size_data);
2163
2164    elm_list_go(size_list);
2165    edje_thaw();
2166    evas_event_thaw(evas);
2167 }
2168
2169 static void
2170 _fnames_list_unselect_cb(void *data       EINA_UNUSED,
2171                          Evas_Object     *obj,
2172                          void *event_info EINA_UNUSED)
2173 {
2174    Evas_Object *styles_list, *sizes_list, *win;
2175
2176    if (elm_list_selected_item_get(obj)) return;
2177
2178    win = elm_object_top_widget_get(obj);
2179
2180    styles_list = evas_object_data_get(win, "font_styles_list");
2181    ELM_LIST_DISABLE(styles_list);
2182
2183    sizes_list = evas_object_data_get(win, "font_sizes_list");
2184    ELM_LIST_DISABLE(sizes_list);
2185 }
2186
2187 static Eina_Bool
2188 _font_list_fill(const Eina_Hash *hash EINA_UNUSED,
2189                 const void *key       EINA_UNUSED,
2190                 void                 *data,
2191                 void                 *fdata)
2192 {
2193    Elm_Font_Properties *efp;
2194    Eina_List **flist;
2195
2196    flist = fdata;
2197    efp = data;
2198
2199    *flist = eina_list_append(*flist, efp->name);
2200
2201    return EINA_TRUE;
2202 }
2203
2204 static void
2205 _font_names_list_load(Evas_Object *flist)
2206 {
2207    Eina_List *l, *names_list = NULL;
2208    const char *font;
2209    Evas *evas;
2210
2211    evas = evas_object_evas_get(flist);
2212    evas_event_freeze(evas);
2213    edje_freeze();
2214
2215    eina_hash_foreach(fndata.font_hash, _font_list_fill, &names_list);
2216    names_list = eina_list_sort(names_list, eina_list_count(names_list),
2217                                _font_sort_cb);
2218
2219    EINA_LIST_FOREACH(names_list, l, font)
2220      elm_list_item_append(flist, font, NULL, NULL, _font_names_list_sel, NULL);
2221
2222    eina_list_free(names_list);
2223
2224    evas_object_smart_callback_add(flist, "unselected",
2225                                   _fnames_list_unselect_cb, NULL);
2226
2227    elm_list_go(flist);
2228
2229    edje_thaw();
2230    evas_event_thaw(evas);
2231 }
2232
2233 static void
2234 _status_config_fonts(Evas_Object *win,
2235                      Evas_Object *naviframe)
2236 {
2237    Evas_Object *base, *fr, *li, *rc, *preview, *sp, *pd, *bt, *bx;
2238    char buf[PATH_MAX];
2239
2240    _fonts_data_fill(evas_object_evas_get(win));
2241
2242    base = elm_table_add(win);
2243    evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2244    evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
2245
2246    /* yeah, dummy rectangles are ugly as hell, but no good way yet of
2247       fixing sizes */
2248    rc = evas_object_rectangle_add(evas_object_evas_get(win));
2249    evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2250    evas_object_size_hint_align_set(rc, EVAS_HINT_FILL, EVAS_HINT_FILL);
2251    evas_object_size_hint_min_set(rc, 70, 170);
2252    elm_table_pack(base, rc, 1, 0, 1, 1);
2253
2254    fr = elm_frame_add(win);
2255    elm_object_text_set(fr, "Font Class");
2256    elm_table_pack(base, fr, 0, 0, 1, 2);
2257    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2258    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2259    evas_object_show(fr);
2260
2261    /* FIXME: no multiselection for this list, for now */
2262    li = elm_list_add(win);
2263    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2264    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2265    elm_object_content_set(fr, li);
2266    evas_object_show(li);
2267
2268    evas_object_data_set(win, "font_classes_list", li);
2269    _font_classes_list_load(li);
2270
2271    fr = elm_frame_add(win);
2272    elm_object_text_set(fr, "Font");
2273    elm_table_pack(base, fr, 1, 0, 1, 2);
2274    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2275    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2276    evas_object_show(fr);
2277
2278    li = elm_list_add(win);
2279    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2280    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2281    elm_object_content_set(fr, li);
2282    evas_object_show(li);
2283
2284    evas_object_data_set(win, "font_names_list", li);
2285    _font_names_list_load(li);
2286    ELM_LIST_DISABLE(li);
2287
2288    rc = evas_object_rectangle_add(evas_object_evas_get(win));
2289    evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2290    evas_object_size_hint_align_set(rc, EVAS_HINT_FILL, EVAS_HINT_FILL);
2291    evas_object_size_hint_min_set(rc, 70, 130);
2292    elm_table_pack(base, rc, 1, 2, 1, 1);
2293
2294    fr = elm_frame_add(win);
2295    elm_object_text_set(fr, "Style");
2296    elm_table_pack(base, fr, 0, 2, 1, 1);
2297    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2298    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2299    evas_object_show(fr);
2300    ELM_LIST_DISABLE(li);
2301
2302    li = elm_list_add(win);
2303    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2304    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2305    elm_object_content_set(fr, li);
2306    evas_object_show(li);
2307
2308    evas_object_data_set(win, "font_styles_list", li);
2309    evas_object_smart_callback_add(li, "unselected", _fstyle_list_unselect_cb,
2310                                   NULL);
2311
2312    fr = elm_frame_add(win);
2313    elm_object_text_set(fr, "Size");
2314    elm_table_pack(base, fr, 1, 2, 1, 1);
2315    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2316    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2317    evas_object_show(fr);
2318
2319    li = elm_list_add(win);
2320    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2321    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2322    elm_object_content_set(fr, li);
2323    evas_object_show(li);
2324
2325    evas_object_data_set(win, "font_sizes_list", li);
2326    _font_sizes_list_load(li);
2327    ELM_LIST_DISABLE(li);
2328
2329    bx = elm_box_add(win);
2330    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2331    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2332    elm_table_pack(base, bx, 0, 3, 2, 1);
2333    evas_object_show(bx);
2334
2335    /* FIXME: what to do here? dedicated widget? some new entry API set? */
2336    snprintf(buf, sizeof(buf), "%s/objects/font_preview.edj", elm_app_data_dir_get());
2337    preview = elm_layout_add(win);
2338    elm_layout_file_set(preview, buf, "font_preview");
2339    elm_object_part_text_set(preview, "elm.text", "Preview Text — 我真的会写中文");
2340    evas_object_size_hint_weight_set(preview, EVAS_HINT_EXPAND, 0.0);
2341    evas_object_size_hint_align_set(preview, EVAS_HINT_FILL, EVAS_HINT_FILL);
2342    evas_object_show(preview);
2343
2344    elm_box_pack_end(bx, preview);
2345    evas_object_data_set(win, "font_preview", elm_layout_edje_get(preview));
2346
2347    /////////////////////////////////////////////
2348    sp = elm_separator_add(win);
2349    elm_separator_horizontal_set(sp, EINA_TRUE);
2350    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2351    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2352    elm_table_pack(base, sp, 0, 4, 2, 1);
2353    evas_object_show(sp);
2354
2355    pd = elm_frame_add(win);
2356    elm_object_style_set(pd, "pad_medium");
2357    evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
2358    evas_object_size_hint_align_set(pd, 0.5, 0.5);
2359    elm_table_pack(base, pd, 0, 5, 2, 1);
2360    evas_object_show(pd);
2361
2362    bx = elm_box_add(win);
2363    elm_box_horizontal_set(bx, EINA_TRUE);
2364    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2365    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2366    evas_object_show(bx);
2367
2368    bt = elm_button_add(win);
2369    evas_object_smart_callback_add(bt, "clicked", _font_overlay_set_all, win);
2370    elm_object_text_set(bt, "Set to All");
2371    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2372    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2373    elm_box_pack_end(bx, bt);
2374    evas_object_show(bt);
2375
2376    bt = elm_button_add(win);
2377    evas_object_smart_callback_add(bt, "clicked", _font_overlay_reset, win);
2378    elm_object_text_set(bt, "Reset");
2379    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2380    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2381    elm_box_pack_end(bx, bt);
2382    evas_object_show(bt);
2383
2384    bt = elm_button_add(win);
2385    evas_object_smart_callback_add(bt, "clicked", _font_overlay_reset_all, win);
2386    elm_object_text_set(bt, "Reset All");
2387    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2388    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2389    elm_box_pack_end(bx, bt);
2390    evas_object_show(bt);
2391
2392    bt = elm_button_add(win);
2393    evas_object_smart_callback_add(bt, "clicked", _font_overlay_change, win);
2394    elm_object_text_set(bt, "Apply");
2395    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2396    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2397    elm_box_pack_end(bx, bt);
2398    evas_object_show(bt);
2399
2400    elm_object_content_set(pd, bx);
2401
2402    evas_object_data_set(win, "fonts", base);
2403
2404    elm_naviframe_item_simple_push(naviframe, base);
2405 }
2406
2407 static void
2408 _engines_list_item_del_cb(void            *data,
2409                           Evas_Object *obj EINA_UNUSED,
2410                           void *event_info EINA_UNUSED)
2411 {
2412    free(data);
2413 }
2414
2415 static void
2416 _profiles_list_item_del_cb(void            *data,
2417                            Evas_Object *obj EINA_UNUSED,
2418                            void *event_info EINA_UNUSED)
2419 {
2420    free(data);
2421 }
2422
2423 static void
2424 _profiles_list_selected_cb(void            *data,
2425                            Evas_Object     *obj,
2426                            void *event_info EINA_UNUSED)
2427 {
2428    const char *cur_profile = NULL;
2429    const char *sel_profile, *pdir;
2430    const char *prof_name;
2431    char buf[PATH_MAX];
2432    Evas_Object *en;
2433 #ifdef ELM_EFREET
2434    Efreet_Desktop *desk = NULL;
2435 #endif
2436
2437    sel_profile = data;
2438    if (!sel_profile)
2439      return;
2440
2441    cur_profile = elm_config_profile_get();
2442
2443    pdir = elm_config_profile_dir_get(sel_profile, EINA_TRUE);
2444    if (!pdir) pdir = elm_config_profile_dir_get(sel_profile, EINA_FALSE);
2445 #ifdef ELM_EFREET
2446    snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
2447    desk = efreet_desktop_new(buf);
2448    if ((desk) && (desk->name)) prof_name = desk->name;
2449    else
2450      {
2451         if (desk) efreet_desktop_free(desk);
2452         if (pdir) elm_config_profile_dir_free(pdir);
2453
2454         pdir = elm_config_profile_dir_get(sel_profile, EINA_FALSE);
2455         snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
2456         desk = efreet_desktop_new(buf);
2457         if ((desk) && (desk->name)) prof_name = desk->name;
2458         else prof_name = cur_profile;
2459      }
2460 #endif
2461    prof_name = cur_profile;
2462
2463    if (!pdir)
2464      elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
2465                              EINA_TRUE);
2466    else
2467      {
2468         elm_object_disabled_set(evas_object_data_get(obj, "prof_del_btn"),
2469                                 EINA_TRUE);
2470         elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
2471                                 EINA_FALSE);
2472         elm_object_disabled_set(evas_object_data_get(obj, "prof_use_btn"),
2473                                 EINA_FALSE);
2474         elm_config_profile_dir_free(pdir);
2475      }
2476
2477    snprintf(buf, sizeof(buf), "<hilight>Selected profile: %s</><br/>",
2478             prof_name);
2479    elm_object_text_set(evas_object_data_get(obj, "prof_name_lbl"), buf);
2480
2481    en = evas_object_data_get(obj, "prof_desc_entry");
2482 #ifdef ELM_EFREET
2483    if (desk) elm_object_text_set(en, desk->comment);
2484    else
2485 #endif
2486    elm_object_text_set(en, "Unknown");
2487
2488 #ifdef ELM_EFREET
2489    if (desk) efreet_desktop_free(desk);
2490 #endif
2491 }
2492
2493 static void
2494 _profiles_list_fill(Evas_Object *l_widget,
2495                     Eina_List   *p_names)
2496 {
2497    const char *cur_profile = NULL;
2498    const char *profile;
2499    void *sel_it = NULL;
2500    Eina_List *l;
2501
2502    if (!p_names)
2503      return;
2504
2505    elm_list_clear(l_widget);
2506
2507    cur_profile = elm_config_profile_get();
2508
2509    EINA_LIST_FOREACH(p_names, l, profile)
2510      {
2511 #ifdef ELM_EFREET
2512         Efreet_Desktop *desk = NULL;
2513 #endif
2514         const char *label, *ext, *pdir;
2515         char buf[PATH_MAX];
2516         Elm_Object_Item *list_it;
2517         Evas_Object *ic;
2518
2519         pdir = elm_config_profile_dir_get(profile, EINA_TRUE);
2520         if (!pdir) pdir = elm_config_profile_dir_get(profile, EINA_FALSE);
2521         label = profile;
2522
2523 #ifdef ELM_EFREET
2524         snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
2525         desk = efreet_desktop_new(buf);
2526         if ((desk) && (desk->name)) label = desk->name;
2527         else
2528           {
2529              if (desk) efreet_desktop_free(desk);
2530              if (pdir) elm_config_profile_dir_free(pdir);
2531
2532              pdir = elm_config_profile_dir_get(profile, EINA_FALSE);
2533              snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
2534              desk = efreet_desktop_new(buf);
2535              if ((desk) && (desk->name)) label = desk->name;
2536              else label = profile;
2537           }
2538 #endif
2539
2540         buf[0] = 0;
2541         if (pdir) snprintf(buf, sizeof(buf), "%s/icon.edj", pdir);
2542 #ifdef ELM_EFREET
2543         if ((desk) && (desk->icon) && (pdir))
2544           snprintf(buf, sizeof(buf), "%s/%s", pdir, desk->icon);
2545 #endif
2546         ic = elm_icon_add(l_widget);
2547         ext = strrchr(buf, '.');
2548         if (ext)
2549           {
2550              if (!strcmp(ext, ".edj")) elm_image_file_set(ic, buf, "icon");
2551              else elm_image_file_set(ic, buf, NULL);
2552           }
2553
2554         evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL,
2555                                          1, 1);
2556         evas_object_show(ic);
2557
2558         list_it = elm_list_item_append(l_widget, label, ic, NULL,
2559                                        _profiles_list_selected_cb,
2560                                        strdup(profile));
2561         elm_object_item_del_cb_set(list_it, _profiles_list_item_del_cb);
2562         if (cur_profile && !strcmp(profile, cur_profile))
2563           sel_it = list_it;
2564
2565         elm_config_profile_dir_free(pdir);
2566
2567 #ifdef ELM_EFREET
2568         if (desk) efreet_desktop_free(desk);
2569 #endif
2570      }
2571
2572    if (sel_it) elm_list_item_selected_set(sel_it, EINA_TRUE);
2573    elm_list_go(l_widget);
2574 }
2575
2576 static void
2577 _profiles_list_unselect_cb(void *data       EINA_UNUSED,
2578                            Evas_Object     *obj,
2579                            void *event_info EINA_UNUSED)
2580 {
2581    if (elm_list_selected_item_get(obj)) return;
2582    elm_object_disabled_set(evas_object_data_get(obj, "prof_del_btn"),
2583                            EINA_TRUE);
2584    elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
2585                            EINA_TRUE);
2586    elm_object_disabled_set(evas_object_data_get(obj, "prof_use_btn"),
2587                            EINA_TRUE);
2588 }
2589
2590 static void
2591 _status_config_profiles(Evas_Object *win,
2592                         Evas_Object *naviframe)
2593 {
2594    Evas_Object *li, *bx, *fr_bx1, *fr_bx2, *btn_bx, *fr, *lb, *en, *sp, *pd,
2595    *bt;
2596    Eina_List *profs;
2597    Evas *evas;
2598
2599    bx = elm_box_add(win);
2600    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2601    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2602
2603    fr_bx1 = elm_box_add(win);
2604    evas_object_size_hint_weight_set(fr_bx1, EVAS_HINT_EXPAND,
2605                                     EVAS_HINT_EXPAND);
2606    evas_object_size_hint_align_set(fr_bx1, EVAS_HINT_FILL, EVAS_HINT_FILL);
2607    elm_box_homogeneous_set(fr_bx1, EINA_TRUE);
2608    evas_object_show(fr_bx1);
2609
2610    fr_bx2 = elm_box_add(win);
2611    evas_object_size_hint_weight_set(fr_bx2, EVAS_HINT_EXPAND,
2612                                     EVAS_HINT_EXPAND);
2613    evas_object_size_hint_align_set(fr_bx2, EVAS_HINT_FILL, EVAS_HINT_FILL);
2614    evas_object_show(fr_bx2);
2615
2616    fr = elm_frame_add(win);
2617    elm_object_text_set(fr, "Available Profiles");
2618    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2619    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2620    elm_object_content_set(fr, fr_bx1);
2621    elm_box_pack_end(bx, fr);
2622    evas_object_show(fr);
2623
2624    li = elm_list_add(win);
2625    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2626    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2627    evas_object_smart_callback_add(li, "unselected", _profiles_list_unselect_cb,
2628                                   NULL);
2629
2630    profs = elm_config_profile_list_get();
2631
2632    evas_object_show(li);
2633    elm_box_pack_end(fr_bx2, li);
2634
2635    lb = elm_label_add(win);
2636    evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.0);
2637    evas_object_size_hint_align_set(lb, EVAS_HINT_FILL, 0.5);
2638
2639    evas_object_show(lb);
2640
2641    en = elm_entry_add(win);
2642    elm_entry_scrollable_set(en, EINA_TRUE);
2643    elm_entry_editable_set(en, EINA_FALSE);
2644    evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2645    evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
2646    evas_object_show(en);
2647
2648    evas_object_data_set(li, "prof_name_lbl", lb);
2649    evas_object_data_set(li, "prof_desc_entry", en);
2650
2651    elm_box_pack_end(fr_bx2, lb);
2652    elm_box_pack_end(fr_bx1, fr_bx2);
2653    elm_box_pack_end(fr_bx1, en);
2654
2655    /////////////////////////////////////////////
2656    sp = elm_separator_add(win);
2657    elm_separator_horizontal_set(sp, EINA_TRUE);
2658    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2659    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2660    elm_box_pack_end(bx, sp);
2661    evas_object_show(sp);
2662
2663    pd = elm_frame_add(win);
2664    elm_object_style_set(pd, "pad_medium");
2665    evas_object_size_hint_weight_set(pd, 0.0, 0.0);
2666    evas_object_size_hint_align_set(pd, 0.5, 0.5);
2667    elm_box_pack_end(bx, pd);
2668    evas_object_show(pd);
2669
2670    btn_bx = elm_box_add(win);
2671    elm_box_horizontal_set(btn_bx, EINA_TRUE);
2672    evas_object_size_hint_weight_set(btn_bx, EVAS_HINT_EXPAND,
2673                                     EVAS_HINT_EXPAND);
2674    evas_object_size_hint_align_set(btn_bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2675    evas_object_show(btn_bx);
2676
2677    bt = elm_button_add(win);
2678    evas_object_smart_callback_add(bt, "clicked", _profile_use, li);
2679    elm_object_text_set(bt, "Use");
2680    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2681    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2682    elm_box_pack_end(btn_bx, bt);
2683    evas_object_show(bt);
2684
2685    evas_object_data_set(li, "prof_use_btn", bt);
2686
2687    bt = elm_button_add(win);
2688    evas_object_smart_callback_add(bt, "clicked", _btn_todo, NULL); /* TODO */
2689    elm_object_text_set(bt, "Delete");
2690    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2691    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2692    elm_box_pack_end(btn_bx, bt);
2693    evas_object_show(bt);
2694
2695    evas_object_data_set(li, "prof_del_btn", bt);
2696
2697    bt = elm_button_add(win);
2698    evas_object_smart_callback_add(bt, "clicked", _profile_reset, li);
2699    elm_object_text_set(bt, "Reset");
2700    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2701    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2702    elm_box_pack_end(btn_bx, bt);
2703    evas_object_show(bt);
2704
2705    evas_object_data_set(li, "prof_reset_btn", bt);
2706
2707    bt = elm_button_add(win);
2708    evas_object_smart_callback_add(bt, "clicked", _btn_todo, NULL); /* TODO */
2709    elm_object_text_set(bt, "Add new");
2710    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2711    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2712    elm_box_pack_end(btn_bx, bt);
2713    evas_object_show(bt);
2714
2715    elm_object_content_set(pd, btn_bx);
2716
2717    evas = evas_object_evas_get(li);
2718    evas_event_freeze(evas);
2719    edje_freeze();
2720
2721    _profiles_list_fill(li, profs);
2722
2723    elm_config_profile_list_free(profs);
2724
2725    edje_thaw();
2726    evas_event_thaw(evas);
2727
2728    evas_object_data_set(win, "profiles", bx);
2729    elm_naviframe_item_simple_push(naviframe, bx);
2730 }
2731
2732 static void
2733 _status_config_scrolling_bounce(Evas_Object *win, Evas_Object *box)
2734 {
2735    Evas_Object *fr, *bx, *ck, *pd, *lb, *sl;
2736
2737    fr = elm_frame_add(box);
2738    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
2739    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2740    elm_object_text_set(fr, "Bounce");
2741    elm_box_pack_end(box, fr);
2742    evas_object_show(fr);
2743
2744    bx = elm_box_add(fr);
2745    elm_object_content_set(fr, bx);
2746    evas_object_show(bx);
2747
2748    /* Enable Scroll Bounce */
2749    ck = elm_check_add(bx);
2750    elm_object_tooltip_text_set(ck, "Set whether scrollers should bounce<br/>"
2751                                    "when they reach their viewport's edge<br/>"
2752                                    "during a scroll");
2753    elm_object_text_set(ck, "Enable scroll bounce");
2754    evas_object_data_set(win, "scroll_bounce_check", ck);
2755    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
2756    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
2757    elm_check_state_set(ck, elm_config_scroll_bounce_enabled_get());
2758    elm_box_pack_end(bx, ck);
2759    evas_object_show(ck);
2760
2761    evas_object_smart_callback_add(ck, "changed", sb_change, NULL);
2762
2763    /* Scroll bounce friction */
2764    LABEL_FRAME_ADD("<hilight>Scroll bounce friction</>");
2765
2766    sl = elm_slider_add(bx);
2767    elm_object_tooltip_text_set(sl, "This is the amount of inertia a <br/>"
2768                                    "scroller will impose at bounce animations");
2769    evas_object_data_set(win, "bounce_friction_slider", sl);
2770    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2771    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2772    elm_slider_span_size_set(sl, 120);
2773    elm_slider_unit_format_set(sl, "%1.2f");
2774    elm_slider_indicator_format_set(sl, "%1.2f");
2775    elm_slider_min_max_set(sl, 0.0, 4.0);
2776    elm_slider_value_set(sl, elm_config_scroll_bounce_friction_get());
2777    elm_box_pack_end(bx, sl);
2778    evas_object_show(sl);
2779
2780    evas_object_smart_callback_add(sl, "changed", bf_round, NULL);
2781    evas_object_smart_callback_add(sl, "delay,changed", bf_change, NULL);
2782 }
2783
2784 static void
2785 _status_config_scrolling_acceleration(Evas_Object *win, Evas_Object *box)
2786 {
2787    Evas_Object *fr, *bx, *sl, *pd, *lb;
2788
2789    fr = elm_frame_add(box);
2790    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
2791    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2792    elm_object_text_set(fr, "Acceleration");
2793    elm_box_pack_end(box, fr);
2794    evas_object_show(fr);
2795
2796    bx = elm_box_add(fr);
2797    elm_object_content_set(fr, bx);
2798    evas_object_show(bx);
2799
2800    /* Thumb scroll acceleration threshold */
2801    LABEL_FRAME_ADD("<hilight>Thumb scroll acceleration threshold</>");
2802
2803    sl = elm_slider_add(bx);
2804    elm_object_tooltip_text_set(sl, "This is the minimum speed of mouse <br/>"
2805                                    "cursor movement which will accelerate<br/>"
2806                                    "scrolling velocity after a<br/>"
2807                                    "mouse up event (pixels/second)");
2808    evas_object_data_set(win, "ts_acceleration_threshold_slider", sl);
2809    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2810    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2811    elm_slider_span_size_set(sl, 120);
2812    elm_slider_unit_format_set(sl, "%1.0f pixels/s");
2813    elm_slider_indicator_format_set(sl, "%1.0f");
2814    elm_slider_min_max_set(sl, 10.0, 5000.0);
2815    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_acceleration_threshold_get());
2816    elm_box_pack_end(bx, sl);
2817    evas_object_show(sl);
2818
2819    evas_object_smart_callback_add(sl, "changed", tsat_round, NULL);
2820    evas_object_smart_callback_add(sl, "delay,changed", tsat_change, NULL);
2821
2822    /* Thumb scroll acceleration time limit */
2823    LABEL_FRAME_ADD("<hilight>Thumb scroll acceleration time limit</>");
2824
2825    sl = elm_slider_add(bx);
2826    elm_object_tooltip_text_set(sl, "This is the time limit for<br/>"
2827                                    "accelerating velocity<br/>");
2828    evas_object_data_set(win, "ts_acceleration_time_limit_slider", sl);
2829    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2830    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2831    elm_slider_span_size_set(sl, 120);
2832    elm_slider_unit_format_set(sl, "%1.1f");
2833    elm_slider_indicator_format_set(sl, "%1.1f");
2834    elm_slider_min_max_set(sl, 0.0, 15.0);
2835    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_acceleration_time_limit_get());
2836    elm_box_pack_end(bx, sl);
2837    evas_object_show(sl);
2838
2839    evas_object_smart_callback_add(sl, "changed", tsatl_round, NULL);
2840    evas_object_smart_callback_add(sl, "delay,changed", tsatl_change, NULL);
2841
2842    /* Thumb scroll acceleration weight */
2843    LABEL_FRAME_ADD("<hilight>Thumb scroll acceleration weight</>");
2844
2845    sl = elm_slider_add(bx);
2846    elm_object_tooltip_text_set(sl, "This is the weight for acceleration");
2847    evas_object_data_set(win, "ts_acceleration_weight_slider", sl);
2848    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2849    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2850    elm_slider_span_size_set(sl, 120);
2851    elm_slider_unit_format_set(sl, "%1.1f");
2852    elm_slider_indicator_format_set(sl, "%1.1f");
2853    elm_slider_min_max_set(sl, 1.0, 10.0);
2854    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_acceleration_weight_get());
2855    elm_box_pack_end(bx, sl);
2856    evas_object_show(sl);
2857
2858    evas_object_smart_callback_add(sl, "changed", tsaw_round, NULL);
2859    evas_object_smart_callback_add(sl, "delay,changed", tsaw_change, NULL);
2860 }
2861
2862 static void
2863 _status_config_scrolling(Evas_Object *win,
2864                          Evas_Object *naviframe)
2865 {
2866    Evas_Object *lb, *pd, *bx, *sl, *sp, *ck, *sc;
2867
2868    bx = elm_box_add(win);
2869    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
2870    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
2871
2872    sc = elm_scroller_add(win);
2873    evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2874    evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
2875    elm_scroller_bounce_set(sc, EINA_FALSE, EINA_TRUE);
2876    evas_object_show(sc);
2877    elm_object_content_set(sc, bx);
2878
2879    /* Bounce */
2880    _status_config_scrolling_bounce(win, bx);
2881
2882    /* Acceleration */
2883    _status_config_scrolling_acceleration(win, bx);
2884
2885    /* Enable thumb scroll */
2886    ck = elm_check_add(win);
2887    elm_object_tooltip_text_set(ck, "Set whether scrollers should be<br/>"
2888                                    "draggable from any point in their views");
2889    elm_object_text_set(ck, "Enable thumb scroll");
2890    evas_object_data_set(win, "thumbscroll_check", ck);
2891    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
2892    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
2893    elm_check_state_set(ck, elm_config_scroll_thumbscroll_enabled_get());
2894    elm_box_pack_end(bx, ck);
2895    evas_object_show(ck);
2896
2897    evas_object_smart_callback_add(ck, "changed", ts_change, NULL);
2898
2899    /* Thumb scroll threadhold */
2900    LABEL_FRAME_ADD("<hilight>Thumb scroll threshold</>");
2901
2902    sl = elm_slider_add(win);
2903    elm_object_tooltip_text_set(sl, "This is the number of pixels one should<br/>"
2904                                    "travel while dragging a scroller's view<br/>"
2905                                    "to actually trigger scrolling");
2906    evas_object_data_set(win, "ts_threshold_slider", sl);
2907    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2908    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2909    elm_slider_span_size_set(sl, 120);
2910    elm_slider_unit_format_set(sl, "%1.0f pixels");
2911    elm_slider_indicator_format_set(sl, "%1.0f");
2912    elm_slider_min_max_set(sl, 8.0, 50.0);
2913    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_threshold_get());
2914    elm_box_pack_end(bx, sl);
2915    evas_object_show(sl);
2916
2917    evas_object_smart_callback_add(sl, "changed", tst_round, NULL);
2918    evas_object_smart_callback_add(sl, "delay,changed", tst_change, NULL);
2919
2920    /* Thumb scroll hold threashold */
2921    LABEL_FRAME_ADD("<hilight>Thumb scroll hold threshold</>");
2922
2923    sl = elm_slider_add(win);
2924    elm_object_tooltip_text_set(sl, "This is the number of pixels the range<br/>"
2925                                    "which can be scrolled, while the scroller<br/>"
2926                                    "is holed");
2927    evas_object_data_set(win, "ts_hold_threshold_slider", sl);
2928    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2929    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2930    elm_slider_span_size_set(sl, 120);
2931    elm_slider_unit_format_set(sl, "%1.0f pixels");
2932    elm_slider_indicator_format_set(sl, "%1.0f");
2933    elm_slider_min_max_set(sl, 4.0, 500.0);
2934    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_hold_threshold_get());
2935    elm_box_pack_end(bx, sl);
2936    evas_object_show(sl);
2937
2938    evas_object_smart_callback_add(sl, "changed", tsht_round, NULL);
2939    evas_object_smart_callback_add(sl, "delay,changed", tsht_change, NULL);
2940
2941    /* Thumb scroll momentum threshold */
2942    LABEL_FRAME_ADD("<hilight>Thumb scroll momentum threshold</>");
2943
2944    sl = elm_slider_add(win);
2945    elm_object_tooltip_text_set(sl, "This is the minimum speed of mouse <br/>"
2946                                    "cursor movement which will trigger<br/>"
2947                                    "list self scrolling animation after a<br/>"
2948                                    "mouse up event (pixels/second)");
2949    evas_object_data_set(win, "ts_momentum_threshold_slider", sl);
2950    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2951    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2952    elm_slider_span_size_set(sl, 120);
2953    elm_slider_unit_format_set(sl, "%1.0f pixels/s");
2954    elm_slider_indicator_format_set(sl, "%1.0f");
2955    elm_slider_min_max_set(sl, 10.0, 200.0);
2956    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_momentum_threshold_get());
2957    elm_box_pack_end(bx, sl);
2958    evas_object_show(sl);
2959
2960    evas_object_smart_callback_add(sl, "changed", tsmt_round, NULL);
2961    evas_object_smart_callback_add(sl, "delay,changed", tsmt_change,
2962                                   NULL);
2963
2964    /* Thumb scroll flick distance tolerance */
2965    LABEL_FRAME_ADD("<hilight>Thumb scroll flick distance tolerance</>");
2966
2967    sl = elm_slider_add(win);
2968    elm_object_tooltip_text_set(sl, "This is the number of pixels the maximum<br/>"
2969                                    "distance which can be flicked. If it is<br/>"
2970                                    "flicked more than this, the flick distance<br/>"
2971                                    "is same with maximum distance");
2972    evas_object_data_set(win, "ts_flick_distance_tolerance_slider", sl);
2973    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2974    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2975    elm_slider_span_size_set(sl, 120);
2976    elm_slider_unit_format_set(sl, "%1.0f pixels");
2977    elm_slider_indicator_format_set(sl, "%1.0f");
2978    elm_slider_min_max_set(sl, 100.0, 3000.0);
2979    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_flick_distance_tolerance_get());
2980    elm_box_pack_end(bx, sl);
2981    evas_object_show(sl);
2982
2983    evas_object_smart_callback_add(sl, "changed", tsfdt_round, NULL);
2984    evas_object_smart_callback_add(sl, "delay,changed", tsfdt_change, NULL);
2985
2986    /* Thumb scroll friction */
2987    LABEL_FRAME_ADD("<hilight>Thumb scroll friction</>");
2988
2989    sl = elm_slider_add(win);
2990    elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br/>"
2991                                    "scroller will impose at self scrolling<br/>"
2992                                    "animations");
2993    evas_object_data_set(win, "ts_friction_slider", sl);
2994    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2995    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2996    elm_slider_span_size_set(sl, 120);
2997    elm_slider_unit_format_set(sl, "%1.1f");
2998    elm_slider_indicator_format_set(sl, "%1.1f");
2999    elm_slider_min_max_set(sl, 0.1, 10.0);
3000    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_friction_get());
3001    elm_box_pack_end(bx, sl);
3002    evas_object_show(sl);
3003
3004    evas_object_smart_callback_add(sl, "changed", tsf_round, NULL);
3005    evas_object_smart_callback_add(sl, "delay,changed", tsf_change, NULL);
3006
3007    /* Thumb scroll min friction */
3008    LABEL_FRAME_ADD("<hilight>Thumb scroll min friction</>");
3009
3010    sl = elm_slider_add(win);
3011    elm_object_tooltip_text_set(sl, "This is the min amount of inertia a<br/>"
3012                                    "scroller will impose at self scrolling<br/>"
3013                                    "animations");
3014    evas_object_data_set(win, "ts_min_friction_slider", sl);
3015    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3016    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3017    elm_slider_span_size_set(sl, 120);
3018    elm_slider_unit_format_set(sl, "%1.1f");
3019    elm_slider_indicator_format_set(sl, "%1.1f");
3020    elm_slider_min_max_set(sl, 0.1, 10.0);
3021    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_min_friction_get());
3022    elm_box_pack_end(bx, sl);
3023    evas_object_show(sl);
3024
3025    evas_object_smart_callback_add(sl, "changed", tsmf_round, NULL);
3026    evas_object_smart_callback_add(sl, "delay,changed", tsmf_change, NULL);
3027
3028    /* Thumb scroll friction standard */
3029    LABEL_FRAME_ADD("<hilight>Thumb scroll friction standard</>");
3030
3031    sl = elm_slider_add(win);
3032    elm_object_tooltip_text_set(sl, "This is the standard velocity of the scroller."
3033                                    "<br/>The scroll animation time is same<br/>"
3034                                    "with thumbscroll friction, if the velocity"
3035                                    "<br/>is same with standard velocity.");
3036    evas_object_data_set(win, "ts_friction_standard_slider", sl);
3037    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3038    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3039    elm_slider_span_size_set(sl, 120);
3040    elm_slider_unit_format_set(sl, "%1.0f pixel/s");
3041    elm_slider_indicator_format_set(sl, "%1.0f");
3042    elm_slider_min_max_set(sl, 10.0, 5000.0);
3043    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_friction_standard_get());
3044    elm_box_pack_end(bx, sl);
3045    evas_object_show(sl);
3046
3047    evas_object_smart_callback_add(sl, "changed", tsfs_round, NULL);
3048    evas_object_smart_callback_add(sl, "delay,changed", tsfs_change, NULL);
3049
3050    /* Thumb scroll border friction */
3051    LABEL_FRAME_ADD("<hilight>Thumb scroll border friction</>");
3052
3053    sl = elm_slider_add(win);
3054    elm_object_tooltip_text_set(sl, "This is the amount of lag between your<br/>"
3055                                    "actual mouse cursor dragging movement<br/>"
3056                                    "and a scroller's view movement itself,<br/>"
3057                                    "while pushing it into bounce state<br/>"
3058                                    "manually");
3059    evas_object_data_set(win, "ts_border_friction_slider", sl);
3060    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3061    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3062    elm_slider_span_size_set(sl, 120);
3063    elm_slider_unit_format_set(sl, "%1.2f");
3064    elm_slider_indicator_format_set(sl, "%1.2f");
3065    elm_slider_min_max_set(sl, 0.0, 1.0);
3066    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_border_friction_get());
3067    elm_box_pack_end(bx, sl);
3068    evas_object_show(sl);
3069
3070    evas_object_smart_callback_add(sl, "changed", tsbf_round, NULL);
3071    evas_object_smart_callback_add(sl, "delay,changed", tsbf_change, NULL);
3072
3073    /* Thumb scroll sensitivity friction */
3074    LABEL_FRAME_ADD("<hilight>Thumb scroll sensitivity friction</>");
3075
3076    sl = elm_slider_add(win);
3077    elm_object_tooltip_text_set(sl, "This is the sensitivity amount which<br/>"
3078                                    "is be multiplied by the length of mouse<br/>"
3079                                    "dragging.");
3080    evas_object_data_set(win, "ts_sensitivity_friction_slider", sl);
3081    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3082    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3083    elm_slider_span_size_set(sl, 120);
3084    elm_slider_unit_format_set(sl, "%1.2f");
3085    elm_slider_indicator_format_set(sl, "%1.2f");
3086    elm_slider_min_max_set(sl, 0.1, 1.0);
3087    elm_slider_value_set(sl, elm_config_scroll_thumbscroll_sensitivity_friction_get());
3088    elm_box_pack_end(bx, sl);
3089    evas_object_show(sl);
3090
3091    evas_object_smart_callback_add(sl, "changed", tssf_round, NULL);
3092    evas_object_smart_callback_add(sl, "delay,changed", tssf_change, NULL);
3093
3094    sp = elm_separator_add(win);
3095    elm_separator_horizontal_set(sp, EINA_TRUE);
3096    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3097    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3098    elm_box_pack_end(bx, sp);
3099    evas_object_show(sp);
3100
3101    /* Page scroll friction */
3102    LABEL_FRAME_ADD("<hilight>Page scroll friction</>");
3103
3104    sl = elm_slider_add(win);
3105    elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br/>"
3106                                    "paged scroller will impose at<br/>"
3107                                    "page fitting animations");
3108    evas_object_data_set(win, "page_scroll_friction_slider", sl);
3109    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3110    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3111    elm_slider_span_size_set(sl, 120);
3112    elm_slider_unit_format_set(sl, "%1.1f");
3113    elm_slider_indicator_format_set(sl, "%1.1f");
3114    elm_slider_min_max_set(sl, 0.0, 5.0);
3115    elm_slider_value_set(sl, elm_config_scroll_page_scroll_friction_get());
3116    elm_box_pack_end(bx, sl);
3117    evas_object_show(sl);
3118
3119    evas_object_smart_callback_add(sl, "changed", ps_round, NULL);
3120    evas_object_smart_callback_add(sl, "delay,changed", ps_change, NULL);
3121
3122    /* Bring in scroll friction */
3123    LABEL_FRAME_ADD("<hilight>Bring in scroll friction</>");
3124
3125    sl = elm_slider_add(win);
3126    elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br/>"
3127                                    "scroller will impose at region bring<br/>"
3128                                    "animations");
3129    evas_object_data_set(win, "bring_in_scroll_friction_slider", sl);
3130    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3131    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3132    elm_slider_span_size_set(sl, 120);
3133    elm_slider_unit_format_set(sl, "%1.1f");
3134    elm_slider_indicator_format_set(sl, "%1.1f");
3135    elm_slider_min_max_set(sl, 0.0, 5.0);
3136    elm_slider_value_set(sl, elm_config_scroll_bring_in_scroll_friction_get());
3137    elm_box_pack_end(bx, sl);
3138    evas_object_show(sl);
3139
3140    evas_object_smart_callback_add(sl, "changed", bis_round, NULL);
3141    evas_object_smart_callback_add(sl, "delay,changed", bis_change, NULL);
3142
3143    /* Zoom scroll friction */
3144    LABEL_FRAME_ADD("<hilight>Zoom scroll friction</>");
3145
3146    sl = elm_slider_add(win);
3147    elm_object_tooltip_text_set(sl, "This is the amount of inertia<br/>"
3148                                    "scrollers will impose at animations<br/>"
3149                                    "triggered by Elementary widgets'<br/>"
3150                                    "zooming API");
3151    evas_object_data_set(win, "zoom_scroll_friction_slider", sl);
3152    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3153    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3154    elm_slider_span_size_set(sl, 120);
3155    elm_slider_unit_format_set(sl, "%1.1f");
3156    elm_slider_indicator_format_set(sl, "%1.1f");
3157    elm_slider_min_max_set(sl, 0.0, 5.0);
3158    elm_slider_value_set(sl, elm_config_scroll_zoom_friction_get());
3159    elm_box_pack_end(bx, sl);
3160    evas_object_show(sl);
3161
3162    evas_object_smart_callback_add(sl, "changed", zf_round, NULL);
3163    evas_object_smart_callback_add(sl, "delay,changed", zf_change, NULL);
3164
3165    evas_object_data_set(win, "scrolling", sc);
3166
3167    elm_naviframe_item_simple_push(naviframe, sc);
3168 }
3169
3170 static char *
3171 _engine_name_prettify(const char *engine)
3172 {
3173    char *ret, *ptr;
3174
3175    ret = strdup(engine);
3176    ret[0] -= 0x20;
3177
3178    while ((ptr = strpbrk(ret, "_")))
3179      {
3180         *ptr = ' ';
3181      }
3182
3183    return ret;
3184 }
3185
3186 /* FIXME! ideally, we would trim elm_config.c's _elm_engines list at
3187    build time, making a getter for is as in ecore-evas. */
3188 static Eina_Bool
3189 _elm_engine_supported(const char *engine)
3190 {
3191    const char *engines[] = {
3192       "software_x11",
3193       "fb",
3194       "directfb",
3195       "software_16_x11",
3196       "software_8_x11",
3197       "xrender_x11",
3198       "opengl_x11",
3199       "software_gdi",
3200       "software_16_wince_gdi",
3201       "sdl",
3202       "software_16_sdl",
3203       "opengl_sdl",
3204       "ews",
3205       "opengl_cocoa",
3206       "psl1ght",
3207       "wayland_shm",
3208       "wayland_egl",
3209       NULL
3210    };
3211
3212    unsigned int i;
3213
3214    for (i = 0; engines[i]; i++)
3215      {
3216 #define ENGINE_COMPARE(name) (!strcmp(engines[i], name))
3217         if (ENGINE_COMPARE(engine))
3218           return EINA_TRUE;
3219 #undef ENGINE_COMPARE
3220      }
3221
3222    return EINA_FALSE;
3223 }
3224
3225 static void
3226 _engines_list_fill(Evas_Object *l_widget,
3227                    Eina_List   *e_names)
3228 {
3229    const char *engine, *cur_engine;
3230    void *sel_it = NULL;
3231    Eina_List *l;
3232
3233    if (!e_names)
3234      return;
3235
3236    cur_engine = elm_config_engine_get();
3237
3238    EINA_LIST_FOREACH(e_names, l, engine)
3239      {
3240         const char *label;
3241         Elm_Object_Item *list_it;
3242
3243         if (!_elm_engine_supported(engine))
3244           continue;
3245
3246         label = _engine_name_prettify(engine);
3247
3248         list_it = elm_list_item_append(l_widget, label, NULL, NULL, NULL,
3249                                   strdup(engine));
3250         elm_object_item_del_cb_set(list_it, _engines_list_item_del_cb);
3251         free((void *)label);
3252
3253         if (!strcmp(cur_engine, engine))
3254           sel_it = list_it;
3255      }
3256
3257    if (sel_it) elm_list_item_selected_set(sel_it, EINA_TRUE);
3258    elm_list_go(l_widget);
3259 }
3260
3261 static void
3262 _status_config_rendering(Evas_Object *win,
3263                          Evas_Object *naviframe)
3264 {
3265    Evas_Object *li, *bx, *fr, *sp, *pd, *bt;
3266    Eina_List *engines;
3267
3268    bx = elm_box_add(win);
3269    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3270    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
3271
3272    fr = elm_frame_add(win);
3273    elm_object_text_set(fr, "Available Engines");
3274    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3275    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3276    elm_box_pack_end(bx, fr);
3277    evas_object_show(fr);
3278
3279    li = elm_list_add(win);
3280    elm_object_content_set(fr, li);
3281    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3282    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3283
3284    engines = ecore_evas_engines_get();
3285    _engines_list_fill(li, engines);
3286    ecore_evas_engines_free(engines);
3287
3288    evas_object_show(li);
3289    evas_object_data_set(win, "engines_list", li);
3290
3291    /////////////////////////////////////////////
3292    sp = elm_separator_add(win);
3293    elm_separator_horizontal_set(sp, EINA_TRUE);
3294    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3295    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3296    elm_box_pack_end(bx, sp);
3297    evas_object_show(sp);
3298
3299    pd = elm_frame_add(win);
3300    elm_object_style_set(pd, "pad_medium");
3301    evas_object_size_hint_weight_set(pd, 0.0, 0.0);
3302    evas_object_size_hint_align_set(pd, 0.5, 0.5);
3303    elm_box_pack_end(bx, pd);
3304    evas_object_show(pd);
3305
3306    bt = elm_button_add(win);
3307    evas_object_smart_callback_add(bt, "clicked", _engine_use, li);
3308    elm_object_text_set(bt, "Use Engine");
3309    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3310    evas_object_size_hint_align_set(bt, 0.5, 0.5);
3311    elm_object_content_set(pd, bt);
3312    evas_object_show(bt);
3313
3314    evas_object_data_set(win, "rendering", bx);
3315    elm_naviframe_item_simple_push(naviframe, bx);
3316 }
3317
3318 static void
3319 _status_config_caches(Evas_Object *win,
3320                       Evas_Object *naviframe)
3321 {
3322    Evas_Object *lb, *pd, *bx, *sl, *sp, *ck;
3323
3324    bx = elm_box_add(win);
3325    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
3326    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
3327
3328    LABEL_FRAME_ADD("<hilight>Cache Flush Interval (8 ticks per second)</>");
3329
3330    sl = elm_slider_add(win);
3331    evas_object_data_set(win, "cache_flush_interval_slider", sl);
3332    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3333    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3334    elm_slider_span_size_set(sl, 120);
3335    elm_slider_unit_format_set(sl, "%1.0f ticks");
3336    elm_slider_indicator_format_set(sl, "%1.0f");
3337    elm_slider_min_max_set(sl, 8.0, 4096.0);
3338    elm_slider_value_set(sl, elm_config_cache_flush_interval_get());
3339    elm_object_disabled_set(sl, !elm_config_cache_flush_enabled_get());
3340
3341    ck = elm_check_add(win);
3342    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
3343    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
3344    elm_object_text_set(ck, "Enable Flushing");
3345    elm_check_state_set(ck, elm_config_cache_flush_enabled_get());
3346    evas_object_smart_callback_add(ck, "changed", cf_enable, sl);
3347    elm_box_pack_end(bx, ck);
3348    evas_object_show(ck);
3349
3350    elm_box_pack_end(bx, sl);
3351    evas_object_show(sl);
3352
3353    evas_object_smart_callback_add(sl, "changed", cf_round, NULL);
3354    evas_object_smart_callback_add(sl, "delay,changed", cf_change, NULL);
3355
3356    sp = elm_separator_add(win);
3357    elm_separator_horizontal_set(sp, EINA_TRUE);
3358    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3359    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3360    elm_box_pack_end(bx, sp);
3361    evas_object_show(sp);
3362
3363    LABEL_FRAME_ADD("<hilight>Font Cache Size</>");
3364
3365    sl = elm_slider_add(win);
3366    evas_object_data_set(win, "font_cache_slider", sl);
3367    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3368    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3369    elm_slider_span_size_set(sl, 120);
3370    elm_slider_unit_format_set(sl, "%1.1f MB");
3371    elm_slider_indicator_format_set(sl, "%1.1f");
3372    elm_slider_min_max_set(sl, 0.0, 4.0);
3373    elm_slider_value_set(sl, (double)elm_config_cache_font_cache_size_get() / 1024.0);
3374    elm_box_pack_end(bx, sl);
3375    evas_object_show(sl);
3376
3377    evas_object_smart_callback_add(sl, "changed", fc_round, NULL);
3378    evas_object_smart_callback_add(sl, "delay,changed", fc_change, NULL);
3379
3380    sp = elm_separator_add(win);
3381    elm_separator_horizontal_set(sp, EINA_TRUE);
3382    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3383    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3384    elm_box_pack_end(bx, sp);
3385    evas_object_show(sp);
3386
3387    LABEL_FRAME_ADD("<hilight>Image Cache Size</>");
3388
3389    sl = elm_slider_add(win);
3390    evas_object_data_set(win, "image_cache_slider", sl);
3391    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3392    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3393    elm_slider_span_size_set(sl, 120);
3394    elm_slider_unit_format_set(sl, "%1.0f MB");
3395    elm_slider_indicator_format_set(sl, "%1.0f");
3396    elm_slider_min_max_set(sl, 0, 32);
3397    elm_slider_value_set(sl, (double)elm_config_cache_image_cache_size_get() / 1024.0);
3398    elm_box_pack_end(bx, sl);
3399    evas_object_show(sl);
3400
3401    evas_object_smart_callback_add(sl, "changed", ic_round, NULL);
3402    evas_object_smart_callback_add(sl, "delay,changed", ic_change, NULL);
3403
3404    sp = elm_separator_add(win);
3405    elm_separator_horizontal_set(sp, EINA_TRUE);
3406    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3407    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3408    elm_box_pack_end(bx, sp);
3409    evas_object_show(sp);
3410
3411    LABEL_FRAME_ADD("<hilight>Number of Edje Files to Cache</>");
3412
3413    sl = elm_slider_add(win);
3414    evas_object_data_set(win, "edje_file_cache_slider", sl);
3415    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3416    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3417    elm_slider_span_size_set(sl, 120);
3418    elm_slider_unit_format_set(sl, "%1.0f files");
3419    elm_slider_indicator_format_set(sl, "%1.0f");
3420    elm_slider_min_max_set(sl, 0, 32);
3421    elm_slider_value_set(sl, elm_config_cache_edje_file_cache_size_get());
3422    elm_box_pack_end(bx, sl);
3423    evas_object_show(sl);
3424
3425    evas_object_smart_callback_add(sl, "changed", efc_round, NULL);
3426    evas_object_smart_callback_add(sl, "delay,changed", efc_change, NULL);
3427
3428    sp = elm_separator_add(win);
3429    elm_separator_horizontal_set(sp, EINA_TRUE);
3430    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3431    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3432    elm_box_pack_end(bx, sp);
3433    evas_object_show(sp);
3434
3435    LABEL_FRAME_ADD("<hilight>Number of Edje Collections to Cache</>");
3436
3437    sl = elm_slider_add(win);
3438    evas_object_data_set(win, "edje_collection_cache_slider", sl);
3439    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3440    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3441    elm_slider_span_size_set(sl, 120);
3442    elm_slider_unit_format_set(sl, "%1.0f collections");
3443    elm_slider_indicator_format_set(sl, "%1.0f");
3444    elm_slider_min_max_set(sl, 0, 128);
3445    elm_slider_value_set(sl, elm_config_cache_edje_collection_cache_size_get());
3446    elm_box_pack_end(bx, sl);
3447    evas_object_show(sl);
3448
3449    evas_object_smart_callback_add(sl, "changed", ecc_round, NULL);
3450    evas_object_smart_callback_add(sl, "delay,changed", ecc_change, NULL);
3451
3452    evas_object_data_set(win, "caches", bx);
3453
3454    elm_naviframe_item_simple_push(naviframe, bx);
3455 }
3456
3457 static void
3458 _status_config_full(Evas_Object *win,
3459                     Evas_Object *bx0)
3460 {
3461    Evas_Object *tb, *naviframe;
3462    Elm_Object_Item *tb_sizing, *tb_it;
3463
3464    tb = elm_toolbar_add(win);
3465    elm_toolbar_select_mode_set(tb, ELM_OBJECT_SELECT_MODE_ALWAYS);
3466    elm_toolbar_menu_parent_set(tb, win);
3467    elm_toolbar_homogeneous_set(tb, EINA_FALSE);
3468    evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, 0.0);
3469    evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
3470
3471    tb_sizing = elm_toolbar_item_append(tb, "zoom-fit-best", "Sizing",
3472                                     _cf_sizing, win);
3473    elm_toolbar_item_priority_set(tb_sizing, 100);
3474
3475    tb_it = elm_toolbar_item_append(tb, "preferences-desktop-theme", "Theme",
3476                                 _cf_themes, win);
3477    elm_toolbar_item_priority_set(tb_it, 90);
3478
3479    elm_toolbar_item_append(tb, "preferences-desktop-font", "Fonts",
3480                            _cf_fonts, win);
3481
3482    tb_it = elm_toolbar_item_append(tb, "system-users", "Profiles",
3483                                 _cf_profiles, win);
3484    elm_toolbar_item_priority_set(tb_it, 90);
3485
3486    elm_toolbar_item_append(tb, "system-run", "Scrolling", _cf_scrolling, win);
3487    elm_toolbar_item_append(tb, "video-display", "Rendering",
3488                            _cf_rendering, win);
3489    elm_toolbar_item_append(tb, "appointment-new", "Caches", _cf_caches, win);
3490    elm_toolbar_item_append(tb, NULL, "Etc", _cf_etc, win);
3491
3492    elm_box_pack_end(bx0, tb);
3493    evas_object_show(tb);
3494
3495    naviframe = elm_naviframe_add(win);
3496    evas_object_size_hint_align_set(naviframe, EVAS_HINT_FILL, EVAS_HINT_FILL);
3497    evas_object_size_hint_weight_set(naviframe, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3498    evas_object_data_set(win, "naviframe", naviframe);
3499
3500    _status_config_themes(win, naviframe);
3501    _status_config_fonts(win, naviframe);
3502    _status_config_profiles(win, naviframe);
3503    _status_config_rendering(win, naviframe);
3504    _status_config_scrolling(win, naviframe);
3505    _status_config_caches(win, naviframe);
3506    _status_config_etc(win, naviframe);
3507    _status_config_sizing(win, naviframe); // Note: call this at the end.
3508
3509    // FIXME uncomment after flip style fix, please
3510    //elm_object_style_set(naviframe, "flip");
3511    elm_toolbar_item_selected_set(tb_sizing, EINA_TRUE);
3512    elm_box_pack_end(bx0, naviframe);
3513    evas_object_show(naviframe);
3514 }
3515
3516 static void
3517 win_create(void)
3518 {
3519    Evas_Object *win, *bx0;
3520
3521    win = elm_win_util_standard_add("main", "Elementary Config");
3522    if (!win) exit(1);
3523    ecore_event_handler_add(ELM_EVENT_CONFIG_ALL_CHANGED, _config_all_changed,
3524                            win);
3525    evas_object_smart_callback_add(win, "delete,request", config_exit, NULL);
3526
3527    bx0 = elm_box_add(win);
3528    evas_object_size_hint_weight_set(bx0, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3529    elm_win_resize_object_add(win, bx0);
3530    evas_object_show(bx0);
3531
3532    if (!interactive) _status_basic(win, bx0);
3533    else if (0)
3534      _status_config(win, bx0);
3535    else _status_config_full(win, bx0);
3536
3537    evas_object_resize(win, 320, 480);
3538    evas_object_show(win);
3539 }
3540
3541 static Eina_Bool
3542 _exit_timer(void *data EINA_UNUSED)
3543 {
3544    elm_exit();
3545    return ECORE_CALLBACK_CANCEL;
3546 }
3547
3548 /* this is your elementary main function - it MUST be called IMMEDIATELY
3549  * after elm_init() and MUST be passed argc and argv, and MUST be called
3550  * elm_main and not be static - must be a visible symbol with EAPI infront */
3551 EAPI_MAIN int
3552 elm_main(int    argc,
3553          char **argv)
3554 {
3555    int i;
3556
3557    elm_app_info_set(elm_main, "elementary", "images/logo.png");
3558    elm_app_compile_bin_dir_set(PACKAGE_BIN_DIR);
3559    elm_app_compile_data_dir_set(PACKAGE_DATA_DIR);
3560
3561    for (i = 1; i < argc; i++)
3562      {
3563         if (!strcmp(argv[i], "-h"))
3564           {
3565              printf("Usage:\n"
3566                     "  -h                This help\n"
3567                     "  -q                Quiet mode (dont show window)\n"
3568                     "  -t THEME          Set theme to THEME (ELM_THEME spec)\n"
3569                     "  -f SIZE           Set finger size to SIZE pixels\n"
3570                     "  -s SCALE          Set scale factor to SCALE\n"
3571                     );
3572           }
3573         else if (!strcmp(argv[i], "-q"))
3574           {
3575              quiet = 1;
3576              interactive = 0;
3577           }
3578         else if ((!strcmp(argv[i], "-t")) && (i < argc - 1))
3579           {
3580              i++;
3581              theme_set = argv[i];
3582              interactive = 0;
3583           }
3584         else if ((!strcmp(argv[i], "-f")) && (i < argc - 1))
3585           {
3586              i++;
3587              finger_size_set = argv[i];
3588              interactive = 0;
3589           }
3590         else if ((!strcmp(argv[i], "-s")) && (i < argc - 1))
3591           {
3592              i++;
3593              scale_set = argv[i];
3594              interactive = 0;
3595           }
3596      }
3597    /* put here any init code specific to this app like parsing args, etc. */
3598    if (!quiet)
3599      {
3600 #ifdef ELM_EFREET
3601         elm_need_efreet();
3602 #endif
3603         win_create(); /* create main window */
3604         if (!interactive)
3605           ecore_timer_add(2.0, _exit_timer, NULL);
3606      }
3607    if (!interactive)
3608      {
3609         if (theme_set) elm_theme_set(NULL, theme_set);
3610         if (finger_size_set) elm_config_finger_size_set(atoi(finger_size_set));
3611         if (scale_set)  elm_config_scale_set(atof(scale_set));
3612
3613         elm_config_all_flush();
3614
3615         if (quiet) elm_exit();
3616      }
3617    elm_run(); /* and run the program now and handle all events, etc. */
3618    /* if the mainloop that elm_run() runs exists, we exit the app */
3619    elm_shutdown(); /* clean up and shut down */
3620    /* exit code */
3621    return 0;
3622 }
3623 /* All elementary apps should use this. Put it right after elm_main() */
3624 ELM_MAIN()