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