wearable/src/bin/config.c

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