ug-lockscreen-setting-efl/src/lockscreen-options-util.c

   1 /*
   2  *  starter
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seungtaek Chung <seungtaek.chung@samsung.com>, Mi-Ju Lee <miju52.lee@samsung.com>, Xi Zhichan <zhichan.xi@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
  22 #include <vconf.h>
  23 #include <vconf-keys.h>
  24 #include <fontconfig/fontconfig.h>
  25 #include <libintl.h>
  26
  27 #include "lockscreen-options-debug.h"
  28 #include "lockscreen-options.h"
  29 #include "lockscreen-options-util.h"
  30 //#include "lockscreen-options-shortcuts.h"
  31 //#include "lockscreen-options-locktitle.h"
  32
  33 #define FONT_PRELOAD_FONT_PATH "/usr/share/fonts"
  34 #define FONT_DOWNLOADED_FONT_PATH "/opt/share/fonts"
  35
  36 const char *sys_str_table[] = {
  37         "IDS_COM_SK_OK",
  38         "IDS_COM_SK_CANCEL",
  39         "IDS_COM_BODY_FACEBOOK",
  40 };
  41
  42 const char *app_str_table[] = {
  43         "IDS_ST_HEADER_LOCK_SCREEN_SETTINGS",
  44         "IDS_LCKSCN_HEADER_PERSONAL_MESSAGE",
  45         "IDS_HS_HEADER_THEMES",
  46         "IDS_LCKSCN_HEADER_LOCK_SCREEN",
  47         "IDS_LCKSCN_HEADER_SET_SHORTCUTS",
  48         "IDS_ST_BODY_SCREEN_LOCK_TYPE",
  49         "IDS_LCKSCN_MBODY_WALLPAPERS",
  50         "IDS_ST_BODY_SHORTCUTS",
  51         "IDS_ST_BODY_SET_SHORTCUTS_ON_LOCK_SCREEN",
  52         "IDS_ST_BODY_SHORTCUTS",
  53         "IDS_LCKSCN_BODY_CUSTOMISE_WHICH_SHORTCUTS_WILL_BE_SHOWN_ON_THE_LOCK_SCREEN",
  54         /* stytle start */
  55         "IDS_LCKSCN_BODY_LOCK_SCREEN_THEMES_ABB",
  56         "",
  57         "Set contents on the lock screen",
  58         "IDS_LCKSCN_BODY_CUSTOMISE_THE_STYLE_OF_YOUR_LOCK_SCREEN",
  59         /* stytle end */
  60         "IDS_LCKSCN_BODY_BRIEFING_BOX_ABB",
  61         "Missed event, Weather, Shortcuts...",
  62         "IDS_LCKSCN_BODY_CUSTOMISE_WHICH_ITEMS_WILL_BE_SHOWN_IN_YOUR_BRIEFING_BOX_ON_THE_LOCK_SCREEN",
  63         "IDS_LCKSCN_BODY_PERSONAL_MESSAGE_ABB",
  64         "IDS_LCKSCN_BODY_DISPLAY_YOUR_PERSONAL_MESSAGE_ON_THE_LOCK_SCREEN",
  65         //"Event notifications",
  66         "IDS_IDLE_MBODY_EVENT_NOTIFICATIONS",
  67         //"View event notification on lock screen",
  68         "IDS_IDLE_BODY_VIEW_EVENT_NOTIFICATIONS_ON_THE_LOCK_SCREEN",
  69         "Context-aware notifications",
  70         "View context-aware notifications on lock screen",
  71 #if USE_CAMERA
  72         "IDS_ST_MBODY_CAMERA_QUICK_ACCESS",
  73         "IDS_ST_BODY_TAP_AND_HOLD_THE_SCREEN_WHILE_ROTATING_THE_DEVICE_TO_OPEN_CAMERA",
  74 #endif
  75         "IDS_ST_BODY_CLOCK",
  76         "IDS_LCKSCN_MBODY_DUAL_CLOCK",
  77         "IDS_ST_BODY_SHOW_DUAL_CLOCK_ON_LOCK_SCREEN_WHEN_ROAMING",
  78         "IDS_ST_MBODY_SET_HOME_CITY",
  79         "IDS_LCKSCN_BODY_WAKE_UP_IN_LOCK_SCREEN_ABB",
  80         "IDS_HELP_BODY_UNLOCK_DEVICE_WITH_YOUR_WAKE_UP_COMMAND_WHEN_SWIPE_OR_MOTION_SCREEN_LOCK_TYPE_IS_ENABLED",
  81         "IDS_SKM_BODY_WEATHER_M_IDEA_SKETCH",
  82         "IDS_IM_BODY_HELP_TEXT",
  83         "IDS_ST_BODY_SHOW_HELP_TEXT_ON_LOCK_SCREEN",
  84         "IDS_ST_BODY_SET_SHORTCUTS",
  85         "IDS_ST_OPT_EDIT_SHORTCUTS",
  86         "IDS_ST_BODY_SET_SHORTCUTS_ON_LOCK_SCREEN",
  87         "IDS_ST_BODY_TAP_SHORTCUT_TO_ASSIGN_APPLICATION",
  88         "IDS_ST_BODY_DRAG_AND_DROP_TO_CHANGE_ORDER",
  89         "IDS_ST_BODY_SELECT_APPLICATION",
  90         "IDS_LCKSCN_BODY_PERSONAL_MESSAGE_ABB",
  91         "IDS_LCKSCN_HEADER_LOCK_SCREEN_THEMES_ABB",
  92         "IDS_ST_BODY_SET_AS_LOCK_SCREEN",
  93         "IDS_ST_BODY_PREVIEW",
  94         "IDS_ST_BODY_APPLY",
  95         "IDS_LCKSCN_HEADER_BRIEFING_BOX",
  96         "IDS_ST_BODY_ITEMS",
  97         "IDS_LCKSCN_BODY_MUSIC_CONTROLLER_ABB",
  98         "IDS_IDLE_MBODY_EVENT_NOTIFICATIONS",
  99         "IDS_LCKSCN_BODY_NEWS_ABB",
 100         "IDS_LCKSCN_BODY_SCHEDULE",
 101         "IDS_LCKSCN_BODY_CLEAR_M_LOCKSCREEN_NAME",
 102         "IDS_LCKSCN_BODY_CLOSE_UP_M_LOCKSCREEN_NAME",
 103         "IDS_LCKSCN_BODY_BOOK_COVER_M_LOCKSCREEN_NAME",
 104         "IDS_LCKSCN_BODY_MAGAZINE_M_LOCKSCREEN_NAME",
 105         "IDS_LCKSCN_BODY_DIARY",
 106         "IDS_LCKSCN_BODY_FUN_M_LOCKSCREEN_NAME",
 107         "IDS_LCKSCN_BODY_POLAROID_M_LOCKSCREEN_NAME",
 108         "IDS_SKM_BODY_WEATHER_M_IDEA_SKETCH",
 109         "IDS_ST_BODY_STYLE",
 110         "IDS_ST_BODY_NONE",
 111         "IDS_ST_MBODY_SWIPE",
 112         "IDS_ST_BODY_MOTION",
 113         "Face and voice",
 114         "IDS_ST_BODY_SIMPLE_PASSWORD",
 115         "IDS_ST_BODY_PASSWORD",
 116         "IDS_ST_POP_LOCK_SCREEN_WALLPAPER_CHANGED_ABB",
 117         "IDS_LCKSCN_MBODY_SET_WAKE_UP_COMMAND",
 118         "IDS_LCKSCN_BODY_EDIT_PERSONAL_MESSAGE",
 119         "IDS_COM_BODY_EDIT",
 120         "IDS_LCKSCN_BODY_YOU_CAN_INPUT_TEXT_ON_THE_LOCK_SCREEN_AND_EDIT_IT_BY_SELECTING_EDIT_PERSONAL_MESSAGE",
 121         "IDS_ST_HEADER_UNLOCK_EFFECT",
 122         "IDS_LCKSCN_OPT_CONFETTI_M_EFFECT",
 123         "IDS_LCKSCN_OPT_GEOMETRIC_M_EFFECT",
 124         "IDS_LCKSCN_OPT_STARDUST_M_EFFECT",
 125         "IDS_LCKSCN_OPT_GLOW_WORMS_M_EFFECT",
 126         "IDS_STORYALBUM_OPT_EDIT_TITLE",
 127         "IDS_LCKSCN_HEADER_SPECIAL_DAY_WALLPAPERS_ABB",
 128         "IDS_ST_HEADER_WEATHER_EFFECT_ABB",
 129         "IDS_LCKSCN_BODY_CUSTOMISE_THE_STYLE_OF_YOUR_LOCK_SCREEN",
 130         "IDS_ST_MBODY_FINGERPRINT",
 131         "IDS_ST_BODY_AUTO_LOCK",
 132         "IDS_ST_BODY_CAMERA_SHORTCUT",
 133         "IDS_ST_BODY_ADDITIONAL_INFORMATION_ABB",
 134         "IDS_ST_BODY_SHOW_INFORMATION_ABOUT_THE_WEATHER_AND_YOUR_STEP_COUNT_ON_THE_LOCK_SCREEN",
 135         "IDS_SKM_BODY_WEATHER_M_IDEA_SKETCH",
 136         "IDS_ST_BUTTON2_PEDOMETER",
 137         "IDS_LCKSCN_BODY_SHOW_INFORMATION_ABOUT_THE_WEATHER_HBASED_ON_THE_WEATHER_APPLICATION_MSG",
 138         "IDS_ST_BODY_DISPLAY_A_WEATHER_EFFECT_ON_THE_LOCK_SCREEN",
 139         "IDS_IM_BODY_HELP_TEXT",//90
 140         "IDS_ST_BODY_SHOW_HELP_TEXT_ON_LOCK_SCREEN",
 141         "IDS_LCKSCN_BODY_THEMED_WALLPAPER_WILL_BE_APPLIED_ON_THE_LOCK_SCREEN_FOR_RUSSIAN_PUBLIC_HOLIDAYS",
 142         "IDS_LCKSCN_MBODY_SWIPE_THEN_ENTER_PASSWORD",
 143         "IDS_LCKSCN_BODY_SET_THE_DEVICE_TO_SHOW_THE_KEYBOARD_AFTER_YOU_SWIPE_THE_LOCK_SCREEN",
 144 };
 145
 146 static Elm_Gen_Item_Class itc_underline;
 147 static Elm_Gen_Item_Class itc_separator;
 148 static Elm_Gen_Item_Class itc_separator2;
 149
 150 Evas_Object *lockscreen_options_util_create_navigation(Evas_Object * parent)
 151 {
 152         Evas_Object *navi_bar = NULL;
 153
 154         if (parent == NULL) {
 155                 LOCKOPTIONS_WARN("Parent is null.");
 156                 return NULL;
 157         }
 158
 159         navi_bar = elm_naviframe_add(parent);
 160         if (navi_bar == NULL) {
 161                 LOCKOPTIONS_ERR("Cannot add naviagtionbar.");
 162                 return NULL;
 163         }
 164
 165         eext_object_event_callback_add(navi_bar, EEXT_CALLBACK_BACK, eext_naviframe_back_cb, NULL);
 166
 167         elm_object_part_content_set(parent, "elm.swallow.content", navi_bar);
 168
 169         evas_object_show(navi_bar);
 170
 171         return navi_bar;
 172 }
 173
 174 Evas_Object *lockscreen_options_util_create_layout(Evas_Object * parent,
 175                                                    const char *file,
 176                                                    const char *group)
 177 {
 178         Evas_Object *layout = NULL;
 179
 180         if (parent == NULL) {
 181                 LOCKOPTIONS_WARN("Parent is null.");
 182                 return NULL;
 183         }
 184
 185         layout = elm_layout_add(parent);
 186         if (layout == NULL) {
 187                 LOCKOPTIONS_ERR("Cannot add layout.");
 188                 return NULL;
 189         }
 190
 191         if ((file != NULL) && (group != NULL)) {
 192                 elm_layout_file_set(layout, file, group);
 193         }
 194
 195         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 196                                          EVAS_HINT_EXPAND);
 197
 198         evas_object_show(layout);
 199
 200         return layout;
 201 }
 202
 203 void lockscreen_options_util_create_seperator(Evas_Object * genlist)
 204 {
 205         if (NULL == genlist)
 206                 return;
 207
 208         Elm_Object_Item *item = NULL;
 209
 210         itc_separator.item_style = LOCKSCREEN_GENLIST_STYLE_SEPERATOR;
 211         itc_separator.func.text_get = NULL;
 212         itc_separator.func.content_get = NULL;
 213         itc_separator.func.state_get = NULL;
 214         itc_separator.func.del = NULL;
 215
 216         item =
 217             elm_genlist_item_append(genlist, &(itc_separator), NULL, NULL,
 218                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 219         elm_genlist_item_select_mode_set(item,
 220                                          ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 221 }
 222
 223 void lockscreen_options_util_create_seperator2(Evas_Object * genlist)
 224 {
 225         if (NULL == genlist)
 226                 return;
 227         Elm_Object_Item *item = NULL;
 228         itc_separator2.item_style = LOCKSCREEN_GENLIST_STYLE_SEPERATOR2;
 229         itc_separator2.func.text_get = NULL;
 230         itc_separator2.func.content_get = NULL;
 231         itc_separator2.func.state_get = NULL;
 232         itc_separator2.func.del = NULL;
 233         item =
 234             elm_genlist_item_append(genlist, &(itc_separator2), NULL, NULL,
 235                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 236         elm_genlist_item_select_mode_set(item,
 237                                          ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 238 }
 239
 240 void lockscreen_options_util_create_underline(Evas_Object * genlist)
 241 {
 242         if (NULL == genlist)
 243                 return;
 244
 245         Elm_Object_Item *item = NULL;
 246
 247         itc_underline.item_style = LOCKSCREEN_GENLIST_STYLE_UNDERLINE;
 248         itc_underline.func.text_get = NULL;
 249         itc_underline.func.content_get = NULL;
 250         itc_underline.func.state_get = NULL;
 251         itc_underline.func.del = NULL;
 252
 253         item =
 254             elm_genlist_item_append(genlist, &(itc_underline), NULL, NULL,
 255                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 256         elm_genlist_item_select_mode_set(item,
 257                                          ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 258 }
 259
 260 char *lockscreen_optoins_get_string(int id)
 261 {
 262         //LOCKOPTIONS_DBG("get string id : %d\n", id);
 263
 264         char *str = NULL;
 265
 266         if (id < IDS_LOCKSCREEN_OPTIONS_SYSTEM_STRING_MAX) {
 267                 /* get system string */
 268                 str = dgettext("sys_string", sys_str_table[id]);
 269         } else {
 270                 /* get application string */
 271                 str =
 272                     dgettext(PKGNAME,
 273                              app_str_table[id -
 274                                            IDS_LOCKSCREEN_OPTIONS_SYSTEM_STRING_MAX]);
 275         }
 276
 277         //LOCKOPTIONS_DBG("get string : %s\n", str);
 278
 279         return str;
 280 }
 281
 282 static char *_lockscreen_options_submenu_gl_label_get(void *data,
 283                                                    Evas_Object * obj,
 284                                                    const char *part)
 285 {
 286         if (data == NULL || part == NULL)
 287                 return NULL;
 288
 289         lockscreen_menu_item_info *lockoption_data =
 290             (lockscreen_menu_item_info *) data;
 291
 292         if ((strcmp(part, "elm.text") == 0) ||
 293             (strcmp(part, "elm.text.1") == 0)) {
 294                 return
 295                     strdup(lockscreen_optoins_get_string
 296                            (lockoption_data->stringId));
 297         }
 298         else{
 299                 return NULL;
 300         }
 301
 302 }
 303
 304 static void _lockscreen_options_submenu_check_changed_cb(void *data, Evas_Object * obj,
 305                                                  void *event_info)
 306 {
 307         if (data == NULL || obj == NULL)
 308                 return;
 309
 310         lockscreen_menu_item_info *lockoption_data =
 311             (lockscreen_menu_item_info *) data;
 312
 313         Eina_Bool ret;
 314         int value = 0;
 315
 316         ret = elm_check_state_get(obj);
 317
 318         LOCKOPTIONS_DBG("_lockscreen_options_check_changed_cb : %s",
 319                         ret == EINA_TRUE ? "ON" : "OFF");
 320
 321         if (ret == EINA_TRUE) {
 322                 /* set on */
 323                 value = 1;
 324         } else {
 325                 /* set off */
 326                 value = 0;
 327         }
 328
 329 }
 330
 331 static Evas_Object *_lockscreen_options_submenu_gl_icon_get(void *data,
 332                                                          Evas_Object * obj,
 333                                                          const char *part)
 334 {
 335         if (data == NULL || obj == NULL)
 336                 return NULL;
 337
 338         lockscreen_menu_item_info *lockoption_data =
 339             (lockscreen_menu_item_info *) data;
 340
 341         Evas_Object *check;
 342         int value = 0;
 343
 344         check = elm_check_add(obj);
 345         elm_object_style_set(check, "on&off");
 346         evas_object_show(check);
 347
 348         elm_check_state_set(check, value);
 349
 350         evas_object_pass_events_set(check, 1);
 351         evas_object_propagate_events_set(check, 0);
 352
 353         evas_object_smart_callback_add(check, "changed",
 354                                        _lockscreen_options_submenu_check_changed_cb,
 355                                        lockoption_data);
 356
 357         lockoption_data->check = check;
 358
 359         return check;
 360 }
 361
 362 void _lockscreen_options_submenu_gl_item(Elm_Gen_Item_Class * item)
 363 {
 364         item->item_style = LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON;
 365         item->func.text_get = _lockscreen_options_submenu_gl_label_get;
 366         item->func.content_get = _lockscreen_options_submenu_gl_icon_get;
 367         item->func.state_get = NULL;
 368         item->func.del = NULL;
 369 }
 370
 371 int x_to_int(char c)
 372 {
 373         int ret = 0;
 374         if(c >= '0' && c <= '9') {
 375                 ret = c - '0';
 376         }else {
 377                 switch(c) {
 378                 case 'A':
 379                         ret = 10;
 380                         break;
 381                 case 'B':
 382                         ret = 11;
 383                         break;
 384                 case 'C':
 385                         ret = 12;
 386                         break;
 387                 case 'D':
 388                         ret = 13;
 389                         break;
 390                 case 'E':
 391                         ret = 14;
 392                         break;
 393                 case 'F':
 394                         ret = 15;
 395                         break;
 396                 case 'a':
 397                         ret = 10;
 398                         break;
 399                 case 'b':
 400                         ret = 11;
 401                         break;
 402                 case 'c':
 403                         ret = 12;
 404                         break;
 405                 case 'd':
 406                         ret = 13;
 407                         break;
 408                 case 'e':
 409                         ret = 14;
 410                         break;
 411                 case 'f':
 412                         ret = 15;
 413                         break;
 414                 default:
 415                         ret = 0;
 416                         break;
 417                 }
 418         }
 419         return ret;
 420 }
 421
 422 void remove_unused_string(char *text, char *unused_string)
 423 {
 424         if(text != NULL && unused_string != NULL && unused_string[0] != '\0') {
 425                 LOCKOPTIONS_DBG("remove unused string %s in string %s", unused_string, text);
 426                 char *p = NULL;
 427                 int len = 0;
 428                 len = strlen(unused_string);
 429
 430                 p = strstr(text, unused_string);
 431                 while(p != NULL) {
 432                         while(*(p + len) != '\0') {
 433                                 *p = *(p + len);
 434                                 *(p + len) = '\0';
 435                                 p++;
 436                         }
 437                         *p = '\0';
 438                         p = strstr(text, unused_string);
 439                 }
 440                 LOCKOPTIONS_DBG("the string after remove is %s", text);
 441         }
 442 }
 443
 444 void replace_unused_string_with_char(char *text, char *unused_string, char c)
 445 {
 446         if(text != NULL && unused_string != NULL && unused_string[0] != '\0') {
 447                 LOCKOPTIONS_DBG("remove unused string %s in string %s", unused_string, text);
 448                 char *p = NULL;
 449                 int len = 0;
 450                 len = strlen(unused_string);
 451
 452                 p = strstr(text, unused_string);
 453                 while(p != NULL) {
 454                         *p = c;
 455                         p++;
 456                         while(*(p + len - 1) != '\0') {
 457                                 *p = *(p + len - 1);
 458                                 *(p + len - 1) = '\0';
 459                                 p++;
 460                         }
 461                         *p = '\0';
 462                         p = strstr(text, unused_string);
 463                 }
 464                 LOCKOPTIONS_DBG("the string after remove is %s", text);
 465         }
 466 }
 467
 468 int translate_cur_idx(int cur_idx)
 469 {
 470
 471         switch(cur_idx) {
 472                 case 0 :
 473                 case 1 :
 474                         return cur_idx;
 475                 case 2 :
 476                         return 3;
 477                 case 3 :
 478                         return 7;
 479                 default :
 480                         return 0;
 481         }
 482 }
 483
 484 int revert_cur_idx(int index)
 485 {
 486         if(index >= 0 && index < 8) {
 487                 if((index == 0) || (index == 1)) {
 488                         return index;
 489                 }
 490                 else if(index == 3) {
 491                         return 2;
 492                 }
 493                 else if(index == 7){
 494                         return 3;
 495                 }
 496                 else{
 497                         return 0;
 498                 }
 499         }
 500         else {
 501                 return 0;
 502         }
 503 }
 504
 505 int ConvertUTF8toUCS2(const char* src, EIWNNSYMB* psTargetStart)
 506 {
 507         unsigned char c = 0;
 508         unsigned short unicode = 0;
 509         int count = 0;
 510         int len = 0;
 511         int i = 0;
 512
 513         len = strlen(src);
 514         for (i=0; i<len;) {
 515                 c = src[i]&0xe0;
 516                 if (c < 0x80) {
 517                   unicode = (unsigned short) src[i];
 518                   i++;
 519                 }
 520                 else if (c < 0xe0) {
 521                         if (len -i < 2)
 522                                 return -1;
 523                   unicode = (unsigned short) src[i] & 0x1f;
 524                   i++;
 525                   unicode = unicode << 6;
 526                   unicode = unicode | ((unsigned short) src[i] & 0x3f);
 527                   i++;
 528                 }
 529                 else if (c < 0xf0) {
 530                         if (len - i < 3)
 531                                 return -1;
 532                   unicode = (unsigned short) src[i] & 0x0f;
 533                   i++;
 534                   unicode = unicode << 6;
 535                   unicode = unicode | ((unsigned short) src[i] & 0x3f);
 536                   i++;
 537                   unicode = unicode << 6;
 538                   unicode = unicode | ((unsigned short) src[i] & 0x3f);
 539                   i++;
 540                 }
 541                 psTargetStart[count] = unicode;
 542                 count++;
 543         }
 544
 545         return count;
 546 }
 547
 548 int WmStrlen(const EIWNNSYMB* mszInText)
 549 {
 550         int n = 0;
 551         while(*(mszInText + n) != 0)
 552         {
 553                 n++;
 554         }
 555
 556         return n;
 557 }
 558
 559 int get_vconf_screenreader(void)
 560 {
 561         int is_screenreader = -1;
 562         if(vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, &is_screenreader) < 0) {
 563                 return EINA_FALSE;
 564         }
 565         return is_screenreader;
 566 }
 567
 568 void *lockscreen_options_tts_reader_object_get(void *obj, lockscreen_object_type_e type, const char *part, void *parent)
 569 {
 570         Evas_Object *to = NULL;
 571         Evas_Object *ao = NULL;
 572
 573         if(obj == NULL) {
 574                 LOCK_SCREEN_TRACE_ERR("invalid parameter");
 575                 return NULL;
 576         }
 577
 578         if(type == LOCKSCREEN_READER_OBJ_TYPE_EDJ_OBJECT && !part) {
 579                 LOCK_SCREEN_TRACE_ERR("invalid parameter");
 580                 return NULL;
 581         }
 582
 583         switch (type) {
 584                 case LOCKSCREEN_READER_OBJ_TYPE_ELM_OBJECT:
 585                         if(part != NULL) {
 586                                 to = (Evas_Object *)elm_object_part_content_get(obj, part);
 587                                 ao = (Evas_Object *)to;
 588                         } else {
 589                                 ao = (Evas_Object *)obj;
 590                         }
 591                         break;
 592
 593                 case LOCKSCREEN_READER_OBJ_TYPE_EDJ_OBJECT:
 594                         to = (Evas_Object *)edje_object_part_object_get(_EDJ(obj), part);
 595                         break;
 596
 597                 default:        // evas, icon
 598                         to = (Evas_Object *)obj;
 599         }
 600
 601         if (!ao && to && parent) {              // edj, evas, icon, elm_object_item
 602                 ao = elm_access_object_get(to);
 603                 if (ao == NULL) {
 604                         ao = elm_access_object_register(to, parent);
 605                 }
 606         }
 607
 608         return ao;
 609 }
 610 void *lockscreen_options_tts_get_focus_object(void *parent)
 611 {
 612         if(parent == NULL)
 613                 return NULL;
 614         Evas_Object *focus = elm_button_add(parent);
 615         if(focus == NULL) {
 616                 LOCKOPTIONS_DBG("elm_button_add() failed");
 617                 return NULL;
 618         }
 619         elm_object_style_set(focus, "focus");
 620         return focus;
 621 }
 622
 623 void lockscreen_options_set_tts_info(Evas_Object* obj, const char* label,
 624                           const char* traits, const char *state,
 625                           const char* guide)
 626 {
 627         if (label)
 628                 elm_access_info_set(obj, ELM_ACCESS_INFO, label);
 629
 630         if (traits)// && isEmptyStr(elm_access_info_get(obj, ELM_ACCESS_TYPE)))
 631                 elm_access_info_set(obj, ELM_ACCESS_TYPE, traits);
 632
 633         if (state)
 634                 elm_access_info_set(obj, ELM_ACCESS_STATE, state);
 635         if (guide)
 636         {
 637                 elm_access_info_set(obj, ELM_ACCESS_CONTEXT_INFO, NULL);
 638                 elm_access_info_set(obj, ELM_ACCESS_CONTEXT_INFO, guide);
 639         }
 640 }
 641
 642 void set_object_colors(void *ao, const char *color_class, int color)
 643 {
 644         int A = 0x00, R = 0x00, G = 0x00, B = 0x00;
 645         COLORTODECIMAL(color, A, R, G, B);
 646
 647         edje_object_color_class_set(_EDJ(ao), color_class,
 648                 R, G, B, A,
 649                 0, 0, 0, 0,
 650                 0, 0, 0, 0);
 651 }
 652
 653 void get_font_list(Eina_List **font_list)
 654 {
 655         LOCKOPTIONS_TRACE_BEGIN;
 656         FcObjectSet *os = NULL;
 657         FcFontSet *fs = NULL;
 658         FcPattern *pat = NULL;
 659         Eina_List *list = NULL;
 660         FcConfig *font_config = NULL;
 661
 662         font_config = FcInitLoadConfigAndFonts();
 663
 664         if(font_config == NULL) {
 665                 LOCKOPTIONS_DBG("Failed: FcInitLoadConfigAndFonts");
 666                 return;
 667         }
 668
 669         pat = FcPatternCreate();
 670
 671         os = FcObjectSetBuild(FC_FAMILY, FC_FILE, (char *) 0);
 672
 673         if(os) {
 674                 fs = FcFontList(font_config, pat, os);
 675                 FcObjectSetDestroy(os);
 676                 os = NULL;
 677         }
 678
 679         if(pat) {
 680                 FcPatternDestroy(pat);
 681                 pat = NULL;
 682         }
 683
 684         if(fs) {
 685                 int j;
 686                 LOCKOPTIONS_DBG("fs->nfont = %d", fs->nfont);
 687
 688                 for(j = 0; j < fs->nfont; j++) {
 689                         FcChar8 *family = NULL;
 690                         FcChar8 *file = NULL;
 691
 692                         if(FcPatternGetString(fs->fonts[j], FC_FILE, 0, &file) == FcResultMatch) {
 693                                 //LOCKOPTIONS_DBG("FC_FILE : %s\n", file);
 694                                 int preload_path_len = strlen(FONT_PRELOAD_FONT_PATH);
 695                                 int download_path_len = strlen(FONT_DOWNLOADED_FONT_PATH);
 696                                 if(!safeStrNCmp((const char*)file, FONT_PRELOAD_FONT_PATH, preload_path_len) ||
 697                                         !safeStrNCmp((const char*)file, FONT_DOWNLOADED_FONT_PATH, download_path_len)) {
 698                                         if(FcPatternGetString(fs->fonts[j], FC_FAMILY, 0, &family) != FcResultMatch) {
 699                                                 LOCKOPTIONS_DBG("Family name is invalid");
 700                                                 continue;
 701                                         }
 702
 703                                         if(eina_list_data_find(list, family) == NULL) {
 704                                                 list = eina_list_append(list, family);
 705                                                 LOCKOPTIONS_DBG("-------- ADDED FONT - family = %s", family);
 706                                         }
 707                                 }
 708                         }
 709                 }
 710                 FcFontSetDestroy(fs);
 711                 fs = NULL;
 712         }
 713
 714         FcConfigDestroy(font_config);
 715         font_config = NULL;
 716
 717         Eina_List *l = NULL;
 718         FcChar8 *temp = NULL;
 719         EINA_LIST_FOREACH(list, l, temp)
 720         {
 721                 if(temp != NULL) {
 722                         char *font_data = strdup((const char *)temp);
 723                         *font_list = eina_list_append(*font_list, font_data);
 724                 }
 725         }
 726
 727         eina_list_free(list);//don't have to free the "family" data in list
 728
 729         LOCKOPTIONS_TRACE_END;
 730 }
 731
 732 void get_font_name(const char *font_data, char *new_name, int bufsize)
 733 {
 734         LOCKOPTIONS_DBG("font data : %s", (char*)font_data);
 735
 736         const char* pos = font_data;
 737         int i = 0;
 738         int count = 0;
 739         while(*pos != '\0' && count < bufsize-1)
 740         {
 741                 //LOCKOPTIONS_DBG(">>>  %c", *pos);
 742                 if (*pos == ' ')
 743                 {
 744                         //LOCKOPTIONS_DBG(">>>  empty ' ' ");
 745                         new_name[count] = '\\';
 746                         count++;
 747                         new_name[count] = ' ';
 748                 } else {
 749                         new_name[count] = font_data[i];
 750                 }
 751
 752                 count++;
 753                 pos++;
 754                 i++;
 755         }
 756         new_name[count] = '\0';
 757
 758         LOCKOPTIONS_DBG("font_name : %s", new_name);
 759 }
 760
 761 Eina_Bool isEmptyStr(const char *str)
 762 {
 763         if (NULL == str || '\0' == str[0])
 764                 return EINA_TRUE;
 765         return EINA_FALSE;
 766 }
 767
 768 int safeStrNCmp(const char *s1, const char *s2, int len)
 769 {
 770         if (isEmptyStr(s1) && isEmptyStr(s2)) {
 771                 return 0;
 772         } else if (isEmptyStr(s1)) {
 773                 return 1;
 774         } else if (isEmptyStr(s2)) {
 775                 return -1;
 776         }
 777
 778         if (0 == len) {
 779                 return 0;
 780         }
 781
 782         return strncmp(s1, s2, len);
 783 }
 784 static void _launch_layout_ug_cb(ui_gadget_h ug,
 785                                                       enum ug_mode mode,
 786                                                       void *priv)
 787 {
 788         LOCKOPTIONS_DBG("_launch_layout_ug_cb begin.\n");
 789         Evas_Object *base;
 790         if (!priv)
 791                 return;
 792         base = (Evas_Object *) ug_get_layout(ug);
 793         if (!base)
 794                 return;
 795         switch (mode) {
 796         case UG_MODE_FULLVIEW:
 797                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 798                                                  EVAS_HINT_EXPAND);
 799                 evas_object_show(base);
 800                 break;
 801         default:
 802                 break;
 803         }
 804         LOCKOPTIONS_DBG("_launch_layout_ug_cb end.\n");
 805 }
 806 static void _launch_destroy_ug_cb(ui_gadget_h ug,
 807                                                        void *priv)
 808 {
 809         LOCKOPTIONS_TRACE_BEGIN;
 810         if (!priv)
 811                 return;
 812         if (ug) {
 813                 ug_destroy(ug);
 814         }
 815         LOCKOPTIONS_TRACE_END;
 816 }
 817
 818 void _fingerprint_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *data)
 819 {
 820         LOCKOPTIONS_DBG("_fingerprint_reply_cb");
 821     if(data == NULL)
 822                 return;
 823         lockscreen_options_ug_data *ad = (lockscreen_options_ug_data *)data;
 824
 825         //if(result == SERVICE_RESULT_SUCCEEDED)
 826         if(!result)
 827         {
 828                         LOCKOPTIONS_DBG("_fingerprint_reply_cb  SERVICE_RESULT_SUCCEEDED");
 829
 830                         Evas_Object *win_main = NULL;
 831                         win_main = ug_get_window();
 832                         if (!win_main) {
 833                                 LOCKOPTIONS_DBG("win is null");
 834                                 return ;
 835                         }
 836                         if (elm_win_wm_rotation_supported_get(win_main)) {
 837                                 LOCKOPTIONS_DBG("_fingerprint_reply_cb elm_win_wm_rotation_supported_get");
 838                                 elm_win_wm_rotation_preferred_rotation_set(win_main, -1);
 839                                 const int rots[4] = {   APP_DEVICE_ORIENTATION_0,
 840                                                                         APP_DEVICE_ORIENTATION_90,
 841                                                                         APP_DEVICE_ORIENTATION_180,
 842                                                                         APP_DEVICE_ORIENTATION_270 };
 843                                 elm_win_wm_rotation_available_rotations_set(win_main, &rots, 4);
 844                         }
 845                         app_control_h new_req;
 846                         if(!app_control_create(&new_req)){
 847                                 launch_ug("setting-locktype-efl", new_req, ad);
 848                                 app_control_destroy(new_req);
 849                         }
 850         }
 851         else
 852         {
 853                 LOCKOPTIONS_DBG("_fingerprint_reply_cb  fail");
 854         }
 855         return;
 856 }
 857
 858 static void _launch_result_password_ug_cb(app_control_h ug, app_control_h reply,app_control_result_e result,void *data)
 859 {
 860         LOCKOPTIONS_TRACE_BEGIN;
 861         if(data == NULL)
 862                 return;
 863         lockscreen_options_ug_data *ad = (lockscreen_options_ug_data *) data;   /* ad is point to priv */
 864
 865         if(!result)
 866         {
 867                 LOCKOPTIONS_DBG(" !result ");
 868                 char *string_result = NULL;
 869                 char *current = NULL;
 870                 app_control_get_extra_data(reply, "result", &string_result);
 871                 if(string_result == NULL)
 872                         return;
 873                 LOCKOPTIONS_DBG("_launch_result_password_ug_cb string_result is %s.",string_result);
 874                 int ret_int = 0;
 875                 if(strcmp(string_result, "Cancel") == 0)
 876                 {
 877                         ret_int = 0;
 878                 }
 879                 else if(strcmp(string_result, "SETTING_PW_TYPE_ENTER_LOCK_TYPE") == 0 || strcmp(string_result, "SETTING_PW_TYPE_VERIFY_FP_ALT_PASSWORD") == 0)
 880                 {
 881                         ret_int = 1;
 882                 }
 883                 free(string_result);
 884
 885                 if(ret_int == 1)
 886                 {
 887                         LOCKOPTIONS_DBG(" SETTING_PW_TYPE_ENTER_LOCK_TYPE ||SETTING_PW_TYPE_VERIFY_FP_ALT_PASSWORD  _launch_result_password_ug_cb");
 888                         ug_destroy(ug);
 889                         app_control_h svc;
 890                         if (app_control_create(&svc)) {
 891                                 return;
 892                         }
 893                         app_control_get_extra_data(reply, "current", &current);
 894                         if(current){
 895                                 app_control_add_extra_data(svc, "current", current);
 896                                 free(current);
 897                         }
 898                         launch_ug("setting-locktype-efl", svc, ad);
 899                         app_control_destroy(svc);
 900                 }
 901         }
 902 }
 903
 904 void launch_ug(char* ug_name, app_control_h svc_mt_ug, void *data)
 905 {
 906         LOCKOPTIONS_DBG("_launch_ug. %s \n", ug_name);
 907         if(data == NULL){
 908                 LOCKOPTIONS_ERR("The data (ug_data)is NULL.");
 909                 return;
 910         }
 911         if(ug_name == NULL) {
 912                 return;
 913         }
 914         lockscreen_options_ug_data *ug_data = (lockscreen_options_ug_data *) data;
 915 #if 0
 916         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 917         if(cbs == NULL)
 918                 return;
 919         cbs->layout_cb = _launch_layout_ug_cb;
 920         if(strcmp(ug_name, "setting-password-efl") == 0) {
 921                 cbs->result_cb = _launch_result_password_ug_cb;
 922         } else {
 923                 cbs->result_cb = NULL;
 924         }
 925         cbs->destroy_cb = _launch_destroy_ug_cb;
 926         cbs->priv = (void *)ug_data;
 927         LOCKOPTIONS_DBG("Launch ug begin. %s \n", ug_name);
 928         ui_gadget_h loading = ug_create(ug_data->ug, ug_name, UG_MODE_FULLVIEW, svc_mt_ug, cbs);
 929
 930 #endif
 931         app_control_set_app_id(svc_mt_ug, ug_name);
 932         Evas_Object *win = (Evas_Object *)ug_get_window();
 933         app_control_set_window(svc_mt_ug, elm_win_xwindow_get(win));
 934
 935         if(strcmp(ug_name, "setting-password-efl") == 0) {
 936                 app_control_send_launch_request(svc_mt_ug, _launch_result_password_ug_cb, data);
 937         } else {
 938                 app_control_send_launch_request(svc_mt_ug, NULL, data);
 939         }
 940         #if 0
 941         if (NULL == svc_handle) {
 942                 LOCKOPTIONS_ERR("Launch ug failed.");
 943     }
 944         free(cbs);
 945         #endif
 946         LOCKOPTIONS_DBG("Launch ug end. %s \n", ug_name);
 947 }
 948 Eina_Bool _client_message_rotation_cb(void *data, int type, void *event)
 949 {
 950         Ecore_X_Event_Client_Message *ev = (Ecore_X_Event_Client_Message *) event;
 951         //LOCKOPTIONS_DBG("--------------------- _client_message_cb-----");
 952
 953         if (ev->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST) {
 954                 if (ev->win == elm_win_xwindow_get(ug_get_window())) {
 955                         angle = ev->data.l[1];
 956                         #if 0
 957                         if (gIseScreenDegree != angle) {
 958
 959                                 if (!g_in_emoji_win) {
 960                                         if ( isVoiceOn )
 961                                                 rotate_voice_input(angle);
 962                                         ise_set_screen_direction(angle);
 963                                         //ise_set_refresh_flag(true);
 964                                         reset_focus_after_rotation(true); /*reset the focus of candidate after the rotation of phone is changed */
 965                                         ise_show(gLastIC,context_layoutid);
 966                                 } else {
 967                                         ise_set_screen_direction(angle);
 968                                         relocate_window(g_in_emoji_win);
 969                                         update_scroller_content(angle);
 970
 971                                 }
 972 #ifdef HANDWRITING
 973                                 PRINTFUNC(DLOG_DEBUG, "%d", gCore->get_input_mode());
 974                                 if (gCore) {
 975                                         if (gCore->get_input_mode() == INPUT_MODE_HANDWRITING) {
 976                                                 _hwr_commit_default_string(true);
 977                                                 _hwr_destroy_handwriting();
 978                                         }
 979                                 }
 980 #endif
 981                         }
 982                         #endif
 983                 }
 984         }
 985   //LOCKOPTIONS_DBG("---------------------------_client_message_cb  angle = %d ",angle);
 986         return ECORE_CALLBACK_RENEW;
 987 }
 988
 989
 990 Evas_Object *_create_check_on_naviframe(Evas_Object *parent,char * vconf,Evas_Smart_Cb func, void *data)
 991 {
 992         lockscreen_menu_item_info *lockoption_data =
 993             (lockscreen_menu_item_info *) data;
 994
 995         Evas_Object *check;
 996         int value = 0;
 997         int ret = 0;
 998
 999         check = elm_check_add(parent);
1000         elm_object_style_set(check, "on&off");
1001         //elm_object_style_set(check, "naviframe/title_on&off");
1002         evas_object_show(check);
1003
1004         //value = _lockscreen_options_get_menu_status(lockoption_data->stringId);
1005         //vconf_get_bool(VCONFKEY_LOCKSCREEN_ADDITIONAL_INFO_DISPLAY, &value);
1006
1007         vconf_get_bool(vconf, &value);
1008         elm_check_state_set(check, value);
1009
1010         evas_object_pass_events_set(check, 1);
1011         evas_object_propagate_events_set(check, 0);
1012
1013     #if 0
1014         if (lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_SHORTCUTS) {
1015                 Eina_Bool is_have = EINA_FALSE;
1016                 is_have = lockscreen_options_shortcuts_check_items();
1017                 if(is_have == EINA_TRUE){
1018                         elm_object_disabled_set(check, EINA_FALSE);
1019                 }else{
1020                         elm_object_disabled_set(check, EINA_TRUE);
1021                         elm_check_state_set(check, EINA_FALSE);
1022                         _lockscreen_options_set_menu_status(lockoption_data->stringId, EINA_FALSE);
1023                 }
1024         }else if (lockoption_data->stringId ==
1025             IDS_LOCKSCREEN_OPTIONS_CONTEXTAWARE_NOTI) {
1026                 elm_object_disabled_set(check, EINA_TRUE);
1027         }
1028         #endif
1029
1030         evas_object_smart_callback_add(check, "changed",
1031                                        func,
1032                                        lockoption_data);
1033
1034         return check;
1035 }
1036