setting-font/src/setting-font-main.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <setting-font-main.h>
  22 #include <dd-deviced.h>
  23 #include <fontconfig/fontconfig.h>
  24 #include <unicode/uloc.h>
  25 #include <libxml/xmlmemory.h>
  26 #include <libxml/parser.h>
  27 #include <Ecore_X.h>
  28 #include <setting-font-font-size.h>
  29
  30
  31 #define SETTING_FONT_MAX_LEN 10
  32 #define FONT_BUF_SIZE 256
  33
  34 static int setting_font_main_create(void *cb);
  35 static int setting_font_main_destroy(void *cb);
  36 static int setting_font_main_update(void *cb);
  37 static int setting_font_main_cleanup(void *cb);
  38
  39 static Eina_Bool __setting_font_main_click_softkey_back_cb(void *data, Elm_Object_Item *it);
  40
  41 setting_view setting_view_font_main = {
  42         .create = setting_font_main_create,
  43         .destroy = setting_font_main_destroy,
  44         .update = setting_font_main_update,
  45         .cleanup = setting_font_main_cleanup,
  46 };
  47 static int format_font_name_by_id(char* font_data,char* font_name_id, char* temp, int bufsize)
  48 {
  49         retvm_if(font_data == NULL, 0, "Invalid argument: event info is NULL");
  50
  51         char* pos = font_data;
  52         char new_name[bufsize];
  53         int i=0;
  54         int count = 0;
  55         while(*pos != '\0')
  56         {
  57                 //SETTING_TRACE(">>>  %c", *pos);
  58                 if (*pos == ' ')
  59                 {
  60                         SETTING_TRACE(">>>  empty ' ' ");
  61                         new_name[count] = '\\';
  62                         count++;
  63                         new_name[count] = ' ';
  64                 } else {
  65                         new_name[count] = font_data[i];
  66                 }
  67
  68                 count++;
  69                 pos++;
  70                 i++;
  71         }
  72         new_name[count] = '\0';
  73         char trans_font_type_name[FONT_BUF_SIZE] = {0,};
  74         if(safeStrCmp(font_name_id, "IDS_ST_BODY_CHOCO_COOKY") == 0) {
  75                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_CHOCO_COOKY"));
  76         }else if(safeStrCmp(font_name_id, "IDS_ST_BODY_COOL_JAZZ") == 0) {
  77                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_COOL_JAZZ"));
  78         }else if(safeStrCmp(font_name_id, "IDS_ST_BODY_FONTSTYLE_ROSEMARY") == 0) {
  79                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_FONTSTYLE_ROSEMARY"));
  80         }else if (safeStrCmp(font_name_id, "IDS_ST_BODY_HELVETICA_NEUE_M_FONT_NAME") == 0) {
  81                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_HELVETICA_NEUE_M_FONT_NAME"));
  82         }else if(safeStrCmp(font_name_id, "IDS_ST_BODY_MARUBERI_JPN_DCM") == 0) {
  83                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_MARUBERI_JPN_DCM"));
  84         }else if(safeStrCmp(font_name_id, "IDS_ST_BODY_POP_JPN_DCM") == 0) {
  85                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_POP_JPN_DCM"));
  86         }else if (safeStrCmp(font_name_id, "IDS_ST_BODY_UDMINCHO_JPN") == 0) {
  87                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDMINCHO_JPN"));
  88         }else if (safeStrCmp(font_name_id, "IDS_ST_BODY_UDRGOTHICM_JPN") == 0) {
  89                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDRGOTHICM_JPN"));
  90         }else if (safeStrCmp(font_name_id, "IDS_ST_BODY_UDGOTHIC_M_FONT") == 0) {
  91                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDGOTHIC_M_FONT"));
  92         }else if (safeStrCmp(font_name_id, "IDS_ST_BODY_DEFAULT_FONT") == 0) {
  93                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_DEFAULT_FONT"));
  94         }else{
  95                 snprintf(trans_font_type_name, bufsize, "%s", font_name_id);
  96         }
  97         snprintf(temp, bufsize, "<font=%s>%s</font>", new_name, trans_font_type_name);
  98         return 1;
  99 }
 100
 101 char *_item_text_keystr2_get(void *data, Evas_Object *obj, const char *part)
 102 {
 103         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 104         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 105         char *ret_str = NULL;
 106         if (!strcmp(part, "elm.text.main.left")) {
 107                 if (item_data->keyStr2) {
 108                         char temp[FONT_BUF_SIZE] = {0,};
 109
 110                         int ret = format_font_name_by_id(item_data->sub_desc,item_data->keyStr2, temp, FONT_BUF_SIZE);
 111
 112                         if (ret == 0) { /* error condition */
 113                                 SETTING_TRACE_ERROR("Error condition font");
 114                         }
 115
 116                         SETTING_TRACE_DEBUG("temp : %s", (char*)temp);
 117                         ret_str = (char *)g_strdup(temp);
 118                 }
 119         }
 120         //SETTING_TRACE_END;
 121         return ret_str;
 122 }
 123
 124
 125
 126
 127 /**
 128  * [API] get a font list from current system
 129  * REFACTORING: move this feature to system-settings
 130  */
 131 static Eina_List *__setting_font_main_available_list_get()
 132 {
 133         SETTING_TRACE_BEGIN;
 134         FcObjectSet *os = NULL;
 135         FcFontSet *fs = NULL;
 136         FcPattern *pat = NULL;
 137         Eina_List *list = NULL;
 138         FcConfig *font_config = NULL;
 139
 140         font_config = FcInitLoadConfigAndFonts();
 141
 142         setting_retvm_if(font_config == NULL, NULL, "Failed: FcInitLoadConfigAndFonts");
 143
 144
 145         char *locale = setlocale(0, NULL);
 146
 147         pat = FcPatternCreate();
 148
 149         os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FAMILYLANG, (char *) 0);
 150
 151         if (os) {
 152                 fs = FcFontList(font_config, pat, os);
 153                 FcObjectSetDestroy(os);
 154                 os = NULL;
 155         }
 156
 157         if (pat) {
 158                 FcPatternDestroy(pat);
 159                 pat = NULL;
 160         }
 161
 162         if (fs) {
 163                 int j;
 164                 SETTING_TRACE_DEBUG("fs->nfont = %d", fs->nfont);
 165
 166                 for (j = 0; j < fs->nfont; j++) {
 167
 168                         FcChar8 *family = NULL;
 169                         FcChar8 *file = NULL;
 170                         if (FcPatternGetString(fs->fonts[j], FC_FILE, 0, &file) == FcResultMatch) {
 171                                 //SETTING_TRACE_DEBUG("FC_FILE : %s\n", file);
 172                                 int preload_path_len = safeStrLen(SETTING_FONT_PRELOAD_FONT_PATH);
 173                                 int download_path_len = safeStrLen(SETTING_FONT_DOWNLOADED_FONT_PATH);
 174                                 if (!safeStrNCmp((const char*)file, SETTING_FONT_PRELOAD_FONT_PATH, preload_path_len) ||
 175                                         !safeStrNCmp((const char*)file, SETTING_FONT_DOWNLOADED_FONT_PATH, download_path_len)){
 176                                         char *family_result = NULL;
 177                                         FcChar8 *lang = NULL;
 178                                         int id = 0;
 179                                         if (FcPatternGetString(fs->fonts[j], FC_FAMILY, id, &family) != FcResultMatch){
 180                                                 break;
 181                                         }
 182                                         if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch){
 183                                                 break;
 184                                         }
 185                                         family_result = (char *)family;
 186
 187                                         // Find proper family name for current locale.
 188                                         while (locale && family && lang) {
 189                                                 if (!strncmp(locale, (char *)lang, strlen((char *)lang))) {
 190                                                         family_result = (char *)family;
 191                                                         break;
 192                                                 }
 193
 194                                                 // I will set english as default family language.
 195                                                 // If there is no proper family language for current locale,
 196                                                 // we have to show the english family name.
 197                                                 if (!strcmp(lang, "en")){
 198                                                         family_result = (char *)family;
 199                                                 }
 200                                                 id++;
 201                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILY, id, &family) != FcResultMatch){
 202                                                         break;
 203                                                 }
 204                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch){
 205                                                         break;
 206                                                 }
 207                                         }
 208                                         if (family_result && eina_list_data_find(list, family_result) == NULL) {
 209                                                 list = eina_list_append(list, family_result);
 210                                                 SETTING_TRACE_DEBUG("-------- ADDED FONT - family = %s", family_result);
 211                                                 /* list = eina_list_append(list, family_result); */
 212                                                 // for TEST because there's 1 font on target.
 213                                         }
 214                                 }
 215                         }
 216                 }
 217                 FcFontSetDestroy(fs);
 218                 fs = NULL;
 219         }
 220
 221         FcConfigDestroy(font_config);
 222         font_config = NULL;
 223         return list;
 224 }
 225 #if 0
 226 static void __setting_font_main_genlist_sel_cb(void *data, Evas_Object * obj, void *event_info)
 227 {
 228         //error check
 229         setting_retm_if(data == NULL, "Data parameter is NULL");
 230
 231         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 232         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 233         elm_genlist_item_selected_set(item, 0);
 234         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *)elm_object_item_data_get(item);
 235
 236         SettingFontUG *ad = (SettingFontUG *)data;
 237
 238         if (ad->font_size == list_item) {
 239                 setting_view_change(&setting_view_font_main, &setting_view_font_font_size, ad);
 240         }
 241 }
 242 #endif
 243 int get_font_name_id(char* font_data, char* temp, int bufsize)
 244 {
 245         //SETTING_TRACE("font data : %s", (char*)font_data);
 246         //char trans_font_type_name[FONT_BUF_SIZE] = {0,};
 247         //SETTING_TRACE(">>> new_name length : %d : string : %s", count, (char*)new_name);
 248         if(safeStrCmp(font_data, "Choco cooky") == 0) {
 249                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_CHOCO_COOKY");
 250         }else if(safeStrCmp(font_data, "Cool jazz") == 0) {
 251                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_COOL_JAZZ");
 252         }else if(safeStrCmp(font_data, "Rosemary") == 0) {
 253                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_FONTSTYLE_ROSEMARY");
 254         }else if (safeStrCmp(font_data, "HelveticaNeue") == 0) {
 255                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_HELVETICA_NEUE_M_FONT_NAME");
 256         }else if(safeStrCmp(font_data, "Maruberi") == 0) {
 257                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_MARUBERI_JPN_DCM");
 258         }else if(safeStrCmp(font_data, "POP") == 0) {
 259                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_POP_JPN_DCM");
 260         }else if (safeStrCmp(font_data, "UDMincho") == 0) {
 261                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_UDMINCHO_JPN");
 262         }else if (safeStrCmp(font_data, "UDRGothic") == 0) {
 263                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_UDRGOTHICM_JPN");
 264         }else if (safeStrCmp(font_data, "UDGothic") == 0) {
 265                 snprintf(temp, bufsize, "%s", "IDS_ST_BODY_UDGOTHIC_M_FONT");
 266         }else {
 267                 snprintf(temp, bufsize, "%s", font_data);
 268         }
 269         return 1;
 270 }
 271
 272
 273 int get_font_name_str(char* font_type_name, char* trans_font_type_name, int bufsize)
 274 {
 275         //SETTING_TRACE_BEGIN;
 276         if(safeStrCmp(font_type_name, "Choco cooky") == 0){
 277                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_CHOCO_COOKY"));
 278                 //SETTING_TRACE("%s", trans_font_type_name);
 279         }
 280         else if(safeStrCmp(font_type_name, "Cool jazz") == 0){
 281                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_COOL_JAZZ"));
 282                 //SETTING_TRACE("%s", trans_font_type_name);
 283         }
 284         else if(safeStrCmp(font_type_name, "Rosemary") == 0){
 285                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_FONTSTYLE_ROSEMARY"));
 286                 //SETTING_TRACE("%s", trans_font_type_name);
 287         }
 288         else if (safeStrCmp(font_type_name, "HelveticaNeue") == 0){
 289                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_HELVETICA_NEUE_M_FONT_NAME"));
 290                 //SETTING_TRACE("%s", trans_font_type_name);
 291         }
 292         else if(safeStrCmp(font_type_name, "Maruberi") == 0){
 293                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_MARUBERI_JPN_DCM"));
 294                 //SETTING_TRACE("%s", trans_font_type_name);
 295         }
 296         else if(safeStrCmp(font_type_name, "POP") == 0){
 297                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_POP_JPN_DCM"));
 298                 //SETTING_TRACE("%s", trans_font_type_name);
 299         }
 300         else if (safeStrCmp(font_type_name, "UDMincho") == 0){
 301                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDMINCHO_JPN"));
 302                 //SETTING_TRACE("%s", trans_font_type_name);
 303         }
 304         else if (safeStrCmp(font_type_name, "UDRGothic") == 0){
 305                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDRGOTHICM_JPN"));
 306                 //SETTING_TRACE("%s", trans_font_type_name);
 307         }
 308         else{
 309                 snprintf(trans_font_type_name, bufsize, "%s", font_type_name);
 310                 //SETTING_TRACE("%s", trans_font_type_name);
 311         }
 312         return 1;
 313 }
 314 void format_default_font(char* font_data, char* temp, int bufsize,char* real_value)
 315 {
 316         //SETTING_TRACE("real_value : %s", (char*)real_value);
 317
 318         char* pos = real_value;
 319         char new_name[bufsize];
 320         int i=0;
 321         int count = 0;
 322         while(*pos != '\0')
 323         {
 324                 //SETTING_TRACE(">>>  %c", *pos);
 325                 if (*pos == ' ')
 326                 {
 327                         //SETTING_TRACE(">>>  empty ' ' ");
 328                         new_name[count] = '\\';
 329                         count++;
 330                         new_name[count] = ' ';
 331                 } else {
 332                         new_name[count] = real_value[i];
 333                 }
 334
 335                 count++;
 336                 pos++;
 337                 i++;
 338         }
 339         new_name[count] = '\0';
 340         snprintf(temp, bufsize, "<font=%s>%s</font>", new_name, font_data);
 341 }
 342
 343 int get_font_name_tag(char* font_data, char* temp, int bufsize)
 344 {
 345         //SETTING_TRACE("font data : %s", (char*)font_data);
 346
 347         char* pos = font_data;
 348         char new_name[bufsize];
 349         int i=0;
 350         int count = 0;
 351         while(*pos != '\0')
 352         {
 353                 //SETTING_TRACE(">>>  %c", *pos);
 354                 if (*pos == ' ')
 355                 {
 356                         SETTING_TRACE(">>>  empty ' ' ");
 357                         new_name[count] = '\\';
 358                         count++;
 359                         new_name[count] = ' ';
 360                 } else {
 361                         new_name[count] = font_data[i];
 362                 }
 363
 364                 count++;
 365                 pos++;
 366                 i++;
 367         }
 368         new_name[count] = '\0';
 369
 370         char trans_font_type_name[FONT_BUF_SIZE] = {0,};
 371         //SETTING_TRACE(">>> new_name length : %d : string : %s", count, (char*)new_name);
 372         if(safeStrCmp(font_data, "Choco cooky") == 0) {
 373                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_CHOCO_COOKY"));
 374         }else if(safeStrCmp(font_data, "Cool jazz") == 0) {
 375                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_COOL_JAZZ"));
 376         }else if(safeStrCmp(font_data, "Rosemary") == 0) {
 377                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_FONTSTYLE_ROSEMARY"));
 378         }else if (safeStrCmp(font_data, "HelveticaNeue") == 0) {
 379                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_HELVETICA_NEUE_M_FONT_NAME"));
 380         }else if(safeStrCmp(font_data, "Maruberi") == 0) {
 381                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_MARUBERI_JPN_DCM"));
 382         }else if(safeStrCmp(font_data, "POP") == 0) {
 383                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_POP_JPN_DCM"));
 384         }else if (safeStrCmp(font_data, "UDMincho") == 0) {
 385                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDMINCHO_JPN"));
 386         }else if (safeStrCmp(font_data, "UDRGothic") == 0) {
 387                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDRGOTHICM_JPN"));
 388         }else if (safeStrCmp(font_data, "UDGothic") == 0) {
 389                 snprintf(trans_font_type_name, bufsize, "%s", _("IDS_ST_BODY_UDGOTHIC_M_FONT"));
 390         }else {
 391                 snprintf(trans_font_type_name, bufsize, "%s", font_data);
 392         }
 393
 394         //
 395         snprintf(temp, bufsize, "<font=%s>%s</font>", new_name, trans_font_type_name);
 396         return 1;
 397 }
 398
 399 static void __setting_font_main_genlist_item_create(void *data)
 400 {
 401         SETTING_TRACE_BEGIN;
 402         setting_retm_if(NULL == data, "data is NULL");
 403
 404         SettingFontUG *ad = (SettingFontUG *)data;
 405         Elm_Object_Item *item = NULL;
 406         setting_create_Gendial_itc("1line", &(ad->itc_1text_1icon_2_font_size));
 407         ad->itc_1text_1icon_2_font_size.func.text_get = _item_text_font_size_keystr2_get;
 408         if (ad->viewmode == FONT_SIZE_AND_FONT_SEL_UG || ad->viewmode == FONT_SEL_VIEW_APPCONTROL)              // font type only
 409         {
 410                 // [UI] Font Type
 411                 item = elm_genlist_item_append(ad->genlist, &itc_seperator, NULL, NULL,
 412                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 413                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 414
 415                 char *font_type_name = NULL;
 416             int ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &font_type_name);
 417                 if(ret !=0 ){
 418                         SETTING_TRACE_ERROR("system-setting call failed with error code %d",ret);
 419                 }
 420                 SETTING_TRACE("---------------- system-setting call : (%s) ", font_type_name);
 421
 422                 #if 0
 423                 char trans_font_type_name[256] = {0,};
 424                 if(safeStrCmp(font_type_name, "Choco cooky") == 0)
 425                         snprintf(trans_font_type_name, 256, "%s", _("IDS_ST_BODY_CHOCO_COOKY"));
 426                 else if(safeStrCmp(font_type_name, "Cool jazz") == 0)
 427                         snprintf(trans_font_type_name, 256, "%s", _("IDS_ST_BODY_COOL_JAZZ"));
 428                 else if (safeStrCmp(font_type_name, "HelveticaNeue") == 0)
 429                         snprintf(trans_font_type_name, 256, "%s", _("IDS_ST_BODY_HELVETICA_NEUE_M_FONT_NAME"));
 430                 else
 431                         snprintf(trans_font_type_name, 256, "%s", font_type_name);
 432                 #else
 433                 char * default_font_name = NULL;
 434                 default_font_name = _get_default_font();
 435                 char trans_font_type_name[FONT_BUF_SIZE] = {0,};
 436                 if(!safeStrCmp(default_font_name,font_type_name)){
 437                         snprintf(trans_font_type_name, FONT_BUF_SIZE, "%s", SETTING_DEFAULT_FONT_TYPE);
 438                 }else{
 439                         ret = get_font_name_id(font_type_name, trans_font_type_name, FONT_BUF_SIZE);
 440                 }
 441                 #endif
 442                 SETTING_TRACE_DEBUG("current font : %s, trans font name: %s", font_type_name, trans_font_type_name);
 443
 444                 ad->font_type = setting_create_Gendial_exp_parent_field(ad->genlist,
 445                                                                 &(ad->itc_2text_3_parent),
 446                                                                 NULL, NULL,
 447                                                                 SWALLOW_Type_INVALID,
 448                                                                 SETTING_FONT_TYPE_STR,
 449                                                                 trans_font_type_name,
 450                                                                 SETTING_GROUP_STYLE_TOP, SETTING_GROUP_STYLE_TOP);
 451                 if (ad->font_type) {
 452                         ad->font_type->userdata = ad;
 453                 } else {
 454                         SETTING_TRACE_ERROR("ad->font_type is NULL");
 455                 }
 456                 G_FREE(ad->font_name);
 457                 ad->font_name = g_strdup(font_type_name);
 458                 G_FREE(font_type_name);
 459         }
 460
 461         if (ad->viewmode == FONT_SIZE_AND_FONT_SEL_UG || ad->viewmode == FONT_SIZE_VIEW_APPCONTROL)             // font size only
 462         {
 463                 int err = -1;
 464                 // [UI] Font Size
 465                 int ret = setting_get_int_slp_key(INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, &ad->ret_font_size, &err);
 466                 if (ret != 0) {
 467                         SETTING_TRACE_ERROR("get vconf failed");
 468                 }
 469
 470                 ad->font_size = setting_create_Gendial_exp_parent_field(ad->genlist, &(ad->itc_2text_3_parent),
 471                                         NULL,
 472                                         NULL, SWALLOW_Type_INVALID,
 473                                         SETTING_FONT_SIZE_STR,
 474                                         __get_font_size_str(ad->ret_font_size),
 475                                         SETTING_GROUP_STYLE_CENTER, SETTING_GROUP_STYLE_BOTTOM);
 476                 if (ad->font_size) {
 477                         ad->font_size->userdata = ad;
 478                         ad->font_size->group_style = SETTING_GROUP_STYLE_BOTTOM;
 479                 } else {
 480                         SETTING_TRACE_ERROR("ad->font_size is NULL");
 481                 }
 482
 483 #if DISABlED_CODE
 484         ADD_GL_HELP(ad->genlist,SETTING_FONT_SIZE_DESC);
 485 #endif
 486         }
 487
 488         if(ad->font_expand_state == FONT_EXPAND_STATE_FONT_TYPE)
 489         {
 490                 if(ad->font_type && ad->font_type->item){
 491                         elm_genlist_item_expanded_set(ad->font_type->item, TRUE);
 492                 }
 493         } else if (ad->font_expand_state == FONT_EXPAND_STATE_FONT_SIZE){
 494                 if(ad->font_size && ad->font_size->item){
 495                         elm_genlist_item_expanded_set(ad->font_size->item, TRUE);
 496                 }
 497         }
 498 }
 499
 500 static void __setting_progress_popup_cb(void *data, Evas_Object *obj, void *event_info)
 501 {
 502         SettingFontUG *ad = (SettingFontUG *) data;
 503         SETTING_TRACE("send ug_destroy_me by callback");
 504         if (ad->main_popup) {
 505                 evas_object_del(ad->main_popup);
 506                 ad->main_popup = NULL;
 507         }
 508         ad->font_change_status = SELECTED_FONT_CHANGE_DONE;
 509         /*fix PLM issue P130606-3323, per tester's request, need to keep in current font veiw after change the font type*/
 510         //ug_destroy_me(ad->ug);
 511         if(ad->font_type && ad->font_type->item) {
 512                 elm_genlist_item_expanded_set(ad->font_type->item, FALSE);
 513         }
 514 }
 515
 516 static Eina_Bool __font_type_change_call(void *data)
 517 {
 518         SETTING_TRACE_BEGIN;
 519         SettingFontUG *ad = (SettingFontUG *) data;
 520
 521         // logic
 522         system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, ad->font_name);
 523
 524         // finalize
 525         ad->font_type_timer = NULL;
 526         return ECORE_CALLBACK_CANCEL;
 527 }
 528
 529 #if 0
 530 static void __setting_font_main_popup_cb(void *data, Evas_Object *obj, void *event_info)
 531 {
 532         SETTING_TRACE_BEGIN;
 533         setting_retm_if(data == NULL, "Data parameter is NULL");
 534         SettingFontUG *ad = (SettingFontUG *) data;
 535
 536         switch (btn_type(obj)) {
 537         case POPUP_RESPONSE_OK:
 538                 {
 539                         /* extract font name from tag mixed string */
 540                         SETTING_TRACE("??? --> popup - get FONT : %s ", ad->subitem->keyStr);
 541                         SETTING_TRACE("sub_desc --> popup - get FONT : %s ", ad->subitem->sub_desc);
 542
 543                         /* set font name to font main and font config */
 544                         /*for mincho font type, need to display "Mincho",but need to update the real font with "UDMincho"*/
 545                         /*keyStr is used to store the string "Mincho", and sub_desc is used to store "UDMDu4"*/
 546                         ad->font_type->sub_desc = (char *)g_strdup(ad->subitem->keyStr);
 547                         elm_object_item_data_set(ad->font_type->item, ad->font_type);
 548                         elm_genlist_item_update(ad->font_type->item);
 549                         // sub - descc
 550                         char *font_name = g_strdup(ad->subitem->sub_desc);
 551
 552                         ad->prev_font = ad->subitem->chk_status;
 553                         G_FREE(ad->font_name);
 554                         ad->font_name = (char *)g_strdup(_(font_name));
 555                         SETTING_TRACE("ad->subitem->keyStr2 = %s", font_name);
 556                         elm_radio_value_set(ad->subitem->rgd, ad->subitem->chk_status);
 557                         /*when the expandlist item is NOT expanded, the subitem object is not existed,so need to clear the list*/
 558                         if(ad->font_type_list != NULL ){
 559                                 Setting_GenGroupItem_Data *font_type_subitem = NULL;
 560                                 EINA_LIST_FREE(ad->font_type_list, font_type_subitem);
 561                                 ad->font_type_list = NULL;
 562                         }
 563                         #if 0
 564                         //vconf_set_str(VCONFKEY_SETAPPL_SETTING_FONT_NAME, font_name);
 565                         system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, font_name);
 566                         G_FREE(font_name);
 567                         #endif
 568
 569                         // waiting
 570                         //Due to long time taken by font Setting, add the block code when font is Setting.
 571                         if (ad->main_popup) {
 572                                 evas_object_del(ad->main_popup);
 573                                 ad->main_popup = NULL;
 574                         }
 575
 576                         // font type popup
 577                         ad->main_popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 578                                         PROGRESSBAR_STYLE,
 579                                         NULL, KeyStr_Loading, __setting_progress_popup_cb, 3/*0*/, TRUE, TRUE); // 3 seconds to wait in maximum
 580
 581                         // ecore timer for change actual font
 582                         ad->font_type_timer = ecore_timer_add(1, (Ecore_Task_Cb)__font_type_change_call, ad);
 583                         break;
 584                 }
 585         case POPUP_RESPONSE_CANCEL:
 586                 {
 587                         elm_radio_value_set(ad->subitem->rgd, ad->prev_font);
 588                         if (ad->main_popup) {
 589                                 evas_object_del(ad->main_popup);
 590                                 ad->main_popup = NULL;
 591                         }
 592                         ad->font_change_status = SELECTED_FONT_CHANGE_DONE;
 593                         break;
 594                 }
 595         default:
 596                 {
 597                         break;
 598                 }
 599         }
 600 }
 601
 602 static void __setting_font_main_popup(void *data)
 603 {
 604         SETTING_TRACE_BEGIN;
 605         setting_retm_if(data == NULL, "Data parameter is NULL");
 606         SettingFontUG *ad = (SettingFontUG *) data;
 607
 608         char temp[FONT_BUF_SIZE] = {0,};
 609         format_font_name_by_id(ad->subitem->sub_desc,ad->subitem->keyStr2, temp, FONT_BUF_SIZE);
 610         char popup_desc[SETTING_STR_SLP_LEN + 1] = {0,};
 611         snprintf(popup_desc, SETTING_STR_SLP_LEN, _(SETTING_FONT_POPUP_DESC), temp);
 612         if(!ad->main_popup){
 613                 ad->main_popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
 614                                          popup_desc,
 615                                          __setting_font_main_popup_cb, 0,
 616                                          2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
 617         }
 618 }
 619 #endif
 620
 621 /**
 622  * [UI][expandable list][event handler:selection][font change]
 623  */
 624 void __setting_font_main_sub_list_sel_cb(void *data, Evas_Object *obj, void *event_info)
 625 {
 626         SETTING_TRACE_BEGIN;
 627         /* error check */
 628         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 629         Elm_Object_Item *subitem = (Elm_Object_Item *) event_info;
 630         elm_genlist_item_selected_set(subitem, 0);
 631         Setting_GenGroupItem_Data *data_subItem = elm_object_item_data_get(subitem);
 632         ret_if(NULL == data_subItem);
 633
 634         SettingFontUG *ad = (SettingFontUG *) data;
 635
 636
 637         /*  if not change, return */
 638         if (ad->prev_font == data_subItem->chk_status) {
 639                 SETTING_TRACE("NOT CHANGED ");
 640                 return;
 641         }
 642         if(ad->font_change_status == SELECTED_FONT_CHANGE_IN_PROCESS){
 643                 return;
 644         }
 645         ad->font_change_status = SELECTED_FONT_CHANGE_IN_PROCESS;
 646         ad->subitem = data_subItem;
 647         /* Fix PLM P131016-04680
 648           when user check the option, make sure the radio button is checked for prev_font font item
 649           the radio of new font item will be checked when user seleck "ok" on popup*/
 650         elm_radio_value_set(ad->subitem->rgd, data_subItem->chk_status);
 651
 652         /* extract font name from tag mixed string */
 653         SETTING_TRACE("??? --> popup - get FONT : %s ", ad->subitem->keyStr);
 654         SETTING_TRACE("sub_desc --> popup - get FONT : %s ", ad->subitem->sub_desc);
 655
 656         /* set font name to font main and font config */
 657         /*for mincho font type, need to display "Mincho",but need to update the real font with "UDMincho"*/
 658         /*keyStr is used to store the string "Mincho", and sub_desc is used to store "UDMDu4"*/
 659         ad->font_type->sub_desc = (char *)g_strdup(ad->subitem->keyStr);
 660         elm_object_item_data_set(ad->font_type->item, ad->font_type);
 661         elm_genlist_item_update(ad->font_type->item);
 662         // sub - descc
 663         char *font_name = g_strdup(ad->subitem->sub_desc);
 664
 665         ad->prev_font = ad->subitem->chk_status;
 666         G_FREE(ad->font_name);
 667         ad->font_name = (char *)g_strdup(_(font_name));
 668         SETTING_TRACE("ad->subitem->keyStr2 = %s", font_name);
 669
 670         /*when the expandlist item is NOT expanded, the subitem object is not existed,so need to clear the list*/
 671         if(ad->font_type_list != NULL ){
 672                 eina_list_free(ad->font_type_list);
 673                 ad->font_type_list = NULL;
 674         }
 675
 676         // waiting
 677         //Due to long time taken by font Setting, add the block code when font is Setting.
 678         if (ad->main_popup) {
 679                 evas_object_del(ad->main_popup);
 680                 ad->main_popup = NULL;
 681         }       // font type popup
 682         ad->main_popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 683                         PROGRESSBAR_STYLE,
 684                         NULL, KeyStr_Loading, __setting_progress_popup_cb, 3/*0*/, TRUE, TRUE); // 3 seconds to wait in maximum
 685
 686         // ecore timer for change actual font
 687         ad->font_type_timer = ecore_timer_add(1, (Ecore_Task_Cb)__font_type_change_call, ad);
 688 }
 689
 690 /**
 691 * @brief expandable list handler for font-type
 692 *
 693 * @param data
 694 * @param obj
 695 * @param event_info
 696 */
 697 static void __setting_font_main_exp_cb(void *data, Evas_Object *obj, void *event_info)
 698 {
 699         ret_if(NULL == data || NULL == event_info);
 700         SETTING_TRACE_BEGIN;
 701         SettingFontUG *ad = (SettingFontUG *) data;
 702         Elm_Object_Item *parentItem = event_info;       /* parent item */
 703         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);      /* parent data */
 704         Evas_Object *scroller = elm_object_item_widget_get(parentItem);
 705
 706         Evas_Object *rgd = NULL;
 707         int i = 0;
 708         int matched_font = -1;
 709         G_FREE(ad->font_name);
 710         int ret = 0;
 711         ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &(ad->font_name));
 712         if(ret != SYSTEM_SETTINGS_ERROR_NONE){
 713                 SETTING_TRACE_ERROR("Failed to call system_settings_get_value_string with error cdoe %d",ret);
 714                 ad->font_name = _get_default_font();
 715         }
 716         if (data_parentItem == ad->font_type) {
 717                 rgd = elm_radio_add(scroller);
 718                 elm_radio_value_set(rgd, -1);
 719
 720                 char * default_font_name = NULL;
 721                 default_font_name = _get_default_font();
 722                 if(NULL != default_font_name){
 723                         //char font_name_dispaly[FONT_BUF_SIZE] = {0,};
 724                         SETTING_TRACE_DEBUG("default_font_name:%s",default_font_name);
 725                         //format_default_font(SETTING_DEFAULT_FONT_TYPE, font_name_dispaly,FONT_BUF_SIZE, default_font_name);
 726                         Setting_GenGroupItem_Data *item_data =  (Setting_GenGroupItem_Data *) calloc(1,sizeof(Setting_GenGroupItem_Data));
 727                         setting_retm_if(!item_data, "calloc failed");
 728                         item_data->keyStr2 = (char *)g_strdup(SETTING_DEFAULT_FONT_TYPE);//for display
 729                         item_data->keyStr = (char *)g_strdup(_(SETTING_DEFAULT_FONT_TYPE));//for tts reading
 730                         item_data->swallow_type = SWALLOW_Type_1RADIO;
 731                         item_data->chk_status = i;
 732                         item_data->rgd = rgd;
 733                         item_data->chk_change_cb = NULL;
 734                         item_data->group_style = SETTING_GROUP_STYLE_CENTER;
 735                         item_data->sub_desc = strdup(default_font_name); //the real font type value
 736                         item_data->item = elm_genlist_item_append(scroller, &(ad->itc_1text_1icon_2), item_data, parentItem, ELM_GENLIST_ITEM_NONE, __setting_font_main_sub_list_sel_cb, ad);
 737
 738                         if (item_data) {
 739                                 setting_genlist_item_groupstyle_set(item_data, SETTING_GROUP_STYLE_CENTER);
 740                                 item_data->userdata = ad;
 741                                 if (!safeStrCmp(ad->font_name, (const char*)item_data->sub_desc)) {
 742                                         matched_font = i;
 743                                 }
 744                         }
 745                         i++;
 746                         ad->font_type_list = eina_list_append(ad->font_type_list,item_data);
 747                 }
 748
 749                 Eina_List *font_list = NULL;
 750                 Eina_List *l = NULL;
 751                 FcChar8 *font_data = NULL;
 752                 font_list = __setting_font_main_available_list_get();
 753                 EINA_LIST_FOREACH(font_list, l, font_data)
 754                 {
 755                         if(safeStrCmp(default_font_name, (char *)font_data) != 0){
 756                                 char keyStr[FONT_BUF_SIZE] = {0,};
 757                                 get_font_name_str((char*)font_data, keyStr, FONT_BUF_SIZE);
 758                                 char temp[FONT_BUF_SIZE] = {0,};
 759                                 //int ret = get_font_name_tag(font_data, temp, FONT_BUF_SIZE);
 760                                 get_font_name_id((char*)font_data, temp, FONT_BUF_SIZE);
 761                                 SETTING_TRACE_DEBUG("font data : %s", (char*)font_data);
 762                                 Setting_GenGroupItem_Data *item_data =  (Setting_GenGroupItem_Data *) calloc(1,sizeof(Setting_GenGroupItem_Data));
 763                                 setting_retm_if(!item_data,"calloc failed");
 764                                 item_data->keyStr2 = (char *)g_strdup(temp);//for display
 765                                 item_data->keyStr = (char *)g_strdup(keyStr);//for tts reading
 766                                 item_data->swallow_type = SWALLOW_Type_1RADIO;
 767                                 item_data->chk_status = i;
 768                                 item_data->rgd = rgd;
 769                                 item_data->chk_change_cb = NULL;
 770                                 item_data->group_style = SETTING_GROUP_STYLE_CENTER;
 771                                 item_data->sub_desc = strdup((char*)font_data);
 772                                 item_data->item = elm_genlist_item_append(scroller, &(ad->itc_1text_1icon_2), item_data, parentItem, ELM_GENLIST_ITEM_NONE, __setting_font_main_sub_list_sel_cb, ad);
 773
 774                                 if (item_data) {
 775                                         item_data->userdata = ad;
 776                                         //if (!safeStrCmp(ad->font_name, (const char*)font_data)) {
 777                                         if (!safeStrCmp(ad->font_name, (const char*)item_data->sub_desc)) {
 778                                                 matched_font = i;
 779                                         }
 780                                 }
 781                                 i++;
 782                                 ad->font_type_list = eina_list_append(ad->font_type_list,item_data);
 783                         }
 784                 }
 785
 786                 /* update check status */
 787                 if (matched_font != -1) {
 788                         elm_radio_value_set(rgd, matched_font);
 789                 }
 790
 791                 ad->prev_font = matched_font;
 792                 G_FREE(default_font_name);
 793         }else if (data_parentItem == ad->font_size) {
 794                 // [UI] create the font list
 795                 ad->size_rdg = elm_radio_add(scroller);
 796                 elm_radio_state_value_set(ad->size_rdg, -1);
 797
 798                 int idx = 0;
 799
 800                 while(font_size_table[idx].key_font_name) {
 801                         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) calloc(1,sizeof(Setting_GenGroupItem_Data));
 802                         setting_retm_if(!item_data, "calloc failed");
 803                         item_data->keyStr2 = (char *)g_strdup(font_size_table[idx].key_font_name);//setting_customize_text(_(font_size_table[idx].key_font_name), convert_font_size(font_size_table[idx].font_size),NULL,NULL);//for display
 804                         item_data->keyStr = (char *)g_strdup(_(font_size_table[idx].key_font_name));//for tts feature;
 805                         item_data->swallow_type = SWALLOW_Type_1RADIO_1LABLE;
 806                         item_data->chk_status = font_size_table[idx].font_size;
 807                         item_data->chk_change_cb = NULL;
 808                         item_data->rgd = ad->size_rdg;
 809                         item_data->userdata = ad;
 810                         if(idx == sizeof(font_size_table)/sizeof(font_size_table[0])-2){
 811                                 item_data->group_style = SETTING_GROUP_STYLE_BOTTOM;
 812                         } else {
 813                                 item_data->group_style = SETTING_GROUP_STYLE_CENTER;
 814                         }
 815
 816                         item_data->item = elm_genlist_item_append(scroller, &(ad->itc_1text_1icon_2_font_size), item_data, parentItem,
 817                                                         ELM_GENLIST_ITEM_NONE, setting_font_font_size_list_mouse_up_cb,ad->size_rdg);
 818
 819                         idx++;
 820                 }
 821                 setting_update_chk_status(ad->size_rdg, INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE);
 822         }
 823 }
 824 static void __setting_font_main_vconf_change_cb(keynode_t *key, void *data)
 825 {
 826         SETTING_TRACE_BEGIN;
 827         setting_retm_if(NULL == key, "key is NULL");
 828         setting_retm_if(NULL == data, "data is NULL");
 829         SettingFontUG *ad = (SettingFontUG *)data;
 830
 831         char *vconf_name = vconf_keynode_get_name(key);
 832
 833         if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME)) {
 834
 835
 836                 char *font_type_name = NULL;
 837                 int ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &font_type_name);
 838                 if(ret !=0 ){
 839                         SETTING_TRACE("system-setting call failed with error code %d", ret);
 840                 }
 841                 SETTING_TRACE("---------------- system-setting call : (%s) ", font_type_name);
 842                 char * default_font_name = NULL;
 843                 default_font_name = _get_default_font();
 844                 char trans_font_type_name[FONT_BUF_SIZE] = {0,};
 845                 if(!safeStrCmp(default_font_name,font_type_name)){
 846                         snprintf(trans_font_type_name, FONT_BUF_SIZE, "%s", SETTING_DEFAULT_FONT_TYPE);
 847                 }else{
 848                         ret = get_font_name_id(font_type_name, trans_font_type_name, FONT_BUF_SIZE);
 849                 }
 850
 851                 if (ad->font_type) {
 852                         G_FREE(ad->font_type->sub_desc);
 853                         ad->font_type->sub_desc = (char *)g_strdup(trans_font_type_name);
 854                         elm_object_item_data_set(ad->font_type->item, ad->font_type);
 855                         elm_genlist_item_update(ad->font_type->item);
 856                         SETTING_TRACE("ad->font_type->sub_desc:%s",trans_font_type_name);
 857
 858                         if(elm_genlist_item_expanded_get(ad->font_type->item)){
 859                                 Eina_List *l = NULL;
 860                                 Setting_GenGroupItem_Data *font_type_subitem;
 861                                 EINA_LIST_FOREACH(ad->font_type_list, l, font_type_subitem) {
 862                                         if (font_type_subitem && !safeStrCmp(font_type_subitem->sub_desc,font_type_name))
 863                                         {
 864
 865                                                 if(font_type_subitem&& font_type_subitem->rgd){
 866                                                         elm_radio_value_set(font_type_subitem->rgd, font_type_subitem->chk_status);
 867                                                         if(ad->font_change_status != SELECTED_FONT_CHANGE_IN_PROCESS ){
 868                                                                 ad->subitem = font_type_subitem;
 869                                                         }
 870                                                 }
 871                                                 break;
 872
 873                                         }
 874                                 }
 875                         }
 876                 }
 877         }else if(!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE)){
 878                 int err = -1;
 879                 // [UI] Font Size
 880                 int ret = setting_get_int_slp_key(INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, &ad->ret_font_size, &err);
 881                 if (ret != 0) {
 882                         SETTING_TRACE_ERROR("get vconf failed");
 883                 }
 884                 if(ad->font_size){
 885                         G_FREE(ad->font_size->sub_desc);
 886                         ad->font_size->sub_desc = (char *)g_strdup(__get_font_size_str(ad->ret_font_size));
 887                         elm_object_item_data_set(ad->font_size->item, ad->font_size);
 888                         elm_genlist_item_update(ad->font_size->item);
 889
 890                         if(elm_genlist_item_expanded_get(ad->font_size->item)){
 891                                 if(ad->size_rdg){
 892                                         setting_update_chk_status(ad->size_rdg, INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE);
 893                                 }
 894                         }
 895                 }
 896
 897         }else{
 898                 SETTING_TRACE_ERROR("vconf_name is error");
 899         }
 900         SETTING_TRACE_END;
 901 }
 902
 903
 904 /* ***************************************************
 905  *
 906  *basic func
 907  *
 908  ***************************************************/
 909 static int setting_font_main_create(void *cb)
 910 {
 911         SETTING_TRACE_BEGIN;
 912         /* error check */
 913         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 914
 915         SettingFontUG *ad = (SettingFontUG *) cb;
 916         setting_create_Gendial_itc("1line", &(ad->itc_1text_1icon_2));
 917         ad->itc_1text_1icon_2.func.text_get = _item_text_keystr2_get;
 918
 919         retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
 920                  "win_main_layout is NULL");
 921         ad->font_change_status = SELECTED_FONT_CHANGE_NONE;
 922         ad->ly_main =
 923             setting_create_layout_navi_bar_genlist(ad->win_main_layout,
 924                                                    ad->win_get,
 925                                                    "IDS_COM_BODY_FONT",
 926                                                    _("IDS_COM_BODY_BACK"),
 927                                                    NULL,
 928                                                    (setting_call_back_func)__setting_font_main_click_softkey_back_cb,
 929                                                    NULL,
 930                                                    ad, &ad->genlist, &ad->navibar);
 931         ad->navi_it_font = elm_naviframe_top_item_get(ad->navibar);
 932         elm_genlist_mode_set(ad->genlist, ELM_LIST_COMPRESS);
 933         evas_object_smart_callback_add(ad->genlist, "realized", __gl_realized_cb, ad);
 934
 935         setting_enable_expandable_genlist(ad->genlist, ad, __setting_font_main_exp_cb, NULL);
 936         int ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME,
 937                         __setting_font_main_vconf_change_cb, ad);
 938         if (ret != 0) {
 939                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
 940         }
 941         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE,
 942                         __setting_font_main_vconf_change_cb, ad);
 943         if (ret != 0) {
 944                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
 945         }
 946         __setting_font_main_genlist_item_create(ad);
 947
 948         evas_font_reinit();
 949
 950         setting_view_font_main.is_create = 1;
 951         return SETTING_RETURN_SUCCESS;
 952 }
 953
 954 static int setting_font_main_destroy(void *cb)
 955 {
 956         SETTING_TRACE_BEGIN;
 957         /* error check */
 958         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 959
 960         SettingFontUG *ad = (SettingFontUG *) cb;
 961         int ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME,
 962                         __setting_font_main_vconf_change_cb);
 963         if (ret != 0) {
 964                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
 965         }
 966         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE,
 967                         __setting_font_main_vconf_change_cb);
 968         if (ret != 0) {
 969                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
 970         }
 971         if(ad->font_name)
 972         {
 973                 G_FREE(ad->font_name);
 974                 ad->font_name = NULL;
 975         }
 976
 977         if (ad->main_popup) {
 978                 evas_object_del(ad->main_popup);
 979                 ad->main_popup = NULL;
 980         }
 981
 982         if (ad->ly_main != NULL) {
 983                 evas_object_del(ad->ly_main);
 984                 ad->ly_main = NULL;
 985         }
 986         if (ad->navi_it_font!= NULL){
 987                 ad->navi_it_font = NULL;
 988         }
 989         if(ad->font_type_list != NULL ){
 990                 eina_list_free(ad->font_type_list);
 991                 ad->font_type_list = NULL;
 992         }
 993
 994         setting_view_font_main.is_create = 0;
 995         SETTING_TRACE_END;
 996         return SETTING_RETURN_SUCCESS;
 997 }
 998
 999 static int setting_font_main_update(void *cb)
1000 {
1001         SETTING_TRACE_BEGIN;
1002         /* error check */
1003         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1004
1005         SettingFontUG *ad = (SettingFontUG *) cb;
1006
1007         if (ad->ly_main != NULL) {
1008                 evas_object_show(ad->ly_main);
1009
1010                 int value = -1;
1011                 int err = -1;
1012                 int ret = setting_get_int_slp_key(INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, &value, &err);
1013                 if (ret != 0) {
1014                         SETTING_TRACE_ERROR("get vconf failed");
1015                 }
1016
1017                 if (ad->font_size) {
1018                         G_FREE(ad->font_size->sub_desc);
1019                         ad->font_size->sub_desc = (char *)g_strdup(__get_font_size_str(value));
1020                         elm_object_item_data_set(ad->font_size->item, ad->font_size);
1021                         elm_genlist_item_update(ad->font_size->item);
1022                 }
1023                 // setting_font_update_vconf_key(ad, SETTING_VCONF_INT_TYPE, INT_SLP_SETTING_LCD_TIMEOUT_NORMAL);
1024         }
1025         if (ad->font_type){
1026                 elm_genlist_item_update(ad->font_type->item);
1027         }
1028         return SETTING_RETURN_SUCCESS;
1029 }
1030
1031 static int setting_font_main_cleanup(void *cb)
1032 {
1033         /* error check */
1034         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1035
1036         SettingFontUG *ad = (SettingFontUG *) cb;
1037
1038         if (ad->ly_main != NULL) {
1039                 evas_object_hide(ad->ly_main);
1040         }
1041
1042         return SETTING_RETURN_SUCCESS;
1043 }
1044
1045 /* ***************************************************
1046  *
1047  *call back func
1048  *
1049  ***************************************************/
1050
1051 static Eina_Bool __setting_font_main_click_softkey_back_cb(void *data, Elm_Object_Item *it)
1052 {
1053         SETTING_TRACE_BEGIN;
1054         /* error check */
1055         retv_if(data == NULL, EINA_FALSE);
1056
1057         SettingFontUG *ad = (SettingFontUG *) data;
1058
1059         if (ad->viewmode == FONT_SEL_VIEW_APPCONTROL)
1060         {
1061                 app_control_h svc;
1062                 if (app_control_create(&svc)) {
1063                         return EINA_FALSE;
1064                 }
1065
1066                 app_control_add_extra_data(svc, "category", "FontType");
1067                 app_control_add_extra_data(svc, "FontType", ad->font_name);
1068
1069                 SETTING_TRACE(" SERVICE_ADD_EXTRA : %s %s","category", "FontType");
1070                 SETTING_TRACE(" SERVICE_ADD_EXTRA : %s %s","FontType", ad->font_name);
1071
1072
1073                 ug_send_result(ad->ug, svc);
1074                 app_control_destroy(svc);
1075         }
1076         else if (ad->viewmode == FONT_SIZE_VIEW_APPCONTROL)
1077         {
1078                 app_control_h svc;
1079
1080                 int err;
1081                 int ret = setting_set_int_slp_key(INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, ad->ret_font_size, &err);
1082                 setting_retvm_if(ret == -1,EINA_FALSE, "Failed to set vconf");
1083
1084                 if (app_control_create(&svc)) {
1085                         return EINA_FALSE;
1086                 }
1087
1088                 char font_size[SETTING_FONT_MAX_LEN] = {0,};
1089                 snprintf(font_size, SETTING_FONT_MAX_LEN, "%d", ad->ret_font_size);
1090
1091                 app_control_add_extra_data(svc, "category", "FontSize");
1092                 app_control_add_extra_data(svc, "FontSize", font_size);
1093
1094                 SETTING_TRACE(" SERVICE_ADD_EXTRA : %s %s","category", "FontSize");
1095                 SETTING_TRACE(" SERVICE_ADD_EXTRA : %s %s","FontSize", font_size);
1096
1097
1098                 ug_send_result(ad->ug, svc);
1099                 app_control_destroy(svc);
1100         }
1101         /* Send destroy request */
1102         ug_destroy_me(ad->ug);
1103         return EINA_FALSE;
1104 }