src/setting-display.c

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