src/setting-display.c

   1 /*
   2  *  Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  *  Licensed under the Flora License, Version 1.0 (the License);
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://floralicense.org/license/
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an AS IS BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  */
  17 /*
  18  * setting-display.c
  19  *
  20  *  Created on: Oct 9, 2013
  21  *      Author: min-hoyun
  22  */
  23
  24 #include <device.h>
  25 #include <system_settings.h>
  26 #include <vconf.h>
  27 #include <vconf-keys.h>
  28 #include <libxml/xmlmemory.h>
  29 #include <libxml/parser.h>
  30 #include <fontconfig/fontconfig.h>
  31
  32 #include "setting_data_vconf.h"
  33 #include "setting-display.h"
  34 #include "setting_view_toast.h"
  35 #include "setting-language.h"
  36 #include "setting-homescreen.h"
  37 #include "setting-motion.h"
  38 #include "util.h"
  39
  40 static struct _display_menu_item display_menu_its[] = {
  41         { "IDS_ST_MBODY_SCREEN_TIMEOUT_ABB",    SETTING_DISPLAY_SCREEN_TIME,    _display_gl_screen_timeout_cb, 0        },
  42         { "IDS_ST_BODY_FONT",                                   SETTING_DISPLAY_FONT,   _display_gl_font_cb, 0          },
  43         { "IDS_ST_BUTTON_LANGUAGE",                             SETTING_DISPLAY_LANG,   _display_gl_language_cb, 0              },
  44         { "IDS_ST_MBODY_ALWAYS_ON_ABB",                                                 SETTING_DISPLAY_AMBIENT_MODE, _display_ambient_mode_cb, 0       },
  45 #if !defined(FEATURE_SETTING_SDK) && !defined(FEATURE_SETTING_EMUL)
  46         { "IDS_ST_MBODY_MANAGE_APPS_ABB",       SETTING_DISPLAY_EDIT_APPS,      _homescreen_gl_edit_apps_cb, 0  },
  47 #endif
  48 };
  49
  50 static struct _font_menu_item font_menu_its[] = {
  51         { "IDS_ST_BODY_FONT_STYLE",             SETTING_DISPLAY_FONT_STYLE, _display_gl_font_style_cb },
  52         { "IDS_ST_BODY_FONT_SIZE_ABB",          SETTING_DISPLAY_FONT_SIZE,      _display_gl_font_size_cb },
  53 };
  54
  55 static int screen_time_str[] = {
  56         10, 15, 30, 1, 5
  57 };
  58 static int timeout_arr[] = {
  59         10, 15, 30, 60, 300
  60 };
  61
  62 static char *font_size_str[] = {
  63         "IDS_EMAIL_OPT_SMALL_M_FONT_SIZE",
  64         "IDS_ST_OPT_MEDIUM_M_FONT_SIZE",
  65         "IDS_ST_BODY_LARGE_M_FONT_SIZE_ABB2"
  66 };
  67
  68 static char *rotate_screen_str[] = {
  69         "IDS_COM_BODY_DEFAULT", "IDS_COM_OPT_ROTATE_CW", "IDS_COM_OPT_ROTATE_CCW", "IDS_ST_SBODY_180_DEGREE"
  70 };
  71
  72 static appdata *temp_ad = NULL;
  73 static Evas_Object *g_display_genlist = NULL;
  74 static Evas_Object *g_screen_time_genlist = NULL;
  75 static Evas_Object *g_font_size_genlist = NULL;
  76 static Evas_Object *g_font_style_genlist = NULL;
  77 static Evas_Object *g_rotate_screen_genlist = NULL;
  78
  79 static int screen_time_index = 1;               /* default: 10 seconds */
  80 static int font_size_index   = 1;               /* default: normal */
  81 static int rotate_screen_rot  = 0;              /* default: 0(0degree), vconf enum */
  82 static int rotate_screen_index  = 0;            /* default: 0, list index */
  83
  84 static int touch_mode = NONE;
  85
  86 /* Main display list item */
  87 static Elm_Object_Item *lang_item = NULL;
  88 static Elm_Object_Item *wake_up_item = NULL;
  89 static Elm_Object_Item *edit_icon_item = NULL;
  90 static Elm_Object_Item *screen_time_item = NULL;
  91 static Elm_Object_Item *ambient_mode_item = NULL;
  92
  93 /* Font list item */
  94 static char *font_name = NULL;
  95
  96 static Elm_Object_Item *font_style_item = NULL;
  97 static Elm_Object_Item *font_size_item = NULL;
  98
  99 static void _font_size_gl_cb(void *data, Evas_Object *obj, void *event_info);
 100 static void _font_style_gl_cb(void *data, Evas_Object *obj, void *event_info);
 101 static Eina_Bool setting_font_style_pop_cb(void *data, Elm_Object_Item *it);
 102 static void settings_font_style_changed_cb(system_settings_key_e key, void *user_data);
 103 static void change_language_enabling(keynode_t *key, void *data);
 104 static void change_screen_time_cb(keynode_t *key, void *data);
 105 static void change_language_cb(keynode_t *key, void *data);
 106 static Eina_Bool setting_font_list_pop_cb(void *data, Elm_Object_Item *it);
 107 static void _lang_update_font_style_list(void *data, Evas_Object *obj, void *event_info);
 108
 109
 110
 111 void _init_display()
 112 {
 113         register_vconf_changing(VCONFKEY_WMS_WMANAGER_CONNECTED, change_language_enabling, NULL);
 114         register_vconf_changing(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, change_screen_time_cb, NULL);
 115         register_vconf_changing(VCONFKEY_LANGSET, change_language_cb, NULL);
 116
 117         /*_init_screen_rotate(); */
 118 }
 119
 120 void _init_screen_rotate()
 121 {
 122         int rotate;
 123         rotate = _get_rotate_screen();
 124         rotate_screen_rot = rotate;
 125
 126         if (rotate == SETTING_SCREENROTATION_90_DEGREE) {
 127                 /*90R */
 128                 rotate_screen_index = 1;
 129         } else if (rotate == SETTING_SCREENROTATION_270_DEGREE) {
 130                 /*90L */
 131                 rotate_screen_index = 2;
 132         } else if (rotate == SETTING_SCREENROTATION_180_DEGREE) {
 133                 /*180 */
 134                 rotate_screen_index = 3;
 135         }
 136
 137         if (rotate == -1) {
 138                 rotate_screen_rot = SETTING_SCREENROTATION_0_DEGREE;
 139         }
 140 }
 141
 142 void _update_menu_text_when_lang_changed()
 143 {
 144         DBG("Setting - Language is changed...update display list");
 145
 146         if (g_display_genlist) {
 147                 elm_genlist_realized_items_update(g_display_genlist);
 148         }
 149
 150         if (temp_ad && temp_ad->main_genlist) {
 151                 elm_genlist_realized_items_update(temp_ad->main_genlist);
 152         }
 153 }
 154
 155 Eina_Bool _clear_display_cb(void *data, Elm_Object_Item *it)
 156 {
 157         temp_ad = NULL;
 158         g_screen_time_genlist = NULL;
 159         g_font_size_genlist = NULL;
 160         g_font_style_genlist = NULL;
 161         g_rotate_screen_genlist = NULL;
 162
 163         touch_mode = NONE;
 164
 165         unregister_vconf_changing(VCONFKEY_WMS_WMANAGER_CONNECTED, change_language_enabling);
 166         unregister_vconf_changing(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, change_screen_time_cb);
 167         unregister_vconf_changing(VCONFKEY_LANGSET, change_language_cb);
 168
 169         return EINA_TRUE;
 170 }
 171
 172 void _display_gl_font_cb(void *data, Evas_Object *obj, void *event_info)
 173 {
 174         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 175
 176         if (data != NULL) {
 177                 _show_font_list(data);
 178         } else {
 179                 DBG("ad->font_name is NULL !!!!!!");
 180         }
 181 }
 182
 183 void _display_gl_font_style_cb(void *data, Evas_Object *obj, void *event_info)
 184 {
 185         DBG("_display_gl_font_style_cb");
 186
 187         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 188
 189         if (data != NULL) {
 190                 _show_font_style_list(data);
 191         }
 192 }
 193
 194 void _display_gl_font_size_cb(void *data, Evas_Object *obj, void *event_info)
 195 {
 196         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 197
 198         if (data != NULL) {
 199                 _show_font_size_list(data);
 200         }
 201 }
 202
 203 void _display_gl_rotate_screen_cb(void *data, Evas_Object *obj, void *event_info)
 204 {
 205         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 206
 207         if (data != NULL) {
 208                 _show_rotate_screen_list(data);
 209         }
 210 }
 211
 212 void _display_gl_screen_timeout_cb(void *data, Evas_Object *obj, void *event_info)
 213 {
 214         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 215
 216         if (data != NULL) {
 217                 _show_screen_timeout_list(data);
 218         }
 219 }
 220
 221 void _display_gl_language_cb(void *data, Evas_Object *obj, void *event_info)
 222 {
 223         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 224
 225         Evas_Object *genlist = NULL;
 226         Elm_Object_Item *nf_it = NULL;
 227         appdata *ad = data;
 228
 229         if (ad == NULL) {
 230                 DBG("Setting - ad is null");
 231                 return;
 232         }
 233
 234         if (ad->MENU_TYPE == SETTING_LANGUAGE) {
 235                 DBG("Already language screen enter:clear");
 236                 return;
 237         }
 238
 239         if (is_connected_GM()) {
 240                 DBG("Setting - language can not change!!");
 241
 242                 /* automatic freed!! */
 243                 struct _toast_data *toast = _create_toast(ad, _("IDS_ST_TPOP_CHANGE_LANGUAGE_ON_MOBILE_DEVICE"));
 244                 if (toast) {
 245                         _show_toast(ad, toast);
 246                 }
 247                 return;
 248         }
 249
 250         ad->MENU_TYPE = SETTING_LANGUAGE;
 251
 252         _initialize_language(ad);
 253         _set_launguage_update_cb(_update_menu_text_when_lang_changed);
 254
 255         genlist = _create_lang_list(data);
 256         if (genlist == NULL) {
 257                 DBG("%s", "language cb - genlist is null");
 258                 return;
 259         }
 260         nf_it = elm_naviframe_item_push(ad->nf, "IDS_ST_BUTTON_LANGUAGE", NULL, NULL, genlist, NULL);
 261         evas_object_event_callback_add(genlist, EVAS_CALLBACK_DEL, _clear_lang_cb, ad);
 262 #if !defined(FEATURE_SETTING_TELEPHONY)
 263         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
 264 #endif
 265         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
 266
 267         ad->MENU_TYPE = SETTING_LANGUAGE;
 268 }
 269
 270 Evas_Object *_gl_display_check_get(void *data, Evas_Object *obj, const char *part)
 271 {
 272         Evas_Object *check = NULL;
 273
 274         Display_Item_Data *id = data;
 275         int index = id->index;
 276
 277         if (!strcmp(part, "elm.icon")) {
 278                 check = elm_check_add(obj);
 279
 280                 if (vconf_get_bool(VCONFKEY_SETAPPL_AMBIENT_MODE_BOOL, &display_menu_its[0].is_enable_ambient_mode) < 0) {
 281                         display_menu_its[0].is_enable_ambient_mode = AMBIENT_MODE_ENABLE;   /*  default value of ambient mode: off */
 282                 }
 283                 elm_check_state_set(check, (display_menu_its[0].is_enable_ambient_mode) ? EINA_TRUE : EINA_FALSE);
 284                 evas_object_smart_callback_add(check, "changed", _display_ambient_mode_cb, (void *)1);
 285                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 286                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 287                 evas_object_propagate_events_set(check, EINA_FALSE);
 288
 289                 id->check = check;
 290
 291                 index++;
 292         }
 293
 294         return check;
 295 }
 296
 297
 298 char *_gl_display_title_get(void *data, Evas_Object *obj, const char *part)
 299 {
 300         char buf[1024] = {0,};
 301         Display_Item_Data *id = data;
 302         int index = id->index;
 303
 304         if (!strcmp(part, "elm.text")) {
 305                 if (id->item == lang_item) {
 306                         if (is_connected_GM()) {
 307                                 snprintf(buf, sizeof(buf) - 1, "<font color=#515151>%s</font>",
 308                                                  _(display_menu_its[index].name));
 309                         } else {
 310                                 snprintf(buf, sizeof(buf) - 1, "%s",
 311                                                  _(display_menu_its[index].name));
 312                         }
 313                         DBG("buf --->%s", buf);
 314                 } else {
 315                         snprintf(buf, sizeof(buf) - 1, "%s", _(display_menu_its[index].name));
 316                         DBG("buf --->%s", buf);
 317                 }
 318         } else if (!strcmp(part, "elm.text.1")) {
 319                 if (id->item == edit_icon_item) {
 320                         char *str = _get_homeview_type_subtitle();
 321                         snprintf(buf, sizeof(buf) - 1, "%s", str);
 322                         DBG("buf --->%s", buf);
 323                         FREE(str);
 324                 } else if (id->item == lang_item) {
 325                         const char *curr_lang = setting_get_lang_title();
 326                         if (curr_lang) {
 327                                 if (is_connected_GM()) {
 328                                         snprintf(buf, sizeof(buf) - 1, "<font color=#515151>%s</font>", curr_lang);
 329                                 } else {
 330                                         snprintf(buf, sizeof(buf) - 1, "%s", curr_lang);
 331                                 }
 332                                 DBG("buf --->%s", buf);
 333                         }
 334                         FREE(curr_lang);
 335                 } else if (id->item == screen_time_item) {
 336                         int time = 10;
 337                         vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, &time);
 338                         switch (time) {
 339                         case 10:
 340                                 snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_10SEC"), screen_time_str[0]);
 341                                 break;
 342                         case 15:
 343                                 snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_15SEC"), screen_time_str[1]);
 344                                 break;
 345                         case 30:
 346                                 snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_30SEC"), screen_time_str[2]);
 347                                 break;
 348                         case 60:
 349                                 snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_1_MINUTE_ABB2"), screen_time_str[3]);
 350                                 break;
 351                         case 300:
 352                                 snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_5_MINUTES"), screen_time_str[4]);
 353                                 break;
 354                         }
 355                         DBG("buf --->%s", buf);
 356                 } else {
 357                         snprintf(buf, sizeof(buf) - 1, "%s", _get_wake_up_gesture_sub_title());
 358                         DBG("buf --->%s", buf);
 359                 }
 360         }
 361         return strdup(buf);
 362 }
 363
 364 void _display_gl_del(void *data, Evas_Object *obj)
 365 {
 366         Display_Item_Data *id = data;
 367         if (id)
 368                 free(id);
 369 }
 370
 371 Evas_Object *_create_display_list(void *data)
 372 {
 373         appdata *ad = data;
 374         if (ad == NULL) {
 375                 DBG("%s", "_create_display_list - appdata is null");
 376                 return NULL;
 377         }
 378         Evas_Object *genlist  = NULL;
 379         struct _display_menu_item *menu_its = NULL;
 380         int idx = 0;
 381
 382         temp_ad = ad;
 383
 384         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 385         itc->item_style = "1text";
 386         itc->func.text_get = _gl_display_title_get;
 387         itc->func.del = _display_gl_del;
 388
 389         Elm_Genlist_Item_Class *itc2 = elm_genlist_item_class_new();
 390         itc2->item_style = "2text";
 391         itc2->func.text_get = _gl_display_title_get;
 392         itc2->func.del = _display_gl_del;
 393
 394         Elm_Genlist_Item_Class *itc_ambient_md = elm_genlist_item_class_new();
 395         itc_ambient_md->item_style = "1text.1icon.1";
 396         itc_ambient_md->func.text_get = _gl_display_title_get;
 397         itc_ambient_md->func.content_get = _gl_display_check_get;
 398         itc_ambient_md->func.del = _display_gl_del;
 399
 400         genlist = elm_genlist_add(ad->nf);
 401         elm_genlist_block_count_set(genlist, 14);
 402         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 403         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 404
 405 #ifdef O_TYPE
 406         Evas_Object *circle_genlist = eext_circle_object_genlist_add(genlist, ad->circle_surface);
 407         eext_circle_object_genlist_scroller_policy_set(circle_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 408         eext_rotary_object_event_activated_set(circle_genlist, EINA_TRUE);
 409 #endif
 410
 411         menu_its = display_menu_its;
 412
 413         int size = sizeof(display_menu_its) / sizeof(struct _display_menu_item);
 414
 415         for (idx = 0; idx < size; idx++) {
 416                 Elm_Genlist_Item_Class *itc_tmp = NULL;
 417
 418                 if (menu_its[idx].type == SETTING_DISPLAY_GESTURE
 419                         || menu_its[idx].type == SETTING_DISPLAY_ICON_SIZE
 420                         || menu_its[idx].type == SETTING_DISPLAY_LANG
 421                         || menu_its[idx].type == SETTING_DISPLAY_SCREEN_TIME) {
 422                         itc_tmp = itc2;
 423                 } else if (menu_its[idx].type == SETTING_DISPLAY_AMBIENT_MODE) {
 424                         itc_tmp = itc_ambient_md;
 425                 } else {
 426                         itc_tmp = itc;
 427                 }
 428
 429                 Display_Item_Data *id = calloc(sizeof(Display_Item_Data), 1);
 430                 if (id) {
 431                         id->index = idx;
 432                         id->item = elm_genlist_item_append(
 433                                                    genlist,             /* genlist object */
 434                                                    itc_tmp,             /* item class */
 435                                                    id,                  /* data */
 436                                                    NULL,
 437                                                    ELM_GENLIST_ITEM_NONE,
 438                                                    menu_its[idx].func,  /* call back */
 439                                                    ad);
 440
 441                         if (menu_its[idx].type == SETTING_DISPLAY_LANG) {
 442                                 lang_item = id->item;
 443                         } else if (menu_its[idx].type == SETTING_DISPLAY_GESTURE) {
 444                                 DBG("wakeup item@!!!");
 445                                 wake_up_item = id->item;
 446                         } else if (menu_its[idx].type == SETTING_DISPLAY_ICON_SIZE) {
 447                                 DBG("edit icon item@!!!");
 448                                 edit_icon_item = id->item;
 449                         } else if (menu_its[idx].type == SETTING_DISPLAY_SCREEN_TIME) {
 450                                 DBG("screen time item@!!!");
 451                                 screen_time_item = id->item;
 452                         } else if (menu_its[idx].type == SETTING_DISPLAY_AMBIENT_MODE) {
 453                                 DBG("ambient mode item@!!!");
 454                                 ambient_mode_item = id->item;
 455                         }
 456                 }
 457         }
 458         elm_genlist_item_class_free(itc);
 459         elm_genlist_item_class_free(itc2);
 460         elm_genlist_item_class_free(itc_ambient_md);
 461
 462         g_display_genlist = genlist;
 463
 464         return genlist;
 465 }
 466
 467 static char *_gl_screen_timeout_title_get(void *data, Evas_Object *obj, const char *part)
 468 {
 469         char buf[1024] = {0,};
 470         Item_Data *id = data;
 471
 472         if (!strcmp(part, "elm.text")) {
 473                 if (id->index == 0) {
 474                         snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_10SEC"), screen_time_str[id->index]);
 475                 } else if (id->index == 1) {
 476                         snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_15SEC"), screen_time_str[id->index]);
 477                 } else if (id->index == 2) {
 478                         snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_30SEC"), screen_time_str[id->index]);
 479                 } else if (id->index == 3) {
 480                         snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_1_MINUTE_ABB2"), screen_time_str[id->index]);
 481                 } else {
 482                         snprintf(buf, sizeof(buf) - 1, _("IDS_ST_BODY_5_MINUTES"), screen_time_str[id->index]);
 483                 }
 484         }
 485         return strdup(buf);
 486 }
 487
 488 static int _get_timeout_index(int seconds)
 489 {
 490         int index;
 491         int length = 0;
 492         length = sizeof(timeout_arr) / sizeof(timeout_arr[0]);
 493
 494         DBG("Setting - timeout_arr's length: %d", length);
 495
 496         for (index = 0; index < length; index++) {
 497                 if (timeout_arr[index] == seconds) {
 498                         DBG("Setting - timeout index : %d, sec : %d", index, timeout_arr[index]);
 499                         break;
 500                 }
 501         }
 502
 503         return index;
 504 }
 505
 506 static void _screen_timeout_gl_cb(void *data, Evas_Object *obj, void *event_info)
 507 {
 508         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 509
 510         screen_time_index = (int)data;
 511
 512         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL , timeout_arr[screen_time_index]);
 513
 514         elm_genlist_realized_items_update(g_screen_time_genlist);
 515
 516         elm_naviframe_item_pop(temp_ad->nf);
 517         if (!temp_ad->screen_timeout_rdg) {
 518                 evas_object_del(temp_ad->screen_timeout_rdg);
 519                 temp_ad->screen_timeout_rdg = NULL;
 520         }
 521 }
 522
 523 static Evas_Object *_gl_screen_timeout_ridio_get(void *data, Evas_Object *obj, const char *part)
 524 {
 525         Evas_Object *radio = NULL;
 526         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
 527         Item_Data *id = data;
 528         static int timeout = -1;
 529
 530         if (!strcmp(part, "elm.icon")) {
 531                 radio = elm_radio_add(obj);
 532                 elm_radio_state_value_set(radio, id->index);
 533                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
 534                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 535                 elm_radio_group_add(radio, radio_main);
 536                 evas_object_smart_callback_add(radio, "changed", _screen_timeout_gl_cb, (void *)id->index);
 537                 evas_object_propagate_events_set(radio, EINA_FALSE);
 538
 539                 if (timeout == -1) {
 540                         vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, &timeout);
 541                         screen_time_index = _get_timeout_index(timeout);
 542                 }
 543
 544                 if (screen_time_index == id->index) {
 545                         elm_radio_value_set(radio_main, screen_time_index);
 546                 }
 547         }
 548         return radio;
 549 }
 550
 551 static void _screen_timeout_gl_del(void *data, Evas_Object *obj)
 552 {
 553         Item_Data *id = data;
 554         if (id)
 555                 free(id);
 556 }
 557
 558 void _show_screen_timeout_list(void *data)
 559 {
 560         appdata *ad = data;
 561         if (ad == NULL) {
 562                 DBG("%s", "_show_screen_timeout_list - appdata is null");
 563                 return;
 564         }
 565         Evas_Object *genlist  = NULL;
 566         Elm_Object_Item *nf_it = NULL;
 567         int idx;
 568
 569         temp_ad = ad;
 570
 571         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 572         itc->item_style = "1text.1icon.1";
 573         itc->func.text_get = _gl_screen_timeout_title_get;
 574         itc->func.content_get = _gl_screen_timeout_ridio_get;
 575         itc->func.del = _screen_timeout_gl_del;
 576
 577         genlist = elm_genlist_add(ad->nf);
 578         elm_genlist_block_count_set(genlist, 14);
 579         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 580         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 581
 582 #ifdef O_TYPE
 583         Evas_Object *circle_genlist = eext_circle_object_genlist_add(genlist, ad->circle_surface);
 584         eext_circle_object_genlist_scroller_policy_set(circle_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 585         eext_rotary_object_event_activated_set(circle_genlist, EINA_TRUE);
 586 #endif
 587
 588         int timeout = 0;
 589         vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, &timeout);
 590         screen_time_index = _get_timeout_index(timeout);
 591
 592         Elm_Object_Item *curr_item = NULL;
 593
 594         for (idx = 0; idx < SCREEN_TIME_COUNT; idx++) {
 595                 Item_Data *id = calloc(sizeof(Item_Data), 1);
 596                 if (id) {
 597                         id->index = idx;
 598                         id->item = elm_genlist_item_append(genlist, itc, id, NULL, ELM_GENLIST_ITEM_NONE, _screen_timeout_gl_cb, (void *)idx);
 599                 }
 600
 601                 if (idx == screen_time_index) {
 602                         curr_item = id->item;
 603                 }
 604         }
 605
 606         ad->screen_timeout_rdg = elm_radio_add(genlist);
 607         elm_radio_state_value_set(ad->screen_timeout_rdg, 6);
 608         elm_radio_value_set(ad->screen_timeout_rdg, screen_time_index);
 609
 610         evas_object_data_set(genlist, "radio_main", ad->screen_timeout_rdg);
 611
 612         if (curr_item) {
 613                 elm_genlist_item_show(curr_item, ELM_GENLIST_ITEM_SCROLLTO_TOP);
 614         }
 615
 616         g_screen_time_genlist = genlist;
 617
 618         elm_genlist_item_class_free(itc);
 619
 620         nf_it = elm_naviframe_item_push(ad->nf, "IDS_ST_MBODY_SCREEN_TIMEOUT_ABB", NULL, NULL, genlist, NULL);
 621 #if !defined(FEATURE_SETTING_TELEPHONY)
 622         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
 623 #endif
 624         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
 625 }
 626
 627 static char *_gl_font_title_get(void *data, Evas_Object *obj, const char *part)
 628 {
 629         char buf[1024] = {0};
 630         Item_Data *id = data;
 631
 632         if (!strcmp(part, "elm.text") || !strcmp(part, "elm.text.1")) {
 633                 snprintf(buf, sizeof(buf) - 1, "%s", _(font_menu_its[id->index].name));
 634         } else if (!strcmp(part, "elm.text.2")) {
 635                 if (id->index == SETTING_DISPLAY_FONT_STYLE) {
 636                         char *font_name = NULL;
 637                         if (system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &font_name)
 638                                 != SYSTEM_SETTINGS_ERROR_NONE) {
 639                                 ERR("failed to call system_setting_get_value_string with err");
 640                         }
 641
 642                         if (font_name) {
 643
 644                                 DBG(" font_name <---------------------- (%s) ", font_name);
 645
 646                                 if (strstr(font_name, "Samsung")) {
 647                                         snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_DEFAULT_FONT"));
 648                                 } else {
 649                                         if (!strcmp(font_name, "Choco cooky")) {
 650                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_LCKSCN_BODY_CHOCO_COOKY_M_FONT"));
 651                                         } else if (!strcmp(font_name, "Cool jazz")) {
 652                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_COOL_JAZZ"));
 653                                         } else if (!strcmp(font_name, "Rosemary")) {
 654                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_FONTSTYLE_ROSEMARY"));
 655                                         } else if (!strcmp(font_name, "Tinkerbell")) {
 656                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_MBODY_TINKERBELL"));
 657                                         } else if (!strcmp(font_name, "Applemint")) {
 658                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_RH_BUTTON2_APPLEMINT_M_FONT"));
 659                                         } else if (!strcmp(font_name, "Kaiti")) {
 660                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_KAITI_M_FONT"));
 661                                         } else if (!strcmp(font_name, "POP")) {
 662                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_POP_JPN_DCM"));
 663                                         } else if (!strcmp(font_name, "UDMincho")) {
 664                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_UDMINCHO_JPN"));
 665                                         } else if (!strcmp(font_name, "UDRGothic")) {
 666                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_UDRGOTHICM_JPN"));
 667                                         } else if (!strcmp(font_name, "TizenSans")) {
 668                                                 snprintf(buf, sizeof(buf) - 1, "%s", _("TizenSans"));
 669                                         } else {
 670                                                 snprintf(buf, sizeof(buf) - 1, "%s", font_name);
 671                                         }
 672                                 }
 673                         } else {
 674                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_UNKNOWN"));
 675                         }
 676                 } else if (id->index == SETTING_DISPLAY_FONT_SIZE) {
 677                         int font_size = -1;
 678                         if (system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &font_size)
 679                                 != SYSTEM_SETTINGS_ERROR_NONE) {
 680                                 DBG("Setting - system_settings_get_value_int() is failed.");
 681                         }
 682
 683                         if (font_size < 0 || font_size > 2) {
 684                                 snprintf(buf, sizeof(buf) - 1, "%s", _("IDS_ST_BODY_UNKNOWN"));
 685                         } else {
 686                                 snprintf(buf, sizeof(buf) - 1, "%s", _(font_size_str[font_size]));
 687                         }
 688                 }
 689         }
 690
 691         return strdup(buf);
 692 }
 693
 694 static char *_gl_font_style_title_get(void *data, Evas_Object *obj, const char *part)
 695 {
 696         char buf[1024];
 697         Font_Style_Item_Data *id = data;
 698
 699         char *pos = id->font_name;
 700         char new_name[256];
 701         int i = 0;
 702         int count = 0;
 703         while (pos && *pos != '\0') {
 704                 if (*pos == ' ') {
 705                         new_name[count] = '\\';
 706                         count++;
 707                         new_name[count] = ' ';
 708                 } else {
 709                         new_name[count] = id->font_name[i];
 710                 }
 711
 712                 count++;
 713                 pos++;
 714                 i++;
 715         }
 716         new_name[count] = '\0';
 717
 718         if (!strcmp(part, "elm.text")) {
 719 #if 0
 720                 if (id->index == 0) {
 721                         snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_DEFAULT_FONT"));
 722                 } else {
 723 #endif
 724
 725                         if (!strcmp(id->font_name, "Choco cooky")) {
 726                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_LCKSCN_BODY_CHOCO_COOKY_M_FONT"));
 727                         } else if (!strcmp(id->font_name, "Cool jazz")) {
 728                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_COOL_JAZZ"));
 729                         } else if (!strcmp(id->font_name, "Rosemary")) {
 730                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_FONTSTYLE_ROSEMARY"));
 731                         } else if (!strcmp(id->font_name, "Tinkerbell")) {
 732                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_MBODY_TINKERBELL"));
 733                         } else if (!strcmp(id->font_name, "Applemint")) {
 734                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_RH_BUTTON2_APPLEMINT_M_FONT"));
 735                         } else if (!strcmp(id->font_name, "Kaiti")) {
 736                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_KAITI_M_FONT"));
 737                         } else if (!strcmp(id->font_name, "POP")) {
 738                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_POP_JPN_DCM"));
 739                         } else if (!strcmp(id->font_name, "UDMincho")) {
 740                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_UDMINCHO_JPN"));
 741                         } else if (!strcmp(id->font_name, "UDRGothic")) {
 742                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, _("IDS_ST_BODY_UDRGOTHICM_JPN"));
 743                         } else {
 744                                 snprintf(buf, sizeof(buf) - 1, "<font=%s>%s</font>", new_name, id->font_name);
 745                         }
 746 #if 0
 747                 }
 748 #endif
 749         }
 750
 751         DBG("font  = %s", buf);
 752         return strdup(buf);
 753 }
 754
 755 static Evas_Object *_gl_font_style_ridio_get(void *data, Evas_Object *obj, const char *part)
 756 {
 757         Evas_Object *radio = NULL;
 758         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
 759         Font_Style_Item_Data *id = data;
 760
 761         if (!strcmp(part, "elm.icon")) {
 762                 radio = elm_radio_add(obj);
 763                 elm_radio_state_value_set(radio, id->index);
 764                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
 765                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 766                 elm_radio_group_add(radio, radio_main);
 767
 768                 evas_object_smart_callback_add(radio, "clicked", _font_style_gl_cb, (void *)id);
 769                 evas_object_propagate_events_set(radio, EINA_FALSE);
 770         }
 771
 772         return radio;
 773 }
 774
 775 static void _font_style_gl_del(void *data, Evas_Object *obj)
 776 {
 777         Font_Style_Item_Data *id = data;
 778         if (id) {
 779                 FREE(id->font_name);
 780                 free(id);
 781         }
 782 }
 783
 784 static char *_gl_font_size_title_get(void *data, Evas_Object *obj, const char *part)
 785 {
 786         int old_font_size = -1;
 787         if (system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &old_font_size)
 788                 != SYSTEM_SETTINGS_ERROR_NONE) {
 789                 DBG("Setting - system_settings_get_value_int() is failed.");
 790         }
 791         char buf[1024] = {0,};
 792         Item_Data *id = data;
 793
 794         if (!strcmp(part, "elm.text")) {
 795                 if (id->index == 0) {
 796                         snprintf(buf, sizeof(buf) - 1, "<font_size=30>%s</font_size>", _(font_size_str[id->index]));
 797                 } else if (id->index == 1) {
 798                         snprintf(buf, sizeof(buf) - 1, "<font_size=38>%s</font_size>", _(font_size_str[id->index]));
 799                 } else {
 800                         snprintf(buf, sizeof(buf) - 1, "<font_size=46>%s</font_size>", _(font_size_str[id->index]));
 801                 }
 802         }
 803         return strdup(buf);
 804 }
 805
 806 static Evas_Object *_gl_font_size_ridio_get(void *data, Evas_Object *obj, const char *part)
 807 {
 808         Evas_Object *radio = NULL;
 809         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
 810         Item_Data *id = data;
 811
 812         int old_font_size = -1;
 813         if (system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &old_font_size)
 814                 != SYSTEM_SETTINGS_ERROR_NONE) {
 815                 DBG("Setting - system_settings_get_value_int() is failed.");
 816         }
 817
 818         if (!strcmp(part, "elm.icon")) {
 819                 radio = elm_radio_add(obj);
 820                 elm_radio_state_value_set(radio, id->index);
 821                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
 822                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 823                 elm_radio_group_add(radio, radio_main);
 824                 evas_object_smart_callback_add(radio, "changed", _font_size_gl_cb, (void *)id->index);
 825                 evas_object_propagate_events_set(radio, EINA_FALSE);
 826
 827                 if (old_font_size == id->index) {
 828                         elm_radio_value_set(radio_main, old_font_size);
 829                 }
 830         }
 831         return radio;
 832 }
 833
 834 static void _font_size_gl_del(void *data, Evas_Object *obj)
 835 {
 836         Item_Data *id = data;
 837         if (id)
 838                 free(id);
 839 }
 840
 841 static Ecore_Timer *font_timer = NULL;
 842
 843 static Eina_Bool _update_font_style(void *data)
 844 {
 845         /* change font style */
 846         if (font_name) {
 847                 system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, font_name);
 848                 FREE(font_name);
 849         } else {
 850                 ERR("font_name is null");
 851         }
 852         font_timer = NULL;
 853
 854         return ECORE_CALLBACK_CANCEL;
 855 }
 856 #if 0
 857 static void _font_style_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 858 {
 859         appdata *ad = data;
 860         if (ad == NULL) {
 861                 ERR("appdata is null");
 862                 return;
 863         }
 864
 865         elm_naviframe_item_pop(ad->nf);
 866         if (!ad->font_style_rdg) {
 867                 evas_object_del(ad->font_style_rdg);
 868                 ad->font_style_rdg = NULL;
 869         }
 870
 871         FREE(font_name);
 872 }
 873
 874 static void _font_style_ok_cb(void *data, Evas_Object *obj, void *event_info)
 875 {
 876         appdata *ad = data;
 877         if (ad == NULL) {
 878                 ERR("appdata is null");
 879                 return;
 880         }
 881
 882         elm_naviframe_item_pop(ad->nf);
 883
 884         if (!ad->font_style_rdg) {
 885                 evas_object_del(ad->font_style_rdg);
 886                 ad->font_style_rdg = NULL;
 887         }
 888
 889         if (font_timer) {
 890                 ecore_timer_del(font_timer);
 891                 font_timer = NULL;
 892         }
 893         font_timer = ecore_timer_add(0.3, (Ecore_Task_Cb) _update_font_style, NULL);
 894 }
 895 #endif
 896
 897 static void _font_style_gl_cb(void *data, Evas_Object *obj, void *event_info)
 898 {
 899         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 900         Font_Style_Item_Data *id = (Font_Style_Item_Data *)data;
 901
 902         /*elm_radio_value_set(temp_ad->font_style_rdg, id->index); */
 903
 904
 905         if (id->font_name) {
 906                 FREE(font_name);
 907                 font_name = strdup(id->font_name);
 908         }
 909
 910         /*elm_genlist_realized_items_update(g_font_style_genlist); */
 911         elm_naviframe_item_pop(temp_ad->nf);
 912
 913         if (font_style_item) {
 914                 elm_genlist_item_update(font_style_item);
 915         }
 916
 917         if (!temp_ad->font_style_rdg) {
 918                 evas_object_del(temp_ad->font_style_rdg);
 919                 temp_ad->font_style_rdg = NULL;
 920         }
 921
 922         if (font_timer) {
 923                 ecore_timer_del(font_timer);
 924                 font_timer = NULL;
 925         }
 926         font_timer = ecore_timer_add(0.3, (Ecore_Task_Cb) _update_font_style, NULL);
 927 }
 928
 929 static Eina_Bool _update_font_size(void *data)
 930 {
 931         /* change font size */
 932         system_settings_set_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, font_size_index);
 933
 934         font_timer = NULL;
 935
 936         if (font_size_item) {
 937                 elm_genlist_item_update(font_size_item);
 938         }
 939
 940         return ECORE_CALLBACK_CANCEL;
 941 }
 942
 943 static void _font_size_gl_cb(void *data, Evas_Object *obj, void *event_info)
 944 {
 945         int old_font_size = 0;
 946
 947         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 948
 949         if (system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &old_font_size)
 950                 != SYSTEM_SETTINGS_ERROR_NONE) {
 951                 DBG("Setting - system_settings_get_value_int() is failed.");
 952                 return;
 953         }
 954         DBG("Setting - old font size is %d.", old_font_size);
 955
 956         font_size_index = (int)data;
 957
 958         DBG("Setting - Curr font size is %d.", font_size_index);
 959
 960         /*elm_genlist_realized_items_update(g_font_size_genlist); */
 961
 962         elm_naviframe_item_pop(temp_ad->nf);
 963
 964         if (!temp_ad->font_size_rdg) {
 965                 evas_object_del(temp_ad->font_size_rdg);
 966                 temp_ad->font_size_rdg = NULL;
 967         }
 968
 969         if (font_timer) {
 970                 ecore_timer_del(font_timer);
 971                 font_timer = NULL;
 972         }
 973
 974         if (old_font_size != font_size_index) {
 975                 DBG("Setting - font size is same with old.");
 976                 font_timer = ecore_timer_add(0.3, (Ecore_Task_Cb) _update_font_size, NULL);
 977         }
 978 }
 979
 980 void _show_font_list(void *data)
 981 {
 982         appdata *ad = data;
 983         if (ad == NULL) {
 984                 DBG("%s", "_show_font_list - appdata is null");
 985                 return;
 986         }
 987
 988         Evas_Object *genlist  = NULL;
 989         Elm_Object_Item *nf_it = NULL;
 990         int idx;
 991
 992         temp_ad = ad;
 993
 994         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 995         itc->item_style = "2text";
 996         itc->func.text_get = _gl_font_title_get;
 997         itc->func.del = _font_size_gl_del;
 998
 999         Evas_Object *layout = elm_layout_add(ad->nf);
1000         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1001         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1002
1003         genlist = elm_genlist_add(layout);
1004         elm_genlist_block_count_set(genlist, 14);
1005         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1006         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1007
1008 #ifdef _CIRCLE
1009         Elm_Genlist_Item_Class *padding = elm_genlist_item_class_new();
1010         padding->item_style = "padding";
1011         padding->func.del = _font_size_gl_del;
1012
1013         elm_genlist_item_append(genlist, padding, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1014 #endif
1015
1016         for (idx = 0; idx < 1; idx++) {
1017                 Item_Data *id = calloc(sizeof(Item_Data), 1);
1018                 if (id) {
1019                         id->index = idx;
1020                         id->item = elm_genlist_item_append(genlist, itc, id, NULL,
1021                                                                                            ELM_GENLIST_ITEM_NONE, _display_gl_font_style_cb, ad);
1022
1023                         if (idx == 0) {
1024                                 font_style_item = id->item;
1025                         }
1026                 }
1027         }
1028
1029         elm_object_part_content_set(layout, "elm.genlist", genlist);
1030
1031         elm_genlist_item_class_free(itc);
1032
1033         nf_it = elm_naviframe_item_push(ad->nf, "IDS_ST_BODY_FONT", NULL, NULL, layout, NULL);
1034 #if !defined(FEATURE_SETTING_TELEPHONY)
1035         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1036 #endif
1037         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1038         elm_naviframe_item_pop_cb_set(nf_it, setting_font_list_pop_cb, ad);
1039
1040         if (system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE, settings_font_style_changed_cb, ad) != 0) {
1041                 ERR("system_settings_set_changed_cb failed!!");
1042         }
1043 }
1044
1045 char *_get_default_font()
1046 {
1047         xmlDocPtr doc = NULL;
1048         xmlNodePtr cur = NULL;
1049         xmlNodePtr cur2 = NULL;
1050         xmlNodePtr cur3 = NULL;
1051         xmlChar *key = NULL;
1052         struct _xmlAttr *properties = NULL;
1053         char *default_font_name = NULL;
1054
1055         doc = xmlParseFile("/usr/opt/etc/fonts/conf.avail/99-slp.conf");
1056
1057         cur = xmlDocGetRootElement(doc);
1058
1059         if (cur == NULL) {
1060                 xmlFreeDoc(doc);
1061                 doc = NULL;
1062                 return NULL;
1063         }
1064
1065         if (xmlStrcmp(cur->name, (const xmlChar *)"fontconfig")) {
1066                 xmlFreeDoc(doc);
1067                 doc = NULL;
1068                 return NULL;
1069         }
1070
1071         cur = cur->xmlChildrenNode;
1072
1073         while (cur != NULL) {
1074                 if ((!xmlStrcmp(cur->name, (const xmlChar *)"match"))) {
1075                         cur2 = cur->xmlChildrenNode;
1076                         while (cur2 != NULL) {
1077                                 if ((!xmlStrcmp(cur2->name, (const xmlChar *)"edit"))) {
1078                                         properties = cur2->properties;
1079                                         /*find the "name" property*/
1080                                         while (NULL != properties) {
1081                                                 if (!xmlStrcmp(properties->name, (const xmlChar *)"name")) {
1082                                                         break;
1083                                                 }
1084                                                 properties = properties->next;
1085                                         }
1086
1087                                         /*If the value of "name" property is "family", then get the child node string,
1088                                           it shall be the default font type*/
1089                                         if (NULL != properties && !xmlStrcmp(properties->children->content, (const xmlChar *)"family")) {
1090                                                 cur3 = cur2->xmlChildrenNode;
1091                                                 while (cur3 != NULL) {
1092                                                         if ((!xmlStrcmp(cur3->name, (const xmlChar *)"string"))) {
1093                                                                 key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1);
1094                                                                 default_font_name = (char *)g_strdup((char *)key);
1095                                                                 xmlFree(key);
1096                                                                 key = NULL;
1097                                                                 xmlFreeDoc(doc);
1098                                                                 doc = NULL;
1099                                                                 return default_font_name;
1100                                                         }
1101                                                         cur3 = cur3->next;
1102                                                 }
1103                                         }
1104                                 }
1105                                 cur2 = cur2->next;
1106                         }
1107                 }
1108                 cur = cur->next;
1109         }
1110
1111         xmlFreeDoc(doc);
1112         doc = NULL;
1113         return NULL;
1114 }
1115
1116 static Eina_List *_get_available_font_list()
1117 {
1118         FcObjectSet *os = NULL;
1119         FcFontSet *fs = NULL;
1120         FcPattern *pat = NULL;
1121         Eina_List *list = NULL;
1122         FcConfig *font_config = NULL;
1123
1124         font_config = FcInitLoadConfigAndFonts();
1125
1126         if (font_config == NULL) {
1127                 ERR("Failed: FcInitLoadConfigAndFonts");
1128                 return NULL;
1129         }
1130
1131         char *locale = setlocale(0, NULL);
1132
1133         pat = FcPatternCreate();
1134
1135         os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FAMILYLANG, (char *) 0);
1136
1137         if (os) {
1138                 fs = FcFontList(font_config, pat, os);
1139                 FcObjectSetDestroy(os);
1140                 os = NULL;
1141         }
1142
1143         if (pat) {
1144                 FcPatternDestroy(pat);
1145                 pat = NULL;
1146         }
1147
1148         if (fs) {
1149                 int j;
1150                 DBG("fs->nfont = %d", fs->nfont);
1151
1152                 for (j = 0; j < fs->nfont; j++) {
1153                         FcChar8 *family = NULL;
1154                         FcChar8 *file = NULL;
1155                         FcChar8 *lang = NULL;
1156                         int id = 0;
1157
1158                         if (FcPatternGetString(fs->fonts[j], FC_FILE, 0, &file) == FcResultMatch) {
1159                                 int preload_path_len = strlen(SETTING_FONT_PRELOAD_FONT_PATH);
1160                                 int download_path_len = strlen(SETTING_FONT_DOWNLOADED_FONT_PATH);
1161
1162                                 char *family_result = NULL;
1163
1164                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILY, 0, &family) != FcResultMatch) {
1165                                         DBG("Family name is invalid");
1166                                         continue;
1167                                 }
1168
1169                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch) {
1170                                         DBG("Family lang is invalid");
1171                                         continue;
1172                                 }
1173
1174                                 if (!strncmp((const char *)file, SETTING_FONT_PRELOAD_FONT_PATH, preload_path_len)) {
1175                                         /* Find proper family name for current locale. */
1176                                         while (locale && family && lang) {
1177                                                 /*DBG("locale: %s, family: %s, lang: %s", locale, family, lang); */
1178
1179                                                 if (!strncmp(locale, (char *)lang, strlen((char *)lang))) {
1180                                                         family_result = (char *)family;
1181                                                         break;
1182                                                 }
1183
1184                                                 /* I will set english as default family language. */
1185                                                 /* If there is no proper family language for current locale, */
1186                                                 /* we have to show the english family name. */
1187                                                 if (!strcmp(lang, "en")) {
1188                                                         family_result = (char *)family;
1189                                                 }
1190                                                 id++;
1191                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILY, id, &family) != FcResultMatch) {
1192                                                         break;
1193                                                 }
1194                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch) {
1195                                                         break;
1196                                                 }
1197                                         }
1198
1199                                         if (eina_list_data_find(list, family_result) == NULL) {
1200                                                 list = eina_list_append(list, family_result);
1201                                                 DBG("-------- ADDED FONT - family result = %s", (char *)family_result);
1202                                         }
1203                                 }
1204
1205                                 id = 0;
1206
1207                                 /* always shown for D/L */
1208                                 if (!strncmp((const char *)file, SETTING_FONT_DOWNLOADED_FONT_PATH, download_path_len)) {
1209                                         /* Find proper family name for current locale. */
1210                                         while (locale && family && lang) {
1211                                                 /*DBG("locale: %s, family: %s, lang: %s", locale, family, lang); */
1212
1213                                                 if (!strncmp(locale, (char *)lang, strlen((char *)lang))) {
1214                                                         family_result = (char *)family;
1215                                                         break;
1216                                                 }
1217
1218                                                 /* I will set english as default family language. */
1219                                                 /* If there is no proper family language for current locale, */
1220                                                 /* we have to show the english family name. */
1221                                                 if (!strcmp(lang, "en")) {
1222                                                         family_result = (char *)family;
1223                                                 }
1224                                                 id++;
1225                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILY, id, &family) != FcResultMatch) {
1226                                                         break;
1227                                                 }
1228                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch) {
1229                                                         break;
1230                                                 }
1231                                         }
1232
1233                                         if (eina_list_data_find(list, family_result) == NULL) {
1234                                                 list = eina_list_append(list, family_result);
1235                                                 DBG("-------- ADDED FONT - family result = %s", (char *)family_result);
1236                                         }
1237                                 }
1238                         }
1239                 }
1240                 FcFontSetDestroy(fs);
1241                 fs = NULL;
1242         }
1243
1244         FcConfigDestroy(font_config);
1245         font_config = NULL;
1246         return list;
1247 }
1248
1249 int _show_font_style_list(void *data)
1250 {
1251         appdata *ad = data;
1252         if (ad == NULL) {
1253                 DBG("%s", "_show_font_style_list - appdata is null");
1254                 return -1;
1255         }
1256         Evas_Object *genlist  = NULL;
1257         Evas_Object *btn  = NULL;
1258         Elm_Object_Item *nf_it = NULL;
1259         char *default_font_name = NULL;
1260         char *tmp_name = NULL;
1261         int idx = 0, matched_idx = 0;
1262         int ret = 0;
1263
1264         temp_ad = ad;
1265
1266         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1267         itc->item_style = "1text.1icon.1";
1268         itc->func.text_get = _gl_font_style_title_get;
1269         itc->func.content_get = _gl_font_style_ridio_get;
1270         itc->func.del = _font_style_gl_del;
1271
1272         Evas_Object *layout = elm_layout_add(ad->nf);
1273         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1274         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1275
1276         genlist = elm_genlist_add(layout);
1277         elm_genlist_block_count_set(genlist, 14);
1278         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1279         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1280
1281         FREE(font_name);
1282         ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &tmp_name);
1283         if (ret != SYSTEM_SETTINGS_ERROR_NONE) {
1284                 ERR("failed to call system_setting_get_value_string with err %d", ret);
1285                 tmp_name = _get_default_font();
1286                 if (tmp_name == NULL) {
1287                         ERR("failed to get default font name");
1288                         return -1;
1289                 } else {
1290                         DBG("get_default_font = %s", tmp_name);
1291                 }
1292         } else {
1293                 DBG("SYSTEM_SETTINGS_KEY_FONT_TYPE = %s", tmp_name);
1294         }
1295
1296 #ifdef _CIRCLE
1297         Elm_Genlist_Item_Class *padding = elm_genlist_item_class_new();
1298         padding->item_style = "padding";
1299         padding->func.del = _font_size_gl_del;
1300
1301         elm_genlist_item_append(genlist, padding, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1302 #endif
1303
1304         default_font_name = _get_default_font();
1305
1306         if (default_font_name) {
1307                 Font_Style_Item_Data *id_default = calloc(sizeof(Font_Style_Item_Data), 1);
1308                 if (default_font_name && tmp_name && !strcmp(tmp_name, default_font_name)) {
1309                         matched_idx = idx;
1310                         font_name = strdup(tmp_name);
1311                 }
1312                 if (id_default) {
1313                         id_default->index = idx++;
1314                         id_default->font_name = strdup(default_font_name);
1315                         id_default->item = elm_genlist_item_append(genlist, itc, id_default, NULL, ELM_GENLIST_ITEM_NONE,
1316                                                                                                            _font_style_gl_cb, (void *)id_default);
1317                 }
1318         } else {
1319                 ERR("default_font_name is NULL");
1320         }
1321
1322         /* get font list */
1323         Eina_List *font_list = NULL;
1324         Eina_List *l = NULL;
1325         FcChar8 *font_data = NULL;
1326         font_list = _get_available_font_list();
1327         EINA_LIST_FOREACH(font_list, l, font_data) {
1328                 if (!default_font_name || strcmp((const char *)default_font_name, (const char *)font_data)) {
1329                         Font_Style_Item_Data *id = calloc(sizeof(Item_Data), 1);
1330                         if (tmp_name && !strcmp((const char *)tmp_name, (const char *)font_data)) {
1331                                 matched_idx = idx;
1332                                 font_name = strdup(tmp_name);
1333                         }
1334
1335                         DBG("font_data -------> %s", (const char *)font_data);
1336
1337                         if (id) {
1338                                 id->index = idx++;
1339                                 id->font_name = (char *)strdup((char *)font_data);
1340                                 id->item = elm_genlist_item_append(genlist, itc, id, NULL, ELM_GENLIST_ITEM_NONE,
1341                                                                                                    _font_style_gl_cb, (void *)id);
1342                         }
1343                 }
1344         }
1345
1346         evas_font_reinit();
1347         ad->font_style_rdg = elm_radio_add(genlist);
1348         elm_radio_state_value_set(ad->font_style_rdg, -1);
1349         elm_radio_value_set(ad->font_style_rdg, matched_idx);
1350
1351         evas_object_data_set(genlist, "radio_main", ad->font_style_rdg);
1352
1353         g_font_style_genlist = genlist;
1354
1355         elm_object_part_content_set(layout, "elm.genlist", genlist);
1356
1357         elm_genlist_item_class_free(itc);
1358
1359         evas_object_smart_callback_add(genlist, "language,changed", _lang_update_font_style_list, ad);
1360
1361         nf_it = elm_naviframe_item_push(ad->nf, "IDS_ST_BODY_FONT_STYLE", NULL, NULL, layout, NULL);
1362 #if !defined(FEATURE_SETTING_TELEPHONY)
1363         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1364 #endif
1365         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1366         elm_naviframe_item_pop_cb_set(nf_it, setting_font_style_pop_cb, ad);
1367
1368         return 0;
1369 }
1370
1371 static void _lang_update_font_style_list(void *data, Evas_Object *obj, void *event_info)
1372 {
1373         DBG("_lang_update_font_style_list");
1374
1375         appdata *ad = data;
1376         if (ad == NULL) {
1377                 DBG("%s", "_lang_update_font_style_list - appdata is null");
1378                 return;
1379         }
1380
1381         if (g_font_style_genlist) {
1382                 elm_genlist_clear(g_font_style_genlist);
1383
1384                 char *default_font_name = NULL;
1385                 char *tmp_name = NULL;
1386                 int idx = 0, matched_idx = 0;
1387                 int ret = 0;
1388
1389                 Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1390                 itc->item_style = "1text.1icon.1";
1391                 itc->func.text_get = _gl_font_style_title_get;
1392                 itc->func.content_get = _gl_font_style_ridio_get;
1393                 itc->func.del = _font_style_gl_del;
1394
1395                 FREE(font_name);
1396                 ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &tmp_name);
1397                 if (ret != SYSTEM_SETTINGS_ERROR_NONE) {
1398                         ERR("failed to call system_setting_get_value_string with err %d", ret);
1399                         tmp_name = _get_default_font();
1400                 }
1401
1402                 default_font_name = _get_default_font();
1403
1404                 Font_Style_Item_Data *id_default = calloc(sizeof(Font_Style_Item_Data), 1);
1405                 if (default_font_name && tmp_name && !strcmp(tmp_name, default_font_name)) {
1406                         matched_idx = idx;
1407                         font_name = strdup(tmp_name);
1408                 }
1409                 if (id_default) {
1410                         id_default->index = idx++;
1411                         id_default->font_name = (default_font_name != NULL) ? strdup(default_font_name) : NULL;
1412                         id_default->item = elm_genlist_item_append(g_font_style_genlist, itc, id_default, NULL, ELM_GENLIST_ITEM_NONE,
1413                                                                                                            _font_style_gl_cb, (void *)id_default);
1414                 }
1415
1416                 Eina_List *font_list = NULL;
1417                 Eina_List *l = NULL;
1418                 FcChar8 *font_data = NULL;
1419                 font_list = _get_available_font_list();
1420                 EINA_LIST_FOREACH(font_list, l, font_data) {
1421                         if (!default_font_name || strcmp((const char *)default_font_name, (const char *)font_data)) {
1422                                 Font_Style_Item_Data *id = calloc(sizeof(Item_Data), 1);
1423                                 if (tmp_name && !strcmp((const char *)tmp_name, (const char *)font_data)) {
1424                                         matched_idx = idx;
1425                                         font_name = strdup(tmp_name);
1426                                 }
1427                                 DBG("Font1: %s, Font2: %s", tmp_name, font_data);
1428
1429                                 if (id) {
1430                                         id->index = idx++;
1431                                         id->font_name = (char *)strdup((char *)font_data);
1432                                         id->item = elm_genlist_item_append(g_font_style_genlist, itc, id, NULL, ELM_GENLIST_ITEM_NONE,
1433                                                                                                            _font_style_gl_cb, (void *)id);
1434                                 }
1435                         }
1436                 }
1437
1438                 ad->font_style_rdg = evas_object_data_get(g_font_style_genlist, "radio_main");
1439                 if (ad->font_style_rdg) {
1440                         evas_object_del(ad->font_style_rdg);
1441                         ad->font_style_rdg = NULL;
1442                 }
1443
1444                 evas_font_reinit();
1445                 ad->font_style_rdg = elm_radio_add(g_font_style_genlist);
1446                 elm_radio_state_value_set(ad->font_style_rdg, -1);
1447
1448                 evas_object_data_set(g_font_style_genlist, "radio_main", ad->font_style_rdg);
1449
1450                 elm_genlist_realized_items_update(g_font_style_genlist);
1451
1452                 DBG("Matched index: %d", matched_idx);
1453
1454                 elm_radio_value_set(ad->font_style_rdg, matched_idx);
1455
1456                 elm_genlist_item_class_free(itc);
1457         }
1458 }
1459
1460 void _show_font_size_list(void *data)
1461 {
1462         appdata *ad = data;
1463         if (ad == NULL) {
1464                 DBG("%s", "_show_screen_timeout_list - appdata is null");
1465                 return;
1466         }
1467         Evas_Object *genlist  = NULL;
1468         Elm_Object_Item *nf_it = NULL;
1469         struct _dt_menu_item *menu_its = NULL;
1470         int idx;
1471
1472         temp_ad = ad;
1473
1474         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1475         itc->item_style = "1text.1icon.1";
1476         itc->func.text_get = _gl_font_size_title_get;
1477         itc->func.content_get = _gl_font_size_ridio_get;
1478         itc->func.del = _font_size_gl_del;
1479
1480         Evas_Object *layout = elm_layout_add(ad->nf);
1481         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1482         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1483
1484         genlist = elm_genlist_add(layout);
1485         elm_genlist_block_count_set(genlist, 14);
1486         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1487         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1488
1489         for (idx = 0; idx < FONT_SIZE_COUNT; idx++) {
1490                 Item_Data *id = calloc(sizeof(Item_Data), 1);
1491                 if (id) {
1492                         id->index = idx;
1493                         id->item = elm_genlist_item_append(genlist, itc, id, NULL, ELM_GENLIST_ITEM_NONE, _font_size_gl_cb, (void *)idx);
1494                 }
1495         }
1496
1497         ad->font_size_rdg = elm_radio_add(genlist);
1498         elm_radio_state_value_set(ad->font_size_rdg, 6);
1499         elm_radio_value_set(ad->font_size_rdg, screen_time_index);
1500
1501         evas_object_data_set(genlist, "radio_main", ad->font_size_rdg);
1502
1503         g_font_size_genlist = genlist;
1504
1505         elm_object_part_content_set(layout, "elm.genlist", genlist);
1506
1507         elm_genlist_item_class_free(itc);
1508
1509         nf_it = elm_naviframe_item_push(ad->nf, "IDS_ST_BODY_FONT_SIZE_ABB", NULL, NULL, layout, NULL);
1510 #if !defined(FEATURE_SETTING_TELEPHONY)
1511         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1512 #endif
1513         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1514 }
1515
1516 static char *_gl_roatate_screen_title_get(void *data, Evas_Object *obj, const char *part)
1517 {
1518         char buf[1024] = {0,};
1519         Item_Data *id = data;
1520
1521         if (!strcmp(part, "elm.text")) {
1522                 snprintf(buf, sizeof(buf) - 1, "%s", _(rotate_screen_str[id->index]));
1523
1524         }
1525         return strdup(buf);
1526 }
1527
1528 static Evas_Object *_gl_rotate_screen_radio_get(void *data, Evas_Object *obj, const char *part)
1529 {
1530         Evas_Object *radio = NULL;
1531         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
1532         Item_Data *id = data;
1533         static int rotate = -1;
1534
1535         if (!strcmp(part, "elm.icon")) {
1536                 radio = elm_radio_add(obj);
1537                 elm_radio_state_value_set(radio, id->index);
1538                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
1539                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1540                 elm_radio_group_add(radio, radio_main);
1541
1542                 /*get_int rotate */
1543                 rotate = _get_rotate_screen();
1544                 rotate_screen_rot = rotate;
1545
1546                 if (rotate == SETTING_SCREENROTATION_90_DEGREE) {
1547                         /*90R */
1548                         rotate_screen_index = 1;
1549                 } else if (rotate == SETTING_SCREENROTATION_270_DEGREE) {
1550                         /*90L */
1551                         rotate_screen_index = 2;
1552                 } else if (rotate == SETTING_SCREENROTATION_180_DEGREE) {
1553                         /*180 */
1554                         rotate_screen_index = 3;
1555                 }
1556
1557                 if (rotate == -1) {
1558                         rotate_screen_rot = SETTING_SCREENROTATION_0_DEGREE;
1559                 }
1560         }
1561         return radio;
1562 }
1563
1564 static void _rotate_screen_gl_del(void *data, Evas_Object *obj)
1565 {
1566         Item_Data *id = data;
1567         if (id)
1568                 free(id);
1569 }
1570
1571 static void _rotate_screen_gl_cb(void *data, Evas_Object *obj, void *event_info)
1572 {
1573         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1574
1575         rotate_screen_index = (int)data;
1576
1577         if (rotate_screen_index == 1) {
1578                 /*90R */
1579                 rotate_screen_rot = SETTING_SCREENROTATION_90_DEGREE;
1580         } else if (rotate_screen_index == 2) {
1581                 /*90L */
1582                 rotate_screen_rot = SETTING_SCREENROTATION_270_DEGREE;
1583         } else if (rotate_screen_index == 3) {
1584                 /*180 */
1585                 rotate_screen_rot = SETTING_SCREENROTATION_180_DEGREE;
1586         } else {
1587                 rotate_screen_rot = SETTING_SCREENROTATION_0_DEGREE;
1588         }
1589
1590         /*set int */
1591         _set_rotate_screen(rotate_screen_rot);
1592
1593         elm_genlist_realized_items_update(g_rotate_screen_genlist);
1594
1595         elm_naviframe_item_pop(temp_ad->nf);
1596         if (!temp_ad->rotate_screen_rdg) {
1597                 evas_object_del(temp_ad->rotate_screen_rdg);
1598                 temp_ad->rotate_screen_rdg = NULL;
1599         }
1600 }
1601
1602 void _show_rotate_screen_list(void *data)
1603 {
1604         appdata *ad = data;
1605         if (ad == NULL) {
1606                 DBG("%s", "_show_screen_timeout_list - appdata is null");
1607                 return;
1608         }
1609         Evas_Object *genlist  = NULL;
1610         Elm_Object_Item *nf_it = NULL;
1611         struct _dt_menu_item *menu_its = NULL;
1612         int idx;
1613
1614         temp_ad = ad;
1615
1616         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1617         itc->item_style = "1text.1icon.1";
1618         itc->func.text_get = _gl_roatate_screen_title_get;
1619         itc->func.content_get = _gl_rotate_screen_radio_get;
1620         itc->func.del = _rotate_screen_gl_del;
1621
1622         genlist = elm_genlist_add(ad->nf);
1623         elm_genlist_block_count_set(genlist, 14);
1624         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1625
1626         for (idx = 0; idx < ROTATE_SCREEN_COUNT; idx++) {
1627                 Item_Data *id = calloc(sizeof(Item_Data), 1);
1628                 if (id) {
1629                         id->index = idx;
1630                         id->item = elm_genlist_item_append(genlist, itc, id, NULL, ELM_GENLIST_ITEM_NONE, _rotate_screen_gl_cb, (void *)idx);
1631                 }
1632         }
1633
1634         ad->rotate_screen_rdg = elm_radio_add(genlist);
1635         elm_radio_state_value_set(ad->rotate_screen_rdg, -1);
1636         elm_radio_value_set(ad->rotate_screen_rdg, rotate_screen_index);
1637
1638         evas_object_data_set(genlist, "radio_main", ad->rotate_screen_rdg);
1639
1640         g_screen_time_genlist = genlist;
1641
1642         elm_genlist_item_class_free(itc);
1643
1644         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, genlist, NULL);
1645         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1646 }
1647
1648 static void _set_rotate_screen(const int rotation)
1649 {
1650         vconf_set_int(VCONFKEY_SETAPPL_SCREENROTATION_DEG_INT, rotation);
1651 }
1652
1653 static int _get_rotate_screen()
1654 {
1655         int rot;
1656         vconf_get_int(VCONFKEY_SETAPPL_SCREENROTATION_DEG_INT, &rot);
1657         return rot;
1658 }
1659
1660 static void settings_font_style_changed_cb(system_settings_key_e key, void *user_data)
1661 {
1662         DBG("settings_font_style_changed_cb");
1663
1664         appdata *ad = user_data;
1665         if (ad == NULL)
1666                 return;
1667
1668         char *font_name = NULL;
1669         Evas_Object *font_style_radio = NULL;
1670         if (g_font_style_genlist) {
1671                 font_style_radio = evas_object_data_get(g_font_style_genlist, "radio_main");
1672                 if (font_style_radio) {
1673                         if (system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &font_name)
1674                                 != SYSTEM_SETTINGS_ERROR_NONE) {
1675                                 ERR("failed to call system_setting_get_value_string with err");
1676                                 return;
1677                         }
1678
1679                         DBG("Update a font style list");
1680
1681                         DBG("System font: %s", font_name);
1682
1683                         int index = 0;
1684                         Eina_List *font_list = NULL;
1685                         Eina_List *l = NULL;
1686                         Elm_Object_Item *font_item = NULL;
1687                         Font_Style_Item_Data *font_data = NULL;
1688
1689                         font_list = elm_genlist_realized_items_get(g_font_style_genlist);
1690                         EINA_LIST_FOREACH(font_list, l, font_item) {
1691                                 font_data = (Font_Style_Item_Data *) elm_object_item_data_get(font_item);
1692                                 if (font_name && !strcmp((const char *)font_name, (const char *)font_data->font_name)) {
1693                                         DBG("1: %s, 2: %s", font_name, font_data->font_name);
1694                                         DBG("Font style matched index : %d", index);
1695                                         elm_radio_value_set(font_style_radio, index);
1696                                         return;
1697                                 }
1698                                 index++;
1699                         }
1700                 }
1701         }
1702
1703         if (font_style_item) {
1704                 elm_genlist_item_update(font_style_item);
1705         }
1706 }
1707
1708 static Eina_Bool setting_font_style_pop_cb(void *data, Elm_Object_Item *it)
1709 {
1710         DBG("setting_font_style_pop_cb");
1711
1712         g_font_style_genlist = NULL;
1713
1714         return EINA_TRUE;
1715 }
1716
1717 static Eina_Bool setting_font_list_pop_cb(void *data, Elm_Object_Item *it)
1718 {
1719         DBG("setting_font_list_pop_cb");
1720
1721         font_size_item = NULL;
1722         font_style_item = NULL;
1723
1724         if (system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE) != 0) {
1725                 ERR("system_settings_unset_changed_cb failed!!");
1726         }
1727
1728         return EINA_TRUE;
1729 }
1730
1731 static void change_language_enabling(keynode_t *key, void *data)
1732 {
1733         if (lang_item == NULL) {
1734                 DBG("Setting - lang_item is null!!");
1735                 return;
1736         }
1737
1738         int enable = 0;
1739         vconf_get_bool(VCONFKEY_WMS_WMANAGER_CONNECTED, &enable);
1740         if (enable) {
1741                 DBG("Setting - Language is disabled");
1742         } else {
1743                 DBG("Setting - Language is enabled");
1744         }
1745
1746         if (lang_item) {
1747                 elm_genlist_item_update(lang_item);
1748         }
1749 }
1750
1751 static void change_screen_time_cb(keynode_t *key, void *data)
1752 {
1753         DBG("Setting - change_screen_time_cb");
1754
1755         if (screen_time_item) {
1756                 elm_genlist_item_update(screen_time_item);
1757         }
1758 }
1759
1760 static void change_language_cb(keynode_t *key, void *data)
1761 {
1762         DBG("Setting - change_language_cb");
1763
1764         if (lang_item) {
1765                 elm_genlist_item_update(lang_item);
1766         }
1767 }
1768
1769 #if 0
1770 static void _display_brightness_cb(void *data, Evas_Object *obj, void *event_info)
1771 {
1772         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1773
1774         Evas_Object *layout = NULL;
1775         Elm_Object_Item *navi_it = NULL;
1776
1777         appdata *ad = data;
1778
1779         if (ad != NULL) {
1780                 layout = _show_brightness_popup(ad, obj, event_info);
1781         }
1782
1783         if (layout) {
1784                 evas_object_event_callback_add(layout, EVAS_CALLBACK_MOUSE_IN, _power_off_popup_dismiss_cb, NULL);
1785
1786                 navi_it = elm_naviframe_item_push(ad->nf, "IDS_ST_BUTTON_BRIGHTNESS", NULL, NULL, layout, NULL);
1787                 elm_object_item_domain_text_translatable_set(navi_it, SETTING_PACKAGE, EINA_TRUE);
1788                 elm_naviframe_item_pop_cb_set(navi_it, _brightness_pop_cb, NULL);
1789
1790                 register_vconf_changing(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, brightness_vconf_changed_cb, NULL);
1791         }
1792 }
1793
1794 Evas_Object *_show_brightness_popup(void *data, Evas_Object *obj, void *event_info)
1795 {
1796         Evas_Object *icon;
1797         Evas_Object *ly;
1798         Evas_Object *vol;
1799         Evas_Object *btn;
1800         appdata *ad = data;
1801         int brightness_level = 0;
1802
1803         if (ad == NULL)
1804                 return NULL;
1805
1806         temp_ad = ad;
1807
1808         pd = (spin_date *) malloc(sizeof(spin_date));
1809
1810         int real_brightness = 0;
1811         device_get_brightness(0, &real_brightness);
1812         DBG("Setting - Real brightness : %d", real_brightness);
1813
1814         /* Vconf brightness level */
1815         vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness_level);
1816
1817         if (real_brightness != brightness_level) {      /* HBM mode -> normal level(4) */
1818                 sync_brightness(real_brightness);
1819
1820                 brightness_level = real_brightness;
1821         }
1822
1823         int enable = display_get_hbm();
1824         if (enable < 0) {
1825                 DBG("Setting - dispaly_get_hbm() is fail!!");
1826         }
1827
1828         if (enable == TRUE) {
1829                 DBG("Setting - current HBM mode!!");
1830                 brightness_index = 6;
1831         } else {
1832                 brightness_index = _change_bright_lovel_to_index(brightness_level);
1833         }
1834
1835         DBG("Setting - level: %d,   index: %d", brightness_level, brightness_index);
1836
1837         brightness_origin_level = brightness_level;
1838
1839         ly = elm_layout_add(ad->nf);
1840         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1841         evas_object_size_hint_min_set(ly, 320, 200);
1842         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1843         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1844
1845         brightness_layout = ly;
1846
1847         pd->spinner = elm_spinner_add(ly);
1848         elm_object_style_set(pd->spinner, "brightnessstyle");
1849         elm_spinner_editable_set(pd->spinner, EINA_TRUE);
1850         elm_spinner_min_max_set(pd->spinner, 1, 6);
1851         evas_object_smart_callback_add(pd->spinner, "changed", _on_spinner_change_cb, pd);
1852         elm_object_part_content_set(ly, "elm.icon.1", pd->spinner);
1853         elm_spinner_value_set(pd->spinner, brightness_index);
1854         _update_brightness_circle(pd->spinner);
1855
1856         btn = elm_button_add(ly);
1857         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1858         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1859         elm_object_part_content_set(ly, "btn1", btn);
1860         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1861
1862         btn = elm_button_add(ly);
1863         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1864         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1865         elm_object_part_content_set(ly, "btn2", btn);
1866         evas_object_smart_callback_add(btn, "clicked", _set_brightness_clicked_cb, ad);
1867
1868         hbm_mode_on_original = enable;  /* backup for cancel */
1869
1870         g_spinner = pd->spinner;
1871
1872         return ly;
1873 }
1874
1875 static void _on_spinner_change_cb(void *data, Evas_Object *obj, void *event_info)
1876 {
1877         DBG("Setting - _on_spinner_change_cb() is called!");
1878
1879         Evas_Coord w;
1880
1881         static int  prev = 0;
1882         double min, max;
1883         int idx = (int) elm_spinner_value_get(obj);
1884
1885         edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL);
1886         elm_spinner_min_max_get(obj, &min, &max);
1887
1888         DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx);
1889
1890         if (idx == max)
1891                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,full", "elm");
1892         else if (idx < max)
1893                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,default", "elm");
1894         if (idx == min)
1895                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
1896         if (idx > min)
1897                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,normal", "elm");
1898
1899
1900         brightness_index = idx;
1901
1902         if (brightness_index > 0 && brightness_index < 6) {
1903                 int enable = display_get_hbm();
1904                 if (enable < 0) {
1905                         DBG("Setting - dispaly_get_hbm() is fail!!");
1906                 } else if (enable == TRUE) {
1907                         DBG("Setting - current HBM mode!!");
1908
1909                         elm_object_part_text_set(brightness_layout, "elm.text.2", "");
1910
1911                         _set_HBM_mode(FALSE);
1912                 }
1913                 /*set off sequnce : hbm off -> bright level down */
1914                 int brightness_level = _change_bright_index_to_level(brightness_index);
1915                 device_set_brightness_to_settings(0, brightness_level);
1916                 vconf_set_int("db/setting/Brightness", brightness_level);
1917         } else if (brightness_index == 6) {
1918                 DBG("Setting - HBM mode on!!");
1919
1920                 _set_HBM_mode(TRUE);
1921
1922                 elm_object_translatable_part_text_set(brightness_layout, "elm.text.2", "IDS_ST_BODY_OUTDOOR_MODE_ABB");
1923         }
1924
1925         double posx2 = (double)(w / max) * brightness_index;
1926
1927         prev = idx;
1928         edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx2, 0);
1929 }
1930
1931 static Eina_Bool _brightness_pop_cb(void *data, Elm_Object_Item *it)
1932 {
1933         DBG("Setting - brightness_pop_cb() is called!");
1934
1935         if (pd) {
1936                 DBG("Setting - Free pd!");
1937                 free(pd);
1938         }
1939
1940         unregister_vconf_changing(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, brightness_vconf_changed_cb);
1941
1942         return EINA_TRUE;
1943 }
1944
1945 static void _power_off_popup_dismiss_cb(void *data, Evas_Object *obj, void *event_info)
1946 {
1947         DBG("Setting - _power_off_popup_dismiss_cb() is called!");
1948
1949         int brightness_level = 0;
1950         vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness_level);
1951         brightness_index = _change_bright_lovel_to_index(brightness_level);
1952
1953         if (g_spinner) {
1954                 int enable = display_get_hbm();
1955                 if (enable) {
1956                         brightness_index = 6;
1957                 }
1958                 elm_spinner_value_set(g_spinner, brightness_index);
1959                 _update_brightness_circle(g_spinner);
1960         }
1961 }
1962
1963 static void brightness_vconf_changed_cb(keynode_t *key, void *data)
1964 {
1965         DBG("Setting - brightness vconf changed!!");
1966
1967         int brightness_level = 0;
1968         brightness_level = vconf_keynode_get_int(key);
1969         brightness_index = _change_bright_lovel_to_index(brightness_level);
1970
1971         if (g_spinner) {
1972                 int enable = display_get_hbm();
1973                 if (enable) {
1974                         brightness_index = 6;
1975                 }
1976                 elm_spinner_value_set(g_spinner, brightness_index);
1977                 _update_brightness_circle(g_spinner);
1978         }
1979 }
1980
1981 static void _set_brightness_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1982 {
1983         appdata *ad = (appdata *) data;
1984         if (ad == NULL)
1985                 return;
1986
1987         int enable = display_get_hbm();
1988         if (enable == TRUE) {
1989                 char buf[1024];
1990                 snprintf(buf, sizeof(buf) - 1, _("IDS_IDLE_POP_AFTER_P1SD_MINS_BRIGHTNESS_WILL_BE_RESET_TO_DEFAULT_LEVEL_HP2SD"), 5, 4);
1991
1992                 /* show toast - automatic freed!! */
1993                 struct _toast_data *toast = _create_toast(ad, buf);
1994                 if (toast) {
1995                         _show_toast(ad, toast);
1996                 }
1997         } else {
1998                 int brightness_level = _change_bright_index_to_level(brightness_index);
1999
2000                 device_set_brightness_to_settings(0, brightness_level);
2001         }
2002
2003         brightness_layout = NULL;
2004         g_brightness_controller = NULL;
2005
2006         if (ad->nf) {
2007                 elm_naviframe_item_pop(ad->nf);
2008         }
2009 }
2010
2011 static void sync_brightness(int real_brightness)
2012 {
2013         DBG("Setting - Synchronized brightness level");
2014
2015         vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, real_brightness);
2016 }
2017
2018 static void _update_brightness_circle(Evas_Object *spiner)
2019 {
2020         if (spiner == NULL)
2021                 return;
2022
2023         Evas_Coord w;
2024         double min, max, posx2;
2025         int idx = (int) elm_spinner_value_get(spiner);
2026
2027         edje_object_part_geometry_get(elm_layout_edje_get(spiner), "center.image2", NULL, NULL, &w, NULL);
2028         elm_spinner_min_max_get(spiner, &min, &max);
2029
2030         int enable = display_get_hbm();
2031         if (enable < 0) {
2032                 DBG("Setting - dispaly_get_hbm() is fail!!");
2033         }
2034
2035         if (enable == TRUE) {
2036                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,full1", "elm");
2037
2038                 elm_object_part_text_set(brightness_layout, "elm.text.2", _("IDS_ST_BODY_OUTDOOR_MODE_ABB"));
2039         } else {
2040                 if (idx == min)
2041                         edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,min", "elm");
2042                 if (idx == max)
2043                         edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,full1", "elm");
2044                 if (idx < max)
2045                         edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,default1", "elm");
2046
2047                 brightness_index = idx;
2048
2049                 posx2 = (double)(w / max) * brightness_index;
2050
2051                 edje_object_part_drag_value_set(elm_layout_edje_get(spiner), "elm.dragable.slider", posx2, 0);
2052
2053                 elm_object_part_text_set(brightness_layout, "elm.text.2", "");
2054         }
2055 }
2056
2057 static void wake_up_vconf_changed_cb(keynode_t *key, void *data)
2058 {
2059         DBG("Setting - motion_vconf_changed_cb() is called!");
2060
2061         if (wake_up_item) {
2062                 elm_genlist_item_update(wake_up_item);
2063         }
2064 }
2065
2066 static void icon_size_vconf_changed_cb(keynode_t *key, void *data)
2067 {
2068         DBG("Setting - icon_size_vconf_changed_cb() is called!");
2069
2070         if (edit_icon_item) {
2071                 elm_genlist_item_update(edit_icon_item);
2072         }
2073 }
2074
2075 static void _set_cancel_cb(void *data, Evas_Object *obj, void *event_info)
2076 {
2077         appdata *ad = data;
2078         if (ad == NULL)
2079                 return;
2080
2081         int enable = display_get_hbm();
2082         if (hbm_mode_on_original) {
2083                 if (enable == DISABLE) {
2084                         _set_HBM_mode(TRUE);
2085                 }
2086         } else {
2087                 if (enable == ENABLE) {
2088                         _set_HBM_mode(FALSE);
2089                 }
2090         }
2091
2092         device_set_brightness_to_settings(0, brightness_origin_level);
2093
2094         brightness_layout = NULL;
2095         g_brightness_controller = NULL;
2096
2097         elm_naviframe_item_pop(ad->nf);
2098 }
2099
2100 static int _change_bright_lovel_to_index(int level)
2101 {
2102         int index = 0;
2103
2104         if (level >= 20 && level <= 100) {
2105                 index = (level / 20);
2106                 DBG("Setting - level -> index : %d", index);
2107         }
2108         return index;
2109 }
2110
2111 static int _change_bright_index_to_level(int index)
2112 {
2113         int level = 1;
2114         if (index > 0 && index < 6) {
2115                 switch (index) {
2116                 case 1:
2117                         level = 20;
2118                         break;
2119                 case 2:
2120                         level = 40;
2121                         break;
2122                 case 3:
2123                         level = 60;
2124                         break;
2125                 case 4:
2126                         level = 80;
2127                         break;
2128                 case 5:
2129                         level = 100;
2130                         break;
2131                 }
2132         }
2133
2134         DBG("Setting - index -> level : %d", level);
2135
2136         return level;
2137 }
2138
2139 static void _set_HBM_mode(int enable)
2140 {
2141         if (display_enable_hbm(enable, 300) == 0) {     /* after 5 minutes, HBM mode will be off! */
2142                 DBG("Setting - HBM %s!!", (enable) ? "enabled" : "disabled");
2143         } else {
2144                 DBG("Setting - HBM api failed!!");
2145         }
2146 }
2147
2148 #endif
2149
2150
2151 void _display_ambient_mode_cb(void *data, Evas_Object *obj, void *event_info)
2152 {
2153         Elm_Object_Item *it = (Elm_Object_Item *)event_info;
2154         appdata *ad = data;
2155         if (ad == NULL) {
2156                 DBG("%s", "_display_gl_ambient_mode_cb - appdata or check is null");
2157                 return;
2158         }
2159         display_menu_its[3].is_enable_ambient_mode = display_menu_its[3].is_enable_ambient_mode ? 0 : 1;
2160         DBG("is_enable_ambient_mode: %d", display_menu_its[3].is_enable_ambient_mode);
2161         vconf_set_bool(VCONFKEY_SETAPPL_AMBIENT_MODE_BOOL, display_menu_its[3].is_enable_ambient_mode);
2162
2163         elm_genlist_item_selected_set(it, EINA_FALSE);
2164
2165         elm_genlist_item_update(it);
2166 }
2167