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 Theme *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_label_label_set(lb, label);                              \
  84        elm_frame_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 fdata = {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(fdata.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(fdata.font_hash);
 120
 121    EINA_LIST_FREE(fdata.font_px_list, sd)
 122      {
 123         eina_stringshare_del(sd->size_str);
 124         free(sd);
 125      }
 126
 127    EINA_LIST_FREE(fdata.font_scale_list, sd)
 128      {
 129         eina_stringshare_del(sd->size_str);
 130         free(sd);
 131      }
 132
 133    if (fdata.cur_font) eina_stringshare_del(fdata.cur_font);
 134    if (fdata.cur_style) eina_stringshare_del(fdata.cur_style);
 135
 136    elm_config_save();
 137    elm_exit(); /* exit the program's main loop that runs in elm_run() */
 138 }
 139
 140 static void
 141 sb_change(void *data       __UNUSED__,
 142           Evas_Object     *obj,
 143           void *event_info __UNUSED__)
 144 {
 145    Eina_Bool val = elm_check_state_get(obj);
 146    Eina_Bool sb = elm_scroll_bounce_enabled_get();
 147
 148    if (val == sb) return;
 149    elm_scroll_bounce_enabled_all_set(val);
 150
 151    /*TODO: enable/disable subordinate sliders (make 'em support it 1st)*/
 152 }
 153
 154 static void
 155 bf_round(void *data       __UNUSED__,
 156          Evas_Object     *obj,
 157          void *event_info __UNUSED__)
 158 {
 159    double val = elm_slider_value_get(obj);
 160    double v;
 161
 162    v = ((double)((int)(val * 10.0))) / 10.0;
 163    if (v != val) elm_slider_value_set(obj, v);
 164 }
 165
 166 static void
 167 bf_change(void *data       __UNUSED__,
 168           Evas_Object     *obj,
 169           void *event_info __UNUSED__)
 170 {
 171    double bf = elm_scroll_bounce_friction_get();
 172    double val = elm_slider_value_get(obj);
 173
 174    if (bf == val) return;
 175    elm_scroll_bounce_friction_all_set(val);
 176 }
 177
 178 static void
 179 ps_round(void *data       __UNUSED__,
 180          Evas_Object     *obj,
 181          void *event_info __UNUSED__)
 182 {
 183    double val = elm_slider_value_get(obj);
 184    double v;
 185
 186    v = ((double)((int)(val * 10.0))) / 10.0;
 187    if (v != val) elm_slider_value_set(obj, v);
 188 }
 189
 190 static void
 191 ps_change(void *data       __UNUSED__,
 192           Evas_Object     *obj,
 193           void *event_info __UNUSED__)
 194 {
 195    double ps = elm_scroll_page_scroll_friction_get();
 196    double val = elm_slider_value_get(obj);
 197
 198    if (ps == val) return;
 199    elm_scroll_page_scroll_friction_all_set(val);
 200 }
 201
 202 static void
 203 bis_round(void *data       __UNUSED__,
 204           Evas_Object     *obj,
 205           void *event_info __UNUSED__)
 206 {
 207    double val = elm_slider_value_get(obj);
 208    double v;
 209
 210    v = ((double)((int)(val * 10.0))) / 10.0;
 211    if (v != val) elm_slider_value_set(obj, v);
 212 }
 213
 214 static void
 215 bis_change(void *data       __UNUSED__,
 216            Evas_Object     *obj,
 217            void *event_info __UNUSED__)
 218 {
 219    double bis = elm_scroll_bring_in_scroll_friction_get();
 220    double val = elm_slider_value_get(obj);
 221
 222    if (bis == val) return;
 223    elm_scroll_bring_in_scroll_friction_all_set(val);
 224 }
 225
 226 static void
 227 zf_round(void *data       __UNUSED__,
 228          Evas_Object     *obj,
 229          void *event_info __UNUSED__)
 230 {
 231    double val = elm_slider_value_get(obj);
 232    double v;
 233
 234    v = ((double)((int)(val * 10.0))) / 10.0;
 235    if (v != val) elm_slider_value_set(obj, v);
 236 }
 237
 238 static void
 239 zf_change(void *data       __UNUSED__,
 240           Evas_Object     *obj,
 241           void *event_info __UNUSED__)
 242 {
 243    double zf = elm_scroll_zoom_friction_get();
 244    double val = elm_slider_value_get(obj);
 245
 246    if (zf == val) return;
 247    elm_scroll_zoom_friction_all_set(val);
 248 }
 249
 250 static void
 251 ts_change(void *data       __UNUSED__,
 252           Evas_Object     *obj,
 253           void *event_info __UNUSED__)
 254 {
 255    Eina_Bool val = elm_check_state_get(obj);
 256    Eina_Bool sb = elm_scroll_bounce_enabled_get();
 257
 258    if (val == sb) return;
 259    elm_scroll_thumbscroll_enabled_all_set(val);
 260
 261    /*TODO: enable/disable subordinate sliders (make 'em support it 1st)*/
 262 }
 263
 264 static void
 265 tst_round(void *data       __UNUSED__,
 266           Evas_Object     *obj,
 267           void *event_info __UNUSED__)
 268 {
 269    double val = elm_slider_value_get(obj);
 270    double v;
 271
 272    v = ((double)((int)(val * 10.0))) / 10.0;
 273    if (v != val) elm_slider_value_set(obj, v);
 274 }
 275
 276 static void
 277 tst_change(void *data       __UNUSED__,
 278            Evas_Object     *obj,
 279            void *event_info __UNUSED__)
 280 {
 281    double tst = elm_scroll_thumbscroll_threshold_get();
 282    double val = elm_slider_value_get(obj);
 283
 284    if (tst == val) return;
 285    elm_scroll_thumbscroll_threshold_all_set(val);
 286 }
 287
 288 static void
 289 tsmt_round(void *data       __UNUSED__,
 290            Evas_Object     *obj,
 291            void *event_info __UNUSED__)
 292 {
 293    double val = elm_slider_value_get(obj);
 294    double v;
 295
 296    v = ((double)((int)(val * 10.0))) / 10.0;
 297    if (v != val) elm_slider_value_set(obj, v);
 298 }
 299
 300 static void
 301 tsmt_change(void *data       __UNUSED__,
 302             Evas_Object     *obj,
 303             void *event_info __UNUSED__)
 304 {
 305    double tsmt = elm_scroll_thumbscroll_momentum_threshold_get();
 306    double val = elm_slider_value_get(obj);
 307
 308    if (tsmt == val) return;
 309    elm_scroll_thumbscroll_momentum_threshold_all_set(val);
 310 }
 311
 312 static void
 313 tsf_round(void *data       __UNUSED__,
 314           Evas_Object     *obj,
 315           void *event_info __UNUSED__)
 316 {
 317    double val = elm_slider_value_get(obj);
 318    double v;
 319
 320    v = ((double)((int)(val * 10.0))) / 10.0;
 321    if (v != val) elm_slider_value_set(obj, v);
 322 }
 323
 324 static void
 325 tsf_change(void *data       __UNUSED__,
 326            Evas_Object     *obj,
 327            void *event_info __UNUSED__)
 328 {
 329    double tsf = elm_scroll_thumbscroll_friction_get();
 330    double val = elm_slider_value_get(obj);
 331
 332    if (tsf == val) return;
 333    elm_scroll_thumbscroll_friction_all_set(val);
 334 }
 335
 336 static void
 337 tsbf_round(void *data       __UNUSED__,
 338            Evas_Object     *obj,
 339            void *event_info __UNUSED__)
 340 {
 341    double val = elm_slider_value_get(obj);
 342    double v;
 343
 344    v = ((double)((int)(val * 10.0))) / 10.0;
 345    if (v != val) elm_slider_value_set(obj, v);
 346 }
 347
 348 static void
 349 tsbf_change(void *data       __UNUSED__,
 350             Evas_Object     *obj,
 351             void *event_info __UNUSED__)
 352 {
 353    double tsbf = elm_scroll_thumbscroll_border_friction_get();
 354    double val = elm_slider_value_get(obj);
 355
 356    if (tsbf == val) return;
 357    elm_scroll_thumbscroll_border_friction_all_set(val);
 358 }
 359
 360 static void
 361 cf_enable(void *data,
 362           Evas_Object     *obj,
 363           void *event_info __UNUSED__)
 364 {
 365    Eina_Bool cf = elm_cache_flush_enmabled_get();
 366    Eina_Bool val = elm_check_state_get(obj);
 367
 368    if (cf == val) return;
 369    elm_object_disabled_set((Evas_Object *)data, !val);
 370    elm_cache_flush_enabled_all_set(val);
 371 }
 372
 373 static void
 374 cf_round(void *data       __UNUSED__,
 375          Evas_Object     *obj,
 376          void *event_info __UNUSED__)
 377 {
 378    double val = elm_slider_value_get(obj);
 379    double v;
 380
 381    v = ((double)((int)(val * 5.0))) / 5.0;
 382    if (v != val) elm_slider_value_set(obj, v);
 383 }
 384
 385 static void
 386 cf_change(void *data       __UNUSED__,
 387           Evas_Object     *obj,
 388           void *event_info __UNUSED__)
 389 {
 390    double cf = elm_cache_flush_interval_get();
 391    double val = elm_slider_value_get(obj);
 392
 393    if (cf == val) return;
 394    elm_cache_flush_interval_all_set(val);
 395 }
 396
 397 static void
 398 fc_round(void *data       __UNUSED__,
 399          Evas_Object     *obj,
 400          void *event_info __UNUSED__)
 401 {
 402    double val = elm_slider_value_get(obj);
 403    double v;
 404
 405    v = ((double)((int)(val * 10.0))) / 10.0;
 406    if (v != val) elm_slider_value_set(obj, v);
 407 }
 408
 409 static void
 410 fc_change(void *data       __UNUSED__,
 411           Evas_Object     *obj,
 412           void *event_info __UNUSED__)
 413 {
 414    double font_cache = elm_font_cache_get();
 415    double val = elm_slider_value_get(obj);
 416
 417    if (font_cache == val) return;
 418    elm_font_cache_all_set(val * 1024);
 419 }
 420
 421 static void
 422 ic_round(void *data       __UNUSED__,
 423          Evas_Object     *obj,
 424          void *event_info __UNUSED__)
 425 {
 426    double val = elm_slider_value_get(obj);
 427    double v;
 428
 429    v = ((double)((int)(val * 10.0))) / 10.0;
 430    if (v != val) elm_slider_value_set(obj, v);
 431 }
 432
 433 static void
 434 ic_change(void *data       __UNUSED__,
 435           Evas_Object     *obj,
 436           void *event_info __UNUSED__)
 437 {
 438    double image_cache = elm_image_cache_get();
 439    double val = elm_slider_value_get(obj);
 440
 441    if (image_cache == val) return;
 442    elm_image_cache_all_set(val * 1024);
 443 }
 444
 445 static void
 446 sc_round(void *data       __UNUSED__,
 447          Evas_Object     *obj,
 448          void *event_info __UNUSED__)
 449 {
 450    double val = elm_slider_value_get(obj);
 451    double v;
 452
 453    v = ((double)((int)(val * 10.0))) / 10.0;
 454    if (v != val) elm_slider_value_set(obj, v);
 455 }
 456
 457 static void
 458 sc_change(void *data       __UNUSED__,
 459           Evas_Object     *obj,
 460           void *event_info __UNUSED__)
 461 {
 462    double scale = elm_scale_get();
 463    double val = elm_slider_value_get(obj);
 464
 465    if (scale == val) return;
 466    elm_scale_all_set(val);
 467 }
 468
 469 static void
 470 fs_round(void *data       __UNUSED__,
 471          Evas_Object     *obj,
 472          void *event_info __UNUSED__)
 473 {
 474    double val = elm_slider_value_get(obj);
 475    double v;
 476
 477    v = ((double)((int)(val * 5.0))) / 5.0;
 478    if (v != val) elm_slider_value_set(obj, v);
 479 }
 480
 481 static void
 482 fs_change(void *data       __UNUSED__,
 483           Evas_Object     *obj,
 484           void *event_info __UNUSED__)
 485 {
 486    double fs = elm_finger_size_get();
 487    double val = elm_slider_value_get(obj);
 488
 489    if (fs == val) return;
 490    elm_finger_size_all_set(val);
 491 }
 492
 493 static void
 494 efc_round(void *data       __UNUSED__,
 495           Evas_Object     *obj,
 496           void *event_info __UNUSED__)
 497 {
 498    double val = elm_slider_value_get(obj);
 499    double v;
 500
 501    v = ((double)((int)(val * 5.0))) / 5.0;
 502    if (v != val) elm_slider_value_set(obj, v);
 503 }
 504
 505 static void
 506 efc_change(void *data       __UNUSED__,
 507            Evas_Object     *obj,
 508            void *event_info __UNUSED__)
 509 {
 510    double efc = elm_edje_file_cache_get();
 511    double val = elm_slider_value_get(obj);
 512
 513    if (efc == val) return;
 514    elm_edje_file_cache_all_set(val);
 515 }
 516
 517 static void
 518 ecc_round(void *data       __UNUSED__,
 519           Evas_Object     *obj,
 520           void *event_info __UNUSED__)
 521 {
 522    double val = elm_slider_value_get(obj);
 523    double v;
 524
 525    v = ((double)((int)(val * 5.0))) / 5.0;
 526    if (v != val) elm_slider_value_set(obj, v);
 527 }
 528
 529 static void
 530 ecc_change(void *data       __UNUSED__,
 531            Evas_Object     *obj,
 532            void *event_info __UNUSED__)
 533 {
 534    double ecc = elm_edje_collection_cache_get();
 535    double val = elm_slider_value_get(obj);
 536
 537    if (ecc == val) return;
 538    elm_edje_collection_cache_all_set(val);
 539 }
 540
 541 static void
 542 _status_basic(Evas_Object *win,
 543               Evas_Object *bx0)
 544 {
 545    Evas_Object *lb, *fr;
 546
 547    fr = elm_frame_add(win);
 548    evas_object_size_hint_weight_set(fr, 1.0, 1.0);
 549    elm_frame_label_set(fr, "Information");
 550    elm_box_pack_end(bx0, fr);
 551    evas_object_show(fr);
 552
 553    lb = elm_label_add(win);
 554    elm_label_label_set(lb,
 555                        "Applying configuration change"
 556                        );
 557    elm_frame_content_set(fr, lb);
 558    evas_object_show(lb);
 559 }
 560
 561 static void
 562 _status_config(Evas_Object *win,
 563                Evas_Object *bx0)
 564 {
 565    Evas_Object *lb, *pd, *bx, *fr, *sl, *sp;
 566
 567    fr = elm_frame_add(win);
 568    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 569    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
 570    elm_frame_label_set(fr, "Sizing");
 571    elm_box_pack_end(bx0, fr);
 572    evas_object_show(fr);
 573
 574    bx = elm_box_add(win);
 575    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
 576    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
 577
 578    LABEL_FRAME_ADD("<hilight>Scale</>");
 579
 580    sl = elm_slider_add(win);
 581    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
 582    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
 583    elm_slider_span_size_set(sl, 120);
 584    elm_slider_unit_format_set(sl, "%1.2f");
 585    elm_slider_indicator_format_set(sl, "%1.2f");
 586    elm_slider_min_max_set(sl, 0.25, 5.0);
 587    elm_slider_value_set(sl, elm_scale_get());
 588    elm_box_pack_end(bx, sl);
 589    evas_object_show(sl);
 590
 591    evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
 592    evas_object_smart_callback_add(sl, "delay,changed", sc_change, NULL);
 593
 594    sp = elm_separator_add(win);
 595    elm_separator_horizontal_set(sp, 1);
 596    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
 597    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
 598    elm_box_pack_end(bx, sp);
 599    evas_object_show(sp);
 600
 601    LABEL_FRAME_ADD("<hilight>Finger Size</><br>");
 602
 603    sl = elm_slider_add(win);
 604    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
 605    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
 606    elm_slider_span_size_set(sl, 120);
 607    elm_slider_unit_format_set(sl, "%1.0f");
 608    elm_slider_indicator_format_set(sl, "%1.0f");
 609    elm_slider_min_max_set(sl, 5, 200);
 610    elm_slider_value_set(sl, elm_finger_size_get());
 611    elm_box_pack_end(bx, sl);
 612    evas_object_show(sl);
 613
 614    evas_object_smart_callback_add(sl, "changed", fs_round, NULL);
 615    evas_object_smart_callback_add(sl, "delay,changed", fs_change, NULL);
 616
 617    // FIXME: add theme selector (basic mode and advanced for fallbacks)
 618    // FIXME: save config
 619    // FIXME: profile selector / creator etc.
 620    elm_frame_content_set(fr, bx);
 621    evas_object_show(bx);
 622 }
 623
 624 static void
 625 _flip_to(Evas_Object *win,
 626          const char  *name)
 627 {
 628    Evas_Object *wid, *pager;
 629    wid = evas_object_data_get(win, name);
 630    pager = evas_object_data_get(win, "pager");
 631    elm_pager_content_promote(pager, wid);
 632 }
 633
 634 static void
 635 _cf_sizing(void            *data,
 636            Evas_Object *obj __UNUSED__,
 637            void *event_info __UNUSED__)
 638 {
 639    _flip_to(data, "sizing");
 640 }
 641
 642 static void
 643 _cf_themes(void            *data,
 644            Evas_Object *obj __UNUSED__,
 645            void *event_info __UNUSED__)
 646 {
 647    _flip_to(data, "themes");
 648 }
 649
 650 static void
 651 _cf_fonts(void            *data,
 652           Evas_Object *obj __UNUSED__,
 653           void *event_info __UNUSED__)
 654 {
 655    _flip_to(data, "fonts");
 656 }
 657
 658 static void
 659 _cf_profiles(void            *data,
 660              Evas_Object *obj __UNUSED__,
 661              void *event_info __UNUSED__)
 662 {
 663    _flip_to(data, "profiles");
 664 }
 665
 666 static void
 667 _cf_scrolling(void            *data,
 668               Evas_Object *obj __UNUSED__,
 669               void *event_info __UNUSED__)
 670 {
 671    _flip_to(data, "scrolling");
 672 }
 673
 674 static void
 675 _cf_rendering(void            *data,
 676               Evas_Object *obj __UNUSED__,
 677               void *event_info __UNUSED__)
 678 {
 679    _flip_to(data, "rendering");
 680 }
 681
 682 static void
 683 _cf_caches(void            *data,
 684            Evas_Object *obj __UNUSED__,
 685            void *event_info __UNUSED__)
 686 {
 687    _flip_to(data, "caches");
 688 }
 689
 690 const char *
 691 _elm_theme_current_get(const char *theme_search_order)
 692 {
 693    const char *ret;
 694    const char *p;
 695
 696    if (!theme_search_order)
 697      return NULL;
 698
 699    for (p = theme_search_order;; p++)
 700      {
 701         if ((*p == ':') || (!*p))
 702           {
 703              if (p > theme_search_order)
 704                {
 705                   char *n = malloc(p - theme_search_order + 1);
 706                   if (!n)
 707                     return NULL;
 708
 709                   strncpy(n, theme_search_order, p - theme_search_order);
 710                   n[p - theme_search_order] = 0;
 711                   ret = eina_stringshare_add(n);
 712                   free(n);
 713                   break;
 714                }
 715           }
 716      }
 717
 718    return ret;
 719 }
 720
 721 static void
 722 _font_overlay_set_all(void            *data,
 723                       Evas_Object *obj __UNUSED__,
 724                       void *event_info __UNUSED__)
 725 {
 726    Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
 727    Elm_Text_Class_Data *tc_data, *tc;
 728    Elm_List_Item *it;
 729    Eina_List *l;
 730
 731    win = data;
 732
 733    fclasses = evas_object_data_get(win, "font_classes_list");
 734    it = elm_list_selected_item_get(fclasses);
 735    if (!it) return;
 736    tc_data = elm_list_item_data_get(it);
 737
 738    fnames = evas_object_data_get(win, "font_names_list");
 739    fstyles = evas_object_data_get(win, "font_styles_list");
 740    fsizes = evas_object_data_get(win, "font_sizes_list");
 741
 742    EINA_LIST_FOREACH(fdata.text_classes, l, tc)
 743      {
 744         eina_stringshare_replace(&tc->font, tc_data->font);
 745         eina_stringshare_replace(&tc->style, tc_data->style);
 746         tc->size = tc_data->size;
 747      }
 748
 749    elm_config_save();
 750 }
 751
 752 static void
 753 _font_overlay_reset(void            *data,
 754                     Evas_Object *obj __UNUSED__,
 755                     void *event_info __UNUSED__)
 756 {
 757    Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
 758    Elm_Text_Class_Data *tc_data;
 759    Elm_List_Item *it;
 760
 761    win = data;
 762
 763    fclasses = evas_object_data_get(win, "font_classes_list");
 764    it = elm_list_selected_item_get(fclasses);
 765    if (!it) return;
 766    tc_data = elm_list_item_data_get(it);
 767
 768    fnames = evas_object_data_get(win, "font_names_list");
 769    fstyles = evas_object_data_get(win, "font_styles_list");
 770    fsizes = evas_object_data_get(win, "font_sizes_list");
 771
 772    elm_font_overlay_unset(tc_data->name);
 773
 774    eina_stringshare_replace(&fdata.cur_font, NULL);
 775    eina_stringshare_replace(&tc_data->font, NULL);
 776    eina_stringshare_replace(&fdata.cur_style, NULL);
 777    eina_stringshare_replace(&tc_data->style, NULL);
 778    fdata.cur_size = 0.0;
 779    tc_data->size = 0.0;
 780
 781    ELM_LIST_DISABLE(fnames);
 782    ELM_LIST_DISABLE(fstyles);
 783    ELM_LIST_DISABLE(fsizes);
 784
 785    elm_config_save();
 786 }
 787
 788 static void
 789 _font_overlay_reset_all(void            *data,
 790                         Evas_Object *obj __UNUSED__,
 791                         void *event_info __UNUSED__)
 792 {
 793    Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
 794    Elm_Text_Class_Data *tc_data;
 795    Elm_List_Item *it;
 796    Eina_List *l;
 797
 798    win = data;
 799    eina_stringshare_replace(&fdata.cur_font, NULL);
 800    eina_stringshare_replace(&fdata.cur_style, NULL);
 801    fdata.cur_size = 0.0;
 802
 803    EINA_LIST_FOREACH(fdata.text_classes, l, tc_data)
 804      {
 805         elm_font_overlay_unset(tc_data->name);
 806
 807         eina_stringshare_replace(&tc_data->font, NULL);
 808         eina_stringshare_replace(&tc_data->style, NULL);
 809         tc_data->size = 0.0;
 810      }
 811
 812    fclasses = evas_object_data_get(win, "font_classes_list");
 813    fnames = evas_object_data_get(win, "font_names_list");
 814    fstyles = evas_object_data_get(win, "font_styles_list");
 815    fsizes = evas_object_data_get(win, "font_sizes_list");
 816
 817    it = elm_list_selected_item_get(fclasses);
 818    if (it) elm_list_item_selected_set(it, EINA_FALSE);
 819
 820    ELM_LIST_DISABLE(fnames);
 821    ELM_LIST_DISABLE(fstyles);
 822    ELM_LIST_DISABLE(fsizes);
 823
 824    elm_config_save();
 825 }
 826
 827 static void
 828 _font_overlay_change(void *data       __UNUSED__,
 829                      Evas_Object *obj __UNUSED__,
 830                      void *event_info __UNUSED__)
 831 {
 832    Elm_Text_Class_Data *tc_data;
 833    Eina_List *l;
 834
 835    EINA_LIST_FOREACH(fdata.text_classes, l, tc_data)
 836      {
 837         if (tc_data->font)
 838           {
 839              const char *name;
 840
 841              name = elm_font_fontconfig_name_get(tc_data->font,
 842                                                  tc_data->style);
 843              elm_font_overlay_set(tc_data->name, name,
 844                                   tc_data->size ? tc_data->size : -100);
 845              elm_font_fontconfig_name_free(name);
 846           }
 847         else
 848           elm_font_overlay_unset(tc_data->name);
 849      }
 850
 851    elm_config_save();
 852    elm_font_overlay_all_apply();
 853
 854    /* TODO: apply hinting */
 855 }
 856
 857 static void
 858 _profile_change_do(Evas_Object *win,
 859                    const char  *profile)
 860 {
 861    int flush_interval, font_c, image_c, edje_file_c, edje_col_c, ts_threshould;
 862    double scale, s_bounce_friction, ts_momentum_threshold, ts_friction,
 863           ts_border_friction, page_friction, bring_in_friction, zoom_friction;
 864    const char *curr_theme, *curr_engine;
 865    const Eina_List *l_items, *l;
 866    Eina_Bool s_bounce, ts;
 867    Elm_List_Item *it;
 868    Elm_Theme *th;
 869    int fs;
 870
 871    elm_profile_all_set(profile);
 872
 873    scale = elm_scale_get();
 874    fs = elm_finger_size_get();
 875    flush_interval = elm_cache_flush_interval_get();
 876    font_c = elm_font_cache_get();
 877    image_c = elm_image_cache_get();
 878    edje_file_c = elm_edje_file_cache_get();
 879    edje_col_c = elm_edje_collection_cache_get();
 880
 881    s_bounce = elm_scroll_bounce_enabled_get();
 882    s_bounce_friction = elm_scroll_bounce_friction_get();
 883    ts = elm_scroll_thumbscroll_enabled_get();
 884    ts_threshould = elm_scroll_thumbscroll_threshold_get();
 885    ts_momentum_threshold = elm_scroll_thumbscroll_momentum_threshold_get();
 886    ts_friction = elm_scroll_thumbscroll_friction_get();
 887    ts_border_friction = elm_scroll_thumbscroll_border_friction_get();
 888    page_friction = elm_scroll_page_scroll_friction_get();
 889    bring_in_friction = elm_scroll_bring_in_scroll_friction_get();
 890    zoom_friction = elm_scroll_zoom_friction_get();
 891
 892    /* gotta update root windows' atoms */
 893    elm_scale_all_set(scale);
 894    elm_slider_value_set(evas_object_data_get(win, "scale_slider"), scale);
 895    elm_finger_size_all_set(fs);
 896    elm_slider_value_set(evas_object_data_get(win, "fs_slider"), fs);
 897
 898    elm_cache_flush_interval_all_set(flush_interval);
 899    elm_slider_value_set(evas_object_data_get(win,
 900                                              "cache_flush_interval_slider"),
 901                         flush_interval);
 902    elm_font_cache_all_set(font_c);
 903    elm_slider_value_set(evas_object_data_get(win, "font_cache_slider"),
 904                         font_c / 1024.0);
 905    elm_image_cache_all_set(image_c);
 906    elm_slider_value_set(evas_object_data_get(win, "image_cache_slider"),
 907                         image_c / 1024.0);
 908    elm_edje_file_cache_all_set(edje_file_c);
 909    elm_slider_value_set(evas_object_data_get(win, "edje_file_cache_slider"),
 910                         edje_file_c);
 911    elm_edje_collection_cache_all_set(edje_col_c);
 912    elm_slider_value_set(evas_object_data_get(win,
 913                                              "edje_collection_cache_slider"),
 914                         edje_col_c);
 915
 916    elm_scroll_bounce_enabled_all_set(s_bounce);
 917    elm_check_state_set(evas_object_data_get(win, "scroll_bounce_check"),
 918                        s_bounce);
 919    elm_scroll_bounce_friction_all_set(s_bounce_friction);
 920    elm_slider_value_set(evas_object_data_get(win, "bounce_friction_slider"),
 921                         s_bounce_friction);
 922    elm_scroll_thumbscroll_enabled_all_set(ts);
 923    elm_check_state_set(evas_object_data_get(win, "thumbscroll_check"), ts);
 924    elm_scroll_thumbscroll_threshold_all_set(ts_threshould);
 925    elm_slider_value_set(evas_object_data_get(win,
 926                                              "thumbscroll_threshold_slider"),
 927                         ts_threshould);
 928    elm_scroll_thumbscroll_momentum_threshold_all_set(ts_momentum_threshold);
 929    elm_slider_value_set(evas_object_data_get(win,
 930                                              "ts_momentum_threshold_slider"),
 931                         ts_momentum_threshold);
 932    elm_scroll_thumbscroll_friction_all_set(ts_friction);
 933    elm_slider_value_set(evas_object_data_get(win,
 934                                              "thumbscroll_friction_slider"),
 935                         ts_friction);
 936    elm_scroll_thumbscroll_border_friction_all_set(ts_border_friction);
 937    elm_slider_value_set(evas_object_data_get(win, "ts_border_friction_slider"),
 938                         ts_border_friction);
 939    elm_scroll_page_scroll_friction_all_set(page_friction);
 940    elm_slider_value_set(evas_object_data_get(win,
 941                                              "page_scroll_friction_slider"),
 942                         page_friction);
 943    elm_scroll_bring_in_scroll_friction_all_set(bring_in_friction);
 944    elm_slider_value_set(evas_object_data_get(win,
 945                                              "bring_in_scroll_friction_slider"),
 946                         bring_in_friction);
 947    elm_scroll_zoom_friction_all_set(zoom_friction);
 948    elm_slider_value_set(evas_object_data_get(win,
 949                                              "zoom_scroll_friction_slider"),
 950                         zoom_friction);
 951
 952    curr_theme = _elm_theme_current_get(elm_theme_get(NULL));
 953    elm_theme_all_set(curr_theme);
 954
 955    th = elm_theme_new();
 956    elm_theme_set(th, curr_theme);
 957    elm_object_theme_set(evas_object_data_get(win, "theme_preview"), th);
 958    elm_theme_free(th);
 959    eina_stringshare_del(curr_theme);
 960
 961    curr_engine = elm_engine_current_get();
 962    l_items = elm_list_items_get(evas_object_data_get(win, "engines_list"));
 963    EINA_LIST_FOREACH(l_items, l, it)
 964      {
 965         if (!strcmp(elm_list_item_data_get(it), curr_engine))
 966           {
 967              elm_list_item_selected_set(it, EINA_TRUE);
 968              break;
 969           }
 970      }
 971 }
 972
 973 static void
 974 _engine_use(void            *data,
 975             Evas_Object *obj __UNUSED__,
 976             void *event_info __UNUSED__)
 977 {
 978    Evas_Object *li;
 979    const char *selection;
 980
 981    li = data;
 982    selection = elm_list_item_data_get(elm_list_selected_item_get(li));
 983
 984    if (!strcmp(elm_engine_current_get(), selection))
 985      return;
 986
 987    elm_engine_set(selection);
 988    elm_config_save(); /* make sure new engine has its data dir */
 989 }
 990
 991 static void
 992 _profile_use(void            *data,
 993              Evas_Object *obj __UNUSED__,
 994              void *event_info __UNUSED__)
 995 {
 996    Evas_Object *li;
 997    const char *selection;
 998    const char *profile;
 999
1000    li = data;
1001    selection = elm_list_item_data_get(elm_list_selected_item_get(li));
1002    profile = elm_profile_current_get();
1003
1004    if (!profile)
1005      {
1006         fprintf(stderr, "No profile currently set!\n"); /* FIXME: log domain */
1007         return;
1008      }
1009
1010    if (!strcmp(profile, selection))
1011      return;
1012
1013    elm_config_save(); /* dump config into old profile's data dir */
1014    elm_profile_set(selection); /* just here to update info for getters below */
1015
1016    _profile_change_do(elm_object_top_widget_get(li), selection);
1017    elm_config_save(); /* make sure new profile has its data dir */
1018 }
1019
1020 static void
1021 _btn_todo(void *data       __UNUSED__,
1022           Evas_Object *obj __UNUSED__,
1023           void *event_info __UNUSED__)
1024 {
1025    printf("To be done!\n");
1026 }
1027
1028 static void
1029 _profile_reset(void            *data,
1030                Evas_Object *obj __UNUSED__,
1031                void *event_info __UNUSED__)
1032 {
1033    const char *selection, *curr;
1034    const char *pdir;
1035    Evas_Object *li;
1036
1037    li = data;
1038    selection = elm_list_item_data_get(elm_list_selected_item_get(li));
1039    curr = elm_profile_current_get();
1040
1041    elm_config_save(); /* dump config into old profile's data dir */
1042
1043    pdir = elm_profile_dir_get(selection, EINA_TRUE);
1044    if (!pdir)
1045      return;
1046
1047    ecore_file_recursive_rm(pdir);
1048    elm_profile_dir_free(pdir);
1049
1050    elm_config_reload();
1051
1052    _profile_change_do(elm_object_top_widget_get(li), curr);
1053    elm_config_save(); /* make sure new profile has its data dir */
1054 }
1055
1056 static void
1057 _theme_use(void *data       __UNUSED__,
1058            Evas_Object *obj __UNUSED__,
1059            void *event_info __UNUSED__)
1060 {
1061    const char *defth;
1062    char *newth;
1063    Theme *t = tsel;
1064
1065    if (!t) return;
1066    defth = elm_theme_get(NULL);
1067    newth = malloc(strlen(defth) + 1 + strlen(t->name) + 1);
1068    if (newth)
1069      {
1070         char *rest;
1071
1072         newth[0] = 0;
1073         rest = strchr(defth, ':');
1074         if (!rest)
1075           strcpy(newth, t->name);
1076         else
1077           {
1078              strcpy(newth, t->name);
1079              strcat(newth, rest);
1080           }
1081         elm_theme_all_set(newth);
1082         free(newth);
1083      }
1084 }
1085
1086 static void
1087 _theme_sel(void            *data,
1088            Evas_Object     *obj,
1089            void *event_info __UNUSED__)
1090 {
1091    Theme *t = data;
1092    Evas_Object *win = elm_object_top_widget_get(obj);
1093    Evas_Object *sample = evas_object_data_get(win, "theme_preview");
1094    Elm_Theme *th;
1095    const char *defth;
1096    char *newth;
1097
1098    tsel = t;
1099    defth = elm_theme_get(NULL);
1100    newth = malloc(strlen(defth) + 1 + strlen(t->name) + 1);
1101    th = elm_theme_new();
1102    if (newth)
1103      {
1104         char *rest;
1105
1106         newth[0] = 0;
1107         rest = strchr(defth, ':');
1108         if (!rest)
1109           strcpy(newth, t->name);
1110         else
1111           {
1112              strcpy(newth, t->name);
1113              strcat(newth, rest);
1114           }
1115         elm_theme_set(th, newth);
1116         free(newth);
1117      }
1118    elm_object_theme_set(sample, th);
1119    elm_theme_free(th);
1120 }
1121
1122 /*static void
1123    _theme_browse(void *data, Evas_Object *obj, void *event_info)
1124    {
1125    printf("not implemented\n");
1126    }*/
1127
1128 static void
1129 _status_config_sizing(Evas_Object *win,
1130                       Evas_Object *pager)
1131 {
1132    Evas_Object *lb, *pd, *bx, *sl, *sp;
1133
1134    bx = elm_box_add(win);
1135    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
1136    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
1137
1138    LABEL_FRAME_ADD("<hilight>Scale</>");
1139
1140    sl = elm_slider_add(win);
1141    evas_object_data_set(win, "scale_slider", sl);
1142    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1143    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1144    elm_slider_span_size_set(sl, 120);
1145    elm_slider_unit_format_set(sl, "%1.2f");
1146    elm_slider_indicator_format_set(sl, "%1.2f");
1147    elm_slider_min_max_set(sl, 0.25, 5.0);
1148    elm_slider_value_set(sl, elm_scale_get());
1149    elm_box_pack_end(bx, sl);
1150    evas_object_show(sl);
1151
1152    evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
1153    evas_object_smart_callback_add(sl, "delay,changed", sc_change, NULL);
1154
1155    sp = elm_separator_add(win);
1156    elm_separator_horizontal_set(sp, 1);
1157    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1158    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1159    elm_box_pack_end(bx, sp);
1160    evas_object_show(sp);
1161
1162    LABEL_FRAME_ADD("<hilight>Finger Size</><br>");
1163
1164    sl = elm_slider_add(win);
1165    evas_object_data_set(win, "fs_slider", sl);
1166    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1167    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1168    elm_slider_span_size_set(sl, 120);
1169    elm_slider_unit_format_set(sl, "%1.0f");
1170    elm_slider_indicator_format_set(sl, "%1.0f");
1171    elm_slider_min_max_set(sl, 5, 200);
1172    elm_slider_value_set(sl, elm_finger_size_get());
1173    elm_box_pack_end(bx, sl);
1174    evas_object_show(sl);
1175
1176    evas_object_smart_callback_add(sl, "changed", fs_round, NULL);
1177    evas_object_smart_callback_add(sl, "delay,changed", fs_change, NULL);
1178
1179    evas_object_data_set(win, "sizing", bx);
1180
1181    elm_pager_content_push(pager, bx);
1182 }
1183
1184 static Evas_Object *
1185 _sample_theme_new(Evas_Object *win)
1186 {
1187    Evas_Object *base, *bg, *bt, *ck, *rd, *rdg, *sl, *fr, *li, *rc, *sp;
1188
1189    base = elm_table_add(win);
1190    evas_object_size_hint_weight_set(base, 1.0, 1.0);
1191    evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
1192
1193    bg = elm_bg_add(win);
1194    evas_object_size_hint_weight_set(bg, 1.0, 1.0);
1195    evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
1196    elm_table_pack(base, bg, 0, 0, 2, 5);
1197    evas_object_show(bg);
1198
1199    bt = elm_button_add(win);
1200    elm_button_label_set(bt, "Button");
1201    elm_table_pack(base, bt, 0, 0, 1, 1);
1202    evas_object_show(bt);
1203
1204    ck = elm_check_add(win);
1205    elm_check_label_set(ck, "Check");
1206    elm_table_pack(base, ck, 0, 1, 1, 1);
1207    evas_object_show(ck);
1208
1209    rd = elm_radio_add(win);
1210    elm_radio_state_value_set(rd, 0);
1211    elm_radio_label_set(rd, "Radio 1");
1212    elm_table_pack(base, rd, 1, 0, 1, 1);
1213    evas_object_show(rd);
1214    rdg = rd;
1215
1216    rd = elm_radio_add(win);
1217    elm_radio_state_value_set(rd, 1);
1218    elm_radio_label_set(rd, "Radio 2");
1219    elm_radio_group_add(rd, rdg);
1220    elm_table_pack(base, rd, 1, 1, 1, 1);
1221    evas_object_show(rd);
1222
1223    sp = elm_separator_add(win);
1224    elm_separator_horizontal_set(sp, 1);
1225    evas_object_size_hint_weight_set(sp, 1.0, 0.0);
1226    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1227    elm_table_pack(base, sp, 0, 2, 2, 1);
1228    evas_object_show(sp);
1229
1230    sl = elm_slider_add(win);
1231    elm_slider_label_set(sl, "Slider");
1232    elm_slider_span_size_set(sl, 120);
1233    elm_slider_min_max_set(sl, 1, 10);
1234    elm_slider_value_set(sl, 4);
1235    evas_object_size_hint_weight_set(sl, 1.0, 0.0);
1236    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, EVAS_HINT_FILL);
1237    elm_table_pack(base, sl, 0, 3, 2, 1);
1238    evas_object_show(sl);
1239
1240    fr = elm_frame_add(win);
1241    elm_frame_label_set(fr, "Frame");
1242    elm_table_pack(base, fr, 0, 4, 2, 1);
1243    evas_object_size_hint_weight_set(fr, 1.0, 1.0);
1244    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1245    evas_object_show(fr);
1246
1247    li = elm_list_add(win);
1248    evas_object_size_hint_weight_set(li, 1.0, 1.0);
1249    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1250    elm_frame_content_set(fr, li);
1251    evas_object_show(li);
1252
1253    elm_list_item_append(li, "List Item 1", NULL, NULL, NULL, NULL);
1254    elm_list_item_append(li, "Second Item", NULL, NULL, NULL, NULL);
1255    elm_list_item_append(li, "Third Item", NULL, NULL, NULL, NULL);
1256    elm_list_go(li);
1257
1258    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1259    evas_object_size_hint_min_set(rc, 160, 120);
1260    elm_table_pack(base, rc, 0, 4, 2, 1);
1261
1262    return base;
1263 }
1264
1265 static void
1266 _status_config_themes(Evas_Object *win,
1267                       Evas_Object *pager)
1268 {
1269    Evas_Object *tb, *rc, *sc, *sp, *li, *pd, *fr, *bt, *sample;
1270    Eina_List *list, *l;
1271    char *th, *s, *ext;
1272
1273    tb = elm_table_add(win);
1274    evas_object_size_hint_weight_set(tb, 1.0, 1.0);
1275    evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
1276
1277    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1278    evas_object_size_hint_min_set(rc, 0, 130);
1279    elm_table_pack(tb, rc, 0, 0, 1, 1);
1280
1281    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1282    evas_object_size_hint_min_set(rc, 0, 200);
1283    elm_table_pack(tb, rc, 0, 1, 1, 1);
1284
1285    /////////////////////////////////////////////
1286
1287    pd = elm_frame_add(win);
1288    elm_object_style_set(pd, "pad_medium");
1289    evas_object_size_hint_weight_set(pd, 1.0, 1.0);
1290    evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
1291    elm_table_pack(tb, pd, 0, 0, 1, 1);
1292    evas_object_show(pd);
1293
1294    li = elm_list_add(win);
1295    evas_object_size_hint_weight_set(li, 1.0, 1.0);
1296    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1297    elm_frame_content_set(pd, li);
1298    evas_object_show(li);
1299
1300    list = elm_theme_name_available_list_new();
1301    EINA_LIST_FOREACH(list, l, th)
1302      {
1303         Theme *t;
1304
1305         t = calloc(1, sizeof(Theme));
1306         t->name = eina_stringshare_add(th);
1307         s = elm_theme_list_item_path_get(th, &(t->in_search_path));
1308         if (s)
1309           {
1310              t->path = eina_stringshare_add(s);
1311              free(s);
1312           }
1313         if (t->in_search_path)
1314           {
1315              s = strdup(th);
1316              if (s)
1317                {
1318                   s[0] = toupper(s[0]);
1319                   t->label = eina_stringshare_add(s);
1320                   free(s);
1321                }
1322              else
1323                t->label = eina_stringshare_add(s);
1324           }
1325         else
1326           {
1327              s = strdup(ecore_file_file_get(th));
1328              if (s)
1329                {
1330                   s[0] = toupper(s[0]);
1331                   ext = strrchr(s, '.');
1332                   if (ext) *ext = 0;
1333                   t->label = eina_stringshare_add(s);
1334                   free(s);
1335                }
1336              else
1337                t->label = eina_stringshare_add(s);
1338           }
1339         themes = eina_list_append(themes, t);
1340         elm_list_item_append(li, t->label, NULL, NULL, _theme_sel, t);
1341      }
1342    elm_theme_name_available_list_free(list);
1343
1344    elm_list_go(li);
1345
1346    pd = elm_frame_add(win);
1347    elm_object_style_set(pd, "pad_medium");
1348    evas_object_size_hint_weight_set(pd, 1.0, 1.0);
1349    evas_object_size_hint_align_set(pd, 0.9, 0.9);
1350    elm_table_pack(tb, pd, 0, 0, 1, 1);
1351    evas_object_show(pd);
1352
1353    /* FIXME: not implemented yet
1354       bt = elm_button_add(win);
1355       evas_object_smart_callback_add(bt, "clicked", _theme_browse, win);
1356       elm_button_label_set(bt, "Browse...");
1357       evas_object_size_hint_weight_set(bt, 1.0, 1.0);
1358       evas_object_size_hint_align_set(bt, 0.9, 0.9);
1359       elm_frame_content_set(pd, bt);
1360       evas_object_show(bt);
1361     */
1362    pd = elm_frame_add(win);
1363    elm_object_style_set(pd, "pad_medium");
1364    evas_object_size_hint_weight_set(pd, 1.0, 0.0);
1365    evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
1366    elm_table_pack(tb, pd, 0, 1, 1, 1);
1367    evas_object_show(pd);
1368
1369    fr = elm_frame_add(win);
1370    elm_frame_label_set(fr, "Preview");
1371    evas_object_size_hint_weight_set(fr, 1.0, 1.0);
1372    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1373    elm_frame_content_set(pd, fr);
1374    evas_object_show(fr);
1375
1376    sc = elm_scroller_add(win);
1377    elm_scroller_bounce_set(sc, 0, 0);
1378    evas_object_size_hint_weight_set(sc, 1.0, 1.0);
1379    evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
1380    elm_frame_content_set(fr, sc);
1381    evas_object_show(sc);
1382
1383    sample = _sample_theme_new(win);
1384    elm_scroller_content_set(sc, sample);
1385    evas_object_show(sample);
1386    evas_object_data_set(win, "theme_preview", sample);
1387
1388    /////////////////////////////////////////////
1389    sp = elm_separator_add(win);
1390    elm_separator_horizontal_set(sp, 1);
1391    evas_object_size_hint_weight_set(sp, 1.0, 0.0);
1392    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1393    elm_table_pack(tb, sp, 0, 2, 1, 1);
1394    evas_object_show(sp);
1395
1396    pd = elm_frame_add(win);
1397    elm_object_style_set(pd, "pad_medium");
1398    evas_object_size_hint_weight_set(pd, 0.0, 0.0);
1399    evas_object_size_hint_align_set(pd, 0.5, 0.5);
1400    elm_table_pack(tb, pd, 0, 3, 1, 1);
1401    evas_object_show(pd);
1402
1403    bt = elm_button_add(win);
1404    evas_object_smart_callback_add(bt, "clicked", _theme_use, win);
1405    elm_button_label_set(bt, "Use Theme");
1406    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
1407    evas_object_size_hint_align_set(bt, 0.5, 0.5);
1408    elm_frame_content_set(pd, bt);
1409    evas_object_show(bt);
1410
1411    evas_object_data_set(win, "themes", tb);
1412    elm_pager_content_push(pager, tb);
1413 }
1414
1415 static void
1416 _font_preview_update(Evas_Object *win)
1417 {
1418    Evas_Font_Size sz;
1419    const char *name;
1420
1421    if (!fdata.cur_font)
1422      return;
1423
1424    name = elm_font_fontconfig_name_get(fdata.cur_font, fdata.cur_style);
1425    sz = fdata.cur_size;
1426
1427    if (sz < 0)
1428      sz = (-sz * 10) / 100;
1429    if (sz == 0)
1430      sz = 10;
1431
1432    edje_object_text_class_set(evas_object_data_get(win, "font_preview"),
1433                               "font_preview", name, sz);
1434
1435    elm_font_fontconfig_name_free(name);
1436 }
1437
1438 static void
1439 _font_classes_list_sel(void *data   __UNUSED__,
1440                        Evas_Object *obj,
1441                        void        *event_info)
1442 {
1443    const Eina_List *f_names_items, *l;
1444    Elm_Text_Class_Data *tc_data;
1445    Evas_Object *f_names_list;
1446    Elm_List_Item *it;
1447
1448    tc_data = elm_list_item_data_get(event_info);
1449
1450    f_names_list = evas_object_data_get(elm_object_top_widget_get(obj),
1451                                        "font_names_list");
1452    ELM_LIST_ENABLE(f_names_list);
1453
1454    f_names_items = elm_list_items_get(f_names_list);
1455
1456    EINA_LIST_FOREACH(f_names_items, l, it)
1457      {
1458         const char *l;
1459
1460         l = elm_list_item_label_get(it);
1461
1462         if (tc_data->font && !strcmp(l, tc_data->font))
1463           {
1464              elm_list_item_selected_set(it, EINA_TRUE);
1465              elm_list_item_show(it);
1466              break;
1467           }
1468      }
1469 }
1470
1471 static void
1472 _font_names_list_sel(void *data   __UNUSED__,
1473                      Evas_Object *obj,
1474                      void        *event_info)
1475 {
1476    Evas_Object *style_list, *cls_list, *sizes_list, *win;
1477    const char *style, *sel_font;
1478    Elm_Text_Class_Data *tc_data;
1479    Elm_List_Item *it, *fc_it;
1480    Elm_Font_Properties *efp;
1481    const Eina_List *l;
1482
1483    it = event_info;
1484    sel_font = elm_list_item_label_get(it);
1485
1486    win = elm_object_top_widget_get(obj);
1487    style_list = evas_object_data_get(win, "font_styles_list");
1488    cls_list = evas_object_data_get(win, "font_classes_list");
1489    sizes_list = evas_object_data_get(win, "font_sizes_list");
1490
1491    fc_it = elm_list_selected_item_get(cls_list);
1492    if (!fc_it) return;  /* should not happen, fonts list disabled in
1493                          * this case */
1494
1495    eina_stringshare_replace(&fdata.cur_font, sel_font);
1496
1497    tc_data = elm_list_item_data_get(fc_it);
1498    if (tc_data->font) eina_stringshare_del(tc_data->font);
1499    if (fdata.cur_font) tc_data->font = eina_stringshare_ref(fdata.cur_font);
1500
1501    /* load styles list */
1502    efp = eina_hash_find(fdata.font_hash, sel_font);
1503
1504    ELM_LIST_ENABLE(style_list);
1505    elm_list_clear(style_list);
1506
1507    evas_event_freeze(evas_object_evas_get(style_list));
1508    edje_freeze();
1509
1510    it = NULL;
1511
1512    EINA_LIST_FOREACH(efp->styles, l, style)
1513      {
1514         Elm_List_Item *i;
1515
1516         i = elm_list_item_append(style_list, style, NULL, NULL,
1517                                  _font_styles_list_sel, NULL);
1518
1519         if (tc_data->style && (!strcmp(style, tc_data->style)))
1520           it = i;
1521      }
1522
1523    elm_list_go(style_list);
1524
1525    edje_thaw();
1526    evas_event_thaw(evas_object_evas_get(style_list));
1527
1528    if (it)
1529      elm_list_item_selected_set(it, EINA_TRUE);
1530
1531    _font_preview_update(win);
1532 }
1533
1534 static void
1535 _font_styles_list_sel(void *data   __UNUSED__,
1536                       Evas_Object *obj,
1537                       void        *event_info)
1538 {
1539    Evas_Object *fc_list, *fs_list, *win;
1540    Elm_Text_Class_Data *tc_data;
1541    const Eina_List *l;
1542    Elm_List_Item *it;
1543
1544    win = elm_object_top_widget_get(obj);
1545    fc_list = evas_object_data_get(win, "font_classes_list");
1546    fs_list = evas_object_data_get(win, "font_sizes_list");
1547
1548    it = elm_list_selected_item_get(fc_list);
1549    if (!it) return;  /* should not happen */
1550
1551    eina_stringshare_replace(&fdata.cur_style,
1552                             elm_list_item_label_get(event_info));
1553    ELM_LIST_ENABLE(fs_list);
1554
1555    tc_data = elm_list_item_data_get(it);
1556    eina_stringshare_del(tc_data->style);
1557    tc_data->style = eina_stringshare_ref(fdata.cur_style);
1558
1559    evas_event_freeze(evas_object_evas_get(fs_list));
1560    edje_freeze();
1561
1562    EINA_LIST_FOREACH(elm_list_items_get(fs_list), l, it)
1563      {
1564         Elm_Font_Size_Data *sdata;
1565
1566         sdata = elm_list_item_data_get(it);
1567         elm_list_item_selected_set(l->data, EINA_FALSE);
1568
1569         if (tc_data->size == sdata->size)
1570           {
1571              elm_list_item_selected_set(it, EINA_TRUE);
1572              elm_list_item_show(it);
1573              break;
1574           }
1575      }
1576
1577    edje_thaw();
1578    evas_event_thaw(evas_object_evas_get(fs_list));
1579
1580    _font_preview_update(win);
1581 }
1582
1583 static void
1584 _font_sizes_list_sel(void *data       __UNUSED__,
1585                      Evas_Object *obj __UNUSED__,
1586                      void *event_info __UNUSED__)
1587 {
1588    Elm_Text_Class_Data *tc_data;
1589    Evas_Object *fc_list, *win;
1590    Elm_Font_Size_Data *sd;
1591    Elm_List_Item *it;
1592
1593    win = elm_object_top_widget_get(obj);
1594    fc_list = evas_object_data_get(win, "font_classes_list");
1595
1596    it = elm_list_selected_item_get(fc_list);
1597    if (!it) return;  /* should not happen */
1598
1599    sd = elm_list_item_data_get(event_info);
1600    fdata.cur_size = sd->size;
1601
1602    tc_data = elm_list_item_data_get(it);
1603    tc_data->size = fdata.cur_size;
1604
1605    _font_preview_update(win);
1606 }
1607
1608 static void
1609 _fstyle_list_unselect_cb(void *data       __UNUSED__,
1610                          Evas_Object     *obj,
1611                          void *event_info __UNUSED__)
1612 {
1613    Evas_Object *sizes_list, *win;
1614
1615    if (elm_list_selected_item_get(obj)) return;
1616
1617    win = elm_object_top_widget_get(obj);
1618
1619    sizes_list = evas_object_data_get(win, "font_sizes_list");
1620    ELM_LIST_DISABLE(sizes_list);
1621 }
1622
1623 static void
1624 _fc_list_unselect_cb(void *data       __UNUSED__,
1625                      Evas_Object     *obj,
1626                      void *event_info __UNUSED__)
1627 {
1628    Evas_Object *font_names_list, *styles_list, *sizes_list, *win;
1629
1630    if (elm_list_selected_item_get(obj)) return;
1631
1632    win = elm_object_top_widget_get(obj);
1633
1634    font_names_list = evas_object_data_get(win, "font_names_list");
1635    ELM_LIST_DISABLE(font_names_list);
1636
1637    styles_list = evas_object_data_get(win, "font_styles_list");
1638    ELM_LIST_DISABLE(styles_list);
1639
1640    sizes_list = evas_object_data_get(win, "font_sizes_list");
1641    ELM_LIST_DISABLE(sizes_list);
1642 }
1643
1644 static void
1645 _font_classes_list_load(Evas_Object *li)
1646 {
1647    Elm_Text_Class_Data *tc_data;
1648    Eina_List *l;
1649    Evas *evas;
1650
1651    evas = evas_object_evas_get(li);
1652    evas_event_freeze(evas);
1653    edje_freeze();
1654
1655    EINA_LIST_FOREACH(fdata.text_classes, l, tc_data)
1656      elm_list_item_append(li, tc_data->desc, NULL, NULL,
1657                           _font_classes_list_sel, tc_data);
1658
1659    evas_object_smart_callback_add(li, "unselected", _fc_list_unselect_cb,
1660                                   NULL);
1661
1662    elm_list_go(li);
1663    edje_thaw();
1664    evas_event_thaw(evas);
1665 }
1666
1667 static void
1668 _fonts_data_fill(Evas *evas)
1669 {
1670    const Eina_List *fo_list, *text_classes, *l;
1671    Elm_Text_Class_Data *tc_data;
1672    Elm_Font_Size_Data *sd;
1673    Elm_Font_Overlay *efo;
1674    Eina_List *evas_fonts;
1675    Elm_Text_Class *etc;
1676    int i;
1677
1678    evas_fonts = evas_font_available_list(evas);
1679    fdata.font_hash = elm_font_available_hash_add(evas_fonts);
1680    evas_font_available_list_free(evas, evas_fonts);
1681
1682    text_classes = elm_text_classes_list_get();
1683    fo_list = elm_font_overlay_list_get();
1684
1685    EINA_LIST_FOREACH(text_classes, l, etc)
1686      {
1687         const Eina_List *ll;
1688
1689         tc_data = calloc(1, sizeof(*tc_data));
1690         tc_data->name = eina_stringshare_add(etc->name);
1691         tc_data->desc = eina_stringshare_add(etc->desc);
1692
1693         EINA_LIST_FOREACH(fo_list, ll, efo)
1694           {
1695              if (strcmp(tc_data->name, efo->text_class))
1696                continue;
1697
1698              if (efo->font)
1699                {
1700                   Elm_Font_Properties *efp;
1701
1702                   efp = elm_font_properties_get(efo->font);
1703                   if (efp)
1704                     {
1705                        tc_data->font = eina_stringshare_add(efp->name);
1706                        /* we're sure we recorded with only 1 style selected */
1707                        tc_data->style = eina_stringshare_add(efp->styles->data);
1708                        elm_font_properties_free(efp);
1709                     }
1710                }
1711              tc_data->size = efo->size;
1712           }
1713
1714         fdata.text_classes = eina_list_append(fdata.text_classes, tc_data);
1715      }
1716
1717    elm_text_classes_list_free(text_classes);
1718
1719    /* FIXME: hinting later */
1720    /* fdata.hinting = e_config->font_hinting; */
1721
1722    sd = calloc(1, sizeof(Elm_Font_Size_Data));
1723    sd->size_str = eina_stringshare_add("Tiny");
1724    sd->size = -50;
1725    fdata.font_scale_list = eina_list_append(fdata.font_scale_list, sd);
1726
1727    sd = calloc(1, sizeof(Elm_Font_Size_Data));
1728    sd->size_str = eina_stringshare_add("Small");
1729    sd->size = -80;
1730    fdata.font_scale_list = eina_list_append(fdata.font_scale_list, sd);
1731
1732    sd = calloc(1, sizeof(Elm_Font_Size_Data));
1733    sd->size_str = eina_stringshare_add("Normal");
1734    sd->size = -100;
1735    fdata.font_scale_list = eina_list_append(fdata.font_scale_list, sd);
1736
1737    sd = calloc(1, sizeof(Elm_Font_Size_Data));
1738    sd->size_str = eina_stringshare_add("Big");
1739    sd->size = -150;
1740    fdata.font_scale_list = eina_list_append(fdata.font_scale_list, sd);
1741
1742    sd = calloc(1, sizeof(Elm_Font_Size_Data));
1743    sd->size_str = eina_stringshare_add("Really Big");
1744    sd->size = -190;
1745    fdata.font_scale_list = eina_list_append(fdata.font_scale_list, sd);
1746
1747    sd = calloc(1, sizeof(Elm_Font_Size_Data));
1748    sd->size_str = eina_stringshare_add("Huge");
1749    sd->size = -250;
1750    fdata.font_scale_list = eina_list_append(fdata.font_scale_list, sd);
1751
1752    for (i = 5; i < 51; i++)
1753      {
1754         char str[16];
1755
1756         str[0] = 0;
1757         snprintf(str, sizeof(str), "%d pixels", i);
1758
1759         sd = calloc(1, sizeof(Elm_Font_Size_Data));
1760         sd->size_str = eina_stringshare_add(str);
1761         sd->size = i;
1762         fdata.font_px_list = eina_list_append(fdata.font_px_list, sd);
1763      }
1764 }
1765
1766 static int
1767 _font_sort_cb(const void *data1,
1768               const void *data2)
1769 {
1770    if (!data1) return 1;
1771    if (!data2) return -1;
1772    return strcmp(data1, data2);
1773 }
1774
1775 static void
1776 _font_sizes_list_load(Evas_Object *size_list)
1777 {
1778    Elm_Font_Size_Data *size_data;
1779    Eina_List *l;
1780    Evas *evas;
1781
1782    evas = evas_object_evas_get(size_list);
1783    evas_event_freeze(evas);
1784    edje_freeze();
1785
1786    EINA_LIST_FOREACH(fdata.font_scale_list, l, size_data)
1787      elm_list_item_append(size_list, size_data->size_str, NULL, NULL,
1788                           _font_sizes_list_sel, size_data);
1789
1790    EINA_LIST_FOREACH(fdata.font_px_list, l, size_data)
1791      elm_list_item_append(size_list, size_data->size_str, NULL, NULL,
1792                           _font_sizes_list_sel, size_data);
1793
1794    elm_list_go(size_list);
1795    edje_thaw();
1796    evas_event_thaw(evas);
1797 }
1798
1799 static void
1800 _fnames_list_unselect_cb(void *data       __UNUSED__,
1801                          Evas_Object     *obj,
1802                          void *event_info __UNUSED__)
1803 {
1804    Evas_Object *styles_list, *sizes_list, *win;
1805
1806    if (elm_list_selected_item_get(obj)) return;
1807
1808    win = elm_object_top_widget_get(obj);
1809
1810    styles_list = evas_object_data_get(win, "font_styles_list");
1811    ELM_LIST_DISABLE(styles_list);
1812
1813    sizes_list = evas_object_data_get(win, "font_sizes_list");
1814    ELM_LIST_DISABLE(sizes_list);
1815 }
1816
1817 static Eina_Bool
1818 _font_list_fill(const Eina_Hash *hash __UNUSED__,
1819                 const void *key       __UNUSED__,
1820                 void                 *data,
1821                 void                 *fdata)
1822 {
1823    Elm_Font_Properties *efp;
1824    Eina_List **flist;
1825
1826    flist = fdata;
1827    efp = data;
1828
1829    *flist = eina_list_append(*flist, efp->name);
1830
1831    return EINA_TRUE;
1832 }
1833
1834 static void
1835 _font_names_list_load(Evas_Object *flist)
1836 {
1837    Eina_List *l, *names_list = NULL;
1838    const char *font;
1839    Evas *evas;
1840
1841    evas = evas_object_evas_get(flist);
1842    evas_event_freeze(evas);
1843    edje_freeze();
1844
1845    eina_hash_foreach(fdata.font_hash, _font_list_fill, &names_list);
1846    names_list = eina_list_sort(names_list, eina_list_count(names_list),
1847                                _font_sort_cb);
1848
1849    EINA_LIST_FOREACH(names_list, l, font)
1850      elm_list_item_append(flist, font, NULL, NULL, _font_names_list_sel, NULL);
1851
1852    EINA_LIST_FREE(names_list, font) ;
1853
1854    evas_object_smart_callback_add(flist, "unselected",
1855                                   _fnames_list_unselect_cb, NULL);
1856
1857    elm_list_go(flist);
1858
1859    edje_thaw();
1860    evas_event_thaw(evas);
1861 }
1862
1863 static void
1864 _status_config_fonts(Evas_Object *win,
1865                      Evas_Object *pager)
1866 {
1867    Evas_Object *base, *fr, *li, *rc, *preview, *sp, *pd, *bt, *bx;
1868    char buf[PATH_MAX];
1869
1870    _fonts_data_fill(evas_object_evas_get(win));
1871
1872    base = elm_table_add(win);
1873    evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1874    evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
1875
1876    /* yeah, dummy rectangles are ugly as hell, but no good way yet of
1877       fixing sizes */
1878    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1879    evas_object_size_hint_min_set(rc, 70, 170);
1880    elm_table_pack(base, rc, 1, 0, 1, 1);
1881
1882    fr = elm_frame_add(win);
1883    elm_frame_label_set(fr, "Font Class");
1884    elm_table_pack(base, fr, 0, 0, 1, 2);
1885    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1886    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1887    evas_object_show(fr);
1888
1889    /* FIXME: no multiselection for this list, for now */
1890    li = elm_list_add(win);
1891    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1892    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1893    elm_frame_content_set(fr, li);
1894    evas_object_show(li);
1895
1896    evas_object_data_set(win, "font_classes_list", li);
1897    _font_classes_list_load(li);
1898
1899    fr = elm_frame_add(win);
1900    elm_frame_label_set(fr, "Font");
1901    elm_table_pack(base, fr, 1, 0, 1, 2);
1902    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1903    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1904    evas_object_show(fr);
1905
1906    li = elm_list_add(win);
1907    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1908    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1909    elm_frame_content_set(fr, li);
1910    evas_object_show(li);
1911
1912    evas_object_data_set(win, "font_names_list", li);
1913    _font_names_list_load(li);
1914    ELM_LIST_DISABLE(li);
1915
1916    rc = evas_object_rectangle_add(evas_object_evas_get(win));
1917    evas_object_size_hint_min_set(rc, 70, 130);
1918    elm_table_pack(base, rc, 1, 2, 1, 1);
1919
1920    fr = elm_frame_add(win);
1921    elm_frame_label_set(fr, "Style");
1922    elm_table_pack(base, fr, 0, 2, 1, 1);
1923    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1924    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1925    evas_object_show(fr);
1926    ELM_LIST_DISABLE(li);
1927
1928    li = elm_list_add(win);
1929    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1930    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1931    elm_frame_content_set(fr, li);
1932    evas_object_show(li);
1933
1934    evas_object_data_set(win, "font_styles_list", li);
1935    evas_object_smart_callback_add(li, "unselected", _fstyle_list_unselect_cb,
1936                                   NULL);
1937
1938    fr = elm_frame_add(win);
1939    elm_frame_label_set(fr, "Size");
1940    elm_table_pack(base, fr, 1, 2, 1, 1);
1941    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1942    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
1943    evas_object_show(fr);
1944
1945    li = elm_list_add(win);
1946    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1947    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
1948    elm_frame_content_set(fr, li);
1949    evas_object_show(li);
1950
1951    evas_object_data_set(win, "font_sizes_list", li);
1952    _font_sizes_list_load(li);
1953    ELM_LIST_DISABLE(li);
1954
1955    bx = elm_box_add(win);
1956    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1957    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
1958    elm_table_pack(base, bx, 0, 3, 2, 1);
1959    evas_object_show(bx);
1960
1961    /* FIXME: what to do here? dedicated widget? some new entry API set? */
1962    snprintf(buf, sizeof(buf), "%s/objects/font_preview.edj", PACKAGE_DATA_DIR);
1963    preview = elm_layout_add(win);
1964    elm_layout_file_set(preview, buf, "font_preview");
1965    elm_layout_text_set(preview, "elm.text", "Preview Text — 我真的会写中文");
1966    evas_object_size_hint_weight_set(preview, EVAS_HINT_EXPAND,
1967                                     EVAS_HINT_EXPAND);
1968    evas_object_size_hint_align_set(preview, EVAS_HINT_FILL, EVAS_HINT_FILL);
1969    evas_object_show(preview);
1970
1971    elm_box_pack_end(bx, preview);
1972    evas_object_data_set(win, "font_preview", elm_layout_edje_get(preview));
1973
1974    /////////////////////////////////////////////
1975    sp = elm_separator_add(win);
1976    elm_separator_horizontal_set(sp, EINA_TRUE);
1977    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1978    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1979    elm_table_pack(base, sp, 0, 4, 2, 1);
1980    evas_object_show(sp);
1981
1982    pd = elm_frame_add(win);
1983    elm_object_style_set(pd, "pad_medium");
1984    evas_object_size_hint_weight_set(pd, 0.0, 0.0);
1985    evas_object_size_hint_align_set(pd, 0.5, 0.5);
1986    elm_table_pack(base, pd, 0, 5, 2, 1);
1987    evas_object_show(pd);
1988
1989    bx = elm_box_add(win);
1990    elm_box_horizontal_set(bx, EINA_TRUE);
1991    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1992    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
1993    evas_object_show(bx);
1994
1995    bt = elm_button_add(win);
1996    evas_object_smart_callback_add(bt, "clicked", _font_overlay_set_all, win);
1997    elm_button_label_set(bt, "Set to All");
1998    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
1999    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2000    elm_box_pack_end(bx, bt);
2001    evas_object_show(bt);
2002
2003    bt = elm_button_add(win);
2004    evas_object_smart_callback_add(bt, "clicked", _font_overlay_reset, win);
2005    elm_button_label_set(bt, "Reset");
2006    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2007    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2008    elm_box_pack_end(bx, bt);
2009    evas_object_show(bt);
2010
2011    bt = elm_button_add(win);
2012    evas_object_smart_callback_add(bt, "clicked", _font_overlay_reset_all, win);
2013    elm_button_label_set(bt, "Reset All");
2014    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2015    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2016    elm_box_pack_end(bx, bt);
2017    evas_object_show(bt);
2018
2019    bt = elm_button_add(win);
2020    evas_object_smart_callback_add(bt, "clicked", _font_overlay_change, win);
2021    elm_button_label_set(bt, "Apply");
2022    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2023    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2024    elm_box_pack_end(bx, bt);
2025    evas_object_show(bt);
2026
2027    elm_frame_content_set(pd, bx);
2028
2029    evas_object_data_set(win, "fonts", base);
2030
2031    elm_pager_content_push(pager, base);
2032 }
2033
2034 static void
2035 _engines_list_item_del_cb(void            *data,
2036                           Evas_Object *obj __UNUSED__,
2037                           void *event_info __UNUSED__)
2038 {
2039    free(data);
2040 }
2041
2042 static void
2043 _profiles_list_item_del_cb(void            *data,
2044                            Evas_Object *obj __UNUSED__,
2045                            void *event_info __UNUSED__)
2046 {
2047    free(data);
2048 }
2049
2050 static void
2051 _profiles_list_selected_cb(void            *data,
2052                            Evas_Object     *obj,
2053                            void *event_info __UNUSED__)
2054 {
2055    const char *cur_profile = NULL;
2056    const char *sel_profile, *pdir;
2057    Eina_Bool cur_selected;
2058    const char *prof_name;
2059    char buf[PATH_MAX];
2060    Evas_Object *en;
2061 #ifdef ELM_EFREET
2062    Efreet_Desktop *desk = NULL;
2063 #endif
2064
2065    sel_profile = data;
2066    if (!sel_profile)
2067      return;
2068
2069    cur_profile = elm_profile_current_get();
2070    cur_selected = !strcmp(cur_profile, sel_profile);
2071
2072    pdir = elm_profile_dir_get(sel_profile, EINA_FALSE);
2073 #ifdef ELM_EFREET
2074    snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
2075    desk = efreet_desktop_new(buf);
2076    if ((desk) && (desk->name)) prof_name = desk->name;
2077    else
2078 #endif
2079    prof_name = cur_profile;
2080
2081    if (!pdir)
2082      elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
2083                              EINA_TRUE);
2084    else
2085      {
2086         elm_object_disabled_set(evas_object_data_get(obj, "prof_del_btn"),
2087                                 EINA_TRUE);
2088         elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
2089                                 EINA_FALSE);
2090         elm_object_disabled_set(evas_object_data_get(obj, "prof_use_btn"),
2091                                 EINA_FALSE);
2092         elm_profile_dir_free(pdir);
2093      }
2094
2095    snprintf(buf, sizeof(buf), "<hilight>Selected profile: %s</><br>",
2096             prof_name);
2097    elm_label_label_set(evas_object_data_get(obj, "prof_name_lbl"), buf);
2098
2099    en = evas_object_data_get(obj, "prof_desc_entry");
2100 #ifdef ELM_EFREET
2101    if (desk) elm_scrolled_entry_entry_set(en, desk->comment);
2102    else
2103 #endif
2104    elm_scrolled_entry_entry_set(en, "Unknown");
2105
2106 #ifdef ELM_EFREET
2107    if (desk) efreet_desktop_free(desk);
2108 #endif
2109 }
2110
2111 static void
2112 _profiles_list_fill(Evas_Object *l_widget,
2113                     Eina_List   *p_names)
2114 {
2115    const char *cur_profile = NULL;
2116    const char *profile;
2117    void *sel_it = NULL;
2118    Eina_List *l;
2119
2120    if (!p_names)
2121      return;
2122
2123    elm_list_clear(l_widget);
2124
2125    cur_profile = elm_profile_current_get();
2126
2127    EINA_LIST_FOREACH(p_names, l, profile)
2128      {
2129 #ifdef ELM_EFREET
2130         Efreet_Desktop *desk = NULL;
2131 #endif
2132         const char *label, *ext, *pdir;
2133         char buf[PATH_MAX];
2134         Elm_List_Item *it;
2135         Evas_Object *ic;
2136
2137         pdir = elm_profile_dir_get(profile, EINA_FALSE);
2138         label = profile;
2139
2140 #ifdef ELM_EFREET
2141         snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
2142         desk = efreet_desktop_new(buf);
2143         if ((desk) && (desk->name)) label = desk->name;
2144 #endif
2145
2146         buf[0] = 0;
2147         if (pdir) snprintf(buf, sizeof(buf), "%s/icon.edj", pdir);
2148 #ifdef ELM_EFREET
2149         if ((desk) && (desk->icon) && (pdir))
2150           snprintf(buf, sizeof(buf), "%s/%s", pdir, desk->icon);
2151 #endif
2152         ic = elm_icon_add(l_widget);
2153         ext = strrchr(buf, '.');
2154         if (ext)
2155           {
2156              if (!strcmp(ext, ".edj")) elm_icon_file_set(ic, buf, "icon");
2157              else elm_icon_file_set(ic, buf, NULL);
2158           }
2159
2160         evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL,
2161                                          1, 1);
2162         evas_object_show(ic);
2163
2164         it = elm_list_item_append(l_widget, label, ic, NULL,
2165                                   _profiles_list_selected_cb, strdup(profile));
2166         elm_list_item_del_cb_set(it, _profiles_list_item_del_cb);
2167         if (cur_profile && !strcmp(profile, cur_profile))
2168           sel_it = it;
2169
2170         elm_profile_dir_free(pdir);
2171
2172 #ifdef ELM_EFREET
2173         if (desk) efreet_desktop_free(desk);
2174 #endif
2175      }
2176
2177    if (sel_it) elm_list_item_selected_set(sel_it, EINA_TRUE);
2178    elm_list_go(l_widget);
2179 }
2180
2181 static void
2182 _profiles_list_unselect_cb(void *data       __UNUSED__,
2183                            Evas_Object     *obj,
2184                            void *event_info __UNUSED__)
2185 {
2186    if (elm_list_selected_item_get(obj)) return;
2187    elm_object_disabled_set(evas_object_data_get(obj, "prof_del_btn"),
2188                            EINA_TRUE);
2189    elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
2190                            EINA_TRUE);
2191    elm_object_disabled_set(evas_object_data_get(obj, "prof_use_btn"),
2192                            EINA_TRUE);
2193 }
2194
2195 static void
2196 _status_config_profiles(Evas_Object *win,
2197                         Evas_Object *pager)
2198 {
2199    Evas_Object *li, *bx, *fr_bx1, *fr_bx2, *btn_bx, *fr, *lb, *en, *sp, *pd,
2200    *bt;
2201    Eina_List *profs;
2202    Evas *evas;
2203
2204    bx = elm_box_add(win);
2205    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2206    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2207
2208    fr_bx1 = elm_box_add(win);
2209    evas_object_size_hint_weight_set(fr_bx1, EVAS_HINT_EXPAND,
2210                                     EVAS_HINT_EXPAND);
2211    evas_object_size_hint_align_set(fr_bx1, EVAS_HINT_FILL, EVAS_HINT_FILL);
2212    elm_box_homogenous_set(fr_bx1, EINA_TRUE);
2213    evas_object_show(fr_bx1);
2214
2215    fr_bx2 = elm_box_add(win);
2216    evas_object_size_hint_weight_set(fr_bx2, EVAS_HINT_EXPAND,
2217                                     EVAS_HINT_EXPAND);
2218    evas_object_size_hint_align_set(fr_bx2, EVAS_HINT_FILL, EVAS_HINT_FILL);
2219    evas_object_show(fr_bx2);
2220
2221    fr = elm_frame_add(win);
2222    elm_frame_label_set(fr, "Available Profiles");
2223    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2224    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2225    elm_frame_content_set(fr, fr_bx1);
2226    elm_box_pack_end(bx, fr);
2227    evas_object_show(fr);
2228
2229    li = elm_list_add(win);
2230    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2231    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2232    evas_object_smart_callback_add(li, "unselected", _profiles_list_unselect_cb,
2233                                   NULL);
2234
2235    profs = elm_profile_list_get();
2236
2237    evas_object_show(li);
2238    elm_box_pack_end(fr_bx2, li);
2239
2240    lb = elm_label_add(win);
2241    evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.0);
2242    evas_object_size_hint_align_set(lb, EVAS_HINT_FILL, 0.5);
2243
2244    evas_object_show(lb);
2245
2246    en = elm_scrolled_entry_add(win);
2247    elm_scrolled_entry_editable_set(en, EINA_FALSE);
2248    evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2249    evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
2250    evas_object_show(en);
2251
2252    evas_object_data_set(li, "prof_name_lbl", lb);
2253    evas_object_data_set(li, "prof_desc_entry", en);
2254
2255    elm_box_pack_end(fr_bx2, lb);
2256    elm_box_pack_end(fr_bx1, fr_bx2);
2257    elm_box_pack_end(fr_bx1, en);
2258
2259    /////////////////////////////////////////////
2260    sp = elm_separator_add(win);
2261    elm_separator_horizontal_set(sp, EINA_TRUE);
2262    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2263    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2264    elm_box_pack_end(bx, sp);
2265    evas_object_show(sp);
2266
2267    pd = elm_frame_add(win);
2268    elm_object_style_set(pd, "pad_medium");
2269    evas_object_size_hint_weight_set(pd, 0.0, 0.0);
2270    evas_object_size_hint_align_set(pd, 0.5, 0.5);
2271    elm_box_pack_end(bx, pd);
2272    evas_object_show(pd);
2273
2274    btn_bx = elm_box_add(win);
2275    elm_box_horizontal_set(btn_bx, EINA_TRUE);
2276    evas_object_size_hint_weight_set(btn_bx, EVAS_HINT_EXPAND,
2277                                     EVAS_HINT_EXPAND);
2278    evas_object_size_hint_align_set(btn_bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2279    evas_object_show(btn_bx);
2280
2281    bt = elm_button_add(win);
2282    evas_object_smart_callback_add(bt, "clicked", _profile_use, li);
2283    elm_button_label_set(bt, "Use");
2284    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2285    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2286    elm_box_pack_end(btn_bx, bt);
2287    evas_object_show(bt);
2288
2289    evas_object_data_set(li, "prof_use_btn", bt);
2290
2291    bt = elm_button_add(win);
2292    evas_object_smart_callback_add(bt, "clicked", _btn_todo, NULL); /* TODO */
2293    elm_button_label_set(bt, "Delete");
2294    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2295    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2296    elm_box_pack_end(btn_bx, bt);
2297    evas_object_show(bt);
2298
2299    evas_object_data_set(li, "prof_del_btn", bt);
2300
2301    bt = elm_button_add(win);
2302    evas_object_smart_callback_add(bt, "clicked", _profile_reset, li);
2303    elm_button_label_set(bt, "Reset");
2304    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2305    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2306    elm_box_pack_end(btn_bx, bt);
2307    evas_object_show(bt);
2308
2309    evas_object_data_set(li, "prof_reset_btn", bt);
2310
2311    bt = elm_button_add(win);
2312    evas_object_smart_callback_add(bt, "clicked", _btn_todo, NULL); /* TODO */
2313    elm_button_label_set(bt, "Add new");
2314    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2315    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2316    elm_box_pack_end(btn_bx, bt);
2317    evas_object_show(bt);
2318
2319    elm_frame_content_set(pd, btn_bx);
2320
2321    evas = evas_object_evas_get(li);
2322    evas_event_freeze(evas);
2323    edje_freeze();
2324
2325    _profiles_list_fill(li, profs);
2326
2327    elm_profile_list_free(profs);
2328
2329    edje_thaw();
2330    evas_event_thaw(evas);
2331
2332    evas_object_data_set(win, "profiles", bx);
2333    elm_pager_content_push(pager, bx);
2334 }
2335
2336 static void
2337 _status_config_scrolling(Evas_Object *win,
2338                          Evas_Object *pager)
2339 {
2340    Evas_Object *lb, *pd, *bx, *sl, *sp, *ck, *sc;
2341
2342    bx = elm_box_add(win);
2343    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
2344    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
2345
2346    sc = elm_scroller_add(win);
2347    evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2348    evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
2349    elm_scroller_bounce_set(sc, EINA_FALSE, EINA_TRUE);
2350    evas_object_show(sc);
2351    elm_scroller_content_set(sc, bx);
2352
2353    ck = elm_check_add(win);
2354    elm_object_tooltip_text_set(ck, "Set whether scrollers should bounce<br>"
2355                                    "when they reach their viewport's edge<br>"
2356                                    "during a scroll");
2357    elm_check_label_set(ck, "Enable scroll bounce");
2358    evas_object_data_set(win, "scroll_bounce_check", ck);
2359    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
2360    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
2361    elm_check_state_set(ck, elm_scroll_bounce_enabled_get());
2362    elm_box_pack_end(bx, ck);
2363    evas_object_show(ck);
2364
2365    evas_object_smart_callback_add(ck, "changed", sb_change, NULL);
2366
2367    LABEL_FRAME_ADD("<hilight>Scroll bounce friction</>");
2368
2369    sl = elm_slider_add(win);
2370    elm_object_tooltip_text_set(sl, "This is the amount of inertia a <br>"
2371                                    "scroller will impose at bounce animations");
2372    evas_object_data_set(win, "bounce_friction_slider", sl);
2373    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2374    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2375    elm_slider_span_size_set(sl, 120);
2376    elm_slider_unit_format_set(sl, "%1.2f");
2377    elm_slider_indicator_format_set(sl, "%1.2f");
2378    elm_slider_min_max_set(sl, 0.0, 4.0);
2379    elm_slider_value_set(sl, elm_scroll_bounce_friction_get());
2380    elm_box_pack_end(bx, sl);
2381    evas_object_show(sl);
2382
2383    evas_object_smart_callback_add(sl, "changed", bf_round, NULL);
2384    evas_object_smart_callback_add(sl, "delay,changed", bf_change, NULL);
2385
2386    sp = elm_separator_add(win);
2387    elm_separator_horizontal_set(sp, EINA_TRUE);
2388    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2389    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2390    elm_box_pack_end(bx, sp);
2391    evas_object_show(sp);
2392
2393    ck = elm_check_add(win);
2394    elm_object_tooltip_text_set(ck, "Set whether scrollers should be<br>"
2395                                    "draggable from any point in their views");
2396    elm_check_label_set(ck, "Enable thumb scroll");
2397    evas_object_data_set(win, "thumbscroll_check", ck);
2398    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
2399    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
2400    elm_check_state_set(ck, elm_scroll_thumbscroll_enabled_get());
2401    elm_box_pack_end(bx, ck);
2402    evas_object_show(ck);
2403
2404    evas_object_smart_callback_add(ck, "changed", ts_change, NULL);
2405
2406    LABEL_FRAME_ADD("<hilight>Thumb scroll threshold</>");
2407
2408    sl = elm_slider_add(win);
2409    elm_object_tooltip_text_set(sl, "This is the number of pixels one should<br>"
2410                                    "travel while dragging a scroller's view<br>"
2411                                    "to actually trigger scrolling");
2412    evas_object_data_set(win, "thumbscroll_threshold_slider", sl);
2413    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2414    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2415    elm_slider_span_size_set(sl, 120);
2416    elm_slider_unit_format_set(sl, "%1.0f pixels");
2417    elm_slider_indicator_format_set(sl, "%1.0f");
2418    elm_slider_min_max_set(sl, 8.0, 50.0);
2419    elm_slider_value_set(sl, elm_scroll_thumbscroll_threshold_get());
2420    elm_box_pack_end(bx, sl);
2421    evas_object_show(sl);
2422
2423    evas_object_smart_callback_add(sl, "changed", tst_round, NULL);
2424    evas_object_smart_callback_add(sl, "delay,changed", tst_change, NULL);
2425
2426    LABEL_FRAME_ADD("<hilight>Thumb scroll momentum threshold</>");
2427
2428    sl = elm_slider_add(win);
2429    elm_object_tooltip_text_set(sl, "This is the minimum speed of mouse <br>"
2430                                    "cursor movement which will trigger<br>"
2431                                    "list self scrolling animation after a<br>"
2432                                    "mouse up event (pixels/second)");
2433    evas_object_data_set(win, "ts_momentum_threshold_slider", sl);
2434    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2435    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2436    elm_slider_span_size_set(sl, 120);
2437    elm_slider_unit_format_set(sl, "%1.0f pixels/s");
2438    elm_slider_indicator_format_set(sl, "%1.0f");
2439    elm_slider_min_max_set(sl, 10.0, 200.0);
2440    elm_slider_value_set(sl, elm_scroll_thumbscroll_momentum_threshold_get());
2441    elm_box_pack_end(bx, sl);
2442    evas_object_show(sl);
2443
2444    evas_object_smart_callback_add(sl, "changed", tsmt_round, NULL);
2445    evas_object_smart_callback_add(sl, "delay,changed", tsmt_change,
2446                                   NULL);
2447
2448    LABEL_FRAME_ADD("<hilight>Thumb scroll friction</>");
2449
2450    sl = elm_slider_add(win);
2451    elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br>"
2452                                    "scroller will impose at self scrolling<br>"
2453                                    "animations");
2454    evas_object_data_set(win, "thumbscroll_friction_slider", sl);
2455    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2456    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2457    elm_slider_span_size_set(sl, 120);
2458    elm_slider_unit_format_set(sl, "%1.1f");
2459    elm_slider_indicator_format_set(sl, "%1.1f");
2460    elm_slider_min_max_set(sl, 0.0, 15.0);
2461    elm_slider_value_set(sl, elm_scroll_thumbscroll_friction_get());
2462    elm_box_pack_end(bx, sl);
2463    evas_object_show(sl);
2464
2465    evas_object_smart_callback_add(sl, "changed", tsf_round, NULL);
2466    evas_object_smart_callback_add(sl, "delay,changed", tsf_change, NULL);
2467
2468    LABEL_FRAME_ADD("<hilight>Thumb scroll border friction</>");
2469
2470    sl = elm_slider_add(win);
2471    elm_object_tooltip_text_set(sl, "This is the amount of lag between your<br>"
2472                                    "actual mouse cursor dragging movement<br>"
2473                                    "and a scroller's view movement itself,<br>"
2474                                    "while pushing it into bounce state<br>"
2475                                    "manually");
2476    evas_object_data_set(win, "ts_border_friction_slider", sl);
2477    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2478    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2479    elm_slider_span_size_set(sl, 120);
2480    elm_slider_unit_format_set(sl, "%1.2f");
2481    elm_slider_indicator_format_set(sl, "%1.2f");
2482    elm_slider_min_max_set(sl, 0.0, 1.0);
2483    elm_slider_value_set(sl, elm_scroll_thumbscroll_border_friction_get());
2484    elm_box_pack_end(bx, sl);
2485    evas_object_show(sl);
2486
2487    evas_object_smart_callback_add(sl, "changed", tsbf_round, NULL);
2488    evas_object_smart_callback_add(sl, "delay,changed", tsbf_change, NULL);
2489
2490    sp = elm_separator_add(win);
2491    elm_separator_horizontal_set(sp, EINA_TRUE);
2492    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2493    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2494    elm_box_pack_end(bx, sp);
2495    evas_object_show(sp);
2496
2497    LABEL_FRAME_ADD("<hilight>Page scroll friction</>");
2498
2499    sl = elm_slider_add(win);
2500    elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br>"
2501                                    "paged scroller will impose at<br>"
2502                                    "page fitting animations");
2503    evas_object_data_set(win, "page_scroll_friction_slider", sl);
2504    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2505    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2506    elm_slider_span_size_set(sl, 120);
2507    elm_slider_unit_format_set(sl, "%1.1f");
2508    elm_slider_indicator_format_set(sl, "%1.1f");
2509    elm_slider_min_max_set(sl, 0.0, 5.0);
2510    elm_slider_value_set(sl, elm_scroll_page_scroll_friction_get());
2511    elm_box_pack_end(bx, sl);
2512    evas_object_show(sl);
2513
2514    evas_object_smart_callback_add(sl, "changed", ps_round, NULL);
2515    evas_object_smart_callback_add(sl, "delay,changed", ps_change, NULL);
2516
2517    LABEL_FRAME_ADD("<hilight>Bring in scroll friction</>");
2518
2519    sl = elm_slider_add(win);
2520    elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br>"
2521                                    "scroller will impose at region bring<br>"
2522                                    "animations");
2523    evas_object_data_set(win, "bring_in_scroll_friction_slider", sl);
2524    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2525    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2526    elm_slider_span_size_set(sl, 120);
2527    elm_slider_unit_format_set(sl, "%1.1f");
2528    elm_slider_indicator_format_set(sl, "%1.1f");
2529    elm_slider_min_max_set(sl, 0.0, 5.0);
2530    elm_slider_value_set(sl, elm_scroll_bring_in_scroll_friction_get());
2531    elm_box_pack_end(bx, sl);
2532    evas_object_show(sl);
2533
2534    evas_object_smart_callback_add(sl, "changed", bis_round, NULL);
2535    evas_object_smart_callback_add(sl, "delay,changed", bis_change, NULL);
2536
2537    LABEL_FRAME_ADD("<hilight>Zoom scroll friction</>");
2538
2539    sl = elm_slider_add(win);
2540    elm_object_tooltip_text_set(sl, "This is the amount of inertia<br>"
2541                                    "scrollers will impose at animations<br>"
2542                                    "triggered by Elementary widgets'<br>"
2543                                    "zooming API");
2544    evas_object_data_set(win, "zoom_scroll_friction_slider", sl);
2545    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2546    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2547    elm_slider_span_size_set(sl, 120);
2548    elm_slider_unit_format_set(sl, "%1.1f");
2549    elm_slider_indicator_format_set(sl, "%1.1f");
2550    elm_slider_min_max_set(sl, 0.0, 5.0);
2551    elm_slider_value_set(sl, elm_scroll_zoom_friction_get());
2552    elm_box_pack_end(bx, sl);
2553    evas_object_show(sl);
2554
2555    evas_object_smart_callback_add(sl, "changed", zf_round, NULL);
2556    evas_object_smart_callback_add(sl, "delay,changed", zf_change, NULL);
2557
2558    evas_object_data_set(win, "scrolling", sc);
2559
2560    elm_pager_content_push(pager, sc);
2561 }
2562
2563 static char *
2564 _engine_name_prettify(const char *engine)
2565 {
2566    char *ret, *ptr;
2567
2568    ret = strdup(engine);
2569    ret[0] -= 0x20;
2570
2571    while ((ptr = strpbrk(ret, "_")))
2572      {
2573         *ptr = ' ';
2574      }
2575
2576    return ret;
2577 }
2578
2579 /* FIXME! ideally, we would trim elm_config.c's _elm_engines list at
2580    build time, making a getter for is as in ecore-evas. */
2581 static Eina_Bool
2582 _elm_engine_supported(const char *engine)
2583 {
2584    const char *engines[] = {
2585       "software_x11",
2586       "fb",
2587       "directfb",
2588       "software_16_x11",
2589       "software_8_x11",
2590       "xrender_x11",
2591       "opengl_x11",
2592       "software_gdi",
2593       "software_16_wince_gdi",
2594       "sdl",
2595       "software_16_sdl",
2596       "opengl_sdl",
2597       NULL
2598    };
2599
2600    unsigned int i;
2601
2602    for (i = 0; engines[i]; i++)
2603      {
2604 #define ENGINE_COMPARE(name) (!strcmp(engines[i], name))
2605         if (ENGINE_COMPARE(engine))
2606           return EINA_TRUE;
2607 #undef ENGINE_COMPARE
2608      }
2609
2610    return EINA_FALSE;
2611 }
2612
2613 static void
2614 _engines_list_fill(Evas_Object *l_widget,
2615                    Eina_List   *e_names)
2616 {
2617    const char *engine, *cur_engine;
2618    void *sel_it = NULL;
2619    Eina_List *l;
2620
2621    if (!e_names)
2622      return;
2623
2624    cur_engine = elm_engine_current_get();
2625
2626    EINA_LIST_FOREACH(e_names, l, engine)
2627      {
2628         const char *label;
2629         Elm_List_Item *it;
2630
2631         if (!_elm_engine_supported(engine))
2632           continue;
2633
2634         label = _engine_name_prettify(engine);
2635
2636         it = elm_list_item_append(l_widget, label, NULL, NULL, NULL,
2637                                   strdup(engine));
2638         elm_list_item_del_cb_set(it, _engines_list_item_del_cb);
2639         free((void *)label);
2640
2641         if (!strcmp(cur_engine, engine))
2642           sel_it = it;
2643      }
2644
2645    if (sel_it) elm_list_item_selected_set(sel_it, EINA_TRUE);
2646    elm_list_go(l_widget);
2647 }
2648
2649 static void
2650 _status_config_rendering(Evas_Object *win,
2651                          Evas_Object *pager)
2652 {
2653    Evas_Object *li, *bx, *fr, *sp, *pd, *bt;
2654    Eina_List *engines;
2655
2656    bx = elm_box_add(win);
2657    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2658    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2659
2660    fr = elm_frame_add(win);
2661    elm_frame_label_set(fr, "Available Engines");
2662    evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2663    evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2664    elm_box_pack_end(bx, fr);
2665    evas_object_show(fr);
2666
2667    li = elm_list_add(win);
2668    elm_frame_content_set(fr, li);
2669    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2670    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2671
2672    engines = ecore_evas_engines_get();
2673    _engines_list_fill(li, engines);
2674    ecore_evas_engines_free(engines);
2675
2676    evas_object_show(li);
2677    evas_object_data_set(win, "engines_list", li);
2678
2679    /////////////////////////////////////////////
2680    sp = elm_separator_add(win);
2681    elm_separator_horizontal_set(sp, EINA_TRUE);
2682    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2683    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2684    elm_box_pack_end(bx, sp);
2685    evas_object_show(sp);
2686
2687    pd = elm_frame_add(win);
2688    elm_object_style_set(pd, "pad_medium");
2689    evas_object_size_hint_weight_set(pd, 0.0, 0.0);
2690    evas_object_size_hint_align_set(pd, 0.5, 0.5);
2691    elm_box_pack_end(bx, pd);
2692    evas_object_show(pd);
2693
2694    bt = elm_button_add(win);
2695    evas_object_smart_callback_add(bt, "clicked", _engine_use, li);
2696    elm_button_label_set(bt, "Use Engine");
2697    evas_object_size_hint_weight_set(bt, 0.0, 0.0);
2698    evas_object_size_hint_align_set(bt, 0.5, 0.5);
2699    elm_frame_content_set(pd, bt);
2700    evas_object_show(bt);
2701
2702    evas_object_data_set(win, "rendering", bx);
2703    elm_pager_content_push(pager, bx);
2704 }
2705
2706 static void
2707 _status_config_caches(Evas_Object *win,
2708                       Evas_Object *pager)
2709 {
2710    Evas_Object *lb, *pd, *bx, *sl, *sp, *ck;
2711
2712    bx = elm_box_add(win);
2713    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
2714    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
2715
2716    LABEL_FRAME_ADD("<hilight>Cache Flush Interval (8 ticks pre second)</>");
2717
2718    sl = elm_slider_add(win);
2719    evas_object_data_set(win, "cache_flush_interval_slider", sl);
2720    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2721    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2722    elm_slider_span_size_set(sl, 120);
2723    elm_slider_unit_format_set(sl, "%1.0f ticks");
2724    elm_slider_indicator_format_set(sl, "%1.0f");
2725    elm_slider_min_max_set(sl, 8.0, 4096.0);
2726    elm_slider_value_set(sl, elm_cache_flush_interval_get());
2727    elm_object_disabled_set(sl, !elm_cache_flush_enmabled_get());
2728
2729    ck = elm_check_add(win);
2730    evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
2731    evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5);
2732    elm_check_label_set(ck, "Enable Flushing");
2733    elm_check_state_set(ck, elm_cache_flush_enmabled_get());
2734    evas_object_smart_callback_add(ck, "changed", cf_enable, sl);
2735    elm_box_pack_end(bx, ck);
2736    evas_object_show(ck);
2737
2738    elm_box_pack_end(bx, sl);
2739    evas_object_show(sl);
2740
2741    evas_object_smart_callback_add(sl, "changed", cf_round, NULL);
2742    evas_object_smart_callback_add(sl, "delay,changed", cf_change, NULL);
2743
2744    sp = elm_separator_add(win);
2745    elm_separator_horizontal_set(sp, 1);
2746    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2747    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2748    elm_box_pack_end(bx, sp);
2749    evas_object_show(sp);
2750
2751    LABEL_FRAME_ADD("<hilight>Font Cache Size</>");
2752
2753    sl = elm_slider_add(win);
2754    evas_object_data_set(win, "font_cache_slider", sl);
2755    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2756    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2757    elm_slider_span_size_set(sl, 120);
2758    elm_slider_unit_format_set(sl, "%1.1f MB");
2759    elm_slider_indicator_format_set(sl, "%1.1f");
2760    elm_slider_min_max_set(sl, 0.0, 4.0);
2761    elm_slider_value_set(sl, (double)elm_font_cache_get() / 1024.0);
2762    elm_box_pack_end(bx, sl);
2763    evas_object_show(sl);
2764
2765    evas_object_smart_callback_add(sl, "changed", fc_round, NULL);
2766    evas_object_smart_callback_add(sl, "delay,changed", fc_change, NULL);
2767
2768    sp = elm_separator_add(win);
2769    elm_separator_horizontal_set(sp, 1);
2770    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2771    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2772    elm_box_pack_end(bx, sp);
2773    evas_object_show(sp);
2774
2775    LABEL_FRAME_ADD("<hilight>Image Cache Size</>");
2776
2777    sl = elm_slider_add(win);
2778    evas_object_data_set(win, "image_cache_slider", sl);
2779    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2780    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2781    elm_slider_span_size_set(sl, 120);
2782    elm_slider_unit_format_set(sl, "%1.0f MB");
2783    elm_slider_indicator_format_set(sl, "%1.0f");
2784    elm_slider_min_max_set(sl, 0, 32);
2785    elm_slider_value_set(sl, (double)elm_image_cache_get() / 1024.0);
2786    elm_box_pack_end(bx, sl);
2787    evas_object_show(sl);
2788
2789    evas_object_smart_callback_add(sl, "changed", ic_round, NULL);
2790    evas_object_smart_callback_add(sl, "delay,changed", ic_change, NULL);
2791
2792    sp = elm_separator_add(win);
2793    elm_separator_horizontal_set(sp, 1);
2794    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2795    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2796    elm_box_pack_end(bx, sp);
2797    evas_object_show(sp);
2798
2799    LABEL_FRAME_ADD("<hilight>Number of Edje Files to Cache</>");
2800
2801    sl = elm_slider_add(win);
2802    evas_object_data_set(win, "edje_file_cache_slider", sl);
2803    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2804    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2805    elm_slider_span_size_set(sl, 120);
2806    elm_slider_unit_format_set(sl, "%1.0f files");
2807    elm_slider_indicator_format_set(sl, "%1.0f");
2808    elm_slider_min_max_set(sl, 0, 32);
2809    elm_slider_value_set(sl, elm_edje_file_cache_get());
2810    elm_box_pack_end(bx, sl);
2811    evas_object_show(sl);
2812
2813    evas_object_smart_callback_add(sl, "changed", efc_round, NULL);
2814    evas_object_smart_callback_add(sl, "delay,changed", efc_change, NULL);
2815
2816    sp = elm_separator_add(win);
2817    elm_separator_horizontal_set(sp, 1);
2818    evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2819    evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2820    elm_box_pack_end(bx, sp);
2821    evas_object_show(sp);
2822
2823    LABEL_FRAME_ADD("<hilight>Number of Edje Collections to Cache</>");
2824
2825    sl = elm_slider_add(win);
2826    evas_object_data_set(win, "edje_collection_cache_slider", sl);
2827    evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2828    evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2829    elm_slider_span_size_set(sl, 120);
2830    elm_slider_unit_format_set(sl, "%1.0f collections");
2831    elm_slider_indicator_format_set(sl, "%1.0f");
2832    elm_slider_min_max_set(sl, 0, 128);
2833    elm_slider_value_set(sl, elm_edje_collection_cache_get());
2834    elm_box_pack_end(bx, sl);
2835    evas_object_show(sl);
2836
2837    evas_object_smart_callback_add(sl, "changed", ecc_round, NULL);
2838    evas_object_smart_callback_add(sl, "delay,changed", ecc_change, NULL);
2839
2840    evas_object_data_set(win, "caches", bx);
2841
2842    elm_pager_content_push(pager, bx);
2843 }
2844
2845 static void
2846 _status_config_full(Evas_Object *win,
2847                     Evas_Object *bx0)
2848 {
2849    Evas_Object *tb, *pager;
2850    Elm_Toolbar_Item *sizing, *it;
2851
2852    tb = elm_toolbar_add(win);
2853    elm_toolbar_menu_parent_set(tb, win);
2854    elm_toolbar_homogenous_set(tb, 0);
2855    evas_object_size_hint_weight_set(tb, 1.0, 0.0);
2856    evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
2857
2858    sizing = elm_toolbar_item_append(tb, "zoom-fit-best", "Sizing",
2859                                     _cf_sizing, win);
2860    elm_toolbar_item_priority_set(sizing, 100);
2861
2862    it = elm_toolbar_item_append(tb, "preferences-desktop-theme", "Theme",
2863                                 _cf_themes, win);
2864    elm_toolbar_item_priority_set(it, 90);
2865
2866    elm_toolbar_item_append(tb, "preferences-desktop-font", "Fonts",
2867                            _cf_fonts, win);
2868
2869    it = elm_toolbar_item_append(tb, "system-users", "Profiles",
2870                                 _cf_profiles, win);
2871    elm_toolbar_item_priority_set(it, 90);
2872
2873    elm_toolbar_item_append(tb, "system-run", "Scrolling", _cf_scrolling, win);
2874    elm_toolbar_item_append(tb, "video-display", "Rendering",
2875                            _cf_rendering, win);
2876    elm_toolbar_item_append(tb, "appointment-new", "Caches", _cf_caches, win);
2877
2878    elm_box_pack_end(bx0, tb);
2879    evas_object_show(tb);
2880
2881    pager = elm_pager_add(win);
2882    evas_object_size_hint_align_set(pager, EVAS_HINT_FILL, EVAS_HINT_FILL);
2883    evas_object_size_hint_weight_set(pager, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2884    evas_object_data_set(win, "pager", pager);
2885
2886    _status_config_themes(win, pager);
2887    _status_config_fonts(win, pager);
2888    _status_config_profiles(win, pager);
2889    _status_config_rendering(win, pager);
2890    _status_config_scrolling(win, pager);
2891    _status_config_caches(win, pager);
2892    _status_config_sizing(win, pager);
2893
2894    // FIXME uncomment after flip style fix, please
2895    //elm_object_style_set(pager, "flip");
2896    elm_toolbar_item_selected_set(sizing, EINA_TRUE);
2897    elm_box_pack_end(bx0, pager);
2898    evas_object_show(pager);
2899 }
2900
2901 static void
2902 status_win(void)
2903 {
2904    Evas_Object *win, *bg, *bx0;
2905
2906    win = elm_win_add(NULL, "main", ELM_WIN_BASIC);
2907    elm_win_title_set(win, "Elementary Config");
2908
2909    evas_object_smart_callback_add(win, "delete,request", config_exit, NULL);
2910    bg = elm_bg_add(win);
2911    evas_object_size_hint_weight_set(bg, 1.0, 1.0);
2912    elm_win_resize_object_add(win, bg);
2913    evas_object_show(bg);
2914
2915    bx0 = elm_box_add(win);
2916    evas_object_size_hint_weight_set(bx0, 1.0, 1.0);
2917    elm_win_resize_object_add(win, bx0);
2918    evas_object_show(bx0);
2919
2920    if (!interactive) _status_basic(win, bx0);
2921    else if (0)
2922      _status_config(win, bx0);
2923    else _status_config_full(win, bx0);
2924
2925    evas_object_resize(win, 320, 480);
2926    evas_object_show(win);
2927 }
2928
2929 static Eina_Bool
2930 _exit_timer(void *data __UNUSED__)
2931 {
2932    elm_exit();
2933    return ECORE_CALLBACK_CANCEL;
2934 }
2935
2936 /* this is your elementary main function - it MUST be called IMMEDIATELY
2937  * after elm_init() and MUST be passed argc and argv, and MUST be called
2938  * elm_main and not be static - must be a visible symbol with EAPI infront */
2939 EAPI int
2940 elm_main(int    argc,
2941          char **argv)
2942 {
2943    int i;
2944
2945    for (i = 1; i < argc; i++)
2946      {
2947         if (!strcmp(argv[i], "-h"))
2948           {
2949              printf("Usage:\n"
2950                     "  -h                This help\n"
2951                     "  -q                Quiet mode (dont show window)\n"
2952                     "  -t THEME          Set theme to THEME (ELM_THEME spec)\n"
2953                     "  -f SIZE           Set finger size to SIZE pixels\n"
2954                     "  -s SCALE          Set scale factor to SCALE\n"
2955                     );
2956           }
2957         else if (!strcmp(argv[i], "-q"))
2958           {
2959              quiet = 1;
2960              interactive = 0;
2961           }
2962         else if ((!strcmp(argv[i], "-t")) && (i < argc - 1))
2963           {
2964              i++;
2965              theme_set = argv[i];
2966              interactive = 0;
2967           }
2968         else if ((!strcmp(argv[i], "-f")) && (i < argc - 1))
2969           {
2970              i++;
2971              finger_size_set = argv[i];
2972              interactive = 0;
2973           }
2974         else if ((!strcmp(argv[i], "-s")) && (i < argc - 1))
2975           {
2976              i++;
2977              scale_set = argv[i];
2978              interactive = 0;
2979           }
2980      }
2981    /* put here any init code specific to this app like parsing args, etc. */
2982    if (!quiet)
2983      {
2984 #ifdef ELM_EFREET
2985         elm_need_efreet();
2986 #endif
2987         status_win(); /* create main window */
2988         if (!interactive)
2989           ecore_timer_add(2.0, _exit_timer, NULL);
2990      }
2991    if (!interactive)
2992      {
2993         if (theme_set)
2994           {
2995              elm_theme_all_set(theme_set);
2996           }
2997         if (finger_size_set)
2998           {
2999              elm_finger_size_all_set(atoi(finger_size_set));
3000           }
3001         if (scale_set)
3002           {
3003              elm_scale_all_set(atof(scale_set));
3004           }
3005         if (quiet)
3006           {
3007              elm_exit();
3008           }
3009      }
3010    elm_run(); /* and run the program now and handle all events, etc. */
3011    /* if the mainloop that elm_run() runs exists, we exit the app */
3012    elm_shutdown(); /* clean up and shut down */
3013    /* exit code */
3014    return 0;
3015 }
3016
3017 #endif
3018 /* All emelentary apps should use this. Put it right after elm_main() */
3019 ELM_MAIN()