src/bin/config.c

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