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

   1 /*
   2  * Copyright (c) 2009 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18
  19 #include <vconf.h>
  20 #include <vconf-keys.h>
  21 #include <ui-gadget.h>
  22 #include <ui-gadget-module.h>
  23 #include <unicode/ucal.h>
  24
  25 #include "lockscreen-options.h"
  26 #include "lockscreen-options-debug.h"
  27 #include "lockscreen-options-main.h"
  28 #include "lockscreen-options-util.h"
  29
  30 #define DEFAULT_LOCK_TITLE           "Personal message"
  31 #define LOCKSCREEN_PACKAGE_NAME                         "org.tizen.lockscreen"
  32
  33 #define LOCKSCREEN_OPTOINS_GENLIST_ITEM_NONE 1
  34 #define LOCKSCREEN_OPTOINS_GENLIST_ITEM_SWIPE 2
  35 #define LOCKSCREEN_OPTOINS_GENLIST_ITEM_PW 2
  36
  37
  38 #define CITY_BUF_SIZE           128
  39 #define GMT_BUF_SIZE        10
  40
  41 #define IS_LOCKTYPE(a,b) \
  42 {       \
  43         if(a == SETTING_SCREEN_LOCK_TYPE_NONE)  \
  44                 b = 0;  \
  45         if(     a == SETTING_SCREEN_LOCK_TYPE_FINGERPRINT ||    \
  46                 a == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD ||        \
  47                 a == SETTING_SCREEN_LOCK_TYPE_PASSWORD) \
  48                 b = 1;  \
  49         if(a == SETTING_SCREEN_LOCK_TYPE_OTHER) \
  50                 b = 2;  \
  51         if(a == SETTING_SCREEN_LOCK_TYPE_MOTION) \
  52                 b = 3 ; \
  53         if(a == SETTING_SCREEN_LOCK_TYPE_SWIPE) \
  54                 b = 4;  \
  55 }
  56
  57 static void _lockscreen_options_register_vconf_change();
  58
  59 void _lockscreen_options_unregister_vconf_change();
  60
  61 static void _lockscreen_options_shortcuts_cb(void *data, Evas_Object * obj,
  62                                                 void *event_info);
  63 static void _lockscreen_options_locktitle_cb(void *data, Evas_Object * obj,
  64                                                 void *event_info);
  65 static void _lockscreen_options_briefing_cb(void *data, Evas_Object * obj,
  66                                                 void *event_info);
  67 static void _lockscreen_options_enter_themes_cb(void *data, Evas_Object * obj,
  68                                                 void *event_info);
  69 static void _lockscreen_options_locktype_cb(void *data, Evas_Object * obj,
  70                                                 void *event_info);
  71 static void _lockscreen_options_unlocktype_cb(void *data, Evas_Object * obj,
  72                                                 void *event_info);
  73 static void _lockscreen_options_addinformation_cb(void *data, Evas_Object * obj,
  74                                                 void *event_info);
  75
  76 static lockscreen_menu_item_info lockscreen_options_menu_item_none[] = {
  77         {ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT, IDS_LOCKSCREEN_OPTIONS_LOCK_SCREEN_TYPE, NULL, _lockscreen_options_locktype_cb, NULL},
  78 };
  79
  80 static lockscreen_menu_item_info lockscreen_options_menu_item_pw[] = {
  81         {ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT, IDS_LOCKSCREEN_OPTIONS_LOCK_SCREEN_TYPE, NULL, _lockscreen_options_locktype_cb, NULL}, //type
  82         {ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON, IDS_LOCKSCREEN_OPTIONS_CAMERA_SHORTCUT, NULL, NULL}, //camera
  83 };
  84
  85 static lockscreen_menu_item_info lockscreen_options_menu_item_swipe[] = {
  86         {ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT, IDS_LOCKSCREEN_OPTIONS_LOCK_SCREEN_TYPE, NULL, _lockscreen_options_locktype_cb, NULL,NULL}, //type
  87         {ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON, IDS_LOCKSCREEN_OPTIONS_CAMERA_SHORTCUT, NULL, NULL,NULL}, //camera
  88 };
  89
  90 static Elm_Gen_Item_Class itc_menu_1text;
  91 static Elm_Gen_Item_Class itc_menu_1text1icon;
  92 static Elm_Gen_Item_Class itc_menu_1text1icon_divider;
  93 static Elm_Gen_Item_Class itc_menu_2text1icon_divider;
  94 static Elm_Gen_Item_Class itc_help_1text;
  95 static Elm_Gen_Item_Class itc_title_1text;
  96 static Elm_Gen_Item_Class itc_variable_height_2icons;
  97 static Elm_Gen_Item_Class itc_title_2text;
  98 static Elm_Gen_Item_Class itc_title_2text_expandable;
  99 static Elm_Gen_Item_Class itc_menu_2text1icon;
 100 static Elm_Gen_Item_Class itc_multiline_text;
 101
 102
 103 static Elm_Object_Item *genlist_selected_item = NULL;
 104 static Evas_Object *g_genlist = NULL;
 105
 106
 107 static Elm_Object_Item *item_title = NULL ;
 108 static Elm_Object_Item *item_theme = NULL ;
 109 static Elm_Object_Item *item_unlock = NULL;
 110 static Elm_Object_Item *item_type = NULL;
 111 static Elm_Object_Item *item_security = NULL;
 112
 113 static Elm_Object_Item *item_radio0 = NULL;
 114 static Elm_Object_Item *item_radio1 = NULL;
 115 static Elm_Object_Item *item_radio2 = NULL;
 116 static Elm_Object_Item *item_radio3 = NULL;
 117
 118 static Evas_Object *radio_group = NULL;
 119
 120 Evas_Object *item_radio = NULL;
 121
 122 static void _lockscreen_options_locktype_cb(void *data, Evas_Object * obj,
 123                                                 void *event_info)
 124 {
 125         int lock_type = 0;
 126         app_control_h svc_mt_ug = NULL;
 127         char* ug_name = NULL;
 128         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type);
 129         if(!app_control_create(&svc_mt_ug)) {
 130                 if(lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD
 131                         || lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 132                 {
 133                         LOCKOPTIONS_DBG("SETTING_SCREEN_LOCK_TYPE_PASSWORD || SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD");
 134                         app_control_add_extra_data(svc_mt_ug, "viewtype", "SETTING_PW_TYPE_ENTER_LOCK_TYPE");
 135                         ug_name = "setting-password-efl";
 136                         launch_ug(ug_name, svc_mt_ug, data);
 137                         app_control_destroy(svc_mt_ug);
 138                 } else {
 139                         LOCKOPTIONS_DBG("setting-locktype-efl");
 140                         ug_name = "setting-locktype-efl";
 141                         launch_ug(ug_name, svc_mt_ug, data);
 142                         app_control_destroy(svc_mt_ug);
 143                 }
 144         }
 145 }
 146
 147 static void _lockscreen_options_unlocktype_cb(void *data, Evas_Object * obj,
 148                                                 void *event_info)
 149 {
 150         LOCKOPTIONS_TRACE_BEGIN;
 151
 152         Eina_Bool expanded = EINA_FALSE;
 153         Elm_Object_Item *item = (Elm_Object_Item*)event_info;
 154         expanded = elm_genlist_item_expanded_get(item);
 155         LOCKOPTIONS_DBG("expanded=%d", expanded);
 156         //elm_genlist_item_selected_set(item, EINA_FALSE);
 157         elm_genlist_item_expanded_set(item, !expanded);
 158         //elm_genlist_item_update(item);
 159
 160         LOCKOPTIONS_TRACE_END;
 161 }
 162
 163 static void _service_locktype_ug_result_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *data)
 164 {
 165         LOCKOPTIONS_TRACE_BEGIN;
 166
 167         lockscreen_options_ug_data * ug_data = (lockscreen_options_ug_data *)data;
 168         if (!ug_data)
 169                 return;
 170         else{
 171                 if(!ug_data->ug)
 172                         return;
 173         }
 174
 175         //ecore_event_handler_del(XClientMsgHandler);
 176         /*if(ug_data->win_main != NULL) {
 177                 evas_object_smart_callback_del(ug_data->win_main, "wm,rotation,changed", _win_rot_changed_cb);
 178         }else {
 179                 LOCKOPTIONS_ERR("ug_data->win_main is NULL, wm,rotation,changed can't be unregistered.");
 180         }*/
 181
 182         if(ug_data->base != NULL) {
 183                 evas_object_del(ug_data->base);
 184                 ug_data->base = NULL;
 185         }
 186
 187         if(ug_data->extra_data != NULL) {
 188                 free(ug_data->extra_data);
 189                 ug_data->extra_data = NULL;
 190         }
 191
 192         if(ug_data->viewtype!= NULL) {
 193                 free(ug_data->viewtype);
 194                 ug_data->viewtype = NULL;
 195         }
 196
 197         if(ug_data->act_pop != NULL) {
 198                 evas_object_del(ug_data->act_pop);
 199                 ug_data->act_pop = NULL;
 200         }
 201
 202         /* Help UI */
 203         if(ug_data->ly_help != NULL) {
 204                 evas_object_del(ug_data->ly_help);
 205                 ug_data->ly_help = NULL;
 206         }
 207         if(ug_data->popup_help != NULL) {
 208                 evas_object_del(ug_data->popup_help);
 209                 ug_data->popup_help = NULL;
 210         }
 211         if(ug_data->help_done_timer) {
 212                 ecore_timer_del(ug_data->help_done_timer);
 213                 ug_data->help_done_timer = NULL;
 214         }
 215
 216         if(ug_data->noti_timer_id) {
 217                 LOCKOPTIONS_DBG("------------------delete  noti_timer-------------");
 218                 ecore_timer_del(ug_data->noti_timer_id);
 219                 ug_data->noti_timer_id = NULL;
 220         }
 221
 222         if (ug_data->th) {
 223                 elm_theme_extension_del(ug_data->th, EDJE_DIR"/lockscreen-options-theme.edj");
 224                 elm_theme_free(ug_data->th);
 225                 ug_data->th = NULL;
 226         }
 227
 228         if(ug_get_layout(ug_data->ug) != NULL) {
 229                 evas_object_hide((Evas_Object *)ug_get_layout(ug_data->ug));
 230                 evas_object_del((Evas_Object *)ug_get_layout(ug_data->ug));
 231         }
 232
 233         ug_destroy_me(ug_data->ug);
 234
 235         LOCKOPTIONS_TRACE_END;
 236 }
 237
 238 void lockscreen_options_locktype_create_view(lockscreen_options_ug_data * ug_data)
 239 {
 240         LOCKOPTIONS_TRACE_BEGIN;
 241 #if 1
 242         int lock_type = 0;
 243         app_control_h svc_mt_ug = NULL;
 244         char* ug_name = NULL;
 245         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type);
 246         if(!app_control_create(&svc_mt_ug)) {
 247                 if(lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD
 248                         || lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 249                 {
 250                         app_control_add_extra_data(svc_mt_ug, "viewtype", "SETTING_PW_TYPE_ENTER_LOCK_TYPE");
 251                         ug_name = "setting-password-efl";
 252                 } else {
 253                         ug_name = "setting-locktype-efl";
 254                 }
 255         }
 256         LOCKOPTIONS_DBG("2");
 257         launch_ug(ug_name, svc_mt_ug, ug_data);
 258         LOCKOPTIONS_DBG("3");
 259         app_control_destroy(svc_mt_ug);
 260 #endif
 261
 262 }
 263
 264 int _lockscreen_options_txt_list_create(char *filename)
 265 {
 266         LOCKOPTIONS_TRACE_BEGIN;
 267
 268         LOCKOPTIONS_DBG("filename=%s", filename);
 269         if(filename == NULL)
 270                 return -1;
 271
 272         if(access(filename, 0) == -1)
 273         {
 274                 LOCKOPTIONS_DBG("%s is not exist.", filename);
 275                 FILE *file = fopen(filename, "w");
 276                 if(!file)
 277                 {
 278                         LOCKOPTIONS_DBG("fopen file failed");
 279                         //fclose(file);
 280                         return -1;
 281                 }
 282                 fclose(file);
 283         }
 284         LOCKOPTIONS_TRACE_END;
 285         return 0;
 286 }
 287
 288 static void _lockscreen_options_shortcuts_cb(void *data, Evas_Object * obj,
 289                                                 void *event_info)
 290 {
 291         lockscreen_options_shortcuts_create_view(data);
 292 }
 293
 294 static void _lockscreen_options_locktitle_cb(void *data, Evas_Object * obj,
 295                                                 void *event_info)
 296 {
 297         lockscreen_options_locktitle_create_view(data);
 298 }
 299
 300 static void _lockscreen_options_briefing_cb(void *data, Evas_Object * obj,
 301                                                 void *event_info)
 302 {
 303         lockscreen_options_briefing_create_view(data);
 304
 305 }
 306
 307 static void _lockscreen_options_addinformation_cb(void *data, Evas_Object * obj,
 308                                                 void *event_info)
 309 {
 310         lockscreen_options_additional_information_view(data);
 311 }
 312
 313
 314 static UChar* _lockscreen_datetime_uastrcpy(const char *chars)
 315 {
 316         int len = 0;
 317         UChar *str = NULL;
 318
 319         if (!chars) return NULL;
 320
 321         len = strlen(chars);
 322         str = (UChar *) malloc(sizeof(UChar) *(len + 1));
 323
 324         if (!str)
 325                 return NULL;
 326
 327         u_uastrcpy(str, chars);
 328         return str;
 329 }
 330
 331
 332 static char *_lockscreen_options_main_gl_label_get(void *data,
 333                                                         Evas_Object * obj,
 334                                                         const char *part)
 335 {
 336         if (data == NULL || part == NULL)
 337                 return NULL;
 338
 339         lockscreen_menu_item_info *lockoption_data = (lockscreen_menu_item_info *) data;
 340
 341         const Elm_Genlist_Item_Class *itc = elm_genlist_item_item_class_get(lockoption_data->item);
 342         if(NULL == itc)
 343         {
 344                 LOCKOPTIONS_DBG("itc is null");
 345                 return NULL;
 346         }
 347
 348                 if (!strcmp(part, "elm.text") || !strcmp(part, "elm.text.main.left") || !strcmp(part, "elm.text.main.left.top")) {      /* title */
 349                         return strdup(lockscreen_optoins_get_string(lockoption_data->stringId));
 350                 } else if (!strcmp(part, "elm.text.sub") || !strcmp(part, "elm.text.sub.left.bottom")) {        /* bottom or right */
 351                         if(lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_LOCK_SCREEN_TYPE) {
 352                                 int lock_type = 0;
 353                                 vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type);
 354                                 char* type_str = NULL;
 355                                 switch(lock_type) {
 356                                         case SETTING_SCREEN_LOCK_TYPE_NONE:
 357                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_NONE);
 358                                                 break;
 359                                         case SETTING_SCREEN_LOCK_TYPE_SWIPE:
 360                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_SWIPE);
 361                                                 break;
 362                                         case SETTING_SCREEN_LOCK_TYPE_MOTION:
 363                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_MOTION);
 364                                                 break;
 365                                         case SETTING_SCREEN_LOCK_TYPE_FACE_AND_VOICE:
 366                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_VOICE);
 367                                                 break;
 368                                         case SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD:
 369                                                 //type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_SIMPLE_PASSWORD);
 370                                                 type_str = "PIN";
 371                                                 break;
 372                                         case SETTING_SCREEN_LOCK_TYPE_PASSWORD:
 373                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_PASSWORD);
 374                                                 break;
 375                                         case SETTING_SCREEN_LOCK_TYPE_FINGERPRINT:
 376                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_FINGERPRINT);
 377                                                 break;
 378                                         case SETTING_SCREEN_LOCK_TYPE_AUTO_LOCK:
 379                                                 type_str = lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STYLE_AUTOLOCK);
 380                                                 break;
 381                                         case SETTING_SCREEN_LOCK_TYPE_OTHER:
 382                                                 return vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR);
 383                                         default:
 384                                                 return NULL;
 385                                 }
 386                                 return strdup(type_str);
 387                         }
 388
 389                 } else if (!strcmp(part, "elm.text.multiline")) {       /* title */
 390                                 LOCKOPTIONS_DBG("elm.text.multiline");
 391                                 return strdup(lockscreen_optoins_get_string(lockoption_data->stringId));
 392                 } else {
 393                         return NULL;
 394                 }
 395
 396         return NULL;
 397
 398 }
 399
 400 static void _lockscreen_options_set_menu_status(int stringId, int value)
 401 {
 402         LOCKOPTIONS_TRACE_BEGIN;
 403         int ret = 0;
 404         switch (stringId) {
 405         case IDS_LOCKSCREEN_OPTIONS_CAMERA_SHORTCUT:
 406                 LOCKOPTIONS_DBG("IDS_LOCKSCREEN_OPTIONS_CAMERA_SHORTCUT : value = %d", value);
 407                 ret = vconf_set_bool(VCONFKEY_LOCKSCREEN_CAMERA_QUICK_ACCESS, value);
 408                 break;
 409         default:
 410                 LOCKOPTIONS_DBG("NO VALID STRINGID %d", stringId);
 411                 break;
 412
 413         }
 414
 415         if (ret != 0) {
 416                 LOCKOPTIONS_ERR("Failed to set vconfkey %d!", stringId);
 417         }
 418 }
 419
 420 static bool _lockscreen_options_get_menu_status(int stringId)
 421 {
 422         LOCKOPTIONS_TRACE_BEGIN;
 423         int status = 0;
 424         int ret = 0;
 425         int theme_index = 0;
 426
 427         switch (stringId) {
 428         case IDS_LOCKSCREEN_OPTIONS_CAMERA_SHORTCUT:
 429                 ret = vconf_get_bool(VCONFKEY_LOCKSCREEN_CAMERA_QUICK_ACCESS, &status);
 430                 LOCKOPTIONS_DBG("VCONFKEY_LOCKSCREEN_CAMERA_QUICK_ACCESS = %d", status);
 431                 break;
 432         default:
 433                 LOCKOPTIONS_DBG("NO VALID INDEX %d", stringId);
 434                 break;
 435         }
 436
 437         if (ret == -1) {
 438                 LOCKOPTIONS_ERR("Failed to get vconfkey %d!", stringId);
 439                 return 0;
 440         }
 441         return status;
 442 }
 443
 444 static void _lockscreen_options_check_changed_cb(void *data, Evas_Object * obj,
 445                                                  void *event_info)
 446 {
 447         if (data == NULL || obj == NULL)
 448                 return;
 449
 450         lockscreen_menu_item_info *lockoption_data = (lockscreen_menu_item_info *) data;
 451
 452         Eina_Bool ret;
 453         int value = 0;
 454
 455         ret = elm_check_state_get(obj);
 456
 457         LOCKOPTIONS_DBG("_lockscreen_options_check_changed_cb : %s",
 458                         ret == EINA_TRUE ? "ON" : "OFF");
 459
 460         if (ret == EINA_TRUE) {
 461                 /* set on */
 462                 value = 1;
 463         } else {
 464                 /* set off */
 465                 value = 0;
 466         }
 467
 468         _lockscreen_options_set_menu_status(lockoption_data->stringId, value);
 469 }
 470
 471 static Evas_Object *_lockscreen_options_main_gl_icon_get(void *data,
 472                                                          Evas_Object * obj,
 473                                                          const char *part)
 474 {
 475         if (data == NULL || obj == NULL)
 476                 return NULL;
 477         lockscreen_menu_item_info *lockoption_data = (lockscreen_menu_item_info *) data;
 478
 479         if (!strcmp(part, "elm.swallow.end") || !strcmp(part, "elm.icon")) {
 480                 int value = 0;
 481                 Evas_Object *check = elm_check_add(obj);
 482                 elm_object_style_set(check, "on&off");
 483                 evas_object_show(check);
 484
 485                 value = _lockscreen_options_get_menu_status(lockoption_data->stringId);
 486                 elm_check_state_set(check, value);
 487
 488                 evas_object_pass_events_set(check, 1);
 489                 evas_object_propagate_events_set(check, 0);
 490
 491                 evas_object_smart_callback_add(check, "changed", _lockscreen_options_check_changed_cb, lockoption_data);
 492
 493                 lockoption_data->check = check;
 494                 return check;
 495         }
 496
 497         return NULL;
 498 }
 499
 500 static void _lockscreen_options_enter_themes_cb(void *data, Evas_Object * obj,
 501                                                 void *event_info)
 502 {
 503         lockscreen_options_ug_data *ug_data =
 504                 (lockscreen_options_ug_data *) data;
 505
 506         if (ug_data == NULL){
 507                 LOCKOPTIONS_ERR("ug_data is null.");
 508                 return;
 509         }
 510 }
 511
 512 static char *_lockscreen_options_main_gl_text_get(void *data,
 513                                                         Evas_Object * obj,
 514                                                         const char *part)
 515 {
 516         LOCKOPTIONS_TRACE_BEGIN;
 517         if (data == NULL || obj == NULL)
 518                 return NULL;
 519
 520         lockscreen_menu_item_info *lockoption_data =
 521                 (lockscreen_menu_item_info *) data;
 522         if (!strcmp(part, "elm.text.multiline")) {
 523                 return strdup(lockscreen_optoins_get_string
 524                                 (lockoption_data->stringId));
 525         }
 526         else
 527         {
 528                 LOCKOPTIONS_DBG("it is not multiline");
 529         }
 530         LOCKOPTIONS_TRACE_END;
 531         return NULL;
 532 }
 533
 534 static void radio_change(void *data, Evas_Object *obj, void *event_info)
 535 {
 536         LOCKOPTIONS_TRACE_BEGIN;
 537         int index = (int )data;
 538         LOCKOPTIONS_DBG("index=%d", index);
 539         if(item_radio) {
 540                 elm_radio_value_set(item_radio, index);
 541         }
 542         LOCKOPTIONS_DBG("index=%d", index);
 543         elm_genlist_item_update(item_unlock);
 544         elm_genlist_item_expanded_set(item_unlock, EINA_FALSE);
 545         LOCKOPTIONS_TRACE_END;
 546 }
 547
 548 static Evas_Object *_gl_content_get(void *data, Evas_Object * obj, const char *part)
 549 {
 550         LOCKOPTIONS_TRACE_BEGIN;
 551         Evas_Object *item = NULL;
 552         int index = (int)data;
 553         if (!strcmp(part, "elm.icon")) {
 554                 if(index == IDS_LOCKSCREEN_OPTIONS_CONFETTI_M_EFFECT) {
 555                         item = elm_radio_add(obj);
 556                         elm_radio_state_value_set(item, 0);
 557                         elm_radio_group_add(item, radio_group);
 558                         item_radio = item;
 559                         evas_object_smart_callback_add(item, "changed", radio_change, (void *)0);
 560                 } else if(index == IDS_LOCKSCREEN_OPTIONS_GEOMETRIC_M_EFFECT) {
 561                         item = elm_radio_add(obj);
 562                         elm_radio_state_value_set(item, 1);
 563                         elm_radio_group_add(item, radio_group);
 564                         item_radio = item;
 565                         evas_object_smart_callback_add(item, "changed", radio_change, (void *)1);
 566                 } else if(index == IDS_LOCKSCREEN_OPTIONS_STARDUST_M_EFFECT) {
 567                         item = elm_radio_add(obj);
 568                         elm_radio_state_value_set(item, 2);
 569                         elm_radio_group_add(item, radio_group);
 570                         item_radio = item;
 571                         evas_object_smart_callback_add(item, "changed", radio_change, (void *)2);
 572                 } else if(index == IDS_LOCKSCREEN_OPTIONS_GLOWWORM_M_EFFECT) {
 573                         item = elm_radio_add(obj);
 574                         elm_radio_state_value_set(item, 3);
 575                         elm_radio_group_add(item, radio_group);
 576                         item_radio = item;
 577                         evas_object_smart_callback_add(item, "changed", radio_change, (void *)3);
 578                 }
 579         }
 580         return item;
 581         LOCKOPTIONS_TRACE_END;
 582 }
 583
 584 static char *_gl_text_get(void *data, Evas_Object *obj, const char *part)
 585 {
 586         LOCKOPTIONS_TRACE_BEGIN;
 587         if (data == NULL || part == NULL)
 588                 return NULL;
 589
 590         int index = (int)data;
 591         if (!strcmp(part, "elm.text")) {
 592                 if(index == IDS_LOCKSCREEN_OPTIONS_CONFETTI_M_EFFECT) {
 593                         return strdup(lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_CONFETTI_M_EFFECT));
 594                 } else if(index == IDS_LOCKSCREEN_OPTIONS_GEOMETRIC_M_EFFECT) {
 595                         return strdup(lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_GEOMETRIC_M_EFFECT));
 596                 } else if(index == IDS_LOCKSCREEN_OPTIONS_STARDUST_M_EFFECT) {
 597                         return strdup(lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_STARDUST_M_EFFECT));
 598                 } else if(index == IDS_LOCKSCREEN_OPTIONS_GLOWWORM_M_EFFECT) {
 599                         return strdup(lockscreen_optoins_get_string(IDS_LOCKSCREEN_OPTIONS_GLOWWORM_M_EFFECT));
 600                 }
 601         }
 602         LOCKOPTIONS_TRACE_END;
 603         return NULL;
 604 }
 605
 606
 607 Evas_Object *_create_check_on_object(Evas_Object *parent,char * vconf,Evas_Smart_Cb func, void *data)
 608 {
 609         lockscreen_menu_item_info *lockoption_data =
 610             (lockscreen_menu_item_info *) data;
 611
 612         Evas_Object *check;
 613         int value = 0;
 614         int ret = 0;
 615
 616         check = elm_check_add(parent);
 617         elm_object_style_set(check, "on&off");
 618         evas_object_show(check);
 619
 620         vconf_get_bool(vconf, &value);
 621         elm_check_state_set(check, value);
 622
 623         evas_object_pass_events_set(check, 1);
 624         evas_object_propagate_events_set(check, 0);
 625
 626         evas_object_smart_callback_add(check, "changed",
 627                                                 func,
 628                                                 lockoption_data);
 629
 630         return check;
 631 }
 632
 633 static void _lockscreen_options_main_gl_del(void *data, Evas_Object * obj)
 634 {
 635
 636 }
 637
 638 static void _lockscreen_options_main_gl_sel(void *data, Evas_Object * obj,
 639                                                 void *event_info)
 640 {
 641         LOCKOPTIONS_DBG(" _lockscreen_options_main_gl_sel");
 642         if (data == NULL)
 643                 return;
 644
 645         lockscreen_menu_item_info *lockoption_data = NULL;
 646         elm_genlist_item_selected_set((Elm_Object_Item *) event_info,
 647                                                 EINA_FALSE);
 648
 649         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 650         genlist_selected_item = item;
 651         lockoption_data =
 652                 (lockscreen_menu_item_info *) elm_object_item_data_get(item);
 653         if (lockoption_data == NULL) {
 654                 return;
 655         }
 656
 657         if (lockoption_data->stringId ==
 658                 IDS_LOCKSCREEN_OPTIONS_EVENT_NOTIFICATIONS
 659                 || lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_HELPTEXT
 660                 || lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_WAKE_UP
 661                 || lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_HELP_SHORTCUT
 662                 || lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_CAMERA_SHORTCUT
 663                 || lockoption_data->stringId == IDS_LOCKSCREEN_OPTIONS_SWIPE_PW) {
 664                 Eina_Bool check_state = elm_check_state_get(lockoption_data->check);
 665                 _lockscreen_options_set_menu_status(lockoption_data->stringId, !check_state);
 666                 elm_genlist_item_update(item);
 667         }
 668
 669         if (lockoption_data->func != NULL) {
 670                 lockoption_data->func(data, obj, event_info);
 671         }
 672 }
 673
 674 static void _lockscreen_options_create_gl_item(Elm_Gen_Item_Class * item,
 675                                                int glStyle)
 676 {
 677         LOCKOPTIONS_DBG("_lockscreen_options_create_gl_item, glStyle = %d", glStyle);
 678         if (glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON) {
 679                 item->item_style = "type1";
 680                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 681                 item->func.content_get = _lockscreen_options_main_gl_icon_get;
 682                 item->func.state_get = NULL;
 683                 item->func.del = _lockscreen_options_main_gl_del;
 684         } else if (glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT) {
 685                 item->item_style = "1line";
 686                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 687                 item->func.content_get = NULL;
 688                 item->func.state_get = NULL;
 689                 item->func.del = _lockscreen_options_main_gl_del;
 690         } else if (glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON_DIVIDER) {
 691                 item->item_style = "1line";
 692                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 693                 item->func.content_get = _lockscreen_options_main_gl_icon_get;
 694                 item->func.state_get = NULL;
 695                 item->func.del = NULL;
 696         } else if (glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT1ICON_DIVIDER) {
 697                 item->item_style = LOCKSCREEN_GENLIST_STYLE_2TEXT1ICON_DIVIDER;
 698                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 699                 item->func.content_get = _lockscreen_options_main_gl_icon_get;
 700                 item->func.state_get = NULL;
 701                 item->func.del = NULL;
 702         } else if (glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_HELP) {
 703                 item->item_style = "1line";
 704                 item->func.text_get = _lockscreen_options_main_gl_text_get;
 705                 item->func.content_get = NULL;
 706                 item->func.state_get = NULL;
 707                 item->func.del = _lockscreen_options_main_gl_del;
 708         } else if (glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_TITLE) {
 709                 item->item_style = LOCKSCREEN_GENLIST_STYLE_TITLE;
 710                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 711                 item->func.content_get = NULL;
 712                 item->func.state_get = NULL;
 713                 item->func.del = _lockscreen_options_main_gl_del;
 714         } else if(glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT) {
 715                 LOCKOPTIONS_DBG("_lockscreen_options_create_gl_item  2line.top");
 716                 item->item_style = "type1";
 717                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 718                 item->func.content_get = NULL;
 719                 item->func.state_get = NULL;
 720                 item->func.del = _lockscreen_options_main_gl_del;
 721         } else if(glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT_EXPANDABLE) {
 722                 item->item_style = LOCKSCREEN_GENLIST_STYLE_2TEXT_EXPANDABLE;
 723                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 724                 item->func.content_get = NULL;
 725                 item->func.state_get = NULL;
 726                 item->func.del = _lockscreen_options_main_gl_del;
 727         }else if(glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT1ICON)
 728         {
 729                 item->item_style = "multiline_sub.main";
 730                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 731                 //item->func.content_get = _lockscreen_options_main_gl_icon_get;
 732                 item->func.state_get = NULL;
 733                 item->func.del = _lockscreen_options_main_gl_del;
 734         }else if(glStyle == ENUM_LOCKSCREEN_GENLIST_STYLE_MULTILINE_SUB)
 735         {
 736                 item->item_style = "multiline_sub";
 737                 item->func.text_get = _lockscreen_options_main_gl_label_get;
 738                 item->func.content_get = NULL;
 739                 item->func.state_get = NULL;
 740                 item->func.del = _lockscreen_options_main_gl_del;
 741         }
 742         else {
 743                 LOCKOPTIONS_DBG("_lockscreen_options_create_gl_item FAIL\n");
 744         }
 745 }
 746
 747 static Eina_Bool _pop_cb(void *data, Elm_Object_Item *it)
 748 {
 749         LOCKOPTIONS_DBG("%s, %d", __func__, __LINE__);
 750
 751         /*do something before destroy*/
 752         _lockscreen_options_unregister_vconf_change();
 753
 754         lockscreen_options_ug_data *ug_data =
 755                 (lockscreen_options_ug_data *) data;
 756
 757         if (ug_data == NULL)
 758                 return EINA_FALSE;
 759
 760         ug_destroy_me(ug_data->ug);
 761
 762         return EINA_FALSE;
 763 }
 764 static void _gl_sel(void *data, Evas_Object *obj, void *event_info)
 765 {
 766         LOCKOPTIONS_TRACE_BEGIN;
 767         /*Elm_Object_Item *it = (Elm_Object_Item*)event_info;
 768         elm_genlist_item_selected_set(it, EINA_FALSE);
 769         int index = (int )data;
 770         elm_radio_value_set(item_radio, index);
 771         vconf_set_int(VCONFKEY_LOCKSCREEN_EFFECT, index);
 772         LOCKOPTIONS_DBG("index=%d", index);
 773         vconf_get_int(VCONFKEY_LOCKSCREEN_EFFECT, &index);
 774         LOCKOPTIONS_DBG("index=%d", index);
 775         elm_genlist_item_update(item_unlock);*/
 776
 777         Elm_Object_Item *it = (Elm_Object_Item*)event_info;
 778         elm_genlist_item_selected_set(it, EINA_FALSE);
 779         radio_change(data, obj, event_info);
 780         LOCKOPTIONS_TRACE_END;
 781 }
 782
 783 static void _gl_exp(void *data, Evas_Object *obj, void *event_info)
 784 {
 785         LOCKOPTIONS_TRACE_BEGIN;
 786         radio_group = elm_radio_add(g_genlist);
 787         elm_radio_state_value_set(radio_group, 0);
 788         elm_radio_value_set(radio_group, 0);
 789
 790         Elm_Object_Item *it = (Elm_Object_Item*)event_info;
 791         Evas_Object *gl = elm_object_item_widget_get(it);
 792
 793         LOCKOPTIONS_TRACE_END;
 794 }
 795
 796 static void _gl_con(void *data, Evas_Object *obj, void *event_info)
 797 {
 798         LOCKOPTIONS_TRACE_BEGIN;
 799         Elm_Object_Item *item = (Elm_Object_Item*)event_info;
 800         elm_genlist_item_subitems_clear(item);
 801
 802         elm_object_item_signal_emit(item, "elm,state,normal", "");
 803         item = NULL;
 804         LOCKOPTIONS_TRACE_END;
 805 }
 806
 807 static void lockscreen_options_main_create_genlist(Evas_Object *genlist, lockscreen_options_ug_data * ug_data)
 808 {
 809
 810     int genlist_show_mode = 0;
 811         int genlist_num = 0;
 812         int i = 0;
 813         int lock_type = 0;
 814         Elm_Object_Item *item = NULL;
 815         if(genlist == NULL)
 816                 return;
 817         evas_object_smart_callback_add(genlist, "expanded", _gl_exp, genlist);
 818         evas_object_smart_callback_add(genlist, "contracted", _gl_con, genlist);
 819
 820         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type);
 821         IS_LOCKTYPE(lock_type, genlist_show_mode);
 822         LOCKOPTIONS_DBG("genlist_show_mode = %d", genlist_show_mode);
 823         switch(genlist_show_mode) {
 824                 case 0:
 825                         genlist_num = LOCKSCREEN_OPTOINS_GENLIST_ITEM_NONE;
 826                         break;
 827                 case 1:
 828                         genlist_num = LOCKSCREEN_OPTOINS_GENLIST_ITEM_PW;
 829                         break;
 830                 case 2:
 831                         genlist_num = LOCKSCREEN_OPTOINS_GENLIST_ITEM_NONE;
 832                         break;
 833                 case 4:
 834                         genlist_num = LOCKSCREEN_OPTOINS_GENLIST_ITEM_SWIPE;
 835                         break;
 836         }
 837
 838         for (i = 0; i < genlist_num; i++) {
 839                 lockscreen_menu_item_info *menu_item = NULL;
 840                 Elm_Gen_Item_Class *itc = NULL;
 841                 if(genlist_show_mode == 0) {
 842                         lockscreen_options_menu_item_none[i].data = ug_data;
 843                         menu_item = &lockscreen_options_menu_item_none[i];
 844                 }else if(genlist_show_mode == 1) {
 845                         lockscreen_options_menu_item_pw[i].data = ug_data;
 846                         menu_item = &lockscreen_options_menu_item_pw[i];
 847                 }else if(genlist_show_mode == 2 ) {
 848                         lockscreen_options_menu_item_none[i].data = ug_data;
 849                         menu_item = &lockscreen_options_menu_item_none[i];
 850                 } else if(genlist_show_mode == 4) {
 851                         lockscreen_options_menu_item_swipe[i].data = ug_data;
 852                         menu_item = &lockscreen_options_menu_item_swipe[i];
 853                 }
 854
 855                 if(menu_item != NULL) {
 856                         switch(menu_item->glStyle) {
 857                                 case ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON: {
 858                                         LOCKOPTIONS_DBG("ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON 000");
 859                                         itc = &(itc_menu_1text1icon);
 860                                         item = elm_genlist_item_append(genlist,
 861                                                         itc,
 862                                                         menu_item, NULL,
 863                                                         ELM_GENLIST_ITEM_NONE,
 864                                                         _lockscreen_options_main_gl_sel,
 865                                                         ug_data);
 866                                         if(IDS_LOCKSCREEN_OPTIONS_SWIPE_PW == menu_item->stringId) {
 867                                                 item_security = item;
 868                                         }
 869                                         menu_item->item = item;
 870                                         break;
 871                                 }
 872                                 case ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT: {
 873                                         LOCKOPTIONS_DBG("ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT");
 874                                         itc = &(itc_menu_1text);
 875                                         item = elm_genlist_item_append(genlist,
 876                                                         itc,
 877                                                         menu_item, NULL,
 878                                                         ELM_GENLIST_ITEM_NONE,
 879                                                         _lockscreen_options_main_gl_sel,
 880                                                         ug_data);
 881
 882                                         menu_item->item = item;
 883                                         break;
 884                                 }
 885                                 case ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT: {
 886                                         LOCKOPTIONS_DBG("ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT");
 887                                         itc = &(itc_title_2text);
 888                                         item = elm_genlist_item_append(genlist,
 889                                                         itc,
 890                                                         menu_item, NULL,
 891                                                         ELM_GENLIST_ITEM_NONE,
 892                                                         _lockscreen_options_main_gl_sel,
 893                                                         ug_data);
 894                                         if(item == NULL) {
 895                                                 LOCKOPTIONS_WARN("elm_genlist_item_append() failed");
 896                                         }
 897                                         if(i == 0 && genlist_show_mode != 4 &&genlist_show_mode != 0){
 898                                            lockscreen_options_util_create_seperator(genlist);
 899                                         }
 900                                         if(IDS_LOCKSCREEN_OPTIONS_LOCK_SCREEN_TYPE == menu_item->stringId)
 901                                         {
 902                                                 item_type = item ;
 903                                         }
 904                                         menu_item->item = item;
 905                                         break;
 906                                 }
 907                                 case ENUM_LOCKSCREEN_GENLIST_STYLE_MULTILINE_SUB: {
 908                                         LOCKOPTIONS_DBG("ENUM_LOCKSCREEN_GENLIST_STYLE_MULTILINE_SUB");
 909                                         itc = &(itc_multiline_text);
 910                                         item = elm_genlist_item_append(genlist,
 911                                                         itc,
 912                                                         menu_item, NULL,
 913                                                         ELM_GENLIST_ITEM_NONE,
 914                                                         NULL, ug_data);
 915                                         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 916                                         menu_item->item = item;
 917                                         break;
 918                                 }
 919                                 default: {
 920                                         LOCKOPTIONS_WARN("lockscreen option has no such type.");
 921                                         return;
 922                                 }
 923                         }
 924                 }
 925         }
 926         LOCKOPTIONS_DBG("lockscreen_options_main_create_genlist end");
 927 }
 928
 929 static Eina_Bool _gl_state_get(void *data, Evas_Object *obj, const char *part)
 930 {
 931         return EINA_FALSE;
 932 }
 933
 934 static void _lockscreen_move_help_ctxpopup(Evas_Object *ctx, lockscreen_options_ug_data *ugd)
 935 {
 936         LOCKOPTIONS_TRACE_BEGIN;
 937         Evas_Coord w, h;
 938         int pos = -1;
 939
 940         ret_if(ugd == NULL);
 941         ret_if(ugd->win_main == NULL);
 942
 943         elm_win_screen_size_get(ugd->win_main, NULL, NULL, &w, &h);
 944         pos = elm_win_rotation_get(ugd->win_main);
 945
 946         switch (pos) {
 947                 case 0:
 948                 case 180:
 949                         evas_object_move(ctx, 0, h);
 950                         break;
 951                 case 90:
 952                         evas_object_move(ctx, 0, w);
 953                         break;
 954                 case 270:
 955                         evas_object_move(ctx, h, w);
 956                         break;
 957         }
 958 }
 959
 960 static void _lockscreen_more_popup_del_cb(void *data)
 961 {
 962         LOCKOPTIONS_TRACE_BEGIN;
 963         lockscreen_options_ug_data *ugd = NULL;
 964
 965         ret_if(data == NULL);
 966
 967         ugd = (lockscreen_options_ug_data *)data;
 968
 969         if (ugd->help_more_popup != NULL) {
 970                 evas_object_del(ugd->help_more_popup);
 971                 ugd->help_more_popup = NULL;
 972         }
 973 }
 974
 975 static void _lockscreen_more_popup_more_cb(void *data,
 976                                 Evas_Object *obj, void *event_info)
 977 {
 978         LOCKOPTIONS_TRACE_BEGIN;
 979         _lockscreen_more_popup_del_cb((lockscreen_options_ug_data *)data);
 980 }
 981
 982 static void _lockscreen_more_popup_back_cb(void *data,
 983                                 Evas_Object *obj, void *event_info)
 984 {
 985         LOCKOPTIONS_TRACE_BEGIN;
 986         _lockscreen_more_popup_del_cb((lockscreen_options_ug_data *)data);
 987 }
 988
 989 static void _lockscreen_more_popup_rotate_cb(void *data, Evas_Object *obj,
 990                                                 void *event_info)
 991 {
 992         LOCKOPTIONS_TRACE_BEGIN;
 993         lockscreen_options_ug_data *ugd;
 994         Evas_Object * ctx;
 995
 996         ugd = (lockscreen_options_ug_data *)data;
 997         ret_if(ugd == NULL);
 998
 999         ctx = ugd->help_more_popup;
1000         ret_if(ctx == NULL);
1001
1002         _lockscreen_move_help_ctxpopup(ctx, ugd);
1003         evas_object_show(ctx);
1004 }
1005
1006 static void _lockscreen_more_popup_dismiss_cb(void *data, Evas_Object *obj,
1007                                                 void *event)
1008 {
1009         LOCKOPTIONS_TRACE_BEGIN;
1010         lockscreen_options_ug_data *ugd;
1011
1012         ugd = (lockscreen_options_ug_data *)data;
1013         ret_if(ugd == NULL);
1014         ret_if(ugd->help_more_popup == NULL);
1015
1016         evas_object_del(ugd->help_more_popup);
1017         ugd->help_more_popup = NULL;
1018 }
1019
1020 static void _lockscreen_more_popup_delete_cb(void *data, Evas *e,
1021                 Evas_Object *obj,       void *event_info)
1022 {
1023         LOCKOPTIONS_TRACE_BEGIN;
1024         Evas_Object *navi = (Evas_Object *)data;
1025         Evas_Object *ctx = obj;
1026
1027         ret_if(navi == NULL);
1028
1029         evas_object_smart_callback_del(ctx, "dismissed",
1030                         _lockscreen_more_popup_dismiss_cb);
1031         evas_object_smart_callback_del(elm_object_top_widget_get(ctx),
1032                         "rotation,changed", _lockscreen_more_popup_rotate_cb);
1033         evas_object_event_callback_del_full(ctx, EVAS_CALLBACK_DEL,
1034                         _lockscreen_more_popup_delete_cb, navi);
1035 }
1036
1037 static void _lockscreen_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
1038 {
1039         LOCKOPTIONS_TRACE_BEGIN;
1040         Evas_Object *base;
1041
1042         ret_if(!ug);
1043
1044         base = ug_get_layout(ug);
1045         if (!base) {
1046                 LOCKOPTIONS_ERR("ug_get_layout() return NULL");
1047                 ug_destroy(ug);
1048                 return;
1049         }
1050
1051         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1052         evas_object_show(base);
1053 }
1054
1055 static void _lockscreen_ug_destroy_cb(ui_gadget_h ug, void *data)
1056 {
1057         LOCKOPTIONS_TRACE_BEGIN;
1058         ret_if(NULL == ug);
1059         ug_destroy(ug);
1060 }
1061
1062 static void _lockscreen_more_popup_help_item_sel_cb(void *data,
1063                                 Evas_Object *obj, void *event_info)
1064 {
1065         LOCKOPTIONS_TRACE_BEGIN;
1066         ret_if(!data);
1067
1068         lockscreen_options_ug_data *ugd = (lockscreen_options_ug_data *)data;
1069         app_control_h service = NULL;
1070         ui_gadget_h ug_h = NULL;
1071         struct ug_cbs cbs = {0};
1072
1073         app_control_create(&service);
1074         app_control_add_extra_data(service, "page","help_basics_lockscreen");
1075
1076         cbs.layout_cb = _lockscreen_ug_layout_cb;
1077         cbs.result_cb = NULL;
1078         cbs.destroy_cb = _lockscreen_ug_destroy_cb;
1079         cbs.priv = NULL;
1080
1081         ug_h = ug_create(NULL, "help-efl", UG_MODE_FULLVIEW, service, &cbs);
1082         if(!ug_h) {
1083                 LOCKOPTIONS_ERR("ug_create() Failed");
1084         }
1085         app_control_destroy(service);
1086         _lockscreen_more_popup_del_cb((lockscreen_options_ug_data *)data);
1087 }
1088
1089 static void _lockscreen_more_menu_cb(void *data, Evas_Object *obj, void *event_info)
1090 {
1091         LOCKOPTIONS_TRACE_BEGIN;
1092
1093         Evas_Object *more_ctxpopup = NULL;
1094         lockscreen_options_ug_data *ugd;
1095
1096         ugd = (lockscreen_options_ug_data *)data;
1097         if(ugd == NULL)
1098                 return;
1099
1100         more_ctxpopup = elm_ctxpopup_add(ugd->base);
1101         ugd->help_more_popup = more_ctxpopup;
1102         eext_object_event_callback_add(more_ctxpopup,
1103                         EEXT_CALLBACK_BACK, _lockscreen_more_popup_back_cb, ugd);
1104         eext_object_event_callback_add(more_ctxpopup,
1105                         EEXT_CALLBACK_MORE, _lockscreen_more_popup_more_cb, ugd);
1106         elm_object_style_set(more_ctxpopup, "more/default");
1107         elm_ctxpopup_auto_hide_disabled_set(more_ctxpopup, EINA_TRUE);
1108
1109         elm_ctxpopup_item_append(more_ctxpopup, _S("IDS_COM_BODY_HELP"),
1110                         NULL, _lockscreen_more_popup_help_item_sel_cb, ugd);
1111
1112         evas_object_smart_callback_add(more_ctxpopup, "dismissed",
1113                         _lockscreen_more_popup_dismiss_cb, ugd);
1114         evas_object_smart_callback_add(elm_object_top_widget_get(more_ctxpopup),
1115                         "rotation,changed",
1116                         _lockscreen_more_popup_rotate_cb, ugd);
1117         evas_object_event_callback_add(more_ctxpopup, EVAS_CALLBACK_DEL,
1118                         _lockscreen_more_popup_delete_cb, ugd->navi_bar);
1119
1120         elm_ctxpopup_direction_priority_set(more_ctxpopup, ELM_CTXPOPUP_DIRECTION_UP,
1121                         ELM_CTXPOPUP_DIRECTION_DOWN,
1122                         ELM_CTXPOPUP_DIRECTION_UNKNOWN,
1123                         ELM_CTXPOPUP_DIRECTION_UNKNOWN);
1124
1125         _lockscreen_move_help_ctxpopup(more_ctxpopup, ugd);
1126         evas_object_show(more_ctxpopup);
1127         LOCKOPTIONS_TRACE_END;
1128 }
1129
1130 void lockscreen_options_main_create_view_for_locktitle(lockscreen_options_ug_data * ug_data)
1131 {
1132         LOCKOPTIONS_TRACE_BEGIN;
1133         lockscreen_options_main_create_view(ug_data);
1134         lockscreen_options_locktitle_create_view(ug_data);
1135         LOCKOPTIONS_TRACE_END;
1136 }
1137
1138 static void _back_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1139 {
1140         elm_naviframe_item_pop(data);
1141 }
1142
1143 void lockscreen_options_main_create_view(lockscreen_options_ug_data * ug_data)
1144 {
1145         LOCKOPTIONS_DBG("lockscreen_options_main_create_view begin\n");
1146
1147         Evas_Object *navi_bar = ug_data->navi_bar;
1148         Evas_Object *back_button = NULL;
1149         Evas_Object *genlist = NULL;
1150         int lock_type = 0;
1151         int wakeup_val = 0;
1152
1153         if (navi_bar == NULL) {
1154                 LOCKOPTIONS_WARN("navi_bar is null.");
1155                 return;
1156         }
1157
1158         //ea_object_event_callback_add(navi_bar, EA_CALLBACK_MORE, _lockscreen_more_menu_cb, ug_data);
1159         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type);
1160         ug_data->locktype = lock_type;
1161
1162         _lockscreen_options_create_gl_item(&(itc_title_2text), ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT);
1163         _lockscreen_options_create_gl_item(&(itc_menu_1text), ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT);
1164         _lockscreen_options_create_gl_item(&(itc_menu_1text1icon), ENUM_LOCKSCREEN_GENLIST_STYLE_1TEXT1ICON);
1165         _lockscreen_options_create_gl_item(&(itc_menu_2text1icon), ENUM_LOCKSCREEN_GENLIST_STYLE_2TEXT1ICON);
1166         _lockscreen_options_create_gl_item(&(itc_multiline_text), ENUM_LOCKSCREEN_GENLIST_STYLE_MULTILINE_SUB);
1167
1168         /* Create genlist */
1169         genlist = elm_genlist_add(navi_bar);
1170         g_genlist = genlist;
1171         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1172         elm_object_style_set(genlist, "dialogue");
1173
1174         lockscreen_options_util_create_seperator(genlist);
1175
1176         lockscreen_options_main_create_genlist(genlist, ug_data);
1177
1178         /* Set navigation objects and push */
1179         back_button = elm_button_add(navi_bar);
1180         elm_object_style_set(back_button, "naviframe/back_btn/default");
1181         evas_object_smart_callback_add(back_button, "clicked", _back_btn_clicked_cb, navi_bar);
1182
1183         Elm_Object_Item *navi_item = elm_naviframe_item_push(navi_bar, "IDS_LCKSCN_HEADER_LOCK_SCREEN", back_button, NULL, genlist, NULL);      /* the same tile */
1184         elm_object_item_domain_text_translatable_set(navi_item, PKGNAME, EINA_TRUE);
1185         elm_naviframe_item_pop_cb_set(navi_item, _pop_cb, ug_data);
1186         ug_data->main_navi_item = navi_item;
1187
1188         _lockscreen_options_register_vconf_change(ug_data);
1189
1190         LOCKOPTIONS_DBG("lockscreen_options_main_create_view end");
1191 }
1192
1193 void lockscreen_options_main_update_view()
1194 {
1195         LOCKOPTIONS_DBG("%s, %d", __func__, __LINE__);
1196         if(g_genlist != NULL) {
1197                 LOCKOPTIONS_DBG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
1198                 Eina_Bool pass = evas_object_pass_events_get(g_genlist);
1199                 if(pass == EINA_TRUE)
1200                         LOCKOPTIONS_DBG("!!!!!!!!!!!!!EINA_TRUE");
1201                 else
1202                         LOCKOPTIONS_DBG("=============EINA_FALSE");
1203                 evas_object_pass_events_set(g_genlist, EINA_FALSE);
1204                 Elm_Object_Item *item = NULL;
1205                 Elm_Object_Item *item_1 = elm_genlist_first_item_get(g_genlist);
1206                 elm_genlist_item_update(item_1);
1207                 while((item = elm_genlist_item_next_get(item_1)) != NULL) {
1208                         elm_genlist_item_update(item);
1209                         item_1 = item;
1210                 }
1211         }
1212 }
1213
1214 void lockscreen_options_main_create_view_update(keynode_t *node, void *data)
1215 {
1216         LOCKOPTIONS_TRACE_BEGIN ;
1217         if(NULL == data){
1218                 LOCKOPTIONS_DBG("---------NULL == ug_data");
1219                 return ;
1220         }
1221         lockscreen_options_ug_data * ug_data = data;
1222         if(g_genlist != NULL) {
1223                 elm_genlist_clear(g_genlist);
1224                 evas_object_del(g_genlist);
1225                 g_genlist = NULL;
1226         }
1227                 lockscreen_options_main_create_view(ug_data);
1228 }
1229
1230 static void _lockscreen_options_style_change_cb(keynode_t *node, void *data)
1231 {
1232         lockscreen_options_main_update_view();
1233 }
1234
1235 static void _lockscreen_options_locktype_change_cb(keynode_t *node, void *data)
1236 {
1237         lockscreen_options_ug_data * ug_data = data;
1238         int old_locktype = ug_data->locktype;
1239         int new_locktype = 0;
1240         int old_type = 0;
1241         int new_type = 0;
1242         int ret = 0;
1243         vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &new_locktype);
1244         LOCKOPTIONS_DBG("_lockscreen_options_locktype_change_cb,old type is %d, new type is %d",old_locktype, new_locktype);
1245         IS_LOCKTYPE(old_locktype, old_type);
1246         IS_LOCKTYPE(new_locktype, new_type);
1247
1248         if(g_genlist != NULL) {
1249                 item_unlock = NULL;
1250                 elm_genlist_clear(g_genlist);
1251                 evas_object_del(g_genlist);
1252                 g_genlist = NULL;
1253         }
1254
1255         g_genlist = elm_genlist_add(ug_data->navi_bar);
1256         //g_genlist = genlist;
1257         elm_genlist_mode_set(g_genlist, ELM_LIST_COMPRESS);
1258         elm_object_style_set(g_genlist, "dialogue");
1259
1260         lockscreen_options_util_create_seperator(g_genlist);
1261         lockscreen_options_main_create_genlist(g_genlist, ug_data);
1262         elm_object_item_part_content_set(ug_data->main_navi_item, "elm.swallow.content", g_genlist);
1263         evas_object_show(g_genlist);
1264         ug_data->locktype = new_locktype;
1265
1266         /* for starter */
1267         if (new_locktype < SETTING_SCREEN_LOCK_TYPE_OTHER) {
1268                 ret = vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, LOCKSCREEN_PACKAGE_NAME);
1269                 LOCKOPTIONS_DBG("VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR set %s [%d] ", LOCKSCREEN_PACKAGE_NAME, ret);
1270         }
1271         return;
1272 }
1273
1274 static void _lockscreen_options_register_vconf_change(lockscreen_options_ug_data * ug_data)
1275 {
1276         LOCKOPTIONS_TRACE_BEGIN;
1277         int ret = -1;
1278         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT,
1279                                         _lockscreen_options_locktype_change_cb, ug_data);
1280         if (ret != 0) {
1281                 LOCKOPTIONS_ERR("Failed to register lockscreen type callback!");
1282         }
1283 }
1284
1285 void _lockscreen_options_unregister_vconf_change()
1286 {
1287         LOCKOPTIONS_TRACE_BEGIN;
1288         int ret = -1;
1289         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT,
1290                                         _lockscreen_options_locktype_change_cb);
1291         if (ret != 0) {
1292                 LOCKOPTIONS_ERR("Failed to unregister lockscreen type callback!");
1293         }
1294
1295 }