efl

1
#ifdef HAVE_CONFIG_H
2
# include "elementary_config.h"
3
#endif
4
#include <Elementary.h>
5

6
typedef struct _Theme               Theme;
7
typedef struct _Fonts_Data          Fonts_Data;
8
typedef struct _Elm_Text_Class_Data Elm_Text_Class_Data;
9
typedef struct _Elm_Font_Size_Data  Elm_Font_Size_Data;
10

11
struct _Theme
12
{
13
   const char *label;
14
   const char *name;
15
   const char *path;
16
   Eina_Bool   in_search_path;
17
};
18

19
static const Eina_List *tsel = NULL;
20
static Eina_List *themes = NULL;
21

22
struct _Elm_Text_Class_Data
23
{
24
   const char    *name;
25
   const char    *desc;
26
   const char    *font;
27
   const char    *style;
28
   Evas_Font_Size size;
29
};
30

31
struct _Elm_Font_Size_Data
32
{
33
   const char    *size_str;
34
   Evas_Font_Size size;
35
};
36

37
struct _Fonts_Data
38
{
39
   Eina_List  *text_classes;
40

41
   Eina_Hash  *font_hash;
42
   Eina_List  *font_px_list;
43
   Eina_List  *font_scale_list;
44

45
   const char *cur_font;
46
   const char *cur_style;
47
   double      cur_size;
48
};
49

50
#define ELM_LIST_DISABLE(list)                         \
51
  do                                                   \
52
    {                                                  \
53
       const Eina_List *_l = elm_list_items_get(list); \
54
       if (_l)                                         \
55
         {                                             \
56
            elm_list_item_show(eina_list_data_get(_l));\
57
            elm_object_disabled_set(list, EINA_TRUE);  \
58
         }                                             \
59
    }                                                  \
60
  while (0)
61

62
#define ELM_LIST_ENABLE(list)                     \
63
  do                                              \
64
    {                                             \
65
       elm_object_disabled_set(list, EINA_FALSE); \
66
    }                                             \
67
  while (0)
68

69
#define LABEL_FRAME_ADD(label)                                      \
70
  do                                                                \
71
    {                                                               \
72
       pd = elm_frame_add(win);                                     \
73
       evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0); \
74
       evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, 0.5);    \
75
       elm_object_style_set(pd, "pad_medium");                      \
76
       elm_box_pack_end(bx, pd);                                    \
77
       evas_object_show(pd);                                        \
78
                                                                    \
79
       lb = elm_label_add(win);                                     \
80
       evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.0); \
81
       evas_object_size_hint_align_set(lb, EVAS_HINT_FILL, 0.5);    \
82
       elm_object_text_set(lb, label);                              \
83
       elm_object_content_set(pd, lb);                              \
84
       evas_object_show(lb);                                        \
85
    }                                                               \
86
  while (0)
87

88
#define CHECK_ADD(_label, _desc, _cb, _cb_param)  \
89
   ck = elm_check_add(win); \
90
   elm_object_text_set(ck, _label); \
91
   elm_object_tooltip_text_set(ck, _desc); \
92
   evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0); \
93
   evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.5); \
94
   elm_box_pack_end(bx, ck); \
95
   evas_object_show(ck); \
96
   evas_object_smart_callback_add(ck, "changed", _cb, _cb_param);
97

98
static int quiet = 0;
99
static int interactive = 1;
100

101
static const char *theme_set = NULL;
102
static const char *finger_size_set = NULL;
103
static const char *scale_set = NULL;
104
static const char *web_backend = NULL;
105
static Fonts_Data fndata = {NULL, NULL, NULL, NULL, NULL, NULL, 0.0};
106
static Evas_Object *web_backend_entry = NULL;
107
static Evas_Object *icon_theme_list = NULL,*icon_theme_elm = NULL;
108
static Evas_Object *icon_preview_frame;
109

110
static void
111
_font_styles_list_sel(void *data   EINA_UNUSED,
112
                      Evas_Object *obj,
113
                      void        *event_info);
114

115
static void
116
config_exit(void *data       EINA_UNUSED,
117
            Evas_Object *obj EINA_UNUSED,
118
            void *event_info EINA_UNUSED)
119
{
120
   Elm_Text_Class_Data *tc_data;
121
   Elm_Font_Size_Data *sd;
122

123
   EINA_LIST_FREE(fndata.text_classes, tc_data)
124
     {
125
        eina_stringshare_del(tc_data->name);
126
        eina_stringshare_del(tc_data->desc);
127
        eina_stringshare_del(tc_data->font);
128
        eina_stringshare_del(tc_data->style);
129
        free(tc_data);
130
     }
131

132
   elm_font_available_hash_del(fndata.font_hash);
133
   fndata.font_hash = NULL;
134

135
   EINA_LIST_FREE(fndata.font_px_list, sd)
136
     {
137
        eina_stringshare_del(sd->size_str);
138
        free(sd);
139
     }
140

141
   EINA_LIST_FREE(fndata.font_scale_list, sd)
142
     {
143
        eina_stringshare_del(sd->size_str);
144
        free(sd);
145
     }
146

147
   if (fndata.cur_font) eina_stringshare_del(fndata.cur_font);
148
   fndata.cur_font = NULL;
149

150
   if (fndata.cur_style) eina_stringshare_del(fndata.cur_style);
151
   fndata.cur_style = NULL;
152

153
   elm_config_save();
154
   efl_exit(0); /* exit the program's main loop that runs in elm_run() */
155
}
156

157
static void
158
scroll_animation_disable_change(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
159
{
160
   Eina_Bool val = elm_check_state_get(obj);
161
   Eina_Bool sb = elm_config_scroll_animation_disabled_get();
162

163
   if (val == sb) return;
164
   elm_config_scroll_animation_disabled_set(val);
165
   elm_config_all_flush();
166
}
167

168
static void
169
scroll_accel_factor_change(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
170
{
171
   double bf = elm_config_scroll_accel_factor_get();
172
   double val = elm_slider_value_get(obj);
173

174
   if (fabs(bf - val) < DBL_EPSILON) return;
175
   elm_config_scroll_accel_factor_set(val);
176
   elm_config_all_flush();
177
}
178

179
static void
180
sb_change(void *data       EINA_UNUSED,
181
          Evas_Object     *obj,
182
          void *event_info EINA_UNUSED)
183
{
184
   Eina_Bool val = elm_check_state_get(obj);
185
   Eina_Bool sb = elm_config_scroll_bounce_enabled_get();
186

187
   if (val == sb) return;
188
   elm_config_scroll_bounce_enabled_set(val);
189
   elm_config_all_flush();
190

191
   /*TODO: enable/disable subordinate sliders (make 'em support it 1st)*/
192
}
193

194
static void
195
ss_change(void *data       EINA_UNUSED,
196
          Evas_Object     *obj,
197
          void *event_info EINA_UNUSED)
198
{
199
   Eina_Bool val = elm_check_state_get(obj);
200
   Eina_Bool ss = elm_config_scroll_thumbscroll_smooth_start_get();
201

202
   if (val == ss) return;
203
   elm_config_scroll_thumbscroll_smooth_start_set(val);
204
   elm_config_all_flush();
205
}
206

207
static void
208
bf_round(void *data       EINA_UNUSED,
209
         Evas_Object     *obj,
210
         void *event_info EINA_UNUSED)
211
{
212
   double val = elm_slider_value_get(obj);
213
   double v;
214

215
   v = ((double)((int)(val * 10.0))) / 10.0;
216
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
217
}
218

219
static void
220
bf_change(void *data       EINA_UNUSED,
221
          Evas_Object     *obj,
222
          void *event_info EINA_UNUSED)
223
{
224
   double bf = elm_config_scroll_bounce_friction_get();
225
   double val = elm_slider_value_get(obj);
226

227
   if (EINA_DBL_EQ(bf, val)) return;
228
   elm_config_scroll_bounce_friction_set(val);
229
   elm_config_all_flush();
230
}
231

232
static void
233
ps_round(void *data       EINA_UNUSED,
234
         Evas_Object     *obj,
235
         void *event_info EINA_UNUSED)
236
{
237
   double val = elm_slider_value_get(obj);
238
   double v;
239

240
   v = ((double)((int)(val * 10.0))) / 10.0;
241
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
242
}
243

244
static void
245
ps_change(void *data       EINA_UNUSED,
246
          Evas_Object     *obj,
247
          void *event_info EINA_UNUSED)
248
{
249
   double ps = elm_config_scroll_page_scroll_friction_get();
250
   double val = elm_slider_value_get(obj);
251

252
   if (EINA_DBL_EQ(ps, val)) return;
253
   elm_config_scroll_page_scroll_friction_set(val);
254
   elm_config_all_flush();
255
}
256

257
static void
258
bis_round(void *data       EINA_UNUSED,
259
          Evas_Object     *obj,
260
          void *event_info EINA_UNUSED)
261
{
262
   double val = elm_slider_value_get(obj);
263
   double v;
264

265
   v = ((double)((int)(val * 10.0))) / 10.0;
266
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
267
}
268

269
static void
270
bis_change(void *data       EINA_UNUSED,
271
           Evas_Object     *obj,
272
           void *event_info EINA_UNUSED)
273
{
274
   double bis = elm_config_scroll_bring_in_scroll_friction_get();
275
   double val = elm_slider_value_get(obj);
276

277
   if (EINA_DBL_EQ(bis, val)) return;
278
   elm_config_scroll_bring_in_scroll_friction_set(val);
279
   elm_config_all_flush();
280
}
281

282
static void
283
zf_round(void *data       EINA_UNUSED,
284
         Evas_Object     *obj,
285
         void *event_info EINA_UNUSED)
286
{
287
   double val = elm_slider_value_get(obj);
288
   double v;
289

290
   v = ((double)((int)(val * 10.0))) / 10.0;
291
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
292
}
293

294
static void
295
zf_change(void *data       EINA_UNUSED,
296
          Evas_Object     *obj,
297
          void *event_info EINA_UNUSED)
298
{
299
   double zf = elm_config_scroll_zoom_friction_get();
300
   double val = elm_slider_value_get(obj);
301

302
   if (EINA_DBL_EQ(zf, val)) return;
303
   elm_config_scroll_zoom_friction_set(val);
304
   elm_config_all_flush();
305
}
306

307
static void
308
smooth_round(void *data       EINA_UNUSED,
309
             Evas_Object     *obj,
310
             void *event_info EINA_UNUSED)
311
{
312
   double val = elm_slider_value_get(obj);
313
   double v;
314

315
   v = ((double)((int)(val * 100.0))) / 100.0;
316
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
317
}
318

319
static void
320
smooth_change(void *data       EINA_UNUSED,
321
              Evas_Object     *obj,
322
              void *event_info EINA_UNUSED)
323
{
324
   double zf = elm_config_scroll_thumbscroll_smooth_amount_get();
325
   double val = elm_slider_value_get(obj);
326

327
   if (EINA_DBL_EQ(zf, val)) return;
328
   elm_config_scroll_thumbscroll_smooth_amount_set(val);
329
   elm_config_all_flush();
330
}
331

332
static void
333
smooth_win_round(void *data       EINA_UNUSED,
334
                 Evas_Object     *obj,
335
                 void *event_info EINA_UNUSED)
336
{
337
   double val = elm_slider_value_get(obj);
338
   double v;
339

340
   v = ((double)((int)(val * 100.0))) / 100.0;
341
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
342
}
343

344
static void
345
smooth_win_change(void *data       EINA_UNUSED,
346
                  Evas_Object     *obj,
347
                  void *event_info EINA_UNUSED)
348
{
349
   double zf = elm_config_scroll_thumbscroll_smooth_time_window_get();
350
   double val = elm_slider_value_get(obj);
351

352
   if (EINA_DBL_EQ(zf, val)) return;
353
   elm_config_scroll_thumbscroll_smooth_time_window_set(val);
354
   elm_config_all_flush();
355
}
356

357
static void
358
ts_change(void *data       EINA_UNUSED,
359
          Evas_Object     *obj,
360
          void *event_info EINA_UNUSED)
361
{
362
   Eina_Bool val = elm_check_state_get(obj);
363
   Eina_Bool sb = elm_config_scroll_thumbscroll_enabled_get();
364

365
   if (val == sb) return;
366
   elm_config_scroll_thumbscroll_enabled_set(val);
367
   elm_config_all_flush();
368

369
   /*TODO: enable/disable subordinate sliders (make 'em support it 1st)*/
370
}
371

372
static void
373
tst_round(void *data       EINA_UNUSED,
374
          Evas_Object     *obj,
375
          void *event_info EINA_UNUSED)
376
{
377
   double val = elm_slider_value_get(obj);
378
   double v;
379

380
   v = ((double)((int)(val * 10.0))) / 10.0;
381
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
382
}
383

384
static void
385
tst_change(void *data       EINA_UNUSED,
386
           Evas_Object     *obj,
387
           void *event_info EINA_UNUSED)
388
{
389
   double tst = elm_config_scroll_thumbscroll_threshold_get();
390
   double val = elm_slider_value_get(obj);
391

392
   if (EINA_DBL_EQ(tst, val)) return;
393
   elm_config_scroll_thumbscroll_threshold_set(val);
394
   elm_config_all_flush();
395
}
396

397
static void
398
tsht_round(void *data       EINA_UNUSED,
399
          Evas_Object     *obj,
400
          void *event_info EINA_UNUSED)
401
{
402
   double val = elm_slider_value_get(obj);
403
   double v;
404

405
   v = ((double)((int)(val * 10.0))) / 10.0;
406
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
407
}
408

409
static void
410
tsht_change(void *data       EINA_UNUSED,
411
           Evas_Object     *obj,
412
           void *event_info EINA_UNUSED)
413
{
414
   double tst = elm_config_scroll_thumbscroll_hold_threshold_get();
415
   double val = elm_slider_value_get(obj);
416

417
   if (EINA_DBL_EQ(tst, val)) return;
418
   elm_config_scroll_thumbscroll_hold_threshold_set(val);
419
   elm_config_all_flush();
420
}
421

422
static void
423
tsmt_round(void *data       EINA_UNUSED,
424
           Evas_Object     *obj,
425
           void *event_info EINA_UNUSED)
426
{
427
   double val = elm_slider_value_get(obj);
428
   double v;
429

430
   v = ((double)((int)(val * 10.0))) / 10.0;
431
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
432
}
433

434
static void
435
tsmt_change(void *data       EINA_UNUSED,
436
            Evas_Object     *obj,
437
            void *event_info EINA_UNUSED)
438
{
439
   double tsmt = elm_config_scroll_thumbscroll_momentum_threshold_get();
440
   double val = elm_slider_value_get(obj);
441

442
   if (EINA_DBL_EQ(tsmt, val)) return;
443
   elm_config_scroll_thumbscroll_momentum_threshold_set(val);
444
   elm_config_all_flush();
445
}
446

447
static void
448
tsfdt_round(void *data       EINA_UNUSED,
449
            Evas_Object     *obj,
450
            void *event_info EINA_UNUSED)
451
{
452
   double val = elm_slider_value_get(obj);
453
   double v;
454

455
   v = ((double)((int)(val * 10.0))) / 10.0;
456
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
457
}
458

459
static void
460
tsfdt_change(void *data       EINA_UNUSED,
461
             Evas_Object     *obj,
462
             void *event_info EINA_UNUSED)
463
{
464
   double tsfdt = elm_config_scroll_thumbscroll_flick_distance_tolerance_get();
465
   double val = elm_slider_value_get(obj);
466

467
   if (EINA_DBL_EQ(tsfdt, val)) return;
468
   elm_config_scroll_thumbscroll_flick_distance_tolerance_set(val);
469
   elm_config_all_flush();
470
}
471

472
static void
473
tsf_round(void *data       EINA_UNUSED,
474
          Evas_Object     *obj,
475
          void *event_info EINA_UNUSED)
476
{
477
   double val = elm_slider_value_get(obj);
478
   double v;
479

480
   v = ((double)((int)(val * 10.0))) / 10.0;
481
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
482
}
483

484
static void
485
tsf_change(void *data       EINA_UNUSED,
486
           Evas_Object     *obj,
487
           void *event_info EINA_UNUSED)
488
{
489
   double tsf = elm_config_scroll_thumbscroll_friction_get();
490
   double val = elm_slider_value_get(obj);
491

492
   if (EINA_DBL_EQ(tsf, val)) return;
493
   elm_config_scroll_thumbscroll_friction_set(val);
494
   elm_config_all_flush();
495
}
496

497
static void
498
tsmf_round(void *data       EINA_UNUSED,
499
           Evas_Object     *obj,
500
           void *event_info EINA_UNUSED)
501
{
502
   double val = elm_slider_value_get(obj);
503
   double v;
504

505
   v = ((double)((int)(val * 10.0))) / 10.0;
506
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
507
}
508

509
static void
510
tsmf_change(void *data       EINA_UNUSED,
511
            Evas_Object     *obj,
512
            void *event_info EINA_UNUSED)
513
{
514
   double tsmf = elm_config_scroll_thumbscroll_min_friction_get();
515
   double val = elm_slider_value_get(obj);
516

517
   if (EINA_DBL_EQ(tsmf, val)) return;
518
   elm_config_scroll_thumbscroll_min_friction_set(val);
519
   elm_config_all_flush();
520
}
521

522
static void
523
tsfs_round(void *data       EINA_UNUSED,
524
           Evas_Object     *obj,
525
           void *event_info EINA_UNUSED)
526
{
527
   double val = elm_slider_value_get(obj);
528
   double v;
529

530
   v = ((double)((int)(val * 10.0))) / 10.0;
531
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
532
}
533

534
static void
535
tsfs_change(void *data       EINA_UNUSED,
536
            Evas_Object     *obj,
537
            void *event_info EINA_UNUSED)
538
{
539
   double tsfs = elm_config_scroll_thumbscroll_friction_standard_get();
540
   double val = elm_slider_value_get(obj);
541

542
   if (EINA_DBL_EQ(tsfs, val)) return;
543
   elm_config_scroll_thumbscroll_friction_standard_set(val);
544
   elm_config_all_flush();
545
}
546

547
static void
548
tsbf_round(void *data       EINA_UNUSED,
549
           Evas_Object     *obj,
550
           void *event_info EINA_UNUSED)
551
{
552
   double val = elm_slider_value_get(obj);
553
   double v;
554

555
   v = ((double)((int)(val * 10.0))) / 10.0;
556
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
557
}
558

559
static void
560
tsbf_change(void *data       EINA_UNUSED,
561
            Evas_Object     *obj,
562
            void *event_info EINA_UNUSED)
563
{
564
   double tsbf = elm_config_scroll_thumbscroll_border_friction_get();
565
   double val = elm_slider_value_get(obj);
566

567
   if (EINA_DBL_EQ(tsbf, val)) return;
568
   elm_config_scroll_thumbscroll_border_friction_set(val);
569
   elm_config_all_flush();
570
}
571

572
static void
573
tssf_round(void *data       EINA_UNUSED,
574
           Evas_Object     *obj,
575
           void *event_info EINA_UNUSED)
576
{
577
   double val = elm_slider_value_get(obj);
578
   double v;
579

580
   v = ((double)((int)(val * 20.0))) / 20.0;
581
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
582
}
583

584
static void
585
tssf_change(void *data       EINA_UNUSED,
586
            Evas_Object     *obj,
587
            void *event_info EINA_UNUSED)
588
{
589
   double tssf = elm_config_scroll_thumbscroll_sensitivity_friction_get();
590
   double val = elm_slider_value_get(obj);
591

592
   if (EINA_DBL_EQ(tssf, val)) return;
593
   elm_config_scroll_thumbscroll_sensitivity_friction_set(val);
594
   elm_config_all_flush();
595
}
596

597
static void
598
tsat_round(void *data       EINA_UNUSED,
599
           Evas_Object     *obj,
600
           void *event_info EINA_UNUSED)
601
{
602
   double val = elm_slider_value_get(obj);
603
   double v;
604

605
   v = ((double)((int)(val * 10.0))) / 10.0;
606
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
607
}
608

609
static void
610
tsat_change(void *data       EINA_UNUSED,
611
            Evas_Object     *obj,
612
            void *event_info EINA_UNUSED)
613
{
614
   double tsat = elm_config_scroll_thumbscroll_acceleration_threshold_get();
615
   double val = elm_slider_value_get(obj);
616

617
   if (EINA_DBL_EQ(tsat, val)) return;
618
   elm_config_scroll_thumbscroll_acceleration_threshold_set(val);
619
   elm_config_all_flush();
620
}
621

622
static void
623
tsatl_round(void *data       EINA_UNUSED,
624
           Evas_Object     *obj,
625
           void *event_info EINA_UNUSED)
626
{
627
   double val = elm_slider_value_get(obj);
628
   double v;
629

630
   v = ((double)((int)(val * 10.0))) / 10.0;
631
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
632
}
633

634
static void
635
tsatl_change(void *data       EINA_UNUSED,
636
            Evas_Object     *obj,
637
            void *event_info EINA_UNUSED)
638
{
639
   double tsatl = elm_config_scroll_thumbscroll_acceleration_time_limit_get();
640
   double val = elm_slider_value_get(obj);
641

642
   if (EINA_DBL_EQ(tsatl, val)) return;
643
   elm_config_scroll_thumbscroll_acceleration_time_limit_set(val);
644
   elm_config_all_flush();
645
}
646

647
static void
648
tsaw_round(void *data       EINA_UNUSED,
649
           Evas_Object     *obj,
650
           void *event_info EINA_UNUSED)
651
{
652
   double val = elm_slider_value_get(obj);
653
   double v;
654

655
   v = ((double)((int)(val * 10.0))) / 10.0;
656
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
657
}
658

659
static void
660
tsaw_change(void *data       EINA_UNUSED,
661
            Evas_Object     *obj,
662
            void *event_info EINA_UNUSED)
663
{
664
   double tsaw = elm_config_scroll_thumbscroll_acceleration_weight_get();
665
   double val = elm_slider_value_get(obj);
666

667
   if (EINA_DBL_EQ(tsaw, val)) return;
668
   elm_config_scroll_thumbscroll_acceleration_weight_set(val);
669
   elm_config_all_flush();
670
}
671

672
static void
673
cf_enable(void *data,
674
          Evas_Object     *obj,
675
          void *event_info EINA_UNUSED)
676
{
677
   Eina_Bool cf = elm_config_cache_flush_enabled_get();
678
   Eina_Bool val = elm_check_state_get(obj);
679

680
   if (cf == val) return;
681
   elm_object_disabled_set((Evas_Object *)data, !val);
682
   elm_config_cache_flush_enabled_set(val);
683
   elm_config_all_flush();
684
}
685

686
static void
687
cf_round(void *data       EINA_UNUSED,
688
         Evas_Object     *obj,
689
         void *event_info EINA_UNUSED)
690
{
691
   double val = elm_slider_value_get(obj);
692
   double v;
693

694
   v = ((double)((int)(val * 5.0))) / 5.0;
695
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
696
}
697

698
static void
699
cf_change(void *data       EINA_UNUSED,
700
          Evas_Object     *obj,
701
          void *event_info EINA_UNUSED)
702
{
703
   double cf = elm_config_cache_flush_interval_get();
704
   double val = elm_slider_value_get(obj);
705

706
   if (EINA_DBL_EQ(cf, val)) return;
707
   elm_config_cache_flush_interval_set(val);
708
   elm_config_all_flush();
709
}
710

711
static void
712
fc_round(void *data       EINA_UNUSED,
713
         Evas_Object     *obj,
714
         void *event_info EINA_UNUSED)
715
{
716
   double val = elm_slider_value_get(obj);
717
   double v;
718

719
   v = ((double)((int)(val * 10.0))) / 10.0;
720
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
721
}
722

723
static void
724
fc_change(void *data       EINA_UNUSED,
725
          Evas_Object     *obj,
726
          void *event_info EINA_UNUSED)
727
{
728
   double font_cache = elm_config_cache_font_cache_size_get();
729
   double val = elm_slider_value_get(obj);
730

731
   if (EINA_DBL_EQ(font_cache, val)) return;
732
   elm_config_cache_font_cache_size_set(val * 1024);
733
   elm_config_all_flush();
734
}
735

736
static void
737
ic_round(void *data       EINA_UNUSED,
738
         Evas_Object     *obj,
739
         void *event_info EINA_UNUSED)
740
{
741
   double val = elm_slider_value_get(obj);
742
   double v;
743

744
   v = ((double)((int)(val * 10.0))) / 10.0;
745
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
746
}
747

748
static void
749
ic_change(void *data       EINA_UNUSED,
750
          Evas_Object     *obj,
751
          void *event_info EINA_UNUSED)
752
{
753
   double image_cache = elm_config_cache_image_cache_size_get();
754
   double val = elm_slider_value_get(obj);
755

756
   if (EINA_DBL_EQ(image_cache, val)) return;
757
   elm_config_cache_image_cache_size_set(val * 1024);
758
   elm_config_all_flush();
759
}
760

761
static void
762
sc_round(void *data       EINA_UNUSED,
763
         Evas_Object     *obj,
764
         void *event_info EINA_UNUSED)
765
{
766
   double val = elm_slider_value_get(obj);
767
   double v;
768

769
   v = ((double)((int)(val * 10.0))) / 10.0;
770
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
771
}
772

773
static void
774
sc_change(void *data       EINA_UNUSED,
775
          Evas_Object     *obj,
776
          void *event_info EINA_UNUSED)
777
{
778
   double scale = elm_config_scale_get();
779
   double val = elm_slider_value_get(obj);
780

781
   if (EINA_DBL_EQ(scale, val)) return;
782
   elm_config_scale_set(val);
783
   elm_config_all_flush();
784
}
785

786
static void
787
fs_round(void *data       EINA_UNUSED,
788
         Evas_Object     *obj,
789
         void *event_info EINA_UNUSED)
790
{
791
   double val = elm_slider_value_get(obj);
792
   double v;
793

794
   v = ((double)((int)(val * 5.0))) / 5.0;
795
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
796
}
797

798
static void
799
fs_change(void *data       EINA_UNUSED,
800
          Evas_Object     *obj,
801
          void *event_info EINA_UNUSED)
802
{
803
   double fs = elm_config_finger_size_get();
804
   double val = elm_slider_value_get(obj);
805

806
   if (EINA_DBL_EQ(fs, val)) return;
807
   elm_config_finger_size_set(val);
808
   elm_config_all_flush();
809
}
810

811
static void
812
efc_round(void *data       EINA_UNUSED,
813
          Evas_Object     *obj,
814
          void *event_info EINA_UNUSED)
815
{
816
   double val = elm_slider_value_get(obj);
817
   double v;
818

819
   v = ((double)((int)(val * 5.0))) / 5.0;
820
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
821
}
822

823
static void
824
efc_change(void *data       EINA_UNUSED,
825
           Evas_Object     *obj,
826
           void *event_info EINA_UNUSED)
827
{
828
   double efc = elm_config_cache_edje_file_cache_size_get();
829
   double val = elm_slider_value_get(obj);
830

831
   if (EINA_DBL_EQ(efc, val)) return;
832
   elm_config_cache_edje_file_cache_size_set(val);
833
   elm_config_all_flush();
834
}
835

836
static void
837
ecc_round(void *data       EINA_UNUSED,
838
          Evas_Object     *obj,
839
          void *event_info EINA_UNUSED)
840
{
841
   double val = elm_slider_value_get(obj);
842
   double v;
843

844
   v = ((double)((int)(val * 5.0))) / 5.0;
845
   if (!EINA_DBL_EQ(v, val)) elm_slider_value_set(obj, v);
846
}
847

848
static void
849
ecc_change(void *data       EINA_UNUSED,
850
           Evas_Object     *obj,
851
           void *event_info EINA_UNUSED)
852
{
853
   double ecc = elm_config_cache_edje_collection_cache_size_get();
854
   double val = elm_slider_value_get(obj);
855

856
   if (EINA_DBL_EQ(ecc, val)) return;
857
   elm_config_cache_edje_collection_cache_size_set(val);
858
   elm_config_all_flush();
859
}
860

861
static void
862
desk_entry_change(void *data       EINA_UNUSED,
863
                  Evas_Object     *obj,
864
                  void *event_info EINA_UNUSED)
865
{
866
   Eina_Bool val = elm_check_state_get(obj);
867
   Eina_Bool de = elm_config_desktop_entry_get();
868

869
   if (val == de) return;
870
   elm_config_desktop_entry_set(val);
871
   elm_config_all_flush();
872
}
873

874
static void
875
mag_change(void *data       EINA_UNUSED,
876
           Evas_Object     *obj,
877
           void *event_info EINA_UNUSED)
878
{
879
   Eina_Bool val = elm_check_state_get(obj);
880
   Eina_Bool mag = elm_config_magnifier_enable_get();
881

882
   if (val == mag) return;
883
   elm_config_magnifier_enable_set(val);
884
   elm_config_all_flush();
885
}
886

887
static void
888
ac_change(void *data       EINA_UNUSED,
889
          Evas_Object     *obj,
890
          void *event_info EINA_UNUSED)
891
{
892
   Eina_Bool val = elm_check_state_get(obj);
893
   Eina_Bool ac = elm_config_access_get();
894

895
   if (val == ac) return;
896
   elm_config_access_set(val);
897
   elm_config_all_flush();
898
}
899

900
static void
901
sel_change(void *data       EINA_UNUSED,
902
          Evas_Object     *obj,
903
          void *event_info EINA_UNUSED)
904
{
905
   Eina_Bool val = elm_check_state_get(obj);
906
   Eina_Bool sel = elm_config_selection_unfocused_clear_get();
907

908
   if (val == sel) return;
909
   elm_config_selection_unfocused_clear_set(val);
910
   elm_config_all_flush();
911
}
912

913
static void
914
dbg_change(void *data       EINA_UNUSED,
915
          Evas_Object     *obj,
916
          void *event_info EINA_UNUSED)
917
{
918
   Eina_Bool val = elm_check_state_get(obj);
919
   Eina_Bool sel = elm_config_clouseau_enabled_get();
920

921
   if (val == sel) return;
922
   elm_config_clouseau_enabled_set(val);
923
   elm_config_all_flush();
924
}
925

926
static void
927
atspi_change(void *data       EINA_UNUSED,
928
          Evas_Object     *obj,
929
          void *event_info EINA_UNUSED)
930
{
931
   Eina_Bool val = elm_check_state_get(obj);
932
   Eina_Bool sel = elm_config_atspi_mode_get();
933

934
   if (val == sel) return;
935
   elm_config_atspi_mode_set(val);
936
   elm_config_all_flush();
937
}
938

939
static void
940
transition_duration_change(void *data EINA_UNUSED,
941
                       Evas_Object *obj,
942
                       void *event_info EINA_UNUSED)
943
{
944
   double val = elm_slider_value_get(obj);
945
   double scale = elm_config_transition_duration_factor_get();
946

947
   if (EINA_DBL_EQ(scale, val)) return;
948
   elm_config_transition_duration_factor_set(val);
949
   elm_config_all_flush();
950
}
951

952
static void
953
tooltip_delay_change(void *data EINA_UNUSED,
954
                     Evas_Object *obj,
955
                     void *event_info EINA_UNUSED)
956
{
957
   double val = elm_slider_value_get(obj);
958
   double delay = elm_config_tooltip_delay_get();
959

960
   if (EINA_DBL_EQ(delay, val)) return;
961
   elm_config_tooltip_delay_set(val);
962
   elm_config_all_flush();
963
}
964

965

966
static void
967
_status_basic(Evas_Object *win,
968
              Evas_Object *bx0)
969
{
970
   Evas_Object *lb, *fr;
971

972
   fr = elm_frame_add(win);
973
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
974
   elm_object_text_set(fr, "Information");
975
   elm_box_pack_end(bx0, fr);
976
   evas_object_show(fr);
977

978
   lb = elm_label_add(win);
979
   elm_object_text_set(lb,
980
                       "Applying configuration change"
981
                       );
982
   elm_object_content_set(fr, lb);
983
   evas_object_show(lb);
984
}
985

986
static void
987
_status_config(Evas_Object *win,
988
               Evas_Object *bx0)
989
{
990
   Evas_Object *lb, *pd, *bx, *fr, *sl, *sp;
991

992
   fr = elm_frame_add(win);
993
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
994
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
995
   elm_object_text_set(fr, "Sizing");
996
   elm_box_pack_end(bx0, fr);
997
   evas_object_show(fr);
998

999
   bx = elm_box_add(win);
1000
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
1001
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
1002

1003
   LABEL_FRAME_ADD("<hilight>Scale</>");
1004

1005
   sl = elm_slider_add(win);
1006
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1007
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1008
   elm_slider_span_size_set(sl, 120);
1009
   elm_slider_unit_format_set(sl, "%1.2f");
1010
   elm_slider_indicator_format_set(sl, "%1.2f");
1011
   elm_slider_min_max_set(sl, 0.25, 5.0);
1012
   elm_slider_value_set(sl, elm_config_scale_get());
1013
   elm_box_pack_end(bx, sl);
1014
   evas_object_show(sl);
1015

1016
   evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
1017
   evas_object_smart_callback_add(sl, "delay,changed", sc_change, NULL);
1018

1019
   sp = elm_separator_add(win);
1020
   elm_separator_horizontal_set(sp, EINA_TRUE);
1021
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1022
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1023
   elm_box_pack_end(bx, sp);
1024
   evas_object_show(sp);
1025

1026
   LABEL_FRAME_ADD("<hilight>Finger Size</><br/>");
1027

1028
   sl = elm_slider_add(win);
1029
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1030
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1031
   elm_slider_span_size_set(sl, 120);
1032
   elm_slider_unit_format_set(sl, "%1.0f");
1033
   elm_slider_indicator_format_set(sl, "%1.0f");
1034
   elm_slider_min_max_set(sl, 5, 200);
1035
   elm_slider_value_set(sl, elm_config_finger_size_get());
1036
   elm_box_pack_end(bx, sl);
1037
   evas_object_show(sl);
1038

1039
   evas_object_smart_callback_add(sl, "changed", fs_round, NULL);
1040
   evas_object_smart_callback_add(sl, "delay,changed", fs_change, NULL);
1041

1042
   // FIXME: add theme selector (basic mode and advanced for fallbacks)
1043
   // FIXME: save config
1044
   // FIXME: profile selector / creator etc.
1045
   elm_object_content_set(fr, bx);
1046
   evas_object_show(bx);
1047
}
1048

1049
static void
1050
_flip_to(Evas_Object *win,
1051
         const char  *name)
1052
{
1053
   Evas_Object *wid, *naviframe;
1054
   wid = evas_object_data_get(win, name);
1055
   naviframe = evas_object_data_get(win, "naviframe");
1056
   if (!naviframe) return;
1057
   elm_naviframe_item_simple_promote(naviframe, wid);
1058
}
1059

1060
static void
1061
_cf_sizing(void            *data,
1062
           Evas_Object *obj EINA_UNUSED,
1063
           void *event_info EINA_UNUSED)
1064
{
1065
   _flip_to(data, "sizing");
1066
}
1067

1068
static void
1069
_cf_themes(void            *data,
1070
           Evas_Object *obj EINA_UNUSED,
1071
           void *event_info EINA_UNUSED)
1072
{
1073
   _flip_to(data, "themes");
1074
}
1075

1076
static void
1077
_cf_icons(void            *data,
1078
           Evas_Object *obj EINA_UNUSED,
1079
           void *event_info EINA_UNUSED)
1080
{
1081
   _flip_to(data, "icons");
1082
}
1083

1084
static void
1085
_cf_fonts(void            *data,
1086
          Evas_Object *obj EINA_UNUSED,
1087
          void *event_info EINA_UNUSED)
1088
{
1089
   _flip_to(data, "fonts");
1090
}
1091

1092
static void
1093
_cf_colors(void            *data,
1094
          Evas_Object *obj EINA_UNUSED,
1095
          void *event_info EINA_UNUSED)
1096
{
1097
   _flip_to(data, "colors");
1098
}
1099

1100
static void
1101
_cf_profiles(void            *data,
1102
             Evas_Object *obj EINA_UNUSED,
1103
             void *event_info EINA_UNUSED)
1104
{
1105
   _flip_to(data, "profiles");
1106
}
1107

1108
static void
1109
_cf_scrolling(void            *data,
1110
              Evas_Object *obj EINA_UNUSED,
1111
              void *event_info EINA_UNUSED)
1112
{
1113
   _flip_to(data, "scrolling");
1114
}
1115

1116
static void
1117
_cf_rendering(void            *data,
1118
              Evas_Object *obj EINA_UNUSED,
1119
              void *event_info EINA_UNUSED)
1120
{
1121
   _flip_to(data, "rendering");
1122
}
1123

1124
static void
1125
_cf_caches(void            *data,
1126
           Evas_Object *obj EINA_UNUSED,
1127
           void *event_info EINA_UNUSED)
1128
{
1129
   _flip_to(data, "caches");
1130
}
1131

1132
static void
1133
_cf_audio(void *data,
1134
        Evas_Object *obj EINA_UNUSED,
1135
        void *event_info EINA_UNUSED)
1136
{
1137
   _flip_to(data,"audio");
1138
}
1139

1140
static void
1141
_cf_focus(void *data,
1142
          Evas_Object *obj EINA_UNUSED,
1143
          void *event_info EINA_UNUSED)
1144
{
1145
   _flip_to(data, "focus");
1146
}
1147

1148
static void
1149
_cf_etc(void *data,
1150
        Evas_Object *obj EINA_UNUSED,
1151
        void *event_info EINA_UNUSED)
1152
{
1153
   _flip_to(data,"etc");
1154
}
1155

1156
const char *
1157
_elm_theme_current_get(const char *theme_search_order)
1158
{
1159
   const char *ret;
1160
   const char *p;
1161

1162
   if (!theme_search_order)
1163
     return NULL;
1164

1165
   for (p = theme_search_order;; p++)
1166
     {
1167
        if ((*p == ':') || (!*p))
1168
          {
1169
             if (p > theme_search_order)
1170
               {
1171
                  char *n = malloc(p - theme_search_order + 1);
1172
                  if (!n)
1173
                    return NULL;
1174

1175
                  strncpy(n, theme_search_order, p - theme_search_order);
1176
                  n[p - theme_search_order] = 0;
1177
                  ret = eina_stringshare_add(n);
1178
                  free(n);
1179
                  break;
1180
               }
1181
          }
1182
     }
1183

1184
   return ret;
1185
}
1186

1187
static void
1188
_font_overlay_set_all(void            *data,
1189
                      Evas_Object *obj EINA_UNUSED,
1190
                      void *event_info EINA_UNUSED)
1191
{
1192
   Evas_Object *win, *fclasses;
1193
   Elm_Text_Class_Data *tc_data, *tc;
1194
   Elm_Object_Item *list_it;
1195
   Eina_List *l;
1196

1197
   win = data;
1198

1199
   fclasses = evas_object_data_get(win, "font_classes_list");
1200
   list_it = elm_list_selected_item_get(fclasses);
1201
   if (!list_it) return;
1202
   tc_data = elm_object_item_data_get(list_it);
1203
   if (!tc_data) return;
1204

1205
   EINA_LIST_FOREACH(fndata.text_classes, l, tc)
1206
     {
1207
        eina_stringshare_replace(&tc->font, tc_data->font);
1208
        eina_stringshare_replace(&tc->style, tc_data->style);
1209
        tc->size = tc_data->size;
1210
     }
1211

1212
   elm_config_all_flush();
1213
}
1214

1215
static void
1216
_font_overlay_reset(void            *data,
1217
                    Evas_Object *obj EINA_UNUSED,
1218
                    void *event_info EINA_UNUSED)
1219
{
1220
   Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
1221
   Elm_Text_Class_Data *tc_data;
1222
   Elm_Object_Item *list_it;
1223

1224
   win = data;
1225

1226
   fclasses = evas_object_data_get(win, "font_classes_list");
1227
   list_it = elm_list_selected_item_get(fclasses);
1228
   if (!list_it) return;
1229
   tc_data = elm_object_item_data_get(list_it);
1230
   if (!tc_data) return;
1231

1232
   fnames = evas_object_data_get(win, "font_names_list");
1233
   fstyles = evas_object_data_get(win, "font_styles_list");
1234
   fsizes = evas_object_data_get(win, "font_sizes_list");
1235

1236
   elm_config_font_overlay_unset(tc_data->name);
1237

1238
   eina_stringshare_replace(&fndata.cur_font, NULL);
1239
   eina_stringshare_replace(&tc_data->font, NULL);
1240
   eina_stringshare_replace(&fndata.cur_style, NULL);
1241
   eina_stringshare_replace(&tc_data->style, NULL);
1242
   fndata.cur_size = 0.0;
1243
   tc_data->size = 0.0;
1244

1245
   ELM_LIST_DISABLE(fnames);
1246
   ELM_LIST_DISABLE(fstyles);
1247
   ELM_LIST_DISABLE(fsizes);
1248

1249
   elm_config_all_flush();
1250
}
1251

1252
static void
1253
_font_overlay_reset_all(void            *data,
1254
                        Evas_Object *obj EINA_UNUSED,
1255
                        void *event_info EINA_UNUSED)
1256
{
1257
   Evas_Object *win, *fclasses, *fnames, *fstyles, *fsizes;
1258
   Elm_Text_Class_Data *tc_data;
1259
   Elm_Object_Item *list_it;
1260
   Eina_List *l;
1261

1262
   win = data;
1263
   eina_stringshare_replace(&fndata.cur_font, NULL);
1264
   eina_stringshare_replace(&fndata.cur_style, NULL);
1265
   fndata.cur_size = 0.0;
1266

1267
   EINA_LIST_FOREACH(fndata.text_classes, l, tc_data)
1268
     {
1269
        elm_config_font_overlay_unset(tc_data->name);
1270

1271
        eina_stringshare_replace(&tc_data->font, NULL);
1272
        eina_stringshare_replace(&tc_data->style, NULL);
1273
        tc_data->size = 0.0;
1274
     }
1275

1276
   fclasses = evas_object_data_get(win, "font_classes_list");
1277
   fnames = evas_object_data_get(win, "font_names_list");
1278
   fstyles = evas_object_data_get(win, "font_styles_list");
1279
   fsizes = evas_object_data_get(win, "font_sizes_list");
1280

1281
   list_it = elm_list_selected_item_get(fclasses);
1282
   if (list_it) elm_list_item_selected_set(list_it, EINA_FALSE);
1283

1284
   ELM_LIST_DISABLE(fnames);
1285
   ELM_LIST_DISABLE(fstyles);
1286
   ELM_LIST_DISABLE(fsizes);
1287

1288
   elm_config_all_flush();
1289
}
1290

1291
static void
1292
_font_overlay_change(void *data       EINA_UNUSED,
1293
                     Evas_Object *obj EINA_UNUSED,
1294
                     void *event_info EINA_UNUSED)
1295
{
1296
   Elm_Text_Class_Data *tc_data;
1297
   Eina_List *l;
1298

1299
   EINA_LIST_FOREACH(fndata.text_classes, l, tc_data)
1300
     {
1301
        if (tc_data->font)
1302
          {
1303
             char *name;
1304

1305
             name = elm_font_fontconfig_name_get(tc_data->font,
1306
                                                 tc_data->style);
1307
             elm_config_font_overlay_set(tc_data->name, name,
1308
                                         tc_data->size ? tc_data->size : -100);
1309
             elm_font_fontconfig_name_free(name);
1310
          }
1311
        else
1312
          elm_config_font_overlay_unset(tc_data->name);
1313
     }
1314

1315
   elm_config_font_overlay_apply();
1316
   elm_config_all_flush();
1317

1318
   /* TODO: apply hinting */
1319
}
1320

1321
static void
1322
_config_display_update(Evas_Object *win)
1323
{
1324
   int flush_interval, font_c, image_c, edje_file_c, edje_col_c, ts_threshould,
1325
       ts_hold_threshold;
1326
   double scale, s_bounce_friction, ts_momentum_threshold,
1327
          ts_flick_distance_tolerance, ts_friction,
1328
          ts_min_friction, ts_friction_standard, ts_border_friction,
1329
          ts_sensitivity_friction, ts_acceleration_threshold,
1330
          ts_acceleration_time_limit, ts_acceleration_weight, page_friction,
1331
          bring_in_friction, zoom_friction, transition_duration,
1332
          smooth_amount, smooth_time_window, tooltip_delay;
1333
   const char *curr_theme;
1334
   Eina_Bool s_bounce, ts, smooth_start;
1335
   Elm_Theme *th;
1336
   int fs;
1337

1338
   scale = elm_config_scale_get();
1339
   fs = elm_config_finger_size_get();
1340
   flush_interval = elm_config_cache_flush_interval_get();
1341
   font_c = elm_config_cache_font_cache_size_get();
1342
   image_c = elm_config_cache_image_cache_size_get();
1343
   transition_duration = elm_config_transition_duration_factor_get();
1344
   tooltip_delay = elm_config_tooltip_delay_get();
1345
   edje_file_c = elm_config_cache_edje_file_cache_size_get();
1346
   edje_col_c = elm_config_cache_edje_collection_cache_size_get();
1347

1348
   s_bounce = elm_config_scroll_bounce_enabled_get();
1349
   s_bounce_friction = elm_config_scroll_bounce_friction_get();
1350
   ts = elm_config_scroll_thumbscroll_enabled_get();
1351
   ts_threshould = elm_config_scroll_thumbscroll_threshold_get();
1352
   ts_hold_threshold = elm_config_scroll_thumbscroll_hold_threshold_get();
1353
   ts_momentum_threshold = elm_config_scroll_thumbscroll_momentum_threshold_get();
1354
   ts_flick_distance_tolerance = elm_config_scroll_thumbscroll_flick_distance_tolerance_get();
1355
   ts_friction = elm_config_scroll_thumbscroll_friction_get();
1356
   ts_min_friction = elm_config_scroll_thumbscroll_min_friction_get();
1357
   ts_friction_standard = elm_config_scroll_thumbscroll_friction_standard_get();
1358
   ts_border_friction = elm_config_scroll_thumbscroll_border_friction_get();
1359
   ts_sensitivity_friction = elm_config_scroll_thumbscroll_sensitivity_friction_get();
1360
   ts_acceleration_threshold = elm_config_scroll_thumbscroll_acceleration_threshold_get();
1361
   ts_acceleration_time_limit = elm_config_scroll_thumbscroll_acceleration_time_limit_get();
1362
   ts_acceleration_weight = elm_config_scroll_thumbscroll_acceleration_weight_get();
1363
   page_friction = elm_config_scroll_page_scroll_friction_get();
1364
   bring_in_friction = elm_config_scroll_bring_in_scroll_friction_get();
1365
   zoom_friction = elm_config_scroll_zoom_friction_get();
1366
   smooth_start = elm_config_scroll_thumbscroll_smooth_start_get();
1367
   smooth_amount = elm_config_scroll_thumbscroll_smooth_amount_get();
1368
   smooth_time_window = elm_config_scroll_thumbscroll_smooth_time_window_get();
1369

1370
   /* gotta update root windows' atoms */
1371
   elm_slider_value_set(evas_object_data_get(win, "scale_slider"), scale);
1372
   elm_slider_value_set(evas_object_data_get(win, "fs_slider"), fs);
1373

1374
   elm_slider_value_set(evas_object_data_get(win,
1375
                                             "cache_flush_interval_slider"),
1376
                        flush_interval);
1377
   elm_slider_value_set(evas_object_data_get(win, "font_cache_slider"),
1378
                        font_c / 1024.0);
1379
   elm_slider_value_set(evas_object_data_get(win, "image_cache_slider"),
1380
                        image_c / 1024.0);
1381
   elm_slider_value_set(evas_object_data_get(win, "edje_file_cache_slider"),
1382
                        edje_file_c);
1383
   elm_slider_value_set(evas_object_data_get(win,
1384
                                             "edje_collection_cache_slider"),
1385
                        edje_col_c);
1386

1387
   elm_check_state_set(evas_object_data_get(win, "scroll_bounce_check"),
1388
                       s_bounce);
1389
   elm_slider_value_set(evas_object_data_get(win, "bounce_friction_slider"),
1390
                        s_bounce_friction);
1391
   elm_check_state_set(evas_object_data_get(win, "thumbscroll_check"), ts);
1392
   elm_slider_value_set(evas_object_data_get(win,
1393
                                             "ts_threshold_slider"),
1394
                        ts_threshould);
1395
   elm_slider_value_set(evas_object_data_get(win,
1396
                                             "ts_hold_threshold_slider"),
1397
                        ts_hold_threshold);
1398
   elm_slider_value_set(evas_object_data_get(win,
1399
                                             "ts_momentum_threshold_slider"),
1400
                        ts_momentum_threshold);
1401
   elm_slider_value_set(evas_object_data_get(win,
1402
                                             "ts_flick_distance_tolerance_slider"),
1403
                        ts_flick_distance_tolerance);
1404
   elm_slider_value_set(evas_object_data_get(win,
1405
                                             "ts_friction_slider"),
1406
                        ts_friction);
1407
   elm_slider_value_set(evas_object_data_get(win,
1408
                                             "ts_min_friction_slider"),
1409
                        ts_min_friction);
1410
   elm_slider_value_set(evas_object_data_get(win,
1411
                                             "ts_friction_standard_slider"),
1412
                        ts_friction_standard);
1413
   elm_slider_value_set(evas_object_data_get(win, "ts_border_friction_slider"),
1414
                        ts_border_friction);
1415
   elm_slider_value_set(evas_object_data_get(win, "ts_sensitivity_friction_slider"),
1416
                        ts_sensitivity_friction);
1417
   elm_slider_value_set(evas_object_data_get(win, "ts_acceleration_threshold_slider"),
1418
                        ts_acceleration_threshold);
1419
   elm_slider_value_set(evas_object_data_get(win, "ts_acceleration_time_limit_slider"),
1420
                        ts_acceleration_time_limit);
1421
   elm_slider_value_set(evas_object_data_get(win, "ts_acceleration_weight_slider"),
1422
                        ts_acceleration_weight);
1423
   elm_slider_value_set(evas_object_data_get(win,
1424
                                             "page_scroll_friction_slider"),
1425
                        page_friction);
1426
   elm_slider_value_set(evas_object_data_get(win,
1427
                                             "bring_in_scroll_friction_slider"),
1428
                        bring_in_friction);
1429
   elm_slider_value_set(evas_object_data_get(win,
1430
                                             "zoom_scroll_friction_slider"),
1431
                        zoom_friction);
1432

1433
   elm_check_state_set(evas_object_data_get(win, "scroll_smooth_start"),
1434
                       smooth_start);
1435
   elm_slider_value_set(evas_object_data_get(win,
1436
                                             "scroll_smooth_amount"),
1437
                        smooth_amount);
1438
   elm_slider_value_set(evas_object_data_get(win,
1439
                                             "scroll_smooth_time_window"),
1440
                        smooth_time_window);
1441

1442
   curr_theme = _elm_theme_current_get(elm_theme_get(NULL));
1443

1444
   th = elm_theme_new();
1445
   elm_theme_set(th, curr_theme);
1446
   elm_object_theme_set(evas_object_data_get(win, "theme_preview"), th);
1447
   elm_theme_free(th);
1448
   elm_config_transition_duration_factor_set(transition_duration);
1449
   elm_config_tooltip_delay_set(tooltip_delay);
1450
   eina_stringshare_del(curr_theme);
1451
}
1452

1453
static Eina_Bool
1454
_config_all_changed(void *data,
1455
                    int ev_type EINA_UNUSED,
1456
                    void *ev EINA_UNUSED)
1457
{
1458
   Evas_Object *win = data;
1459
   _config_display_update(win);
1460
   return ECORE_CALLBACK_PASS_ON;
1461
}
1462

1463
static void
1464
_profile_use(void            *data,
1465
             Evas_Object *obj EINA_UNUSED,
1466
             void *event_info EINA_UNUSED)
1467
{
1468
   Evas_Object *li;
1469
   const char *selection;
1470
   const char *profile;
1471

1472
   li = data;
1473
   selection = elm_object_item_data_get(elm_list_selected_item_get(li));
1474
   if (!selection) return;
1475
   profile = elm_config_profile_get();
1476

1477
   if (!profile)
1478
     {
1479
        fprintf(stderr, "No profile currently set!\n"); /* FIXME: log domain */
1480
        return;
1481
     }
1482

1483
   if (!strcmp(profile, selection))
1484
     return;
1485

1486
   elm_config_profile_set(selection); /* just here to update info for getters below */
1487

1488
   _config_display_update(elm_object_top_widget_get(li));
1489
   elm_config_all_flush();
1490
}
1491

1492
static void
1493
_btn_todo(void *data       EINA_UNUSED,
1494
          Evas_Object *obj EINA_UNUSED,
1495
          void *event_info EINA_UNUSED)
1496
{
1497
   printf("To be done!\n");
1498
}
1499

1500
static void
1501
_profile_reset(void            *data,
1502
               Evas_Object *obj EINA_UNUSED,
1503
               void *event_info EINA_UNUSED)
1504
{
1505
   const char *selection;
1506
   const char *pdir;
1507
   Evas_Object *li;
1508

1509
   li = data;
1510
   selection = elm_object_item_data_get(elm_list_selected_item_get(li));
1511
   if (!selection) return;
1512

1513
   elm_config_all_flush();
1514

1515
   pdir = elm_config_profile_dir_get(selection, EINA_TRUE);
1516
   if (!pdir)
1517
     return;
1518

1519
   ecore_file_recursive_rm(pdir);
1520
   elm_config_profile_dir_free(pdir);
1521

1522
   elm_config_reload();
1523

1524
   elm_config_all_flush();
1525
   _config_display_update(elm_object_top_widget_get(li));
1526
}
1527

1528
static void
1529
_theme_use(void *data       EINA_UNUSED,
1530
           Evas_Object *obj EINA_UNUSED,
1531
           void *event_info EINA_UNUSED)
1532
{
1533
   const char *defth;
1534
   Elm_Theme *th;
1535
   Evas_Object *win = elm_object_top_widget_get(obj);
1536
   Evas_Object *sample = evas_object_data_get(win, "theme_preview");
1537

1538
   th = elm_object_theme_get(sample);
1539
   defth = elm_theme_get(th);
1540
   elm_theme_set(NULL, defth);
1541
   elm_config_all_flush();
1542
}
1543

1544
static void
1545
_theme_sel(void            *data EINA_UNUSED,
1546
           Evas_Object     *obj,
1547
           void *event_info EINA_UNUSED)
1548
{
1549
   Evas_Object *win = elm_object_top_widget_get(obj);
1550
   Evas_Object *sample = evas_object_data_get(win, "theme_preview");
1551
   Elm_Theme *th;
1552
   Elm_Object_Item *list_it;
1553
   Eina_Strbuf *newth;
1554
   Eina_List *l;
1555

1556
   if (!sample) return;
1557
   tsel = elm_list_selected_items_get(obj);
1558
   newth = eina_strbuf_new();
1559
   EINA_SAFETY_ON_NULL_RETURN(newth);
1560
   th = elm_theme_new();
1561
   if (!th)
1562
     {
1563
        eina_strbuf_free(newth);
1564
        return;
1565
     }
1566
   EINA_LIST_REVERSE_FOREACH((Eina_List*)tsel, l, list_it)
1567
     {
1568
        Theme *t = elm_object_item_data_get(list_it);
1569
        if (!t) continue;
1570

1571
        eina_strbuf_append_printf(newth, "%s:", t->name);
1572
        if ((!l->prev) && strcmp(t->name, "default"))
1573
          /* ensure default theme is always there for fallback */
1574
          eina_strbuf_append(newth, "default");
1575
     }
1576
   elm_theme_set(th, eina_strbuf_string_get(newth));
1577
   eina_strbuf_free(newth);
1578
   elm_object_theme_set(sample, th);
1579
   elm_theme_free(th);
1580
}
1581

1582
/*static void
1583
   _theme_browse(void *data, Evas_Object *obj, void *event_info)
1584
   {
1585
   printf("not implemented\n");
1586
   }*/
1587

1588
static void
1589
_icon_preview_icon_add(const char *icon, const char *theme)
1590
{
1591
   Evas_Object *ic;
1592

1593
   if (!icon_preview_frame)
1594
   return;
1595

1596
   ic = elm_icon_add(icon_preview_frame);
1597
   elm_image_aspect_fixed_set(ic, EINA_TRUE);
1598
   evas_object_size_hint_min_set(ic, 48, 48);
1599
   elm_box_pack_end(icon_preview_frame, ic);
1600
   evas_object_show(ic);
1601

1602
   if (!strcmp(theme, ELM_CONFIG_ICON_THEME_ELEMENTARY))
1603
     elm_icon_standard_set(ic, icon);
1604
   else
1605
     elm_image_file_set(ic, efreet_icon_path_find(theme, icon, 48), NULL);
1606
}
1607

1608

1609
static void
1610
_icon_preview_update(Evas_Object *win)
1611
{
1612
   const char **example_icon, *example_icons[] =
1613
   {
1614
      "folder",
1615
      "video-display",
1616
      "mail-unread",
1617
      "start-here",
1618
      "preferences-system",
1619
      NULL,
1620
   };
1621
   const char *theme = evas_object_data_get(win, "icon_theme");
1622

1623
   elm_box_clear(icon_preview_frame);
1624
   for (example_icon = example_icons; !!*example_icon; example_icon++)
1625
     _icon_preview_icon_add(*example_icon, theme);
1626
}
1627

1628
static void
1629
_icon_elm_change(void *data       EINA_UNUSED,
1630
          Evas_Object     *obj,
1631
          void *event_info EINA_UNUSED)
1632
{
1633
   Evas_Object *win = elm_object_top_widget_get(obj);
1634
   Eina_Bool val = elm_check_state_get(obj);
1635
   Elm_Object_Item *item;
1636

1637
   if (val)
1638
     {
1639
        evas_object_data_set(win, "icon_theme", ELM_CONFIG_ICON_THEME_ELEMENTARY);
1640

1641
        item = elm_list_selected_item_get(icon_theme_list);
1642
        if (item)
1643
          elm_list_item_selected_set(item, EINA_FALSE);
1644
     }
1645
   else
1646
     {
1647
        evas_object_data_set(win, "icon_theme", "hicolor");
1648

1649
        item = elm_list_first_item_get(icon_theme_list);
1650
        if (item)
1651
          elm_list_item_selected_set(item, EINA_TRUE);
1652
     }
1653

1654
   _icon_preview_update(win);
1655
}
1656

1657
static void
1658
_icon_theme_use(void *data  EINA_UNUSED,
1659
           Evas_Object *obj EINA_UNUSED,
1660
           void *event_info EINA_UNUSED)
1661
{
1662
   Evas_Object *win = elm_object_top_widget_get(obj);
1663
   const char *theme = evas_object_data_get(win, "icon_theme");
1664

1665
   elm_config_icon_theme_set(theme);
1666
   elm_config_all_flush();
1667
}
1668

1669
static void
1670
_icon_theme_sel(void *data, Evas_Object *obj,
1671
           void *event_info EINA_UNUSED)
1672
{
1673
   const char *theme = (const char *)data;
1674
   Evas_Object *win = elm_object_top_widget_get(obj);
1675

1676
   elm_check_state_set(icon_theme_elm, EINA_FALSE);
1677
   evas_object_data_set(win, "icon_theme", theme);
1678

1679
   _icon_preview_update(win);
1680
}
1681

1682
static Eina_Bool
1683
_icon_theme_valid(const char *theme)
1684
{
1685
   const char *icon_path;
1686

1687
   icon_path = efreet_icon_path_find(theme, "folder", 48);
1688
   return !!icon_path;
1689
}
1690

1691
static int
1692
_icon_theme_list_sort(const void *data1, const void *data2)
1693
{
1694
   const Efreet_Icon_Theme *t1, *t2;
1695

1696
   t1 = data1;
1697
   t2 = data2;
1698

1699
   if (!t1->name.name) return 1;
1700
   if (!t2->name.name) return -1;
1701

1702
   return strcmp(t1->name.name, t2->name.name);
1703
}
1704

1705
static void
1706
_status_config_sizing(Evas_Object *win,
1707
                      Evas_Object *naviframe)
1708
{
1709
   Evas_Object *lb, *pd, *bx, *sl, *sp;
1710

1711
   bx = elm_box_add(win);
1712
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
1713
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
1714

1715
   LABEL_FRAME_ADD("<hilight>Scale</>");
1716

1717
   sl = elm_slider_add(win);
1718
   evas_object_data_set(win, "scale_slider", sl);
1719
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1720
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1721
   elm_slider_span_size_set(sl, 120);
1722
   elm_slider_unit_format_set(sl, "%1.2f");
1723
   elm_slider_indicator_format_set(sl, "%1.2f");
1724
   elm_slider_min_max_set(sl, 0.25, 5.0);
1725
   elm_slider_value_set(sl, elm_config_scale_get());
1726
   elm_box_pack_end(bx, sl);
1727
   evas_object_show(sl);
1728

1729
   evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
1730
   evas_object_smart_callback_add(sl, "delay,changed", sc_change, NULL);
1731

1732
   sp = elm_separator_add(win);
1733
   elm_separator_horizontal_set(sp, EINA_TRUE);
1734
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
1735
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
1736
   elm_box_pack_end(bx, sp);
1737
   evas_object_show(sp);
1738

1739
   LABEL_FRAME_ADD("<hilight>Finger Size</><br/>");
1740

1741
   sl = elm_slider_add(win);
1742
   evas_object_data_set(win, "fs_slider", sl);
1743
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
1744
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
1745
   elm_slider_span_size_set(sl, 120);
1746
   elm_slider_unit_format_set(sl, "%1.0f");
1747
   elm_slider_indicator_format_set(sl, "%1.0f");
1748
   elm_slider_min_max_set(sl, 5, 200);
1749
   elm_slider_value_set(sl, elm_config_finger_size_get());
1750
   elm_box_pack_end(bx, sl);
1751
   evas_object_show(sl);
1752

1753
   evas_object_smart_callback_add(sl, "changed", fs_round, NULL);
1754
   evas_object_smart_callback_add(sl, "delay,changed", fs_change, NULL);
1755

1756
   evas_object_data_set(win, "sizing", bx);
1757

1758
   elm_naviframe_item_simple_push(naviframe, bx);
1759
}
1760

1761
#define MUTE_CB(_cb, _chan) \
1762
static void \
1763
_cb(void *data       EINA_UNUSED, \
1764
    Evas_Object     *obj, \
1765
    void *event_info EINA_UNUSED) \
1766
{ \
1767
   Eina_Bool val = elm_check_state_get(obj); \
1768
   Eina_Bool v = elm_config_audio_mute_get(_chan); \
1769
   if (val == v) return; \
1770
   elm_config_audio_mute_set(_chan, val); \
1771
   elm_config_all_flush(); \
1772
}
1773

1774
MUTE_CB(mute_effect_change, EDJE_CHANNEL_EFFECT)
1775
MUTE_CB(mute_background_change, EDJE_CHANNEL_BACKGROUND)
1776
MUTE_CB(mute_music_change, EDJE_CHANNEL_MUSIC)
1777
MUTE_CB(mute_foreground_change, EDJE_CHANNEL_FOREGROUND)
1778
MUTE_CB(mute_interface_change, EDJE_CHANNEL_INTERFACE)
1779
MUTE_CB(mute_input_change, EDJE_CHANNEL_INPUT)
1780
MUTE_CB(mute_alert_change, EDJE_CHANNEL_ALERT)
1781
MUTE_CB(mute_all_change, EDJE_CHANNEL_ALL)
1782

1783
static void
1784
_status_config_audio(Evas_Object *win,
1785
                     Evas_Object *naviframe)
1786
{
1787
   Evas_Object *bx, *ck;
1788

1789
   bx = elm_box_add(win);
1790
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
1791
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
1792

1793
#define MUTE_CHECK(_label, _chan, _cb)  \
1794
   CHECK_ADD(_label, _label, _cb, NULL) \
1795
   elm_check_state_set(ck, elm_config_audio_mute_get(_chan));
1796

1797
   MUTE_CHECK("Mute Effects", EDJE_CHANNEL_EFFECT, mute_effect_change);
1798
   MUTE_CHECK("Mute Background", EDJE_CHANNEL_BACKGROUND, mute_background_change);
1799
   MUTE_CHECK("Mute Music", EDJE_CHANNEL_MUSIC, mute_music_change);
1800
   MUTE_CHECK("Mute Foreground", EDJE_CHANNEL_FOREGROUND, mute_foreground_change);
1801
   MUTE_CHECK("Mute Interface", EDJE_CHANNEL_INTERFACE, mute_interface_change);
1802
   MUTE_CHECK("Mute Input", EDJE_CHANNEL_INPUT, mute_input_change);
1803
   MUTE_CHECK("Mute Alert", EDJE_CHANNEL_ALERT, mute_alert_change);
1804
   MUTE_CHECK("Mute Everything", EDJE_CHANNEL_ALL, mute_all_change);
1805

1806
   evas_object_data_set(win, "audio", bx);
1807

1808
   elm_naviframe_item_simple_push(naviframe, bx);
1809
}
1810

1811
static void
1812
_config_focus_highlight_enabled_cb(void *data EINA_UNUSED, Evas_Object *obj,
1813
                                   void *event_info EINA_UNUSED)
1814
{
1815
   Eina_Bool cf = elm_config_focus_highlight_enabled_get();
1816
   Eina_Bool val = elm_check_state_get(obj);
1817

1818
   printf("%d %d\n", cf, val);
1819
   if (cf == val) return;
1820
   elm_config_focus_highlight_enabled_set(val);
1821
   elm_config_all_flush();
1822
}
1823

1824
static void
1825
_config_focus_highlight_anim_cb(void *data EINA_UNUSED, Evas_Object *obj,
1826
                                void *event_info EINA_UNUSED)
1827
{
1828
   Eina_Bool cf = elm_config_focus_highlight_animate_get();
1829
   Eina_Bool val = elm_check_state_get(obj);
1830

1831
   if (cf == val) return;
1832
   elm_config_focus_highlight_animate_set(val);
1833
   elm_config_all_flush();
1834
}
1835

1836
static void
1837
_config_focus_highlight_clip_cb(void *data EINA_UNUSED, Evas_Object *obj,
1838
                                void *event_info EINA_UNUSED)
1839
{
1840
   Eina_Bool cf = elm_config_focus_highlight_clip_disabled_get();
1841
   Eina_Bool val = elm_check_state_get(obj);
1842

1843
   if (cf == val) return;
1844
   elm_config_focus_highlight_clip_disabled_set(val);
1845
   elm_config_all_flush();
1846
}
1847

1848
static void
1849
_config_focus_item_select_on_focus_cb(void *data EINA_UNUSED, Evas_Object *obj,
1850
                                      void *event_info EINA_UNUSED)
1851
{
1852
   Eina_Bool cf = elm_config_item_select_on_focus_disabled_get();
1853
   Eina_Bool val = elm_check_state_get(obj);
1854

1855
   if (cf == val) return;
1856
   elm_config_item_select_on_focus_disabled_set(val);
1857
   elm_config_all_flush();
1858
}
1859

1860
static void
1861
_status_config_focus_autoscroll_changed_cb(void *data EINA_UNUSED,
1862
                                           Evas_Object *obj,
1863
                                           void *event_info EINA_UNUSED)
1864
{
1865
   elm_config_focus_autoscroll_mode_set(elm_radio_value_get(obj));
1866
}
1867

1868
static void
1869
_config_focus_auto_show_cb(void *data EINA_UNUSED, Evas_Object *obj,
1870
                           void *event_info EINA_UNUSED)
1871
{
1872
   Eina_Bool cf = elm_config_window_auto_focus_enable_get();
1873
   Eina_Bool val = elm_check_state_get(obj);
1874

1875
   if (cf == val) return;
1876
   elm_config_window_auto_focus_enable_set(val);
1877
   elm_config_all_flush();
1878
}
1879

1880
static void
1881
_config_focus_auto_animate_cb(void *data EINA_UNUSED, Evas_Object *obj,
1882
                           void *event_info EINA_UNUSED)
1883
{
1884
   Eina_Bool cf = elm_config_window_auto_focus_animate_get();
1885
   Eina_Bool val = elm_check_state_get(obj);
1886

1887
   if (cf == val) return;
1888
   elm_config_window_auto_focus_animate_set(val);
1889
   elm_config_all_flush();
1890
}
1891

1892
static void
1893
_status_config_focus(Evas_Object *win,
1894
                     Evas_Object *naviframe)
1895
{
1896
   Evas_Object *bx, *ck, *fr;
1897

1898
   bx = elm_box_add(win);
1899

1900
   CHECK_ADD("Enable Focus Highlight (only new window)",
1901
             "Set whether enable/disable focus highlight.<br/>"
1902
             "This feature is disabled by default.",
1903
             _config_focus_highlight_enabled_cb, NULL);
1904
   elm_check_state_set(ck, elm_config_focus_highlight_enabled_get());
1905

1906
   CHECK_ADD("Enable Focus Highlight Animation (only new window)",
1907
             "Set whether enable/disable focus highlight animation.<br/>"
1908
             "This feature is disabled by default",
1909
             _config_focus_highlight_anim_cb, NULL);
1910
   elm_check_state_set(ck, elm_config_focus_highlight_animate_get());
1911

1912
   CHECK_ADD("Disable Focus Highlight clip",
1913
             "Set whether enable/disable focus highlight clip feature.<br/>"
1914
             "If the focus highlight clip is disabled,<br/>"
1915
             "focus highlight object would not be clipped"
1916
             "by the target object's parent",
1917
             _config_focus_highlight_clip_cb, NULL);
1918
   elm_check_state_set(ck, elm_config_focus_highlight_clip_disabled_get());
1919

1920
   CHECK_ADD("Disable Item Select on Focus",
1921
             "Set whether item would be selected on item focus.<br/>"
1922
             "This is enabled by default.",
1923
             _config_focus_item_select_on_focus_cb, NULL);
1924
   elm_check_state_set(ck, elm_config_item_select_on_focus_disabled_get());
1925

1926
   CHECK_ADD("Enable Automatic focus display",
1927
             "Set whether enable/disable focus highlight automatically.",
1928
             _config_focus_auto_show_cb, NULL);
1929
   elm_check_state_set(ck, elm_config_window_auto_focus_enable_get());
1930
   CHECK_ADD("Enable Automatic focus animation",
1931
             "Set whether enable/disable focus highlight animation<br/>"
1932
             "automatically when automatic focus shows.",
1933
             _config_focus_auto_animate_cb, NULL);
1934
   elm_check_state_set(ck, elm_config_window_auto_focus_enable_get());
1935

1936
   fr = elm_frame_add(bx);
1937
   elm_object_text_set(fr, "Focus Autoscroll Mode");
1938
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
1939
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, 0.5);
1940
   elm_box_pack_end(bx, fr);
1941
   evas_object_show(fr);
1942
     {
1943
        Evas_Object *bx2, *rdg, *rd;
1944
        bx2 = elm_box_add(fr);
1945
        elm_object_content_set(fr, bx2);
1946
        evas_object_show(bx2);
1947

1948
        rdg = rd = elm_radio_add(bx2);
1949
        elm_radio_state_value_set(rd, ELM_FOCUS_AUTOSCROLL_MODE_SHOW);
1950
        elm_object_text_set(rd, "ELM_FOCUS_AUTOSCROLL_MODE_SHOW");
1951
        elm_object_tooltip_text_set(rd, "Directly show the focused region<br/>"
1952
                                    "or item automatically inside a scroller.");
1953
        evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
1954
        evas_object_size_hint_align_set(rd, 0.0, EVAS_HINT_FILL);
1955
        elm_box_pack_end(bx2, rd);
1956
        evas_object_show(rd);
1957
        evas_object_smart_callback_add(rd, "changed",
1958
                                       _status_config_focus_autoscroll_changed_cb,
1959
                                       NULL);
1960

1961
        rd = elm_radio_add(bx2);
1962
        elm_radio_state_value_set(rd, ELM_FOCUS_AUTOSCROLL_MODE_NONE);
1963
        elm_object_text_set(rd, "ELM_FOCUS_AUTOSCROLL_MODE_NONE");
1964
        elm_object_tooltip_text_set(rd, "Do not show the focused region or<br/>"
1965
                                    "item automatically inside a scroller.");
1966
        evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
1967
        evas_object_size_hint_align_set(rd, 0.0, EVAS_HINT_FILL);
1968
        elm_box_pack_end(bx2, rd);
1969
        elm_radio_group_add(rd, rdg);
1970
        evas_object_show(rd);
1971
        evas_object_smart_callback_add(rd, "changed",
1972
                                       _status_config_focus_autoscroll_changed_cb,
1973
                                       NULL);
1974

1975

1976
        rd = elm_radio_add(bx2);
1977
        elm_radio_state_value_set(rd, ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN);
1978
        elm_object_text_set(rd, "ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN");
1979
        elm_object_tooltip_text_set(rd, "Bring in the focused region or item<br/>"
1980
                                    "automatically which might invole the scrolling.");
1981
        evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
1982
        evas_object_size_hint_align_set(rd, 0.0, EVAS_HINT_FILL);
1983
        elm_box_pack_end(bx2, rd);
1984
        elm_radio_group_add(rd, rdg);
1985
        evas_object_show(rd);
1986
        evas_object_smart_callback_add(rd, "changed",
1987
                                       _status_config_focus_autoscroll_changed_cb,
1988
                                       NULL);
1989

1990
        elm_radio_value_set(rdg, elm_config_focus_autoscroll_mode_get());
1991
     }
1992

1993
   evas_object_data_set(win, "focus", bx);
1994

1995
   elm_naviframe_item_simple_push(naviframe, bx);
1996
}
1997

1998
static void
1999
_web_entry_del(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *info EINA_UNUSED)
2000
{
2001
   if (interactive)
2002
     {
2003
        const char *web_backend_set = elm_config_web_backend_get();
2004

2005
        web_backend = elm_object_text_get(obj);
2006
        if ((web_backend_set != web_backend) ||
2007
            (web_backend && web_backend_set &&
2008
             (!!strcmp(web_backend, web_backend_set))))
2009
          {
2010
             elm_config_web_backend_set(web_backend);
2011
             fprintf(stderr, "web backend set to : [%s]\n", elm_config_web_backend_get());
2012
             elm_config_all_flush();
2013
          }
2014
     }
2015
}
2016

2017
static void
2018
_status_config_etc(Evas_Object *win,
2019
                   Evas_Object *naviframe)
2020
{
2021
   Evas_Object *bx, *ck, *sl, *fr, *bx2, *fr2, *bx3, *en;
2022

2023
   bx = elm_box_add(win);
2024
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
2025
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
2026

2027
   // desktop_entry
2028
   CHECK_ADD("Desktop style entries", "Set entries to do things like on a normal desktop (non-touch) system", desk_entry_change, NULL);
2029
   elm_check_state_set(ck, elm_config_desktop_entry_get());
2030

2031
   // desktop_entry
2032
   CHECK_ADD("Entry Magnifiers", "Set popup magnifiers on start/end selection handles in entries", mag_change, NULL);
2033
   elm_check_state_set(ck, elm_config_magnifier_enable_get());
2034

2035
   // access
2036
   CHECK_ADD("Enable Access Mode", "Set access mode", ac_change, NULL);
2037
   elm_check_state_set(ck, elm_config_access_get());
2038

2039
   // selection
2040
   CHECK_ADD("Enable clear selection when unfocus", "Set selection mode",
2041
             sel_change, NULL);
2042
   elm_check_state_set(ck, elm_config_selection_unfocused_clear_get());
2043

2044
   // clouseau
2045
   CHECK_ADD("Enable clouseau", "Set clouseau mode", dbg_change, NULL);
2046
   elm_check_state_set(ck, elm_config_clouseau_enabled_get());
2047

2048
   // atspi
2049
   CHECK_ADD("Enable ATSPI support", "Set atspi mode", atspi_change, NULL);
2050
   elm_check_state_set(ck, elm_config_atspi_mode_get());
2051

2052
   // tooltip delay
2053
   fr = elm_frame_add(bx);
2054
   elm_object_text_set(fr, "Tooltip delay");
2055
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
2056
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, 0.5);
2057
   elm_box_pack_end(bx, fr);
2058
   evas_object_show(fr);
2059

2060
   bx2 = elm_box_add(fr);
2061
   elm_object_content_set(fr, bx2);
2062
   evas_object_show(bx2);
2063

2064
   sl = elm_slider_add(bx2);
2065
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2066
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2067
   elm_slider_span_size_set(sl, 120);
2068
   elm_slider_unit_format_set(sl, "%1.1f");
2069
   elm_slider_indicator_format_set(sl, "%1.1f");
2070
   elm_slider_min_max_set(sl, 0, 20.0);
2071
   elm_slider_value_set(sl, elm_config_tooltip_delay_get());
2072
   elm_box_pack_end(bx2, sl);
2073
   evas_object_show(sl);
2074
   evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
2075
   evas_object_smart_callback_add(sl, "delay,changed", tooltip_delay_change, NULL);
2076

2077

2078
   // transition duration in edje
2079
   fr = elm_frame_add(bx);
2080
   elm_object_text_set(fr, "Edje Transition Duration Factor");
2081
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
2082
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, 0.5);
2083
   elm_box_pack_end(bx, fr);
2084
   evas_object_show(fr);
2085

2086
   bx2 = elm_box_add(fr);
2087
   elm_object_content_set(fr, bx2);
2088
   evas_object_show(bx2);
2089

2090
   sl = elm_slider_add(bx2);
2091
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2092
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
2093
   elm_slider_span_size_set(sl, 120);
2094
   elm_slider_unit_format_set(sl, "%1.1f");
2095
   elm_slider_indicator_format_set(sl, "%1.1f");
2096
   elm_slider_min_max_set(sl, 0, 20.0);
2097
   elm_slider_value_set(sl, elm_config_transition_duration_factor_get());
2098
   elm_box_pack_end(bx2, sl);
2099
   evas_object_show(sl);
2100
   evas_object_smart_callback_add(sl, "changed", sc_round, NULL);
2101
   evas_object_smart_callback_add(sl, "delay,changed", transition_duration_change, NULL);
2102

2103
   // Web backend
2104
   fr2 = elm_frame_add(bx);
2105
   elm_object_text_set(fr2, "Elm_Web backend");
2106
   evas_object_size_hint_weight_set(fr2, EVAS_HINT_EXPAND, 0.0);
2107
   evas_object_size_hint_align_set(fr2, EVAS_HINT_FILL, 0.5);
2108
   elm_box_pack_end(bx, fr2);
2109
   evas_object_show(fr2);
2110

2111
   bx3 = elm_box_add(fr2);
2112
   elm_object_content_set(fr2, bx3);
2113
   evas_object_show(bx3);
2114

2115
   en = elm_entry_add(win);
2116
   elm_entry_editable_set(en, EINA_TRUE);
2117
   elm_entry_scrollable_set(en, EINA_FALSE);
2118
   elm_object_text_set(en, elm_config_web_backend_get());
2119
   evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2120
   evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
2121
   evas_object_show(en);
2122
   elm_box_pack_end(bx3, en);
2123
   evas_object_event_callback_add(en, EVAS_CALLBACK_DEL, _web_entry_del, NULL);
2124

2125
   web_backend_entry = en;
2126

2127
   evas_object_data_set(win, "etc", bx);
2128

2129
   elm_naviframe_item_simple_push(naviframe, bx);
2130
}
2131

2132
static Evas_Object *
2133
_sample_theme_new(Evas_Object *win)
2134
{
2135
   Evas_Object *base, *bg, *bt, *ck, *rd, *rdg, *sl, *fr, *li, *rc, *sp;
2136

2137
   base = elm_table_add(win);
2138
   evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2139
   evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
2140

2141
   bg = elm_bg_add(win);
2142
   evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2143
   evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
2144
   elm_table_pack(base, bg, 0, 0, 2, 5);
2145
   evas_object_show(bg);
2146

2147
   bt = elm_button_add(win);
2148
   evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
2149
   elm_object_text_set(bt, "Button");
2150
   elm_table_pack(base, bt, 0, 0, 1, 1);
2151
   evas_object_show(bt);
2152

2153
   ck = elm_check_add(win);
2154
   evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 0.0);
2155
   elm_object_text_set(ck, "Check");
2156
   elm_table_pack(base, ck, 0, 1, 1, 1);
2157
   evas_object_show(ck);
2158

2159
   rd = elm_radio_add(win);
2160
   evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
2161
   elm_radio_state_value_set(rd, 0);
2162
   elm_object_text_set(rd, "Radio 1");
2163
   elm_table_pack(base, rd, 1, 0, 1, 1);
2164
   evas_object_show(rd);
2165
   rdg = rd;
2166

2167
   rd = elm_radio_add(win);
2168
   evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, 0.0);
2169
   elm_radio_state_value_set(rd, 1);
2170
   elm_object_text_set(rd, "Radio 2");
2171
   elm_radio_group_add(rd, rdg);
2172
   elm_table_pack(base, rd, 1, 1, 1, 1);
2173
   evas_object_show(rd);
2174

2175
   sp = elm_separator_add(win);
2176
   elm_separator_horizontal_set(sp, EINA_TRUE);
2177
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2178
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2179
   elm_table_pack(base, sp, 0, 2, 2, 1);
2180
   evas_object_show(sp);
2181

2182
   sl = elm_slider_add(win);
2183
   elm_object_text_set(sl, "Slider");
2184
   elm_slider_span_size_set(sl, 120);
2185
   elm_slider_min_max_set(sl, 1, 10);
2186
   elm_slider_value_set(sl, 4);
2187
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
2188
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, EVAS_HINT_FILL);
2189
   elm_table_pack(base, sl, 0, 3, 2, 1);
2190
   evas_object_show(sl);
2191

2192
   fr = elm_frame_add(win);
2193
   elm_object_text_set(fr, "Frame");
2194
   elm_table_pack(base, fr, 0, 4, 2, 1);
2195
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2196
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2197
   evas_object_show(fr);
2198

2199
   li = elm_list_add(win);
2200
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2201
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2202
   elm_object_content_set(fr, li);
2203
   evas_object_show(li);
2204

2205
   elm_list_item_append(li, "List Item 1", NULL, NULL, NULL, NULL);
2206
   elm_list_item_append(li, "Second Item", NULL, NULL, NULL, NULL);
2207
   elm_list_item_append(li, "Third Item", NULL, NULL, NULL, NULL);
2208
   elm_list_go(li);
2209

2210
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
2211
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2212
   evas_object_size_hint_min_set(rc, 160, 120);
2213
   elm_table_pack(base, rc, 0, 4, 2, 1);
2214

2215
   return base;
2216
}
2217

2218
static void
2219
_status_config_themes(Evas_Object *win,
2220
                      Evas_Object *naviframe)
2221
{
2222
   Evas_Object *tb, *rc, *sc, *sp, *li, *pd, *fr, *bt, *sample;
2223
   Eina_List *list, *l;
2224
   char *th, *s, *ext;
2225
   Elm_Theme *d;
2226
   Elm_Object_Item *list_it, *def_it = NULL;
2227
   const char *theme_name, *sep[20];
2228
   unsigned int x;
2229

2230
   tb = elm_table_add(win);
2231
   evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2232
   evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
2233

2234
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
2235
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2236
   evas_object_size_hint_min_set(rc, 0, 130);
2237
   elm_table_pack(tb, rc, 0, 0, 1, 1);
2238

2239
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
2240
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2241
   evas_object_size_hint_min_set(rc, 0, 200);
2242
   elm_table_pack(tb, rc, 0, 1, 1, 1);
2243

2244
   /////////////////////////////////////////////
2245

2246
   pd = elm_frame_add(win);
2247
   elm_object_style_set(pd, "pad_medium");
2248
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2249
   evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
2250
   elm_table_pack(tb, pd, 0, 0, 1, 1);
2251
   evas_object_show(pd);
2252

2253
   li = elm_list_add(win);
2254
   elm_list_multi_select_set(li, EINA_TRUE);
2255
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2256
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2257
   elm_object_content_set(pd, li);
2258
   evas_object_show(li);
2259

2260
   list = elm_theme_name_available_list_new();
2261
   d = elm_theme_default_get();
2262
   theme_name = elm_theme_get(d);
2263
   for (x = 1, sep[0] = theme_name; x < sizeof(sep) / sizeof(sep[0]); x++)
2264
     {
2265
        sep[x] = strchr(sep[x - 1] + 1, ':');
2266
        if (!sep[x]) break;
2267
     }
2268
   EINA_LIST_FOREACH(list, l, th)
2269
     {
2270
        Theme *t;
2271
        int y;
2272

2273
        t = calloc(1, sizeof(Theme));
2274
        t->name = eina_stringshare_add(th);
2275
        s = elm_theme_list_item_path_get(th, &(t->in_search_path));
2276
        if (s)
2277
          {
2278
             t->path = eina_stringshare_add(s);
2279
             free(s);
2280
          }
2281
        if (t->in_search_path)
2282
          {
2283
             s = strdup(th);
2284
             if (s)
2285
               {
2286
                  s[0] = toupper(s[0]);
2287
                  t->label = eina_stringshare_add(s);
2288
                  free(s);
2289
               }
2290
             else
2291
               t->label = eina_stringshare_add(s);
2292
          }
2293
        else
2294
          {
2295
             s = strdup(ecore_file_file_get(th));
2296
             if (s)
2297
               {
2298
                  s[0] = toupper(s[0]);
2299
                  ext = strrchr(s, '.');
2300
                  if (ext) *ext = 0;
2301
                  t->label = eina_stringshare_add(s);
2302
                  free(s);
2303
               }
2304
             else
2305
               t->label = eina_stringshare_add(s);
2306
          }
2307
        themes = eina_list_append(themes, t);
2308
        list_it = elm_list_item_append(li, t->label, NULL, NULL, NULL, t);
2309
        if (!strcmp(t->name, "default")) def_it = list_it;
2310
        for (y = x - 1 /* ignore default e theme */; y > 0; y--)
2311
          {
2312
             const char *start = (sep[y - 1][0] == ':') ? sep[y - 1] + 1 : sep[y - 1];
2313
             unsigned int len = (unsigned int)(sep[y] - start);
2314
             if (strncmp(start , t->name, len) || (strlen(t->name) != len)) continue;
2315

2316
             if (!elm_list_item_selected_get(list_it))
2317
               elm_list_item_selected_set(list_it, EINA_TRUE);
2318
             break;
2319
          }
2320
     }
2321
   if (!elm_list_selected_items_get(li))
2322
     elm_list_item_selected_set(def_it, EINA_TRUE);
2323
   evas_object_smart_callback_add(li, "selected", _theme_sel, NULL);
2324
   evas_object_smart_callback_add(li, "unselected", _theme_sel, NULL);
2325
   elm_theme_name_available_list_free(list);
2326

2327
   elm_list_go(li);
2328

2329
   pd = elm_frame_add(win);
2330
   elm_object_style_set(pd, "pad_medium");
2331
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2332
   evas_object_size_hint_align_set(pd, 0.9, 0.9);
2333
   elm_table_pack(tb, pd, 0, 0, 1, 1);
2334
   evas_object_show(pd);
2335

2336
   /* FIXME: not implemented yet
2337
      bt = elm_button_add(win);
2338
      evas_object_smart_callback_add(bt, "clicked", _theme_browse, win);
2339
      elm_object_text_set(bt, "Browse...");
2340
      evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2341
      evas_object_size_hint_align_set(bt, 0.9, 0.9);
2342
      elm_object_content_set(pd, bt);
2343
      evas_object_show(bt);
2344
    */
2345
   pd = elm_frame_add(win);
2346
   elm_object_style_set(pd, "pad_medium");
2347
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
2348
   evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
2349
   elm_table_pack(tb, pd, 0, 1, 1, 1);
2350
   evas_object_show(pd);
2351

2352
   fr = elm_frame_add(win);
2353
   elm_object_text_set(fr, "Preview");
2354
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2355
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2356
   elm_object_content_set(pd, fr);
2357
   evas_object_show(fr);
2358

2359
   sc = elm_scroller_add(win);
2360
   elm_scroller_bounce_set(sc, EINA_FALSE, EINA_FALSE);
2361
   evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2362
   evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
2363
   elm_object_content_set(fr, sc);
2364
   evas_object_show(sc);
2365

2366
   sample = _sample_theme_new(win);
2367
   elm_object_content_set(sc, sample);
2368
   evas_object_show(sample);
2369
   evas_object_data_set(win, "theme_preview", sample);
2370

2371
   /////////////////////////////////////////////
2372
   sp = elm_separator_add(win);
2373
   elm_separator_horizontal_set(sp, EINA_TRUE);
2374
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2375
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2376
   elm_table_pack(tb, sp, 0, 2, 1, 1);
2377
   evas_object_show(sp);
2378

2379
   pd = elm_frame_add(win);
2380
   elm_object_style_set(pd, "pad_medium");
2381
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
2382
   evas_object_size_hint_align_set(pd, 0.5, 0.5);
2383
   elm_table_pack(tb, pd, 0, 3, 1, 1);
2384
   evas_object_show(pd);
2385

2386
   bt = elm_button_add(win);
2387
   evas_object_smart_callback_add(bt, "clicked", _theme_use, win);
2388
   elm_object_text_set(bt, "Use Theme");
2389
   evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
2390
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
2391
   elm_object_content_set(pd, bt);
2392
   evas_object_show(bt);
2393

2394
   evas_object_data_set(win, "themes", tb);
2395
   elm_naviframe_item_simple_push(naviframe, tb);
2396
}
2397

2398
static void
2399
_status_config_icons(Evas_Object *win,
2400
                      Evas_Object *naviframe)
2401
{
2402
   Evas_Object *tb, *rc, *sp, *ck, *li, *bx, *ic, *pd, *fr, *bt;
2403
   Eina_List *list, *l;
2404
   const Efreet_Icon_Theme *th;
2405
   Elm_Object_Item *list_it, *def_it = NULL;
2406

2407
   tb = elm_table_add(win);
2408
   evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2409
   evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
2410

2411
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
2412
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2413
   evas_object_size_hint_min_set(rc, 0, 130);
2414
   elm_table_pack(tb, rc, 0, 0, 1, 1);
2415

2416
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
2417
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2418
   evas_object_size_hint_min_set(rc, 0, 130);
2419
   elm_table_pack(tb, rc, 0, 1, 1, 1);
2420

2421
   /////////////////////////////////////////////
2422

2423
   pd = elm_frame_add(win);
2424
   elm_object_style_set(pd, "pad_medium");
2425
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2426
   evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
2427
   elm_table_pack(tb, pd, 0, 0, 1, 1);
2428
   evas_object_show(pd);
2429

2430
   bx = elm_box_add(pd);
2431
   elm_object_content_set(pd, bx);
2432
   evas_object_show(bx);
2433
   CHECK_ADD("Use Elementary icons", "Use icons from current elementary theme",
2434
             _icon_elm_change, NULL);
2435
   if (!strcmp(elm_config_icon_theme_get(), ELM_CONFIG_ICON_THEME_ELEMENTARY))
2436
     elm_check_state_set(ck, EINA_TRUE);
2437
   icon_theme_elm = ck;
2438

2439
   li = icon_theme_list = elm_list_add(win);
2440
   elm_list_multi_select_set(li, EINA_FALSE);
2441
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2442
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
2443
   elm_box_pack_end(bx, li);
2444
   evas_object_show(li);
2445

2446
   evas_object_data_set(win, "icon_theme", elm_config_icon_theme_get());
2447

2448
   list = efreet_icon_theme_list_get();
2449
   list = eina_list_sort(list, eina_list_count(list), _icon_theme_list_sort);
2450
   EINA_LIST_FOREACH(list, l, th)
2451
     {
2452
        if (!_icon_theme_valid(th->name.internal))
2453
          continue;
2454

2455
        ic = elm_icon_add(li);
2456
        elm_image_file_set(ic, efreet_icon_path_find(th->name.internal, "folder", 48), NULL);
2457
        list_it = elm_list_item_append(li, th->name.name, ic, NULL,
2458
                                       _icon_theme_sel,
2459
                                       eina_stringshare_add(th->name.internal));
2460

2461
        if (!strcmp(th->name.internal, "hicolor"))
2462
          def_it = list_it;
2463
        if (!strcmp(elm_config_icon_theme_get(), th->name.internal))
2464
          elm_list_item_selected_set(list_it, EINA_TRUE);
2465
     }
2466
   if (!elm_list_selected_items_get(li))
2467
     elm_list_item_selected_set(def_it, EINA_TRUE);
2468

2469
   elm_list_go(li);
2470

2471
   pd = elm_frame_add(win);
2472
   elm_object_style_set(pd, "pad_medium");
2473
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
2474
   evas_object_size_hint_align_set(pd, EVAS_HINT_FILL, EVAS_HINT_FILL);
2475
   elm_table_pack(tb, pd, 0, 1, 1, 1);
2476
   evas_object_show(pd);
2477

2478
   fr = elm_frame_add(win);
2479
   elm_object_text_set(fr, "Preview");
2480
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2481
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
2482
   elm_object_content_set(pd, fr);
2483
   evas_object_show(fr);
2484

2485
   bx = icon_preview_frame = elm_box_add(fr);
2486
   elm_box_homogeneous_set(bx, EINA_TRUE);
2487
   elm_box_horizontal_set(bx, EINA_TRUE);
2488
   elm_object_content_set(fr, bx);
2489
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2490
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
2491
   evas_object_show(bx);
2492

2493
   /////////////////////////////////////////////
2494
   sp = elm_separator_add(win);
2495
   elm_separator_horizontal_set(sp, EINA_TRUE);
2496
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
2497
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
2498
   elm_table_pack(tb, sp, 0, 2, 1, 1);
2499
   evas_object_show(sp);
2500

2501
   pd = elm_frame_add(win);
2502
   elm_object_style_set(pd, "pad_medium");
2503
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
2504
   evas_object_size_hint_align_set(pd, 0.5, 0.5);
2505
   elm_table_pack(tb, pd, 0, 3, 1, 1);
2506
   evas_object_show(pd);
2507

2508
   bt = elm_button_add(win);
2509
   evas_object_smart_callback_add(bt, "clicked", _icon_theme_use, win);
2510
   elm_object_text_set(bt, "Use Icon Theme");
2511
   evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
2512
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
2513
   elm_object_content_set(pd, bt);
2514
   evas_object_show(bt);
2515

2516
   _icon_preview_update(win);
2517
   evas_object_data_set(win, "icons", tb);
2518
   elm_naviframe_item_simple_push(naviframe, tb);
2519
}
2520

2521

2522
static void
2523
_font_preview_update(Evas_Object *win)
2524
{
2525
   Evas_Font_Size sz;
2526
   char *name;
2527

2528
   if (!fndata.cur_font)
2529
     return;
2530

2531
   name = elm_font_fontconfig_name_get(fndata.cur_font, fndata.cur_style);
2532
   sz = fndata.cur_size;
2533

2534
   if (sz < 0)
2535
     sz = (-sz * 10) / 100;
2536
   if (sz == 0)
2537
     sz = 10;
2538

2539
   edje_object_text_class_set(evas_object_data_get(win, "font_preview"),
2540
                              "font_preview", name, sz);
2541

2542
   elm_font_fontconfig_name_free(name);
2543
}
2544

2545
static void
2546
_font_classes_list_sel(void *data   EINA_UNUSED,
2547
                       Evas_Object *obj,
2548
                       void        *event_info)
2549
{
2550
   const Eina_List *f_names_items, *l;
2551
   Elm_Text_Class_Data *tc_data;
2552
   Evas_Object *f_names_list;
2553
   Elm_Object_Item *list_it;
2554

2555
   tc_data = elm_object_item_data_get(event_info);
2556
   if (!tc_data) return;
2557

2558
   f_names_list = evas_object_data_get(elm_object_top_widget_get(obj),
2559
                                       "font_names_list");
2560
   ELM_LIST_ENABLE(f_names_list);
2561

2562
   f_names_items = elm_list_items_get(f_names_list);
2563

2564
   EINA_LIST_FOREACH(f_names_items, l, list_it)
2565
     {
2566
        const char *s;
2567

2568
        s = elm_object_item_text_get(list_it);
2569
        if (!s) continue;
2570

2571
        if (tc_data->font && !strcmp(s, tc_data->font))
2572
          {
2573
             elm_list_item_selected_set(list_it, EINA_TRUE);
2574
             elm_list_item_show(list_it);
2575
             break;
2576
          }
2577
     }
2578
}
2579

2580
static void
2581
_font_names_list_sel(void *data   EINA_UNUSED,
2582
                     Evas_Object *obj,
2583
                     void        *event_info)
2584
{
2585
   Evas_Object *style_list, *cls_list, *win;
2586
   const char *style, *sel_font;
2587
   Elm_Text_Class_Data *tc_data;
2588
   Elm_Object_Item *list_it, *fc_list_it;
2589
   Elm_Font_Properties *efp;
2590
   const Eina_List *l;
2591

2592
   list_it = event_info;
2593
   sel_font = elm_object_item_text_get(list_it);
2594

2595
   win = elm_object_top_widget_get(obj);
2596
   style_list = evas_object_data_get(win, "font_styles_list");
2597
   cls_list = evas_object_data_get(win, "font_classes_list");
2598

2599
   fc_list_it = elm_list_selected_item_get(cls_list);
2600
   if (!fc_list_it) return;  /* should not happen, fonts list disabled in
2601
                         * this case */
2602

2603
   eina_stringshare_replace(&fndata.cur_font, sel_font);
2604

2605
   tc_data = elm_object_item_data_get(fc_list_it);
2606
   if (!tc_data) return;
2607
   if (tc_data->font) eina_stringshare_del(tc_data->font);
2608
   if (fndata.cur_font) tc_data->font = eina_stringshare_ref(fndata.cur_font);
2609

2610
   /* load styles list */
2611
   efp = eina_hash_find(fndata.font_hash, sel_font);
2612
   if (!efp) return;
2613

2614
   ELM_LIST_ENABLE(style_list);
2615
   elm_list_clear(style_list);
2616

2617
   evas_event_freeze(evas_object_evas_get(style_list));
2618
   edje_freeze();
2619

2620
   list_it = NULL;
2621

2622
   EINA_LIST_FOREACH(efp->styles, l, style)
2623
     {
2624
        Elm_Object_Item *i;
2625

2626
        i = elm_list_item_append(style_list, style, NULL, NULL,
2627
                                 _font_styles_list_sel, NULL);
2628

2629
        if (tc_data->style && (!strcmp(style, tc_data->style)))
2630
          list_it = i;
2631
     }
2632

2633
   elm_list_go(style_list);
2634

2635
   edje_thaw();
2636
   evas_event_thaw(evas_object_evas_get(style_list));
2637

2638
   if (list_it)
2639
     elm_list_item_selected_set(list_it, EINA_TRUE);
2640

2641
   _font_preview_update(win);
2642
}
2643

2644
static void
2645
_font_styles_list_sel(void *data   EINA_UNUSED,
2646
                      Evas_Object *obj,
2647
                      void        *event_info)
2648
{
2649
   Evas_Object *fc_list, *fs_list, *win;
2650
   Elm_Text_Class_Data *tc_data;
2651
   const Eina_List *l;
2652
   Elm_Object_Item *list_it;
2653

2654
   win = elm_object_top_widget_get(obj);
2655
   fc_list = evas_object_data_get(win, "font_classes_list");
2656
   fs_list = evas_object_data_get(win, "font_sizes_list");
2657

2658
   list_it = elm_list_selected_item_get(fc_list);
2659
   if (!list_it) return;  /* should not happen */
2660

2661
   eina_stringshare_replace(&fndata.cur_style,
2662
                            elm_object_item_text_get(event_info));
2663
   ELM_LIST_ENABLE(fs_list);
2664

2665
   tc_data = elm_object_item_data_get(list_it);
2666
   if (!tc_data) return;
2667
   eina_stringshare_del(tc_data->style);
2668
   tc_data->style = eina_stringshare_ref(fndata.cur_style);
2669

2670
   evas_event_freeze(evas_object_evas_get(fs_list));
2671
   edje_freeze();
2672

2673
   EINA_LIST_FOREACH(elm_list_items_get(fs_list), l, list_it)
2674
     {
2675
        Elm_Font_Size_Data *sdata;
2676

2677
        sdata = elm_object_item_data_get(list_it);
2678
        if (!sdata) continue;
2679
        elm_list_item_selected_set(l->data, EINA_FALSE);
2680

2681
        if (tc_data->size == sdata->size)
2682
          {
2683
             elm_list_item_selected_set(list_it, EINA_TRUE);
2684
             elm_list_item_show(list_it);
2685
             break;
2686
          }
2687
     }
2688

2689
   edje_thaw();
2690
   evas_event_thaw(evas_object_evas_get(fs_list));
2691

2692
   _font_preview_update(win);
2693
}
2694

2695
static void
2696
_font_sizes_list_sel(void *data       EINA_UNUSED,
2697
                     Evas_Object *obj EINA_UNUSED,
2698
                     void *event_info EINA_UNUSED)
2699
{
2700
   Elm_Text_Class_Data *tc_data;
2701
   Evas_Object *fc_list, *win;
2702
   Elm_Font_Size_Data *sd;
2703
   Elm_Object_Item *list_it;
2704

2705
   win = elm_object_top_widget_get(obj);
2706
   fc_list = evas_object_data_get(win, "font_classes_list");
2707

2708
   list_it = elm_list_selected_item_get(fc_list);
2709
   if (!list_it) return;  /* should not happen */
2710
   sd = elm_object_item_data_get(event_info);
2711
   if (!sd) return;
2712

2713
   fndata.cur_size = sd->size;
2714

2715
   tc_data = elm_object_item_data_get(list_it);
2716
   if (!tc_data) return;
2717
   tc_data->size = fndata.cur_size;
2718

2719
   _font_preview_update(win);
2720
}
2721

2722
static void
2723
_fstyle_list_unselect_cb(void *data       EINA_UNUSED,
2724
                         Evas_Object     *obj,
2725
                         void *event_info EINA_UNUSED)
2726
{
2727
   Evas_Object *sizes_list, *win;
2728

2729
   if (elm_list_selected_item_get(obj)) return;
2730

2731
   win = elm_object_top_widget_get(obj);
2732

2733
   sizes_list = evas_object_data_get(win, "font_sizes_list");
2734
   ELM_LIST_DISABLE(sizes_list);
2735
}
2736

2737
static void
2738
_fc_list_unselect_cb(void *data       EINA_UNUSED,
2739
                     Evas_Object     *obj,
2740
                     void *event_info EINA_UNUSED)
2741
{
2742
   Evas_Object *font_names_list, *styles_list, *sizes_list, *win;
2743

2744
   if (elm_list_selected_item_get(obj)) return;
2745

2746
   win = elm_object_top_widget_get(obj);
2747

2748
   font_names_list = evas_object_data_get(win, "font_names_list");
2749
   ELM_LIST_DISABLE(font_names_list);
2750

2751
   styles_list = evas_object_data_get(win, "font_styles_list");
2752
   ELM_LIST_DISABLE(styles_list);
2753

2754
   sizes_list = evas_object_data_get(win, "font_sizes_list");
2755
   ELM_LIST_DISABLE(sizes_list);
2756
}
2757

2758
static void
2759
_font_classes_list_load(Evas_Object *li)
2760
{
2761
   Elm_Text_Class_Data *tc_data;
2762
   Eina_List *l;
2763
   Evas *evas;
2764

2765
   evas = evas_object_evas_get(li);
2766
   evas_event_freeze(evas);
2767
   edje_freeze();
2768

2769
   EINA_LIST_FOREACH(fndata.text_classes, l, tc_data)
2770
     elm_list_item_append(li, tc_data->desc, NULL, NULL,
2771
                          _font_classes_list_sel, tc_data);
2772

2773
   evas_object_smart_callback_add(li, "unselected", _fc_list_unselect_cb,
2774
                                  NULL);
2775

2776
   elm_list_go(li);
2777
   edje_thaw();
2778
   evas_event_thaw(evas);
2779
}
2780

2781
static void
2782
_fonts_data_fill(Evas *evas)
2783
{
2784
   const Eina_List *fo_list, *l;
2785
   Eina_List *text_classes;
2786
   Elm_Text_Class_Data *tc_data;
2787
   Elm_Font_Size_Data *sd;
2788
   Elm_Font_Overlay *efo;
2789
   Eina_List *evas_fonts;
2790
   Elm_Text_Class *etc;
2791
   int i;
2792

2793
   evas_fonts = evas_font_available_list(evas);
2794
   fndata.font_hash = elm_font_available_hash_add(evas_fonts);
2795
   evas_font_available_list_free(evas, evas_fonts);
2796

2797
   text_classes = elm_config_text_classes_list_get();
2798
   fo_list = elm_config_font_overlay_list_get();
2799

2800
   EINA_LIST_FOREACH(text_classes, l, etc)
2801
     {
2802
        const Eina_List *ll;
2803

2804
        tc_data = calloc(1, sizeof(*tc_data));
2805
        if (!tc_data) continue;
2806

2807
        tc_data->name = eina_stringshare_add(etc->name);
2808
        tc_data->desc = eina_stringshare_add(etc->desc);
2809

2810
        EINA_LIST_FOREACH(fo_list, ll, efo)
2811
          {
2812
             if (strcmp(tc_data->name, efo->text_class))
2813
               continue;
2814

2815
             if (efo->font)
2816
               {
2817
                  Elm_Font_Properties *efp;
2818

2819
                  efp = elm_font_properties_get(efo->font);
2820
                  if (efp)
2821
                    {
2822
                       tc_data->font = eina_stringshare_add(efp->name);
2823
                       /* we're sure we recorded with only 1 style selected */
2824
                       tc_data->style = eina_stringshare_add(efp->styles->data);
2825
                       elm_font_properties_free(efp);
2826
                    }
2827
               }
2828
             tc_data->size = efo->size;
2829
          }
2830

2831
        fndata.text_classes = eina_list_append(fndata.text_classes, tc_data);
2832
     }
2833

2834
   elm_config_text_classes_list_free(text_classes);
2835

2836
   /* FIXME: hinting later */
2837
   /* fndata.hinting = e_config->font_hinting; */
2838

2839
   sd = calloc(1, sizeof(Elm_Font_Size_Data));
2840
   sd->size_str = eina_stringshare_add("Tiny");
2841
   sd->size = -50;
2842
   fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2843

2844
   sd = calloc(1, sizeof(Elm_Font_Size_Data));
2845
   sd->size_str = eina_stringshare_add("Small");
2846
   sd->size = -80;
2847
   fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2848

2849
   sd = calloc(1, sizeof(Elm_Font_Size_Data));
2850
   sd->size_str = eina_stringshare_add("Normal");
2851
   sd->size = -100;
2852
   fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2853

2854
   sd = calloc(1, sizeof(Elm_Font_Size_Data));
2855
   sd->size_str = eina_stringshare_add("Big");
2856
   sd->size = -150;
2857
   fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2858

2859
   sd = calloc(1, sizeof(Elm_Font_Size_Data));
2860
   sd->size_str = eina_stringshare_add("Really Big");
2861
   sd->size = -190;
2862
   fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2863

2864
   sd = calloc(1, sizeof(Elm_Font_Size_Data));
2865
   sd->size_str = eina_stringshare_add("Huge");
2866
   sd->size = -250;
2867
   fndata.font_scale_list = eina_list_append(fndata.font_scale_list, sd);
2868

2869
   for (i = 5; i < 51; i++)
2870
     {
2871
        char str[16];
2872

2873
        str[0] = 0;
2874
        snprintf(str, sizeof(str), "%d pixels", i);
2875

2876
        sd = calloc(1, sizeof(Elm_Font_Size_Data));
2877
        sd->size_str = eina_stringshare_add(str);
2878
        sd->size = i;
2879
        fndata.font_px_list = eina_list_append(fndata.font_px_list, sd);
2880
     }
2881
}
2882

2883
static int
2884
_font_sort_cb(const void *data1,
2885
              const void *data2)
2886
{
2887
   if (!data1) return 1;
2888
   if (!data2) return -1;
2889
   return strcmp(data1, data2);
2890
}
2891

2892
static void
2893
_font_sizes_list_load(Evas_Object *size_list)
2894
{
2895
   Elm_Font_Size_Data *size_data;
2896
   Eina_List *l;
2897
   Evas *evas;
2898

2899
   evas = evas_object_evas_get(size_list);
2900
   evas_event_freeze(evas);
2901
   edje_freeze();
2902

2903
   EINA_LIST_FOREACH(fndata.font_scale_list, l, size_data)
2904
     elm_list_item_append(size_list, size_data->size_str, NULL, NULL,
2905
                          _font_sizes_list_sel, size_data);
2906

2907
   EINA_LIST_FOREACH(fndata.font_px_list, l, size_data)
2908
     elm_list_item_append(size_list, size_data->size_str, NULL, NULL,
2909
                          _font_sizes_list_sel, size_data);
2910

2911
   elm_list_go(size_list);
2912
   edje_thaw();
2913
   evas_event_thaw(evas);
2914
}
2915

2916
static void
2917
_fnames_list_unselect_cb(void *data       EINA_UNUSED,
2918
                         Evas_Object     *obj,
2919
                         void *event_info EINA_UNUSED)
2920
{
2921
   Evas_Object *styles_list, *sizes_list, *win;
2922

2923
   if (elm_list_selected_item_get(obj)) return;
2924

2925
   win = elm_object_top_widget_get(obj);
2926

2927
   styles_list = evas_object_data_get(win, "font_styles_list");
2928
   ELM_LIST_DISABLE(styles_list);
2929

2930
   sizes_list = evas_object_data_get(win, "font_sizes_list");
2931
   ELM_LIST_DISABLE(sizes_list);
2932
}
2933

2934
static Eina_Bool
2935
_font_list_fill(const Eina_Hash *hash EINA_UNUSED,
2936
                const void *key       EINA_UNUSED,
2937
                void                 *data,
2938
                void                 *fdata)
2939
{
2940
   Elm_Font_Properties *efp;
2941
   Eina_List **flist;
2942

2943
   flist = fdata;
2944
   efp = data;
2945

2946
   *flist = eina_list_append(*flist, efp->name);
2947

2948
   return EINA_TRUE;
2949
}
2950

2951
static void
2952
_font_names_list_load(Evas_Object *flist)
2953
{
2954
   Eina_List *l, *names_list = NULL;
2955
   const char *font;
2956
   Evas *evas;
2957

2958
   evas = evas_object_evas_get(flist);
2959
   evas_event_freeze(evas);
2960
   edje_freeze();
2961

2962
   eina_hash_foreach(fndata.font_hash, _font_list_fill, &names_list);
2963
   names_list = eina_list_sort(names_list, eina_list_count(names_list),
2964
                               _font_sort_cb);
2965

2966
   EINA_LIST_FOREACH(names_list, l, font)
2967
     elm_list_item_append(flist, font, NULL, NULL, _font_names_list_sel, NULL);
2968

2969
   eina_list_free(names_list);
2970

2971
   evas_object_smart_callback_add(flist, "unselected",
2972
                                  _fnames_list_unselect_cb, NULL);
2973

2974
   elm_list_go(flist);
2975

2976
   edje_thaw();
2977
   evas_event_thaw(evas);
2978
}
2979

2980
static void
2981
_status_config_fonts(Evas_Object *win,
2982
                     Evas_Object *naviframe)
2983
{
2984
   Evas_Object *base, *fr, *li, *rc, *preview, *sp, *pd, *bt, *bx;
2985
   char buf[PATH_MAX];
2986

2987
   _fonts_data_fill(evas_object_evas_get(win));
2988

2989
   base = elm_table_add(win);
2990
   evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2991
   evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
2992

2993
   /* yeah, dummy rectangles are ugly as hell, but no good way yet of
2994
      fixing sizes */
2995
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
2996
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2997
   evas_object_size_hint_align_set(rc, EVAS_HINT_FILL, EVAS_HINT_FILL);
2998
   evas_object_size_hint_min_set(rc, 70, 170);
2999
   elm_table_pack(base, rc, 1, 0, 1, 1);
3000

3001
   fr = elm_frame_add(win);
3002
   elm_object_text_set(fr, "Font Class");
3003
   elm_table_pack(base, fr, 0, 0, 1, 2);
3004
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3005
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3006
   evas_object_show(fr);
3007

3008
   /* FIXME: no multiselection for this list, for now */
3009
   li = elm_list_add(win);
3010
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3011
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3012
   elm_object_content_set(fr, li);
3013
   evas_object_show(li);
3014

3015
   evas_object_data_set(win, "font_classes_list", li);
3016
   _font_classes_list_load(li);
3017

3018
   fr = elm_frame_add(win);
3019
   elm_object_text_set(fr, "Font");
3020
   elm_table_pack(base, fr, 1, 0, 1, 2);
3021
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3022
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3023
   evas_object_show(fr);
3024

3025
   li = elm_list_add(win);
3026
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3027
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3028
   elm_object_content_set(fr, li);
3029
   evas_object_show(li);
3030

3031
   evas_object_data_set(win, "font_names_list", li);
3032
   _font_names_list_load(li);
3033
   ELM_LIST_DISABLE(li);
3034

3035
   rc = evas_object_rectangle_add(evas_object_evas_get(win));
3036
   evas_object_size_hint_weight_set(rc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3037
   evas_object_size_hint_align_set(rc, EVAS_HINT_FILL, EVAS_HINT_FILL);
3038
   evas_object_size_hint_min_set(rc, 70, 130);
3039
   elm_table_pack(base, rc, 1, 2, 1, 1);
3040

3041
   fr = elm_frame_add(win);
3042
   elm_object_text_set(fr, "Style");
3043
   elm_table_pack(base, fr, 0, 2, 1, 1);
3044
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3045
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3046
   evas_object_show(fr);
3047
   ELM_LIST_DISABLE(li);
3048

3049
   li = elm_list_add(win);
3050
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3051
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3052
   elm_object_content_set(fr, li);
3053
   evas_object_show(li);
3054

3055
   evas_object_data_set(win, "font_styles_list", li);
3056
   evas_object_smart_callback_add(li, "unselected", _fstyle_list_unselect_cb,
3057
                                  NULL);
3058

3059
   fr = elm_frame_add(win);
3060
   elm_object_text_set(fr, "Size");
3061
   elm_table_pack(base, fr, 1, 2, 1, 1);
3062
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3063
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3064
   evas_object_show(fr);
3065

3066
   li = elm_list_add(win);
3067
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3068
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3069
   elm_object_content_set(fr, li);
3070
   evas_object_show(li);
3071

3072
   evas_object_data_set(win, "font_sizes_list", li);
3073
   _font_sizes_list_load(li);
3074
   ELM_LIST_DISABLE(li);
3075

3076
   bx = elm_box_add(win);
3077
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3078
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
3079
   elm_table_pack(base, bx, 0, 3, 2, 1);
3080
   evas_object_show(bx);
3081

3082
   /* FIXME: what to do here? dedicated widget? some new entry API set? */
3083
   snprintf(buf, sizeof(buf), "%s/objects/font_preview.edj", elm_app_data_dir_get());
3084
   preview = elm_layout_add(win);
3085
   elm_layout_file_set(preview, buf, "font_preview");
3086
   elm_object_part_text_set(preview, "elm.text", "Preview Text — 我真的会写中文");
3087
   evas_object_size_hint_weight_set(preview, EVAS_HINT_EXPAND, 0.0);
3088
   evas_object_size_hint_align_set(preview, EVAS_HINT_FILL, EVAS_HINT_FILL);
3089
   evas_object_show(preview);
3090

3091
   elm_box_pack_end(bx, preview);
3092
   evas_object_data_set(win, "font_preview", elm_layout_edje_get(preview));
3093

3094
   /////////////////////////////////////////////
3095
   sp = elm_separator_add(win);
3096
   elm_separator_horizontal_set(sp, EINA_TRUE);
3097
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3098
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3099
   elm_table_pack(base, sp, 0, 4, 2, 1);
3100
   evas_object_show(sp);
3101

3102
   pd = elm_frame_add(win);
3103
   elm_object_style_set(pd, "pad_medium");
3104
   evas_object_size_hint_weight_set(pd, EVAS_HINT_EXPAND, 0.0);
3105
   evas_object_size_hint_align_set(pd, 0.5, 0.5);
3106
   elm_table_pack(base, pd, 0, 5, 2, 1);
3107
   evas_object_show(pd);
3108

3109
   bx = elm_box_add(win);
3110
   elm_box_horizontal_set(bx, EINA_TRUE);
3111
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3112
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
3113
   evas_object_show(bx);
3114

3115
   bt = elm_button_add(win);
3116
   evas_object_smart_callback_add(bt, "clicked", _font_overlay_set_all, win);
3117
   elm_object_text_set(bt, "Set to All");
3118
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3119
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3120
   elm_box_pack_end(bx, bt);
3121
   evas_object_show(bt);
3122

3123
   bt = elm_button_add(win);
3124
   evas_object_smart_callback_add(bt, "clicked", _font_overlay_reset, win);
3125
   elm_object_text_set(bt, "Reset");
3126
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3127
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3128
   elm_box_pack_end(bx, bt);
3129
   evas_object_show(bt);
3130

3131
   bt = elm_button_add(win);
3132
   evas_object_smart_callback_add(bt, "clicked", _font_overlay_reset_all, win);
3133
   elm_object_text_set(bt, "Reset All");
3134
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3135
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3136
   elm_box_pack_end(bx, bt);
3137
   evas_object_show(bt);
3138

3139
   bt = elm_button_add(win);
3140
   evas_object_smart_callback_add(bt, "clicked", _font_overlay_change, win);
3141
   elm_object_text_set(bt, "Apply");
3142
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3143
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3144
   elm_box_pack_end(bx, bt);
3145
   evas_object_show(bt);
3146

3147
   elm_object_content_set(pd, bx);
3148

3149
   evas_object_data_set(win, "fonts", base);
3150

3151
   elm_naviframe_item_simple_push(naviframe, base);
3152
}
3153

3154
// singleton only initted once so .. don't care
3155
static Eina_List *colors = NULL;
3156

3157
static void
3158
_color_sel(void            *data EINA_UNUSED,
3159
           Evas_Object     *obj,
3160
           void *event_info EINA_UNUSED)
3161
{
3162
   Elm_Widget_Item *it = elm_list_selected_item_get(obj);
3163
   if (it)
3164
     {
3165
        char *s2 = elm_object_item_data_get(it);
3166
        if (s2) elm_config_palette_set(s2);
3167
     }
3168
}
3169

3170
static void
3171
_status_config_colors(Evas_Object *win,
3172
                      Evas_Object *naviframe)
3173
{
3174
   Evas_Object *base, *li;
3175
   Eina_List *list, *l;
3176
   const char *s, *pal;
3177
   char *s2;
3178
   Elm_Widget_Item *it;
3179

3180
   base = elm_table_add(win);
3181
   evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3182
   evas_object_size_hint_align_set(base, EVAS_HINT_FILL, EVAS_HINT_FILL);
3183

3184
   li = elm_list_add(win);
3185
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3186
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3187
   elm_table_pack(base, li, 0, 0, 1, 1);
3188
   evas_object_show(li);
3189

3190
   list = elm_config_palette_list();
3191
   pal = elm_config_palette_get();
3192
   EINA_LIST_FOREACH(list, l, s)
3193
     {
3194
        if (s)
3195
          {
3196
             s2 = strdup(s);
3197
             if (s2)
3198
               {
3199
                  colors = eina_list_append(colors, s2);
3200
                  it = elm_list_item_append(li, s2, NULL, NULL, NULL, s2);
3201
                  if ((pal) && (!strcmp(s2, pal)))
3202
                    elm_list_item_selected_set(it, EINA_TRUE);
3203
               }
3204
          }
3205
     }
3206
   evas_object_smart_callback_add(li, "selected", _color_sel, NULL);
3207
   elm_list_go(li);
3208
   elm_config_palette_list_free(list);
3209

3210
   evas_object_data_set(win, "colors", base);
3211

3212
   elm_naviframe_item_simple_push(naviframe, base);
3213
}
3214

3215
static void
3216
_profiles_list_item_del_cb(void            *data,
3217
                           Evas_Object *obj EINA_UNUSED,
3218
                           void *event_info EINA_UNUSED)
3219
{
3220
   free(data);
3221
}
3222

3223
static void
3224
_profiles_list_selected_cb(void            *data,
3225
                           Evas_Object     *obj,
3226
                           void *event_info EINA_UNUSED)
3227
{
3228
   const char *cur_profile = NULL;
3229
   const char *sel_profile, *pdir;
3230
   const char *prof_name;
3231
   char buf[PATH_MAX];
3232
   Evas_Object *en;
3233
#ifdef ELM_EFREET
3234
   Efreet_Desktop *desk = NULL;
3235
#endif
3236

3237
   sel_profile = data;
3238
   if (!sel_profile)
3239
     return;
3240

3241
   cur_profile = elm_config_profile_get();
3242

3243
   pdir = elm_config_profile_dir_get(sel_profile, EINA_TRUE);
3244
   if (!pdir) pdir = elm_config_profile_dir_get(sel_profile, EINA_FALSE);
3245
#ifdef ELM_EFREET
3246
   snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
3247
   desk = efreet_desktop_new(buf);
3248
   if ((desk) && (desk->name)) prof_name = desk->name;
3249
   else
3250
     {
3251
        if (desk) efreet_desktop_free(desk);
3252
        if (pdir) elm_config_profile_dir_free(pdir);
3253

3254
        pdir = elm_config_profile_dir_get(sel_profile, EINA_FALSE);
3255
        snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
3256
        desk = efreet_desktop_new(buf);
3257
        if ((desk) && (desk->name)) prof_name = desk->name;
3258
        else prof_name = cur_profile;
3259
     }
3260
#endif
3261

3262
   if (!pdir)
3263
     elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
3264
                             EINA_TRUE);
3265
   else
3266
     {
3267
        elm_object_disabled_set(evas_object_data_get(obj, "prof_del_btn"),
3268
                                EINA_TRUE);
3269
        elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
3270
                                EINA_FALSE);
3271
        elm_object_disabled_set(evas_object_data_get(obj, "prof_use_btn"),
3272
                                EINA_FALSE);
3273
        elm_config_profile_dir_free(pdir);
3274
     }
3275

3276
   snprintf(buf, sizeof(buf), "<hilight>Selected profile: %s</><br/>",
3277
            prof_name);
3278
   elm_object_text_set(evas_object_data_get(obj, "prof_name_lbl"), buf);
3279

3280
   en = evas_object_data_get(obj, "prof_desc_entry");
3281
#ifdef ELM_EFREET
3282
   if (desk) elm_object_text_set(en, desk->comment);
3283
   else
3284
#endif
3285
   elm_object_text_set(en, "Unknown");
3286

3287
#ifdef ELM_EFREET
3288
   if (desk) efreet_desktop_free(desk);
3289
#endif
3290
}
3291

3292
static void
3293
_profiles_list_fill(Evas_Object *l_widget,
3294
                    Eina_List   *p_names)
3295
{
3296
   const char *cur_profile = NULL;
3297
   const char *profile;
3298
   void *sel_it = NULL;
3299
   Eina_List *l;
3300

3301
   if (!p_names)
3302
     return;
3303

3304
   elm_list_clear(l_widget);
3305

3306
   cur_profile = elm_config_profile_get();
3307

3308
   EINA_LIST_FOREACH(p_names, l, profile)
3309
     {
3310
#ifdef ELM_EFREET
3311
        Efreet_Desktop *desk = NULL;
3312
#endif
3313
        const char *label, *ext, *pdir;
3314
        char buf[PATH_MAX];
3315
        Elm_Object_Item *list_it;
3316
        Evas_Object *ic;
3317

3318
        pdir = elm_config_profile_dir_get(profile, EINA_TRUE);
3319
        if (!pdir) pdir = elm_config_profile_dir_get(profile, EINA_FALSE);
3320

3321
#ifdef ELM_EFREET
3322
        snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
3323
        desk = efreet_desktop_new(buf);
3324
        if ((desk) && (desk->name)) label = desk->name;
3325
        else
3326
          {
3327
             if (desk) efreet_desktop_free(desk);
3328
             if (pdir) elm_config_profile_dir_free(pdir);
3329

3330
             pdir = elm_config_profile_dir_get(profile, EINA_FALSE);
3331
             snprintf(buf, sizeof(buf), "%s/profile.desktop", pdir);
3332
             desk = efreet_desktop_new(buf);
3333
             if ((desk) && (desk->name)) label = desk->name;
3334
             else label = profile;
3335
          }
3336
#endif
3337

3338
        buf[0] = 0;
3339
        if (pdir) snprintf(buf, sizeof(buf), "%s/icon.edj", pdir);
3340
#ifdef ELM_EFREET
3341
        if ((desk) && (desk->icon) && (pdir))
3342
          snprintf(buf, sizeof(buf), "%s/%s", pdir, desk->icon);
3343
#endif
3344
        ic = elm_icon_add(l_widget);
3345
        ext = strrchr(buf, '.');
3346
        if (ext)
3347
          {
3348
             if (!strcmp(ext, ".edj")) elm_image_file_set(ic, buf, "icon");
3349
             else elm_image_file_set(ic, buf, NULL);
3350
          }
3351

3352
        evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL,
3353
                                         1, 1);
3354
        evas_object_show(ic);
3355

3356
        list_it = elm_list_item_append(l_widget, label, ic, NULL,
3357
                                       _profiles_list_selected_cb,
3358
                                       strdup(profile));
3359
        elm_object_item_del_cb_set(list_it, _profiles_list_item_del_cb);
3360
        if (cur_profile && !strcmp(profile, cur_profile))
3361
          sel_it = list_it;
3362

3363
        elm_config_profile_dir_free(pdir);
3364

3365
#ifdef ELM_EFREET
3366
        if (desk) efreet_desktop_free(desk);
3367
#endif
3368
     }
3369

3370
   if (sel_it) elm_list_item_selected_set(sel_it, EINA_TRUE);
3371
   elm_list_go(l_widget);
3372
}
3373

3374
static void
3375
_profiles_list_unselect_cb(void *data       EINA_UNUSED,
3376
                           Evas_Object     *obj,
3377
                           void *event_info EINA_UNUSED)
3378
{
3379
   if (!elm_list_selected_item_get(obj)) return;
3380
   elm_object_disabled_set(evas_object_data_get(obj, "prof_del_btn"),
3381
                           EINA_TRUE);
3382
   elm_object_disabled_set(evas_object_data_get(obj, "prof_reset_btn"),
3383
                           EINA_TRUE);
3384
   elm_object_disabled_set(evas_object_data_get(obj, "prof_use_btn"),
3385
                           EINA_TRUE);
3386
}
3387

3388
static void
3389
_status_config_profiles(Evas_Object *win,
3390
                        Evas_Object *naviframe)
3391
{
3392
   Evas_Object *li, *bx, *fr_bx1, *fr_bx2, *btn_bx, *fr, *lb, *en, *sp, *pd,
3393
   *bt;
3394
   Eina_List *profs;
3395
   Evas *evas;
3396

3397
   bx = elm_box_add(win);
3398
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3399
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
3400

3401
   fr_bx1 = elm_box_add(win);
3402
   evas_object_size_hint_weight_set(fr_bx1, EVAS_HINT_EXPAND,
3403
                                    EVAS_HINT_EXPAND);
3404
   evas_object_size_hint_align_set(fr_bx1, EVAS_HINT_FILL, EVAS_HINT_FILL);
3405
   elm_box_homogeneous_set(fr_bx1, EINA_TRUE);
3406
   evas_object_show(fr_bx1);
3407

3408
   fr_bx2 = elm_box_add(win);
3409
   evas_object_size_hint_weight_set(fr_bx2, EVAS_HINT_EXPAND,
3410
                                    EVAS_HINT_EXPAND);
3411
   evas_object_size_hint_align_set(fr_bx2, EVAS_HINT_FILL, EVAS_HINT_FILL);
3412
   evas_object_show(fr_bx2);
3413

3414
   fr = elm_frame_add(win);
3415
   elm_object_text_set(fr, "Available Profiles");
3416
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3417
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3418
   elm_object_content_set(fr, fr_bx1);
3419
   elm_box_pack_end(bx, fr);
3420
   evas_object_show(fr);
3421

3422
   li = elm_list_add(win);
3423
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3424
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
3425
   evas_object_smart_callback_add(li, "unselected", _profiles_list_unselect_cb,
3426
                                  NULL);
3427

3428
   profs = elm_config_profile_list_get();
3429

3430
   evas_object_show(li);
3431
   elm_box_pack_end(fr_bx2, li);
3432

3433
   lb = elm_label_add(win);
3434
   evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, 0.0);
3435
   evas_object_size_hint_align_set(lb, EVAS_HINT_FILL, 0.5);
3436

3437
   evas_object_show(lb);
3438

3439
   en = elm_entry_add(win);
3440
   elm_entry_scrollable_set(en, EINA_TRUE);
3441
   elm_entry_editable_set(en, EINA_FALSE);
3442
   evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3443
   evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
3444
   evas_object_show(en);
3445

3446
   evas_object_data_set(li, "prof_name_lbl", lb);
3447
   evas_object_data_set(li, "prof_desc_entry", en);
3448

3449
   elm_box_pack_end(fr_bx2, lb);
3450
   elm_box_pack_end(fr_bx1, fr_bx2);
3451
   elm_box_pack_end(fr_bx1, en);
3452

3453
   /////////////////////////////////////////////
3454
   sp = elm_separator_add(win);
3455
   elm_separator_horizontal_set(sp, EINA_TRUE);
3456
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3457
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3458
   elm_box_pack_end(bx, sp);
3459
   evas_object_show(sp);
3460

3461
   pd = elm_frame_add(win);
3462
   elm_object_style_set(pd, "pad_medium");
3463
   evas_object_size_hint_weight_set(pd, 0.0, 0.0);
3464
   evas_object_size_hint_align_set(pd, 0.5, 0.5);
3465
   elm_box_pack_end(bx, pd);
3466
   evas_object_show(pd);
3467

3468
   btn_bx = elm_box_add(win);
3469
   elm_box_horizontal_set(btn_bx, EINA_TRUE);
3470
   evas_object_size_hint_weight_set(btn_bx, EVAS_HINT_EXPAND,
3471
                                    EVAS_HINT_EXPAND);
3472
   evas_object_size_hint_align_set(btn_bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
3473
   evas_object_show(btn_bx);
3474

3475
   bt = elm_button_add(win);
3476
   evas_object_smart_callback_add(bt, "clicked", _profile_use, li);
3477
   elm_object_text_set(bt, "Use");
3478
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3479
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3480
   elm_box_pack_end(btn_bx, bt);
3481
   evas_object_show(bt);
3482

3483
   evas_object_data_set(li, "prof_use_btn", bt);
3484

3485
   bt = elm_button_add(win);
3486
   evas_object_smart_callback_add(bt, "clicked", _btn_todo, NULL); /* TODO */
3487
   elm_object_text_set(bt, "Delete");
3488
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3489
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3490
   elm_box_pack_end(btn_bx, bt);
3491
   evas_object_show(bt);
3492

3493
   evas_object_data_set(li, "prof_del_btn", bt);
3494

3495
   bt = elm_button_add(win);
3496
   evas_object_smart_callback_add(bt, "clicked", _profile_reset, li);
3497
   elm_object_text_set(bt, "Reset");
3498
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3499
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3500
   elm_box_pack_end(btn_bx, bt);
3501
   evas_object_show(bt);
3502

3503
   evas_object_data_set(li, "prof_reset_btn", bt);
3504

3505
   bt = elm_button_add(win);
3506
   evas_object_smart_callback_add(bt, "clicked", _btn_todo, NULL); /* TODO */
3507
   elm_object_text_set(bt, "Add new");
3508
   evas_object_size_hint_weight_set(bt, 0.0, 0.0);
3509
   evas_object_size_hint_align_set(bt, 0.5, 0.5);
3510
   elm_box_pack_end(btn_bx, bt);
3511
   evas_object_show(bt);
3512

3513
   elm_object_content_set(pd, btn_bx);
3514

3515
   evas = evas_object_evas_get(li);
3516
   evas_event_freeze(evas);
3517
   edje_freeze();
3518

3519
   _profiles_list_fill(li, profs);
3520

3521
   elm_config_profile_list_free(profs);
3522

3523
   edje_thaw();
3524
   evas_event_thaw(evas);
3525

3526
   evas_object_data_set(win, "profiles", bx);
3527
   elm_naviframe_item_simple_push(naviframe, bx);
3528
}
3529

3530
static void
3531
_status_config_scrolling_bounce(Evas_Object *win, Evas_Object *box)
3532
{
3533
   Evas_Object *fr, *bx, *ck, *pd, *lb, *sl;
3534

3535
   fr = elm_frame_add(box);
3536
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
3537
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3538
   elm_object_text_set(fr, "Bounce");
3539
   elm_box_pack_end(box, fr);
3540
   evas_object_show(fr);
3541

3542
   bx = elm_box_add(fr);
3543
   elm_object_content_set(fr, bx);
3544
   evas_object_show(bx);
3545

3546
   /* Enable Scroll Bounce */
3547
   CHECK_ADD("Enable scroll bounce",
3548
             "Set whether scrollers should bounce<br/>"
3549
             "when they reach their viewport's edge<br/>"
3550
             "during a scroll",
3551
             sb_change, NULL);
3552
   evas_object_data_set(win, "scroll_bounce_check", ck);
3553
   elm_check_state_set(ck, elm_config_scroll_bounce_enabled_get());
3554

3555
   /* Scroll bounce friction */
3556
   LABEL_FRAME_ADD("<hilight>Scroll bounce friction</>");
3557

3558
   sl = elm_slider_add(bx);
3559
   elm_object_tooltip_text_set(sl, "This is the amount of inertia a <br/>"
3560
                                   "scroller will impose at bounce animations");
3561
   evas_object_data_set(win, "bounce_friction_slider", sl);
3562
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3563
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3564
   elm_slider_span_size_set(sl, 120);
3565
   elm_slider_unit_format_set(sl, "%1.2f");
3566
   elm_slider_indicator_format_set(sl, "%1.2f");
3567
   elm_slider_min_max_set(sl, 0.0, 4.0);
3568
   elm_slider_value_set(sl, elm_config_scroll_bounce_friction_get());
3569
   elm_box_pack_end(bx, sl);
3570
   evas_object_show(sl);
3571

3572
   evas_object_smart_callback_add(sl, "changed", bf_round, NULL);
3573
   evas_object_smart_callback_add(sl, "delay,changed", bf_change, NULL);
3574
}
3575

3576
static void
3577
_status_config_scrolling_thumb(Evas_Object *win, Evas_Object *box)
3578
{
3579
   Evas_Object *fr, *bx, *ck, *sl, *sp, *pd, *lb;
3580

3581
   fr = elm_frame_add(box);
3582
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
3583
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3584
   elm_object_text_set(fr, "Thumb Scroll");
3585
   elm_box_pack_end(box, fr);
3586
   evas_object_show(fr);
3587

3588
   bx = elm_box_add(fr);
3589
   elm_object_content_set(fr, bx);
3590
   evas_object_show(bx);
3591

3592
   /* Enable thumb scroll */
3593
   CHECK_ADD("Enable thumb scroll",
3594
             "Set whether scrollers should be<br/>"
3595
             "draggable from any point in their views",
3596
             ts_change, NULL);
3597
   evas_object_data_set(win, "thumbscroll_check", ck);
3598
   elm_check_state_set(ck, elm_config_scroll_thumbscroll_enabled_get());
3599

3600
   /* Thumb scroll threadhold */
3601
   LABEL_FRAME_ADD("<hilight>Thumb scroll threshold</>");
3602

3603
   sl = elm_slider_add(win);
3604
   elm_object_tooltip_text_set(sl, "This is the number of pixels one should<br/>"
3605
                                   "travel while dragging a scroller's view<br/>"
3606
                                   "to actually trigger scrolling");
3607
   evas_object_data_set(win, "ts_threshold_slider", sl);
3608
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3609
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3610
   elm_slider_span_size_set(sl, 120);
3611
   elm_slider_unit_format_set(sl, "%1.0f pixels");
3612
   elm_slider_indicator_format_set(sl, "%1.0f");
3613
   elm_slider_min_max_set(sl, 8.0, 50.0);
3614
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_threshold_get());
3615
   elm_box_pack_end(bx, sl);
3616
   evas_object_show(sl);
3617

3618
   evas_object_smart_callback_add(sl, "changed", tst_round, NULL);
3619
   evas_object_smart_callback_add(sl, "delay,changed", tst_change, NULL);
3620

3621
   /* Thumb scroll hold threashold */
3622
   LABEL_FRAME_ADD("<hilight>Thumb scroll hold threshold</>");
3623

3624
   sl = elm_slider_add(win);
3625
   elm_object_tooltip_text_set(sl, "This is the number of pixels the range<br/>"
3626
                                   "which can be scrolled, while the scroller<br/>"
3627
                                   "is holed");
3628
   evas_object_data_set(win, "ts_hold_threshold_slider", sl);
3629
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3630
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3631
   elm_slider_span_size_set(sl, 120);
3632
   elm_slider_unit_format_set(sl, "%1.0f pixels");
3633
   elm_slider_indicator_format_set(sl, "%1.0f");
3634
   elm_slider_min_max_set(sl, 4.0, 500.0);
3635
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_hold_threshold_get());
3636
   elm_box_pack_end(bx, sl);
3637
   evas_object_show(sl);
3638

3639
   evas_object_smart_callback_add(sl, "changed", tsht_round, NULL);
3640
   evas_object_smart_callback_add(sl, "delay,changed", tsht_change, NULL);
3641

3642
   /* Thumb scroll momentum threshold */
3643
   LABEL_FRAME_ADD("<hilight>Thumb scroll momentum threshold</>");
3644

3645
   sl = elm_slider_add(win);
3646
   elm_object_tooltip_text_set(sl, "This is the minimum speed of mouse <br/>"
3647
                                   "cursor movement which will trigger<br/>"
3648
                                   "list self scrolling animation after a<br/>"
3649
                                   "mouse up event (pixels/second)");
3650
   evas_object_data_set(win, "ts_momentum_threshold_slider", sl);
3651
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3652
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3653
   elm_slider_span_size_set(sl, 120);
3654
   elm_slider_unit_format_set(sl, "%1.0f pixels/s");
3655
   elm_slider_indicator_format_set(sl, "%1.0f");
3656
   elm_slider_min_max_set(sl, 10.0, 200.0);
3657
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_momentum_threshold_get());
3658
   elm_box_pack_end(bx, sl);
3659
   evas_object_show(sl);
3660

3661
   evas_object_smart_callback_add(sl, "changed", tsmt_round, NULL);
3662
   evas_object_smart_callback_add(sl, "delay,changed", tsmt_change,
3663
                                  NULL);
3664

3665
   /* Thumb scroll flick distance tolerance */
3666
   LABEL_FRAME_ADD("<hilight>Thumb scroll flick distance tolerance</>");
3667

3668
   sl = elm_slider_add(win);
3669
   elm_object_tooltip_text_set(sl, "This is the number of pixels the maximum<br/>"
3670
                                   "distance which can be flicked. If it is<br/>"
3671
                                   "flicked more than this, the flick distance<br/>"
3672
                                   "is same with maximum distance");
3673
   evas_object_data_set(win, "ts_flick_distance_tolerance_slider", sl);
3674
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3675
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3676
   elm_slider_span_size_set(sl, 120);
3677
   elm_slider_unit_format_set(sl, "%1.0f pixels");
3678
   elm_slider_indicator_format_set(sl, "%1.0f");
3679
   elm_slider_min_max_set(sl, 100.0, 3000.0);
3680
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_flick_distance_tolerance_get());
3681
   elm_box_pack_end(bx, sl);
3682
   evas_object_show(sl);
3683

3684
   evas_object_smart_callback_add(sl, "changed", tsfdt_round, NULL);
3685
   evas_object_smart_callback_add(sl, "delay,changed", tsfdt_change, NULL);
3686

3687
   /* Thumb scroll friction */
3688
   LABEL_FRAME_ADD("<hilight>Thumb scroll friction</>");
3689

3690
   sl = elm_slider_add(win);
3691
   elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br/>"
3692
                                   "scroller will impose at self scrolling<br/>"
3693
                                   "animations");
3694
   evas_object_data_set(win, "ts_friction_slider", sl);
3695
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3696
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3697
   elm_slider_span_size_set(sl, 120);
3698
   elm_slider_unit_format_set(sl, "%1.1f");
3699
   elm_slider_indicator_format_set(sl, "%1.1f");
3700
   elm_slider_min_max_set(sl, 0.1, 10.0);
3701
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_friction_get());
3702
   elm_box_pack_end(bx, sl);
3703
   evas_object_show(sl);
3704

3705
   evas_object_smart_callback_add(sl, "changed", tsf_round, NULL);
3706
   evas_object_smart_callback_add(sl, "delay,changed", tsf_change, NULL);
3707

3708
   /* Thumb scroll min friction */
3709
   LABEL_FRAME_ADD("<hilight>Thumb scroll min friction</>");
3710

3711
   sl = elm_slider_add(win);
3712
   elm_object_tooltip_text_set(sl, "This is the min amount of inertia a<br/>"
3713
                                   "scroller will impose at self scrolling<br/>"
3714
                                   "animations");
3715
   evas_object_data_set(win, "ts_min_friction_slider", sl);
3716
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3717
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3718
   elm_slider_span_size_set(sl, 120);
3719
   elm_slider_unit_format_set(sl, "%1.1f");
3720
   elm_slider_indicator_format_set(sl, "%1.1f");
3721
   elm_slider_min_max_set(sl, 0.1, 10.0);
3722
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_min_friction_get());
3723
   elm_box_pack_end(bx, sl);
3724
   evas_object_show(sl);
3725

3726
   evas_object_smart_callback_add(sl, "changed", tsmf_round, NULL);
3727
   evas_object_smart_callback_add(sl, "delay,changed", tsmf_change, NULL);
3728

3729
   /* Thumb scroll friction standard */
3730
   LABEL_FRAME_ADD("<hilight>Thumb scroll friction standard</>");
3731

3732
   sl = elm_slider_add(win);
3733
   elm_object_tooltip_text_set(sl, "This is the standard velocity of the scroller."
3734
                                   "<br/>The scroll animation time is same<br/>"
3735
                                   "with thumbscroll friction, if the velocity"
3736
                                   "<br/>is same with standard velocity.");
3737
   evas_object_data_set(win, "ts_friction_standard_slider", sl);
3738
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3739
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3740
   elm_slider_span_size_set(sl, 120);
3741
   elm_slider_unit_format_set(sl, "%1.0f pixel/s");
3742
   elm_slider_indicator_format_set(sl, "%1.0f");
3743
   elm_slider_min_max_set(sl, 10.0, 5000.0);
3744
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_friction_standard_get());
3745
   elm_box_pack_end(bx, sl);
3746
   evas_object_show(sl);
3747

3748
   evas_object_smart_callback_add(sl, "changed", tsfs_round, NULL);
3749
   evas_object_smart_callback_add(sl, "delay,changed", tsfs_change, NULL);
3750

3751
   /* Thumb scroll border friction */
3752
   LABEL_FRAME_ADD("<hilight>Thumb scroll border friction</>");
3753

3754
   sl = elm_slider_add(win);
3755
   elm_object_tooltip_text_set(sl, "This is the amount of lag between your<br/>"
3756
                                   "actual mouse cursor dragging movement<br/>"
3757
                                   "and a scroller's view movement itself,<br/>"
3758
                                   "while pushing it into bounce state<br/>"
3759
                                   "manually");
3760
   evas_object_data_set(win, "ts_border_friction_slider", sl);
3761
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3762
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3763
   elm_slider_span_size_set(sl, 120);
3764
   elm_slider_unit_format_set(sl, "%1.2f");
3765
   elm_slider_indicator_format_set(sl, "%1.2f");
3766
   elm_slider_min_max_set(sl, 0.0, 1.0);
3767
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_border_friction_get());
3768
   elm_box_pack_end(bx, sl);
3769
   evas_object_show(sl);
3770

3771
   evas_object_smart_callback_add(sl, "changed", tsbf_round, NULL);
3772
   evas_object_smart_callback_add(sl, "delay,changed", tsbf_change, NULL);
3773

3774
   /* Thumb scroll sensitivity friction */
3775
   LABEL_FRAME_ADD("<hilight>Thumb scroll sensitivity friction</>");
3776

3777
   sl = elm_slider_add(win);
3778
   elm_object_tooltip_text_set(sl, "This is the sensitivity amount which<br/>"
3779
                                   "is be multiplied by the length of mouse<br/>"
3780
                                   "dragging.");
3781
   evas_object_data_set(win, "ts_sensitivity_friction_slider", sl);
3782
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3783
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3784
   elm_slider_span_size_set(sl, 120);
3785
   elm_slider_unit_format_set(sl, "%1.2f");
3786
   elm_slider_indicator_format_set(sl, "%1.2f");
3787
   elm_slider_min_max_set(sl, 0.1, 1.0);
3788
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_sensitivity_friction_get());
3789
   elm_box_pack_end(bx, sl);
3790
   evas_object_show(sl);
3791

3792
   evas_object_smart_callback_add(sl, "changed", tssf_round, NULL);
3793
   evas_object_smart_callback_add(sl, "delay,changed", tssf_change, NULL);
3794

3795
   sp = elm_separator_add(win);
3796
   elm_separator_horizontal_set(sp, EINA_TRUE);
3797
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
3798
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
3799
   elm_box_pack_end(bx, sp);
3800
   evas_object_show(sp);
3801
}
3802

3803
static void
3804
_status_config_scrolling_acceleration(Evas_Object *win, Evas_Object *box)
3805
{
3806
   Evas_Object *fr, *bx, *sl, *pd, *lb;
3807

3808
   fr = elm_frame_add(box);
3809
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
3810
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3811
   elm_object_text_set(fr, "Thumb Scroll Acceleration");
3812
   elm_box_pack_end(box, fr);
3813
   evas_object_show(fr);
3814

3815
   bx = elm_box_add(fr);
3816
   elm_object_content_set(fr, bx);
3817
   evas_object_show(bx);
3818

3819
   /* Thumb scroll acceleration threshold */
3820
   LABEL_FRAME_ADD("<hilight>Thumb scroll acceleration threshold</>");
3821

3822
   sl = elm_slider_add(bx);
3823
   elm_object_tooltip_text_set(sl, "This is the minimum speed of mouse <br/>"
3824
                                   "cursor movement which will accelerate<br/>"
3825
                                   "scrolling velocity after a<br/>"
3826
                                   "mouse up event (pixels/second)");
3827
   evas_object_data_set(win, "ts_acceleration_threshold_slider", sl);
3828
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3829
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3830
   elm_slider_span_size_set(sl, 120);
3831
   elm_slider_unit_format_set(sl, "%1.0f pixels/s");
3832
   elm_slider_indicator_format_set(sl, "%1.0f");
3833
   elm_slider_min_max_set(sl, 10.0, 5000.0);
3834
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_acceleration_threshold_get());
3835
   elm_box_pack_end(bx, sl);
3836
   evas_object_show(sl);
3837

3838
   evas_object_smart_callback_add(sl, "changed", tsat_round, NULL);
3839
   evas_object_smart_callback_add(sl, "delay,changed", tsat_change, NULL);
3840

3841
   /* Thumb scroll acceleration time limit */
3842
   LABEL_FRAME_ADD("<hilight>Thumb scroll acceleration time limit</>");
3843

3844
   sl = elm_slider_add(bx);
3845
   elm_object_tooltip_text_set(sl, "This is the time limit for<br/>"
3846
                                   "accelerating velocity<br/>");
3847
   evas_object_data_set(win, "ts_acceleration_time_limit_slider", sl);
3848
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3849
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3850
   elm_slider_span_size_set(sl, 120);
3851
   elm_slider_unit_format_set(sl, "%1.1f");
3852
   elm_slider_indicator_format_set(sl, "%1.1f");
3853
   elm_slider_min_max_set(sl, 0.0, 15.0);
3854
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_acceleration_time_limit_get());
3855
   elm_box_pack_end(bx, sl);
3856
   evas_object_show(sl);
3857

3858
   evas_object_smart_callback_add(sl, "changed", tsatl_round, NULL);
3859
   evas_object_smart_callback_add(sl, "delay,changed", tsatl_change, NULL);
3860

3861
   /* Thumb scroll acceleration weight */
3862
   LABEL_FRAME_ADD("<hilight>Thumb scroll acceleration weight</>");
3863

3864
   sl = elm_slider_add(bx);
3865
   elm_object_tooltip_text_set(sl, "This is the weight for acceleration");
3866
   evas_object_data_set(win, "ts_acceleration_weight_slider", sl);
3867
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3868
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3869
   elm_slider_span_size_set(sl, 120);
3870
   elm_slider_unit_format_set(sl, "%1.1f");
3871
   elm_slider_indicator_format_set(sl, "%1.1f");
3872
   elm_slider_min_max_set(sl, 1.0, 10.0);
3873
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_acceleration_weight_get());
3874
   elm_box_pack_end(bx, sl);
3875
   evas_object_show(sl);
3876

3877
   evas_object_smart_callback_add(sl, "changed", tsaw_round, NULL);
3878
   evas_object_smart_callback_add(sl, "delay,changed", tsaw_change, NULL);
3879
}
3880

3881
static void
3882
_status_config_scrolling(Evas_Object *win,
3883
                         Evas_Object *naviframe)
3884
{
3885
   Evas_Object *lb, *pd, *box, *bx, *sl, *sc, *ck, *fr;
3886

3887
   box = elm_box_add(win);
3888
   evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, 0.0);
3889
   evas_object_size_hint_align_set(box, EVAS_HINT_FILL, 0.5);
3890

3891
   sc = elm_scroller_add(win);
3892
   elm_scroller_step_size_set(sc, 32, 64 * elm_config_scale_get());
3893
   evas_object_size_hint_weight_set(sc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3894
   evas_object_size_hint_align_set(sc, EVAS_HINT_FILL, EVAS_HINT_FILL);
3895
   elm_scroller_bounce_set(sc, EINA_FALSE, EINA_TRUE);
3896
   evas_object_show(sc);
3897
   elm_object_content_set(sc, box);
3898

3899
   fr = elm_frame_add(box);
3900
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
3901
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3902
   elm_object_text_set(fr, "Acceleration");
3903
   elm_box_pack_end(box, fr);
3904
   evas_object_show(fr);
3905

3906
   bx = elm_box_add(fr);
3907
   elm_object_content_set(fr, bx);
3908
   evas_object_show(bx);
3909

3910
   LABEL_FRAME_ADD("<hilight>Wheel acceleration factor</>");
3911

3912
   sl = elm_slider_add(win);
3913
   elm_object_tooltip_text_set(sl, "This is the factor by which scrolling<br/>"
3914
                                   "increments will be multiplied when scrolling<br/>"
3915
                                   "quickly");
3916
   evas_object_data_set(win, "scroll_accel_factor", sl);
3917
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3918
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3919
   elm_slider_span_size_set(sl, 120);
3920
   elm_slider_unit_format_set(sl, "%1.1f");
3921
   elm_slider_indicator_format_set(sl, "%2.1f");
3922
   elm_slider_min_max_set(sl, 0.0, 10.0);
3923
   elm_slider_value_set(sl, elm_config_scroll_accel_factor_get());
3924
   elm_box_pack_end(bx, sl);
3925
   evas_object_show(sl);
3926

3927
   evas_object_smart_callback_add(sl, "changed", bis_round, NULL);
3928
   evas_object_smart_callback_add(sl, "delay,changed", scroll_accel_factor_change, NULL);
3929

3930
   fr = elm_frame_add(box);
3931
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
3932
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3933
   elm_object_text_set(fr, "Animation");
3934
   elm_box_pack_end(box, fr);
3935
   evas_object_show(fr);
3936

3937
   bx = elm_box_add(fr);
3938
   elm_object_content_set(fr, bx);
3939
   evas_object_show(bx);
3940

3941
   /* Disable Scroll Animation */
3942
   CHECK_ADD("Disable scroll animation",
3943
             "Set whether scrollers should scroll<br/>"
3944
             "immediately instead of animating",
3945
             scroll_animation_disable_change, NULL);
3946
   evas_object_data_set(win, "scroll_animation_disable", ck);
3947
   elm_check_state_set(ck, elm_config_scroll_animation_disabled_get());
3948

3949
   /* Bounce */
3950
   _status_config_scrolling_bounce(win, box);
3951

3952
   _status_config_scrolling_thumb(win, box);
3953

3954
   /* Acceleration */
3955
   _status_config_scrolling_acceleration(win, box);
3956

3957
   fr = elm_frame_add(box);
3958
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
3959
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
3960
   elm_object_text_set(fr, "Friction");
3961
   elm_box_pack_end(box, fr);
3962
   evas_object_show(fr);
3963

3964
   bx = elm_box_add(fr);
3965
   elm_object_content_set(fr, bx);
3966
   evas_object_show(bx);
3967
   /* Page scroll friction */
3968
   LABEL_FRAME_ADD("<hilight>Page scroll friction</>");
3969

3970
   sl = elm_slider_add(win);
3971
   elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br/>"
3972
                                   "paged scroller will impose at<br/>"
3973
                                   "page fitting animations");
3974
   evas_object_data_set(win, "page_scroll_friction_slider", sl);
3975
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3976
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3977
   elm_slider_span_size_set(sl, 120);
3978
   elm_slider_unit_format_set(sl, "%1.1f");
3979
   elm_slider_indicator_format_set(sl, "%1.1f");
3980
   elm_slider_min_max_set(sl, 0.0, 5.0);
3981
   elm_slider_value_set(sl, elm_config_scroll_page_scroll_friction_get());
3982
   elm_box_pack_end(bx, sl);
3983
   evas_object_show(sl);
3984

3985
   evas_object_smart_callback_add(sl, "changed", ps_round, NULL);
3986
   evas_object_smart_callback_add(sl, "delay,changed", ps_change, NULL);
3987

3988
   /* Bring in scroll friction */
3989
   LABEL_FRAME_ADD("<hilight>Bring in scroll friction</>");
3990

3991
   sl = elm_slider_add(win);
3992
   elm_object_tooltip_text_set(sl, "This is the amount of inertia a<br/>"
3993
                                   "scroller will impose at region bring<br/>"
3994
                                   "animations");
3995
   evas_object_data_set(win, "bring_in_scroll_friction_slider", sl);
3996
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
3997
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
3998
   elm_slider_span_size_set(sl, 120);
3999
   elm_slider_unit_format_set(sl, "%1.1f");
4000
   elm_slider_indicator_format_set(sl, "%1.1f");
4001
   elm_slider_min_max_set(sl, 0.0, 5.0);
4002
   elm_slider_value_set(sl, elm_config_scroll_bring_in_scroll_friction_get());
4003
   elm_box_pack_end(bx, sl);
4004
   evas_object_show(sl);
4005

4006
   evas_object_smart_callback_add(sl, "changed", bis_round, NULL);
4007
   evas_object_smart_callback_add(sl, "delay,changed", bis_change, NULL);
4008

4009
   /* Zoom scroll friction */
4010
   LABEL_FRAME_ADD("<hilight>Zoom scroll friction</>");
4011

4012
   sl = elm_slider_add(win);
4013
   elm_object_tooltip_text_set(sl, "This is the amount of inertia<br/>"
4014
                                   "scrollers will impose at animations<br/>"
4015
                                   "triggered by Elementary widgets'<br/>"
4016
                                   "zooming API");
4017
   evas_object_data_set(win, "zoom_scroll_friction_slider", sl);
4018
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4019
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4020
   elm_slider_span_size_set(sl, 120);
4021
   elm_slider_unit_format_set(sl, "%1.1f");
4022
   elm_slider_indicator_format_set(sl, "%1.1f");
4023
   elm_slider_min_max_set(sl, 0.0, 5.0);
4024
   elm_slider_value_set(sl, elm_config_scroll_zoom_friction_get());
4025
   elm_box_pack_end(bx, sl);
4026
   evas_object_show(sl);
4027

4028
   evas_object_smart_callback_add(sl, "changed", zf_round, NULL);
4029
   evas_object_smart_callback_add(sl, "delay,changed", zf_change, NULL);
4030

4031
   fr = elm_frame_add(box);
4032
   evas_object_size_hint_weight_set(fr, EVAS_HINT_EXPAND, 0.0);
4033
   evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
4034
   elm_object_text_set(fr, "Smooth Start");
4035
   elm_box_pack_end(box, fr);
4036
   evas_object_show(fr);
4037

4038
   bx = elm_box_add(fr);
4039
   elm_object_content_set(fr, bx);
4040
   evas_object_show(bx);
4041
   CHECK_ADD("Enable smooth start",
4042
             "Set whether scrollers start smoothly on thumb<br/>"
4043
             "scroll",
4044
             ss_change, NULL);
4045
   evas_object_data_set(win, "scroll_smooth_start", ck);
4046
   elm_check_state_set(ck, elm_config_scroll_thumbscroll_smooth_start_get());
4047

4048
   /* Scroll Smooth Amount */
4049
   LABEL_FRAME_ADD("<hilight>Scroll Smooth Amount</>");
4050

4051
   sl = elm_slider_add(win);
4052
   elm_object_tooltip_text_set(sl, "This is the amount smoothing to apply<br/>"
4053
                                   "to thumbscroll to avoid jerky input");
4054
   evas_object_data_set(win, "scroll_smooth_amount", sl);
4055
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4056
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4057
   elm_slider_span_size_set(sl, 120);
4058
   elm_slider_unit_format_set(sl, "%1.2f");
4059
   elm_slider_indicator_format_set(sl, "%1.2f");
4060
   elm_slider_min_max_set(sl, 0.0, 1.0);
4061
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_smooth_amount_get());
4062
   elm_box_pack_end(bx, sl);
4063
   evas_object_show(sl);
4064

4065
   evas_object_smart_callback_add(sl, "changed", smooth_round, NULL);
4066
   evas_object_smart_callback_add(sl, "delay,changed", smooth_change, NULL);
4067

4068
   /* Scroll Smooth Time Window */
4069
   LABEL_FRAME_ADD("<hilight>Scroll Smooth Time Window</>");
4070

4071
   sl = elm_slider_add(win);
4072
   elm_object_tooltip_text_set(sl, "This is the window of time to look back<br/>"
4073
                                   "into for smoothing of thumbscroll");
4074
   evas_object_data_set(win, "scroll_smooth_time_window", sl);
4075
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4076
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4077
   elm_slider_span_size_set(sl, 120);
4078
   elm_slider_unit_format_set(sl, "%1.2f");
4079
   elm_slider_indicator_format_set(sl, "%1.2f");
4080
   elm_slider_min_max_set(sl, 0.0, 1.0);
4081
   elm_slider_value_set(sl, elm_config_scroll_thumbscroll_smooth_time_window_get());
4082
   elm_box_pack_end(bx, sl);
4083
   evas_object_show(sl);
4084

4085
   evas_object_smart_callback_add(sl, "changed", smooth_win_round, NULL);
4086
   evas_object_smart_callback_add(sl, "delay,changed", smooth_win_change, NULL);
4087

4088

4089
   evas_object_data_set(win, "scrolling", bx);
4090

4091
   elm_naviframe_item_simple_push(naviframe, bx);
4092
}
4093

4094
static void
4095
_cb_accel(void *data, Evas_Object *obj EINA_UNUSED, void *info EINA_UNUSED)
4096
{
4097
   const char *val = data;
4098
   const char *ss = elm_config_accel_preference_get();
4099

4100
   if ((!ss) || (strcasecmp(ss, val)))
4101
     {
4102
        elm_config_accel_preference_set(val);
4103
        elm_config_all_flush();
4104
     }
4105
}
4106

4107
static void
4108
_cb_accel_override(void *data EINA_UNUSED, Evas_Object *obj, void *info EINA_UNUSED)
4109
{
4110
   Eina_Bool val = elm_check_state_get(obj);
4111
   Eina_Bool sb = elm_config_accel_preference_override_get();
4112

4113
   if (val != sb)
4114
     {
4115
        elm_config_accel_preference_override_set(val);
4116
        elm_config_all_flush();
4117
     }
4118
}
4119

4120
static void
4121
_cb_vsync(void *data EINA_UNUSED, Evas_Object *obj, void *info EINA_UNUSED)
4122
{
4123
   Eina_Bool val = elm_check_state_get(obj);
4124
   Eina_Bool sb = elm_config_vsync_get();
4125

4126
   if (val != sb)
4127
     {
4128
        elm_config_vsync_set(val);
4129
        elm_config_all_flush();
4130
     }
4131
}
4132

4133
static void
4134
_cb_withdrawn(void *data EINA_UNUSED, Evas_Object *obj, void *info EINA_UNUSED)
4135
{
4136
   Eina_Bool val = elm_check_state_get(obj);
4137
   Eina_Bool sb = elm_config_agressive_withdrawn_get();
4138

4139
   if (val != sb)
4140
     {
4141
        elm_config_agressive_withdrawn_set(val);
4142
        elm_config_all_flush();
4143
     }
4144
}
4145

4146
static void
4147
_status_config_rendering(Evas_Object *win,
4148
                         Evas_Object *naviframe)
4149
{
4150
   Evas_Object *li, *bx, *ck, *sp;
4151
   Elm_Object_Item *it;
4152

4153
   bx = elm_box_add(win);
4154
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
4155
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
4156

4157
   li = elm_list_add(win);
4158
   evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
4159
   evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
4160
   elm_box_pack_end(bx, li);
4161
   evas_object_show(li);
4162

4163
   it = elm_list_item_append(li, "No Acceleration", NULL, NULL,
4164
                             _cb_accel, "none");
4165
   if (!elm_config_accel_preference_get() ||
4166
       (!strcasecmp(elm_config_accel_preference_get(), "none")))
4167
     elm_list_item_selected_set(it, EINA_TRUE);
4168

4169
   it = elm_list_item_append(li, "OpenGL / OpenGL-ES", NULL, NULL,
4170
                             _cb_accel, "gl");
4171
   if (elm_config_accel_preference_get() &&
4172
       ((!strcasecmp(elm_config_accel_preference_get(), "gl")) ||
4173
        (!strcasecmp(elm_config_accel_preference_get(), "opengl"))))
4174
     elm_list_item_selected_set(it, EINA_TRUE);
4175

4176
   it = elm_list_item_append(li, "3D (any 3D hardware)", NULL, NULL,
4177
                             _cb_accel, "3d");
4178
   if (elm_config_accel_preference_get() &&
4179
       (!strcasecmp(elm_config_accel_preference_get(), "3d")))
4180
     elm_list_item_selected_set(it, EINA_TRUE);
4181

4182
   it = elm_list_item_append(li, "Hardware (any hardware)", NULL, NULL,
4183
                             _cb_accel, "hw");
4184
   if (elm_config_accel_preference_get() &&
4185
       ((!strcasecmp(elm_config_accel_preference_get(), "hw")) ||
4186
        (!strcasecmp(elm_config_accel_preference_get(), "hardware")) ||
4187
        (!strcasecmp(elm_config_accel_preference_get(), "accel"))))
4188
     elm_list_item_selected_set(it, EINA_TRUE);
4189

4190
   elm_list_go(li);
4191

4192
   CHECK_ADD("Override Preferred Acceleration",
4193
             "Force any application requesting<br>"
4194
             "acceleration to use the system<br>"
4195
             "configured acceleration as above",
4196
             _cb_accel_override, NULL);
4197
   elm_check_state_set(ck, elm_config_accel_preference_override_get());
4198

4199
   /////////////////////////////////////////////
4200
   sp = elm_separator_add(win);
4201
   elm_separator_horizontal_set(sp, EINA_TRUE);
4202
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
4203
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
4204
   elm_box_pack_end(bx, sp);
4205
   evas_object_show(sp);
4206

4207
   CHECK_ADD("Tear-free rendering (VSync)",
4208
             "This enables Vsync hints for some<br>"
4209
             "rendering engines to try keep display<br>"
4210
             "VSynced and from Tearing",
4211
             _cb_vsync, NULL);
4212
   elm_check_state_set(ck, elm_config_vsync_get());
4213

4214
   CHECK_ADD("Aggressive withdrawn",
4215
             "When the application is iconified it will<br>"
4216
             "drop its ressource and switch to a paused state<br>"
4217
             "if the application handle that lifecycle state.",
4218
             _cb_withdrawn, NULL);
4219
   elm_check_state_set(ck, elm_config_agressive_withdrawn_get());
4220

4221
   evas_object_data_set(win, "rendering", bx);
4222
   elm_naviframe_item_simple_push(naviframe, bx);
4223
}
4224

4225
static void
4226
_status_config_caches(Evas_Object *win,
4227
                      Evas_Object *naviframe)
4228
{
4229
   Evas_Object *lb, *pd, *bx, *sl, *sp, *ck;
4230

4231
   bx = elm_box_add(win);
4232
   evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
4233
   evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.5);
4234

4235
   LABEL_FRAME_ADD("<hilight>Cache Flush Interval (8 ticks per second)</>");
4236

4237
   sl = elm_slider_add(win);
4238
   evas_object_data_set(win, "cache_flush_interval_slider", sl);
4239
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4240
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4241
   elm_slider_span_size_set(sl, 120);
4242
   elm_slider_unit_format_set(sl, "%1.0f ticks");
4243
   elm_slider_indicator_format_set(sl, "%1.0f");
4244
   elm_slider_min_max_set(sl, 8.0, 4096.0);
4245
   elm_slider_value_set(sl, elm_config_cache_flush_interval_get());
4246
   elm_object_disabled_set(sl, !elm_config_cache_flush_enabled_get());
4247

4248
   CHECK_ADD("Enable Flushing", "Enable Flushing", cf_enable, sl);
4249
   elm_check_state_set(ck, elm_config_cache_flush_enabled_get());
4250

4251
   elm_box_pack_end(bx, sl);
4252
   evas_object_show(sl);
4253

4254
   evas_object_smart_callback_add(sl, "changed", cf_round, NULL);
4255
   evas_object_smart_callback_add(sl, "delay,changed", cf_change, NULL);
4256

4257
   sp = elm_separator_add(win);
4258
   elm_separator_horizontal_set(sp, EINA_TRUE);
4259
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
4260
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
4261
   elm_box_pack_end(bx, sp);
4262
   evas_object_show(sp);
4263

4264
   LABEL_FRAME_ADD("<hilight>Font Cache Size</>");
4265

4266
   sl = elm_slider_add(win);
4267
   evas_object_data_set(win, "font_cache_slider", sl);
4268
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4269
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4270
   elm_slider_span_size_set(sl, 120);
4271
   elm_slider_unit_format_set(sl, "%1.1f MiB");
4272
   elm_slider_indicator_format_set(sl, "%1.1f");
4273
   elm_slider_min_max_set(sl, 0.0, 4.0);
4274
   elm_slider_value_set(sl, (double)elm_config_cache_font_cache_size_get() / 1024.0);
4275
   elm_box_pack_end(bx, sl);
4276
   evas_object_show(sl);
4277

4278
   evas_object_smart_callback_add(sl, "changed", fc_round, NULL);
4279
   evas_object_smart_callback_add(sl, "delay,changed", fc_change, NULL);
4280

4281
   sp = elm_separator_add(win);
4282
   elm_separator_horizontal_set(sp, EINA_TRUE);
4283
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
4284
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
4285
   elm_box_pack_end(bx, sp);
4286
   evas_object_show(sp);
4287

4288
   LABEL_FRAME_ADD("<hilight>Image Cache Size</>");
4289

4290
   sl = elm_slider_add(win);
4291
   evas_object_data_set(win, "image_cache_slider", sl);
4292
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4293
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4294
   elm_slider_span_size_set(sl, 120);
4295
   elm_slider_unit_format_set(sl, "%1.0f MiB");
4296
   elm_slider_indicator_format_set(sl, "%1.0f");
4297
   elm_slider_min_max_set(sl, 0, 512);
4298
   elm_slider_value_set(sl, (double)elm_config_cache_image_cache_size_get() / 1024.0);
4299
   elm_box_pack_end(bx, sl);
4300
   evas_object_show(sl);
4301

4302
   evas_object_smart_callback_add(sl, "changed", ic_round, NULL);
4303
   evas_object_smart_callback_add(sl, "delay,changed", ic_change, NULL);
4304

4305
   sp = elm_separator_add(win);
4306
   elm_separator_horizontal_set(sp, EINA_TRUE);
4307
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
4308
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
4309
   elm_box_pack_end(bx, sp);
4310
   evas_object_show(sp);
4311

4312
   LABEL_FRAME_ADD("<hilight>Number of Edje Files to Cache</>");
4313

4314
   sl = elm_slider_add(win);
4315
   evas_object_data_set(win, "edje_file_cache_slider", sl);
4316
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4317
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4318
   elm_slider_span_size_set(sl, 120);
4319
   elm_slider_unit_format_set(sl, "%1.0f files");
4320
   elm_slider_indicator_format_set(sl, "%1.0f");
4321
   elm_slider_min_max_set(sl, 0, 32);
4322
   elm_slider_value_set(sl, elm_config_cache_edje_file_cache_size_get());
4323
   elm_box_pack_end(bx, sl);
4324
   evas_object_show(sl);
4325

4326
   evas_object_smart_callback_add(sl, "changed", efc_round, NULL);
4327
   evas_object_smart_callback_add(sl, "delay,changed", efc_change, NULL);
4328

4329
   sp = elm_separator_add(win);
4330
   elm_separator_horizontal_set(sp, EINA_TRUE);
4331
   evas_object_size_hint_weight_set(sp, EVAS_HINT_EXPAND, 0.0);
4332
   evas_object_size_hint_align_set(sp, EVAS_HINT_FILL, 0.5);
4333
   elm_box_pack_end(bx, sp);
4334
   evas_object_show(sp);
4335

4336
   LABEL_FRAME_ADD("<hilight>Number of Edje Collections to Cache</>");
4337

4338
   sl = elm_slider_add(win);
4339
   evas_object_data_set(win, "edje_collection_cache_slider", sl);
4340
   evas_object_size_hint_weight_set(sl, EVAS_HINT_EXPAND, 0.0);
4341
   evas_object_size_hint_align_set(sl, EVAS_HINT_FILL, 0.5);
4342
   elm_slider_span_size_set(sl, 120);
4343
   elm_slider_unit_format_set(sl, "%1.0f collections");
4344
   elm_slider_indicator_format_set(sl, "%1.0f");
4345
   elm_slider_min_max_set(sl, 0, 128);
4346
   elm_slider_value_set(sl, elm_config_cache_edje_collection_cache_size_get());
4347
   elm_box_pack_end(bx, sl);
4348
   evas_object_show(sl);
4349

4350
   evas_object_smart_callback_add(sl, "changed", ecc_round, NULL);
4351
   evas_object_smart_callback_add(sl, "delay,changed", ecc_change, NULL);
4352

4353
   evas_object_data_set(win, "caches", bx);
4354

4355
   elm_naviframe_item_simple_push(naviframe, bx);
4356
}
4357

4358
static void
4359
_status_config_full(Evas_Object *win,
4360
                    Evas_Object *bx0)
4361
{
4362
   Evas_Object *tb, *naviframe;
4363
   Elm_Object_Item *tb_it;
4364

4365
   tb = elm_toolbar_add(win);
4366
   elm_toolbar_select_mode_set(tb, ELM_OBJECT_SELECT_MODE_ALWAYS);
4367
   elm_toolbar_menu_parent_set(tb, win);
4368
   elm_toolbar_homogeneous_set(tb, EINA_FALSE);
4369
   evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, 0.0);
4370
   evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
4371

4372
   tb_it = elm_toolbar_item_append(tb, "preferences-scale",
4373
                                   "Sizing", _cf_sizing, win);
4374
   elm_toolbar_item_append(tb, "preferences-desktop-theme",
4375
                           "Theme", _cf_themes, win);
4376
   elm_toolbar_item_append(tb, "preferences-icons",
4377
                           "Icons", _cf_icons, win);
4378
   elm_toolbar_item_append(tb, "preferences-fonts",
4379
                           "Fonts", _cf_fonts, win);
4380
   elm_toolbar_item_append(tb, "preferences-color",
4381
                           "Colors", _cf_colors, win);
4382
   elm_toolbar_item_append(tb, "preferences-desktop-multimedia",
4383
                           "Audio", _cf_audio, win);
4384
   elm_toolbar_item_append(tb, "preferences-profile",
4385
                           "Profiles", _cf_profiles, win);
4386
   elm_toolbar_item_append(tb, "system-run", 
4387
                           "Scrolling", _cf_scrolling, win);
4388
   elm_toolbar_item_append(tb, "preferences-desktop", 
4389
                           "Rendering", _cf_rendering, win);
4390
   elm_toolbar_item_append(tb, "appointment-new", 
4391
                           "Caches", _cf_caches, win);
4392
   elm_toolbar_item_append(tb, "magnifying-glass", 
4393
                           "Focus", _cf_focus, win);
4394
   elm_toolbar_item_append(tb, "preferences-etc", 
4395
                           "Etc", _cf_etc, win);
4396

4397
   elm_box_pack_end(bx0, tb);
4398
   evas_object_show(tb);
4399

4400
   naviframe = elm_naviframe_add(win);
4401
   evas_object_size_hint_align_set(naviframe, EVAS_HINT_FILL, EVAS_HINT_FILL);
4402
   evas_object_size_hint_weight_set(naviframe, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
4403
   evas_object_data_set(win, "naviframe", naviframe);
4404

4405
   _status_config_themes(win, naviframe);
4406
   _status_config_icons(win, naviframe);
4407
   _status_config_fonts(win, naviframe);
4408
   _status_config_colors(win, naviframe);
4409
   _status_config_profiles(win, naviframe);
4410
   _status_config_rendering(win, naviframe);
4411
   _status_config_scrolling(win, naviframe);
4412
   _status_config_caches(win, naviframe);
4413
   _status_config_audio(win, naviframe);
4414
   _status_config_focus(win, naviframe);
4415
   _status_config_etc(win, naviframe);
4416
   _status_config_sizing(win, naviframe); // Note: call this at the end.
4417

4418
   // FIXME uncomment after flip style fix, please
4419
   //elm_object_style_set(naviframe, "flip");
4420
   elm_toolbar_item_selected_set(tb_it, EINA_TRUE);
4421
   elm_box_pack_end(bx0, naviframe);
4422
   evas_object_show(naviframe);
4423
}
4424

4425
static void
4426
win_create(void)
4427
{
4428
   Evas_Object *win, *bx0;
4429

4430
   win = elm_win_util_standard_add("main", "Elementary Config");
4431
   if (!win) exit(1);
4432
   ecore_event_handler_add(ELM_EVENT_CONFIG_ALL_CHANGED, _config_all_changed,
4433
                           win);
4434
   evas_object_smart_callback_add(win, "delete,request", config_exit, NULL);
4435

4436
   bx0 = elm_box_add(win);
4437
   evas_object_size_hint_weight_set(bx0, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
4438
   elm_win_resize_object_add(win, bx0);
4439
   evas_object_show(bx0);
4440

4441
   if (!interactive) _status_basic(win, bx0);
4442
   else if (0)
4443
     _status_config(win, bx0);
4444
   else _status_config_full(win, bx0);
4445

4446
   evas_object_resize(win, 320 * elm_config_scale_get(),
4447
                           480 * elm_config_scale_get());
4448
   evas_object_show(win);
4449
}
4450

4451
static Eina_Bool
4452
_exit_timer(void *data EINA_UNUSED)
4453
{
4454
   efl_exit(0);
4455
   return ECORE_CALLBACK_CANCEL;
4456
}
4457

4458
EAPI_MAIN void
4459
efl_terminate(void *data EINA_UNUSED,
4460
              const Efl_Event *ev EINA_UNUSED)
4461
{
4462
   fprintf(stderr, "Terminating.\n");
4463
}
4464

4465
/* this is your elementary main function - it MUST be called IMMEDIATELY
4466
 * after elm_init() and MUST be passed argc and argv, and MUST be called
4467
 * elm_main and not be static - must be a visible symbol with EAPI infront */
4468
EAPI_MAIN void
4469
efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
4470
{
4471
   Efl_Loop_Arguments *arge = ev->info;
4472
   char               *arg;
4473
   Eina_Array_Iterator iterator;
4474
   unsigned int        i;
4475

4476
   EINA_ARRAY_ITER_NEXT(arge->argv, i, arg, iterator)
4477
     {
4478
        if (!strcmp(arg, "-h"))
4479
          {
4480
             printf("Usage:\n"
4481
                    "  -h                This help\n"
4482
                    "  -q                Quiet mode (don't show window)\n"
4483
                    "  -t THEME          Set theme to THEME (ELM_THEME spec)\n"
4484
                    "  -f SIZE           Set finger size to SIZE pixels\n"
4485
                    "  -s SCALE          Set scale factor to SCALE\n"
4486
                    "  -w WEB_BACKEND    Set the web backend to be used\n"
4487
                    );
4488
          }
4489
        else if (!strcmp(arg, "-q"))
4490
          {
4491
             quiet = 1;
4492
             interactive = 0;
4493
          }
4494
        else if ((!strcmp(arg, "-t")) && (i < eina_array_count(arge->argv)))
4495
          {
4496
             i++;
4497
             theme_set = eina_array_data_get(arge->argv, i);
4498
             interactive = 0;
4499
          }
4500
        else if ((!strcmp(arg, "-f")) && (i < eina_array_count(arge->argv)))
4501
          {
4502
             i++;
4503
             finger_size_set = eina_array_data_get(arge->argv, i);
4504
             interactive = 0;
4505
          }
4506
        else if ((!strcmp(arg, "-s")) && (i < eina_array_count(arge->argv)))
4507
          {
4508
             i++;
4509
             scale_set = eina_array_data_get(arge->argv, i);
4510
             interactive = 0;
4511
          }
4512
        else if ((!strcmp(arg, "-w")) && (i < eina_array_count(arge->argv)))
4513
          {
4514
             i++;
4515
             web_backend = eina_array_data_get(arge->argv, i);
4516
             interactive = 0;
4517
          }
4518
     }
4519

4520
   /* put here any init code specific to this app like parsing args, etc. */
4521
   if (arge->initialization)
4522
     {
4523
#ifdef ELM_EFREET
4524
        elm_need_efreet();
4525
#endif
4526
        elm_app_info_set(efl_main, "elementary", "images/logo.png");
4527
        elm_app_compile_bin_dir_set(PACKAGE_BIN_DIR);
4528
        elm_app_compile_data_dir_set(PACKAGE_DATA_DIR);
4529
     }
4530

4531
   if (!quiet)
4532
     {
4533
        win_create(); /* create main window */
4534
        if (!interactive)
4535
          ecore_timer_add(2.0, _exit_timer, NULL);
4536
     }
4537
   if (!interactive)
4538
     {
4539
        if (theme_set) elm_theme_set(NULL, theme_set);
4540
        if (finger_size_set) elm_config_finger_size_set(atoi(finger_size_set));
4541
        if (scale_set) elm_config_scale_set(atof(scale_set));
4542
        if (web_backend) elm_config_web_backend_set(web_backend);
4543

4544
        elm_config_all_flush();
4545

4546
        if (quiet) efl_exit(0);
4547
     }
4548
}
4549

4550
EAPI_MAIN void
4551
efl_resume(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
4552
{
4553
   fprintf(stderr, "Resuming activity.\n");
4554
}
4555

4556
EAPI_MAIN void
4557
efl_pause(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
4558
{
4559
   fprintf(stderr, "Let's take a pause.\n");
4560
   elm_config_all_flush();
4561
}
4562

4563
/* All elementary apps should use this. Put it right after elm_main() */
4564
EFL_MAIN_EX()
4565