src/setting-clock.c

   1 /*
   2  *  Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  *  Licensed under the Flora License, Version 1.0 (the License);
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://floralicense.org/license/
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an AS IS BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  */
  17 #include <vconf.h>
  18 #include <vconf-keys.h>
  19 #include <unicode/ucal.h>
  20 #include <unicode/uloc.h>
  21 #include <unicode/udat.h>
  22 #include <unicode/ustring.h>
  23 #include <unicode/udatpg.h>
  24 #include <unicode/utmscale.h>
  25 #include <unicode/ucol.h>
  26 #include <package-manager.h>
  27 #include <pkgmgr-info.h>
  28 #include <feedback.h>
  29
  30 #include "setting-clock.h"
  31 #include "util.h"
  32 #include "setting.h"
  33 #include "setting_view_toast.h"
  34
  35 #include "setting_data_vconf.h"
  36
  37 static void _datetime_auto_sync_cb(void *data, Evas_Object *obj, void *event_info);
  38 static void _datetime_date_cb(void *data, Evas_Object *obj, void *event_info);
  39 static void _datetime_time_cb(void *data, Evas_Object *obj, void *event_info);
  40 static char *get_timezone_str();
  41 static UChar *uastrcpy(const char *chars);
  42 static void ICU_set_timezone(const char *timezone);
  43
  44 static void _mouse_down_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  45 static void _mouse_up_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  46 static void _mouse_move_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  47 static void _page_show(void *data, Evas *e, Evas_Object *obj, void *event_info);
  48
  49 static struct _clock_menu_item clock_menu_its[] = {
  50         { "IDS_ST_BODY_CLOCK_TYPE_ABB",         1,              _clock_type_cb },
  51 #ifndef FEATURE_SETTING_SDK
  52         { "IDS_ST_BODY_DATE_AND_TIME_ABB",      0,      _dt_cb },
  53         { "IDS_ST_BODY_HOURLY_ALERT_ABB",       0,              _hourly_alert_cb },
  54 #endif
  55 };
  56
  57 static struct _dt_menu_item dt_menu_its[] = {
  58         { "IDS_ST_BODY_AUTO_SYNC_ABB2",                 "IDS_ST_BODY_SYNC_WITH_PHONE_ABB",      _datetime_auto_sync_cb   },
  59         { "IDS_ST_BODY_SET_DATE_ABB2",                  "",                                                             _datetime_date_cb                },
  60         { "IDS_SMEMO_BUTTON_SET_TIME_ABB",              "",                                                             _datetime_time_cb                },
  61 };
  62
  63 static Elm_Object_Item *auto_sync_item = NULL;
  64 static Elm_Object_Item *date_item = NULL;
  65 static Elm_Object_Item *time_item = NULL;
  66 static Evas_Object *g_date_time_genlist = NULL;
  67 static Evas_Object *g_clock_genlist = NULL;
  68 static Evas_Object *auto_sync_check = NULL;
  69 static Evas_Object *g_clock_scroller = NULL;
  70 static Evas_Object *g_clock_box = NULL;
  71 /*pkgmgr_client *pc_clock = NULL; */
  72 /*pkgmgr_client *pc_clock2 = NULL; */
  73 static UCollator *coll = NULL;
  74
  75 static int clock_idx = 0;
  76 static int is_alert_mode_type = 0;
  77 static appdata *temp_ad = NULL;
  78
  79 static int _clock_type_compare_cb(const void *d1, const void *d2);
  80
  81
  82 Evas_Object *_elm_min_set(Evas_Object *obj, Evas_Object *parent, Evas_Coord w, Evas_Coord h)
  83 {
  84         Evas_Object *table, *rect;
  85
  86         table = elm_table_add(parent);
  87
  88         rect = evas_object_rectangle_add(evas_object_evas_get(table));
  89         evas_object_size_hint_min_set(rect, w, h);
  90         evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  91         evas_object_size_hint_align_set(rect, EVAS_HINT_FILL, EVAS_HINT_FILL);
  92         elm_table_pack(table, rect, 0, 0, 1, 1);
  93         evas_object_size_hint_weight_set(obj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  94         evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
  95         elm_table_pack(table, obj, 0, 0, 1, 1);
  96
  97         return table;
  98 }
  99
 100 static Clock_Type_Item *_get_selected_clock()
 101 {
 102         Clock_Type_Item *pitem = NULL;
 103         char *pkgid = NULL;
 104         char *p = NULL;
 105         int i = 0;
 106
 107         pkgid = vconf_get_str(VCONFKEY_WMS_CLOCKS_SET_IDLE);
 108
 109         if (pkgid && strlen(pkgid)) {
 110                 Eina_List *list = NULL;
 111                 for (i = 0; i < 3; i++) {
 112                         EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
 113                                 if (pitem->pkgid) {
 114                                         if (!strcmp(pkgid, pitem->pkgid)) {
 115                                                 /*DBG("pkgid for selected idleclock is %s", pitem->pkgid); */
 116                                                 return pitem;
 117                                         }
 118                                 }
 119                         }
 120                 }
 121         }
 122
 123         return NULL;
 124 }
 125
 126 static void update_clock_list(void *data, Eina_Bool reload, Eina_Bool show)
 127 {
 128         appdata *ad = data;
 129
 130         if (!ad) {
 131                 ERR("appdata is null!!");
 132                 return;
 133         }
 134
 135         Evas_Object *page_layout = NULL;
 136         Evas_Object *box = g_clock_box;
 137
 138         if (reload) {
 139                 _clocklist_load();
 140         }
 141
 142         if (box) {
 143                 elm_box_clear(box);
 144                 Clock_Type_Item *selected = _get_selected_clock();
 145                 Clock_Type_Item *pitem = NULL;
 146                 Eina_List *list = NULL;
 147                 int i;
 148                 for (i = 0; i < 3; i++) {
 149                         EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
 150                                 /* Create Pages */
 151                                 page_layout = elm_layout_add(box);
 152                                 /*elm_layout_file_set(page_layout, EDJE_PATH, "setting/bg_thumbnail"); */
 153                                 elm_layout_theme_set(page_layout, "layout", "body_thumbnail", "default");
 154                                 evas_object_size_hint_weight_set(page_layout, 0, 0);
 155                                 evas_object_size_hint_align_set(page_layout, 0, EVAS_HINT_FILL);
 156                                 evas_object_show(page_layout);
 157
 158                                 Evas_Object *clock_layout = elm_layout_add(page_layout);
 159                                 elm_layout_file_set(clock_layout, EDJE_PATH, "setting-test/clock-type");
 160                                 evas_object_size_hint_weight_set(clock_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 161                                 evas_object_size_hint_align_set(clock_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 162                                 evas_object_show(clock_layout);
 163
 164                                 /*clock bg wallpaper */
 165                                 int bg_mode;
 166                                 vconf_get_int("db/wms/home_bg_mode", &bg_mode);
 167                                 if (!bg_mode) {
 168                                         char *bg_color = NULL;
 169                                         int R = 0x00, G = 0x00, B = 0x00;
 170                                         bg_color = vconf_get_str("db/wms/home_bg_palette");
 171                                         colorstr_to_decimal(bg_color, &R, &G, &B);
 172                                         DBG("R : [%d] G : [%d] B : [%d]", R, G, B);
 173                                         Evas_Object *color_page = evas_object_rectangle_add(evas_object_evas_get(page_layout));
 174                                         evas_object_color_set(color_page, R, G, B, 255);
 175                                         evas_object_size_hint_weight_set(color_page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 176                                         evas_object_size_hint_align_set(color_page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 177                                         elm_object_part_content_set(clock_layout, "clock-color", color_page);
 178                                 } else {
 179                                         char *bg_wallpaper = NULL;
 180                                         bg_wallpaper = vconf_get_str(VCONFKEY_BGSET);
 181                                         Evas_Object *wall_page = elm_image_add(clock_layout);
 182                                         elm_image_file_set(wall_page, bg_wallpaper, NULL);
 183                                         evas_object_size_hint_weight_set(wall_page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 184                                         evas_object_size_hint_align_set(wall_page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 185                                         elm_object_part_content_set(clock_layout, "clock-wallpaper", wall_page);
 186                                 }
 187
 188                                 /*clock image */
 189                                 Evas_Object *page = elm_image_add(clock_layout);
 190                                 elm_image_file_set(page, pitem->icon, NULL);
 191                                 evas_object_size_hint_weight_set(page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 192                                 evas_object_size_hint_align_set(page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 193
 194                                 /* touch event */
 195                                 evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, NULL);
 196                                 evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, (void *)pitem->pkgid);
 197                                 evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb, NULL);
 198
 199                                 elm_object_part_content_set(clock_layout, "clock-image", page);
 200                                 if (pitem == selected) {
 201                                         elm_object_signal_emit(page_layout, "elm,state,thumbnail,focus", "*");
 202                                 } else {
 203                                         elm_object_signal_emit(page_layout, "elm,state,thumbnail,unfocus", "*");
 204                                 }
 205
 206                                 elm_object_part_content_set(page_layout, "elm.icon", clock_layout);
 207
 208                                 elm_box_pack_end(box, page_layout);
 209                         }
 210                 }
 211
 212         }
 213
 214         if (show) {
 215                 _page_show(NULL, NULL, g_clock_scroller, NULL);
 216         }
 217 }
 218
 219 static int _clock_appinfo_cb(pkgmgrinfo_appinfo_h handle, void *data)
 220 {
 221         appdata *ad = data;
 222
 223         if (!ad) {
 224                 ERR("appdata is null!!");
 225                 return -1;
 226         }
 227         char *appid = NULL;
 228         int r;
 229         pkgmgrinfo_appinfo_h tmp_handle;
 230         int clockapp = 0;
 231
 232         r = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 233         if (r < 0 || !appid) {
 234                 ERR("pkgmgrinfo_appinfo_get_appid error");
 235                 return -1;
 236         } else {
 237                 r = pkgmgrinfo_appinfo_get_appinfo(appid, &tmp_handle);
 238                 if (r != PMINFO_R_OK) {
 239                         ERR("pkgmgrinfo_appinfo_get_appinfo error");
 240                         return -1;
 241                 }
 242
 243                 r = pkgmgrinfo_appinfo_is_category_exist(tmp_handle, IDLE_CLOCK_CATEGROY, &clockapp);
 244                 if (r != PMINFO_R_OK) {
 245                         ERR("pkgmgrinfo_appinfo_is_category_exist error");
 246                         return -1;
 247                 }
 248
 249                 if (!clockapp) {
 250                         r = pkgmgrinfo_appinfo_is_category_exist(tmp_handle, IDLE_CLOCK_CATEGROY2, &clockapp);
 251                         if (r != PMINFO_R_OK) {
 252                                 ERR("pkgmgrinfo_appinfo_is_category_exist error");
 253                                 return -1;
 254                         }
 255                 }
 256         }
 257
 258         if (clockapp)   {
 259                 update_clock_list(ad, EINA_TRUE, EINA_TRUE);
 260         }
 261
 262         return 0;
 263 }
 264
 265 static int _clock_app_event_cb(int req_id, const char *pkg_type, const char *pkgid,
 266                                                            const char *key, const char *val, const void *pmsg, void *data)
 267 {
 268         appdata *ad = data;
 269
 270         if (!ad) {
 271                 ERR("appdata is null!!");
 272                 return -1;
 273         }
 274
 275         if (!pkgid || !key || !val) {
 276                 ERR("pkgid or key or val is null");
 277                 return -1;
 278         }
 279
 280         int ret = 0;
 281         if (!strncmp(key, "end", 3) && !strncmp(val, "ok", 2)) {
 282                 DBG("end install/update for some pkgid");
 283
 284                 pkgmgrinfo_pkginfo_h handle;
 285
 286                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
 287                 if (ret != PMINFO_R_OK)
 288                         return -1;
 289                 ret = pkgmgrinfo_appinfo_get_list(handle, PMINFO_UI_APP, _clock_appinfo_cb , data);
 290                 if (ret != PMINFO_R_OK) {
 291                         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 292                         return -1;
 293                 }
 294                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 295
 296         }
 297         return 0;
 298 }
 299
 300 static int _clock_app_uninstall_event_cb(int req_id, const char *pkg_type, const char *pkgid,
 301                                                                                  const char *key, const char *val, const void *pmsg, void *data)
 302 {
 303         appdata *ad = data;
 304
 305         if (!ad) {
 306                 ERR("appdata is null!!");
 307                 return -1;
 308         }
 309
 310         if (!pkgid || !key || !val) {
 311                 ERR("pkgid or key or val is null");
 312                 return -1;
 313         }
 314
 315         int ret = 0;
 316         if (!strncmp(key, "end", 3) && !strncmp(val, "ok", 2)) {
 317                 DBG("end uninstall for some pkgid");
 318                 update_clock_list(ad, EINA_TRUE, EINA_TRUE);
 319         }
 320         return 0;
 321 }
 322
 323 static void update_clock_list_cb(keynode_t *key, void *data)
 324 {
 325         appdata *ad = data;
 326
 327         if (!ad) {
 328                 ERR("appdata is null!!");
 329                 return;
 330         }
 331
 332         char *vconf = NULL;
 333         vconf = vconf_keynode_get_name(key);
 334
 335         if (vconf && !strcmp(vconf, VCONFKEY_WMS_CLOCKS_SET_IDLE)) {
 336                 update_clock_list(ad, EINA_FALSE, EINA_TRUE);
 337         } else {
 338                 update_clock_list(ad, EINA_FALSE, EINA_FALSE);
 339         }
 340 }
 341
 342 static int _clock_check_appinfo(void *data, char *appid)
 343 {
 344         appdata *ad = data;
 345
 346         if (!ad) {
 347                 ERR("appdata is null!!");
 348                 return -1;
 349         }
 350         int r;
 351         pkgmgrinfo_appinfo_h tmp_handle;
 352         int clockapp = 0;
 353
 354         r = pkgmgrinfo_appinfo_get_appinfo(appid, &tmp_handle);
 355         if (r != PMINFO_R_OK) {
 356                 ERR("pkgmgrinfo_appinfo_get_appinfo error");
 357                 return -1;
 358         }
 359
 360         r = pkgmgrinfo_appinfo_is_category_exist(tmp_handle, IDLE_CLOCK_CATEGROY, &clockapp);
 361         if (r != PMINFO_R_OK) {
 362                 ERR("pkgmgrinfo_appinfo_is_category_exist error");
 363                 return -1;
 364         }
 365
 366         if (!clockapp) {
 367                 r = pkgmgrinfo_appinfo_is_category_exist(tmp_handle, IDLE_CLOCK_CATEGROY2, &clockapp);
 368                 if (r != PMINFO_R_OK) {
 369                         ERR("pkgmgrinfo_appinfo_is_category_exist error");
 370                         return -1;
 371                 }
 372         }
 373
 374         if (clockapp)   {
 375                 update_clock_list(ad, EINA_TRUE, EINA_TRUE);
 376         }
 377
 378         return 0;
 379 }
 380
 381 static void change_clock_app_state_cb(keynode_t *key, void *data)
 382 {
 383         appdata *ad = data;
 384
 385         if (!ad) {
 386                 ERR("appdata is null!!");
 387                 return;
 388         }
 389
 390         char appid[256] = {0, };
 391         char type[7] = {0, };
 392         char *value = NULL;
 393         char *p = NULL;
 394
 395         value = vconf_get_str(VCONFKEY_AIL_INFO_STATE);
 396
 397         if (value && (strlen(value + 7) < 256)) {
 398                 strcpy(appid, value + 7);
 399                 strncpy(type, value, 6);
 400
 401                 if (!strncmp(type, "delete", 6)) {
 402                         update_clock_list(ad, EINA_TRUE, EINA_TRUE);
 403                 } else if (!strncmp(type, "create", 6) || !strncmp(type, "update", 6)) {
 404                         _clock_check_appinfo(ad, appid);
 405                 }
 406         }
 407 }
 408
 409 void initialize_clock(void *data)
 410 {
 411         appdata *ad = data;
 412
 413         if (!ad) {
 414                 ERR("appdata is null!!");
 415                 return;
 416         }
 417         UErrorCode status = U_ZERO_ERROR;
 418         if (coll) {
 419                 ucol_close(coll);
 420                 coll = NULL;
 421         }
 422         const char *lang = vconf_get_str(VCONFKEY_LANGSET);
 423         coll = ucol_open(lang, &status);
 424
 425         int event_type = PMINFO_CLIENT_STATUS_INSTALL | PMINFO_CLIENT_STATUS_UPGRADE;
 426
 427 #if 0
 428         if (pc_clock) {
 429                 pkgmgr_client_free(pc_clock);
 430                 pc_clock = NULL;
 431         }
 432
 433         if (!ad->pc_clock) {
 434                 ad->pc_clock = pkgmgr_client_new(PMINFO_LISTENING);
 435                 pkgmgr_client_set_status_type(ad->pc_clock, event_type);
 436                 pkgmgr_client_listen_status(ad->pc_clock, _clock_app_event_cb, ad);
 437         }
 438
 439         int event_type2 = PMINFO_CLIENT_STATUS_UNINSTALL;
 440
 441         if (pc_clock2) {
 442                 pkgmgr_client_free(pc_clock2);
 443                 pc_clock2 = NULL;
 444         }
 445
 446         if (!ad->pc_clock2) {
 447                 ad->pc_clock2 = pkgmgr_client_new(PC_LISTENING);
 448                 pkgmgr_client_set_status_type(ad->pc_clock2, event_type2);
 449                 pkgmgr_client_listen_status(ad->pc_clock2, _clock_app_uninstall_event_cb, ad);
 450         }
 451 #endif
 452
 453         _clocklist_load();
 454
 455         register_vconf_changing("db/wms/home_bg_mode", update_clock_list_cb, ad);
 456         register_vconf_changing(VCONFKEY_WMS_CLOCKS_SET_IDLE, update_clock_list_cb, ad);
 457         register_vconf_changing(VCONFKEY_AIL_INFO_STATE, change_clock_app_state_cb, ad);
 458 }
 459
 460 void _clear_clock_cb(void *data , Evas *e, Evas_Object *obj, void *event_info)
 461 {
 462         auto_sync_item = NULL;
 463         date_item = NULL;
 464         time_item = NULL;
 465         g_date_time_genlist = NULL;
 466         g_clock_genlist = NULL;
 467         g_clock_box = NULL;
 468         g_clock_scroller = NULL;
 469
 470         temp_ad = NULL;
 471         is_alert_mode_type = 0;
 472
 473 #if 0
 474         if (pc_clock) {
 475                 pkgmgr_client_free(pc_clock);
 476                 pc_clock = NULL;
 477         }
 478         if (pc_clock2) {
 479                 pkgmgr_client_free(pc_clock2);
 480                 pc_clock2 = NULL;
 481         }
 482 #endif
 483
 484         if (coll) {
 485                 ucol_close(coll);
 486                 coll = NULL;
 487         }
 488         _clocklist_destroy();
 489
 490         unregister_vconf_changing("db/wms/home_bg_mode", update_clock_list_cb);
 491         unregister_vconf_changing(VCONFKEY_WMS_CLOCKS_SET_IDLE, update_clock_list_cb);
 492         unregister_vconf_changing(VCONFKEY_AIL_INFO_STATE, change_clock_app_state_cb);
 493
 494         is_running_clock = 0;
 495 }
 496
 497 static void _layout_del_cb(void *data , Evas *e, Evas_Object *obj, void *event_info)
 498 {
 499         clock_page_data *pd = data;
 500         free(pd);
 501
 502         int ret;
 503         ret = feedback_deinitialize();
 504         if (ret != FEEDBACK_ERROR_NONE) {
 505                 DBG("feedback_deinitialize failed");
 506         }
 507 }
 508
 509 static Eina_Bool animator_cb(void *data)
 510 {
 511         clock_page_data *pd = (clock_page_data *)data;
 512
 513         elm_mapbuf_enabled_set(pd->mapbuf[0], EINA_TRUE);
 514
 515         return ECORE_CALLBACK_CANCEL;
 516 }
 517
 518 static int _set_clock_type(char *pkgid)
 519 {
 520         if (!pkgid || !strlen(pkgid)) {
 521                 ERR("pkgid is NULL");
 522                 return FALSE;
 523         }
 524         unregister_vconf_changing(VCONFKEY_WMS_CLOCKS_SET_IDLE, update_clock_list_cb);
 525         vconf_set_str(VCONFKEY_WMS_CLOCKS_SET_IDLE, pkgid);
 526         /*DBG("Setting - package name: %s", pkgid); */
 527
 528         return TRUE;
 529 }
 530
 531 static int prev_x = 0;
 532 static int touch_mode = NONE;
 533
 534 static void _mouse_down_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 535 {
 536         touch_mode = TOUCH_DOWN;
 537
 538         Evas_Event_Mouse_Down *ev = event_info;
 539         prev_x = ev->canvas.x;
 540 }
 541
 542 static void _mouse_up_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 543 {
 544         if (touch_mode == TOUCH_MOVE)
 545                 return;
 546
 547         char *pkgid = (char *)data;
 548
 549         prev_x = 0;
 550         touch_mode = NONE;
 551
 552         feedback_play(FEEDBACK_PATTERN_TOUCH_TAP);
 553
 554         /* set gb vconf */
 555         if (_set_clock_type(pkgid)) {
 556                 if (temp_ad != NULL) {
 557                         elm_naviframe_item_pop(temp_ad->nf);
 558                 }
 559
 560                 /* automatic freed!! */
 561                 struct _toast_data *toast = _create_toast(temp_ad, _("IDS_ST_TPOP_CLOCK_CHANGED"));
 562                 if (toast) {
 563                         _show_toast(temp_ad, toast);
 564                 }
 565
 566                 if (g_clock_genlist) {
 567                         elm_genlist_realized_items_update(g_clock_genlist);
 568                 }
 569         } else {
 570                 DBG("Setting - Clock type is wrong!!");
 571         }
 572
 573 }
 574
 575 static void _mouse_move_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 576 {
 577         Evas_Event_Mouse_Move *ev = event_info;
 578
 579         int cur_x = ev->cur.canvas.x;
 580         if (abs(cur_x - prev_x) > 15) {
 581                 /* todo : confirm and remove */
 582                 touch_mode = TOUCH_MOVE;
 583         }
 584 }
 585
 586 static void _page_show(void *data, Evas *e, Evas_Object *obj, void *event_info)
 587 {
 588         int page = 0;
 589
 590         Clock_Type_Item *pitem = _get_selected_clock();
 591
 592         if (pitem) {
 593                 page = pitem->index;
 594                 DBG("name : %s, index : %d", pitem->name, pitem->index);
 595         }
 596
 597         int w, h;
 598         elm_scroller_region_get(obj, NULL, NULL, &w, &h);
 599         printf("%d %d\n", w, h);
 600
 601         elm_scroller_page_show(obj, page, 0);
 602 }
 603
 604 static Evas_Object *_create_index(Evas_Object *parent)
 605 {
 606         Evas_Object *layout, *scroller, *box, *page_layout, *mapbuf, *table;
 607         Evas_Coord w = 0, h = 0;
 608
 609         if (parent == NULL)
 610                 return NULL;
 611
 612         /* Create Layout */
 613         layout = elm_layout_add(parent);
 614         if (layout == NULL)
 615                 return NULL;
 616
 617         clock_page_data *pd = calloc(1, sizeof(clock_page_data));
 618         if (pd == NULL)
 619                 return NULL;
 620
 621         /*elm_layout_file_set(layout, EDJE_PATH, "setting-test/index"); */
 622         elm_layout_file_set(layout, EDJE_PATH, "scroller_custom_layout");
 623         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 624         evas_object_show(layout);
 625         evas_object_event_callback_add(layout, EVAS_CALLBACK_DEL, _layout_del_cb, pd);
 626
 627         /* Create Scroller */
 628         scroller = elm_scroller_add(layout);
 629         elm_scroller_loop_set(scroller, EINA_FALSE, EINA_FALSE);
 630         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 631         evas_object_size_hint_align_set(scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
 632         elm_scroller_page_relative_set(scroller, 1.0, 0.0);
 633         elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_AUTO, ELM_SCROLLER_POLICY_OFF);
 634         elm_scroller_page_scroll_limit_set(scroller, 1, 0);
 635         elm_object_scroll_lock_y_set(scroller, EINA_TRUE);
 636         elm_object_part_content_set(layout, "scroller", scroller);
 637         elm_object_style_set(scroller, "effect");
 638         evas_object_show(scroller);
 639         g_clock_scroller = scroller;
 640
 641         /* Create Box */
 642         box = elm_box_add(scroller);
 643         elm_box_horizontal_set(box, EINA_TRUE);
 644         elm_object_content_set(scroller, box);
 645         evas_object_show(box);
 646         g_clock_box = box;
 647
 648         Clock_Type_Item *selected = _get_selected_clock();
 649         Clock_Type_Item *pitem = NULL;
 650         Eina_List *list = NULL;
 651         int i;
 652         for (i = 0; i < 3; i++) {
 653                 EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
 654                         /* Create Pages */
 655                         page_layout = elm_layout_add(box);
 656                         /*elm_layout_file_set(page_layout, EDJE_PATH, "setting/bg_thumbnail"); */
 657                         elm_layout_theme_set(page_layout, "layout", "body_thumbnail", "default");
 658                         evas_object_size_hint_weight_set(page_layout, 0, 0);
 659                         evas_object_size_hint_align_set(page_layout, 0, EVAS_HINT_FILL);
 660                         evas_object_show(page_layout);
 661
 662                         Evas_Object *clock_layout = elm_layout_add(page_layout);
 663                         elm_layout_file_set(clock_layout, EDJE_PATH, "setting-test/clock-type");
 664                         evas_object_size_hint_weight_set(clock_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 665                         evas_object_size_hint_align_set(clock_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 666                         evas_object_show(clock_layout);
 667
 668                         /*clock bg wallpaper */
 669                         int bg_mode;
 670                         vconf_get_int("db/wms/home_bg_mode", &bg_mode);
 671                         if (!bg_mode) {
 672                                 char *bg_color = NULL;
 673                                 int R = 0x00, G = 0x00, B = 0x00;
 674                                 bg_color = vconf_get_str("db/wms/home_bg_palette");
 675                                 colorstr_to_decimal(bg_color, &R, &G, &B);
 676                                 DBG("R : [%d] G : [%d] B : [%d]", R, G, B);
 677                                 Evas_Object *color_page = evas_object_rectangle_add(evas_object_evas_get(page_layout));
 678                                 evas_object_color_set(color_page, R, G, B, 255);
 679                                 evas_object_size_hint_weight_set(color_page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 680                                 evas_object_size_hint_align_set(color_page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 681                                 elm_object_part_content_set(clock_layout, "clock-color", color_page);
 682                         } else {
 683                                 char *bg_wallpaper = NULL;
 684                                 bg_wallpaper = vconf_get_str(VCONFKEY_BGSET);
 685                                 Evas_Object *wall_page = elm_image_add(clock_layout);
 686                                 elm_image_file_set(wall_page, bg_wallpaper, NULL);
 687                                 evas_object_size_hint_weight_set(wall_page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 688                                 evas_object_size_hint_align_set(wall_page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 689                                 elm_object_part_content_set(clock_layout, "clock-wallpaper", wall_page);
 690                         }
 691
 692                         /*clock image */
 693                         Evas_Object *page = elm_image_add(clock_layout);
 694                         elm_image_file_set(page, pitem->icon, NULL);
 695                         evas_object_size_hint_weight_set(page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 696                         evas_object_size_hint_align_set(page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 697
 698                         /* touch event */
 699                         evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, NULL);
 700                         evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, (void *)pitem->pkgid);
 701                         evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb, NULL);
 702
 703                         elm_object_part_content_set(clock_layout, "clock-image", page);
 704                         if (pitem == selected) {
 705                                 elm_object_signal_emit(page_layout, "elm,state,thumbnail,focus", "*");
 706                         } else {
 707                                 elm_object_signal_emit(page_layout, "elm,state,thumbnail,unfocus", "*");
 708                         }
 709
 710                         elm_object_part_content_set(page_layout, "elm.icon", clock_layout);
 711
 712 #if 0
 713                         /* mapbuf for page 1 */
 714                         mapbuf = elm_mapbuf_add(box);
 715                         evas_object_size_hint_weight_set(mapbuf, 0, 0);
 716                         evas_object_size_hint_align_set(mapbuf, 0, EVAS_HINT_FILL);
 717                         evas_object_show(mapbuf);
 718                         elm_object_content_set(mapbuf, page_layout);
 719                         pd->mapbuf[pitem->index] = mapbuf;
 720 #endif
 721                         elm_win_screen_size_get(elm_widget_top_get(parent), NULL, NULL, &w, &h);
 722                         table = _elm_min_set(page_layout, box, w, h);
 723                         evas_object_size_hint_weight_set(table, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 724                         evas_object_size_hint_align_set(table, EVAS_HINT_FILL, EVAS_HINT_FILL);
 725                         evas_object_show(table);
 726                         elm_box_pack_end(box, table);
 727                 }
 728         }
 729
 730         evas_object_event_callback_add(scroller, EVAS_CALLBACK_RESIZE, _page_show, NULL);
 731
 732         int ret;
 733         ret = feedback_initialize();
 734         if (ret != FEEDBACK_ERROR_NONE) {
 735                 DBG("feedback_initialize failed");
 736         }
 737
 738         /*ecore_animator_add(animator_cb, pd); */
 739
 740         return layout;
 741 }
 742
 743 static int _category_app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
 744 {
 745         char *appid = NULL;
 746         char *name = NULL;
 747         char *pkgid = NULL;
 748         char *icon = NULL;
 749         int ret = 0;
 750         int preload = 0;
 751         char *m_value = NULL;
 752         int type = CLOCKTYPE_INVALID;
 753
 754         pkgmgrinfo_appinfo_h tmp_handle;
 755
 756         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 757
 758         if (ret < 0 || !appid) {
 759                 ERR("pkgmgrinfo_appinfo_get_appid error");
 760                 return -1;
 761         } else {
 762                 ret = pkgmgrinfo_appinfo_get_appinfo(appid, &tmp_handle);
 763                 if (ret != PMINFO_R_OK) {
 764                         ERR("pkgmgrinfo_appinfo_get_appinfo error");
 765                         return -1;
 766                 }
 767                 ret = pkgmgrinfo_appinfo_get_pkgid(tmp_handle, &pkgid);
 768                 if (ret != PMINFO_R_OK) {
 769                         ERR("pkgmgrinfo_appinfo_get_pkgid error");
 770                         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 771                         return -1;
 772                 }
 773                 ret = pkgmgrinfo_appinfo_get_label(tmp_handle, &name);
 774                 if (ret != PMINFO_R_OK) {
 775                         INFO("pkgmgrinfo_appinfo_get_label error");
 776                         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 777                 }
 778                 ret = pkgmgrinfo_appinfo_get_icon(tmp_handle, &icon);
 779                 if (ret != PMINFO_R_OK) {
 780                         INFO("pkgmgrinfo_appinfo_get_icon error");
 781                         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 782                 }
 783                 ret = pkgmgrinfo_appinfo_is_preload(tmp_handle, &preload);
 784                 if (ret != PMINFO_R_OK) {
 785                         INFO("pkgmgrinfo_appinfo_is_preload error or 3rd party");
 786                 }
 787                 ret = pkgmgrinfo_appinfo_get_metadata_value(tmp_handle, "clocktype", &m_value);
 788                 if (ret != PMINFO_R_OK) {
 789                         INFO("pkgmgrinfo_appinfo_get_metadata_value error or 3rd party");
 790                 }
 791
 792                 Clock_Type_Item *pitem = NULL;
 793                 pitem = (Clock_Type_Item *)calloc(1, sizeof(Clock_Type_Item));
 794                 setting_retvm_if(NULL == pitem, SETTING_RETURN_FAIL, "pitem is NULL");
 795                 memset(pitem, 0x0, sizeof(Clock_Type_Item));
 796
 797                 pitem->appid = strdup(appid);
 798                 pitem->pkgid = strdup(pkgid);
 799                 pitem->name = strdup(name);
 800                 pitem->icon = strdup(icon);
 801
 802                 if (m_value && strlen(m_value) > 0) {
 803                         if (!strcmp(m_value, "function")) {
 804                                 type = CLOCKTYPE_FUNCTION;
 805                         } else if (!strcmp(m_value, "style")) {
 806                                 type = CLOCKTYPE_STYLE;
 807                         }
 808                 } else {
 809                         type = CLOCKTYPE_3RD;
 810                 }
 811
 812                 if (preload) {
 813                         switch (type) {
 814                         case CLOCKTYPE_FUNCTION:
 815                                 g_clock_list[0] = eina_list_sorted_insert(g_clock_list[0], _clock_type_compare_cb, pitem);
 816                                 break;
 817                         case CLOCKTYPE_STYLE:
 818                                 g_clock_list[1] = eina_list_sorted_insert(g_clock_list[1], _clock_type_compare_cb, pitem);
 819                                 break;
 820                         default:
 821                                 g_clock_list[2] = eina_list_sorted_insert(g_clock_list[2], _clock_type_compare_cb, pitem);
 822                         }
 823                 } else {
 824                         g_clock_list[2] = eina_list_sorted_insert(g_clock_list[2], _clock_type_compare_cb, pitem);
 825                 }
 826         }
 827
 828         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 829         return 0;
 830 }
 831
 832 Evas_Object *_clock_type_cb(void *data)
 833 {
 834         /*elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE); */
 835
 836         appdata *ad = NULL;
 837         Evas_Object *layout_inner = NULL;
 838         Elm_Object_Item *it = NULL;
 839
 840         ad = (appdata *)data;
 841         if (ad == NULL)
 842                 return NULL;
 843
 844         temp_ad = ad;
 845
 846         layout_inner = _create_index(ad->nf);
 847         /*it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout_inner, NULL); */
 848         /*elm_naviframe_item_title_enabled_set(it, EINA_FALSE, EINA_FALSE); */
 849
 850         return layout_inner;
 851 }
 852
 853 void _hourly_alert_cb(void *data, Evas_Object *obj, void *event_info)
 854 {
 855         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 856
 857         _show_hourly_alert_list(data);
 858 }
 859
 860 static char *_date_format_get()
 861 {
 862         int ret = 0;
 863         int date_val = 0;
 864
 865         char *date_fmt[] = { "%d%m%Y", "%m%d%Y", "%Y%m%d", "%Y%d%m" };
 866
 867         ret = vconf_get_int(VCONFKEY_SETAPPL_DATE_FORMAT_INT, &date_val);
 868
 869         return strdup(date_fmt[date_val]);
 870 }
 871
 872 static char *_time_format_get()
 873 {
 874         int ret = 0;
 875         int is_hour24 = 0;
 876         int time_val = 0;
 877         char *time_fmt[] = { "%d%m%Y%I:%M%p", "%d%m%Y%H:%M" };
 878
 879         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
 880
 881         if (ret < 0)
 882                 is_hour24 = 0;
 883         else if (time_val == VCONFKEY_TIME_FORMAT_12 || time_val == VCONFKEY_TIME_FORMAT_24)
 884                 is_hour24 = time_val - 1;
 885
 886         return strdup(time_fmt[is_hour24]);
 887 }
 888
 889 static char *_datetime_format_get()
 890 {
 891         char *dt_fmt, *region_fmt, *lang, *temp_fmt = NULL;
 892         char buf[256] = {0,};
 893         int time_val = 0, is_hour24 = 0, ret;
 894
 895         lang = getenv("LANGUAGE");
 896         setenv("LANGUAGE", "en_US", 1);
 897
 898         temp_fmt = vconf_get_str(VCONFKEY_REGIONFORMAT);
 899
 900         DBG("Setting - %s", temp_fmt);
 901
 902         region_fmt = replace(temp_fmt, "utf8", "UTF-8");
 903
 904         DBG("Setting - %s", region_fmt);
 905
 906         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
 907         if (ret < 0)
 908                 is_hour24 = 0;
 909         else if (time_val == VCONFKEY_TIME_FORMAT_12 || time_val == VCONFKEY_TIME_FORMAT_24)
 910                 is_hour24 = time_val - 1;
 911
 912         if (is_hour24)
 913                 snprintf(buf, sizeof(buf), "%s_DTFMT_24HR", region_fmt);
 914         else
 915                 snprintf(buf, sizeof(buf), "%s_DTFMT_12HR", region_fmt);
 916
 917         dt_fmt = dgettext("dt_fmt", buf);
 918
 919         if (!lang || !strcmp(lang, ""))
 920                 unsetenv("LANGUAGE");
 921         else
 922                 setenv("LANGUAGE", lang, 1);
 923
 924         return strdup(dt_fmt);
 925 }
 926
 927 static void _vconf_date_format_changed_cb(keynode_t *node, void *data)
 928 {
 929         ICU_set_timezone(get_timezone_str());
 930         Evas_Object *datetime = (Evas_Object *) data;
 931         char *dt_fmt = _date_format_get();
 932         elm_datetime_format_set(datetime, dt_fmt);
 933         free(dt_fmt);
 934 }
 935
 936 static void _vconf_time_format_changed_cb(keynode_t *node, void *data)
 937 {
 938         ICU_set_timezone(get_timezone_str());
 939         Evas_Object *datetime = (Evas_Object *) data;
 940         char *dt_fmt = _time_format_get();
 941         elm_datetime_format_set(datetime, dt_fmt);
 942         free(dt_fmt);
 943 }
 944
 945 static void _vconf_datetime_format_changed_cb(keynode_t *node, void *data)
 946 {
 947         Evas_Object *datetime = (Evas_Object *) data;
 948         char *dt_fmt = _datetime_format_get();
 949         elm_datetime_format_set(datetime, dt_fmt);
 950         free(dt_fmt);
 951 }
 952
 953 static Eina_Bool _clear_date_changed_cb(void *data, Elm_Object_Item *it)
 954 {
 955         unregister_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, _vconf_date_format_changed_cb);
 956         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_date_format_changed_cb);
 957
 958         return EINA_TRUE;
 959 }
 960
 961 static Eina_Bool _clear_time_changed_cb(void *data, Elm_Object_Item *it)
 962 {
 963         unregister_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, _vconf_time_format_changed_cb);
 964         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_date_format_changed_cb);
 965
 966         return EINA_TRUE;
 967 }
 968
 969 static Evas_Object *_create_scroller(Evas_Object *parent)
 970 {
 971         Evas_Object *scroller = elm_scroller_add(parent);
 972         elm_scroller_bounce_set(scroller, EINA_FALSE, EINA_TRUE);
 973         elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 974         evas_object_show(scroller);
 975
 976         return scroller;
 977 }
 978
 979 void _dt_cb(void *data, Evas_Object *obj, void *event_info)
 980 {
 981         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 982
 983         _show_date_and_time_list(data);
 984 }
 985
 986 char *_gl_clock_title_get(void *data, Evas_Object *obj, const char *part)
 987 {
 988         char buf[1024] = {0, };
 989         Item_Data *id = data;
 990         int index = id->index;
 991
 992         if (!strcmp(part, "elm.text") || !strcmp(part, "elm.text.1")) {
 993                 snprintf(buf, sizeof(buf) - 1, "%s", _(clock_menu_its[index % 3].name));
 994         } else if (!strcmp(part, "elm.text.2")) {
 995                 if (index == 0) {
 996                         Clock_Type_Item *selected_clock = _get_selected_clock();
 997                         if (selected_clock) {
 998                                 snprintf(buf, sizeof(buf) - 1, "%s", selected_clock->name);
 999                         }
1000                 } else if (index == 1) {
1001                         return NULL;
1002                 } else if (index == 2) {
1003                         char *_houly_alert_str[] = { "IDS_ST_BODY_OFF_M_STATUS", "IDS_ST_BODY_ON_M_STATUS" };
1004
1005                         vconf_get_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, &clock_menu_its[index % 3].type_num);
1006                         snprintf(buf, sizeof(buf) - 1, "%s", _(_houly_alert_str[clock_menu_its[index % 3].type_num]));
1007                 }
1008                 index++;
1009         }
1010         return strdup(buf);
1011 }
1012
1013 static void _clock_gl_del(void *data, Evas_Object *obj)
1014 {
1015         Item_Data *id = data;
1016         if (id)
1017                 free(id);
1018 }
1019
1020 Evas_Object *_create_clock_list(void *data)
1021 {
1022         appdata *ad = data;
1023         if (ad == NULL) {
1024                 DBG("%s", "_create_clock_list - appdata is null");
1025                 return NULL;
1026         }
1027         Evas_Object *genlist  = NULL;
1028         Elm_Genlist_Item_Class *itc_tmp;
1029         struct _clock_menu_item *menu_its = NULL;
1030         int idx = 0;
1031
1032         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1033         itc->item_style = "2text";
1034         itc->func.text_get = _gl_clock_title_get;
1035         itc->func.del = _clock_gl_del;
1036
1037         Elm_Genlist_Item_Class *itc_date_time = elm_genlist_item_class_new();
1038         itc_date_time->item_style = "1text";
1039         itc_date_time->func.text_get = _gl_clock_title_get;
1040         itc_date_time->func.del = _clock_gl_del;
1041
1042         Evas_Object *layout = elm_layout_add(ad->nf);
1043         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1044         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1045
1046         genlist = elm_genlist_add(layout);
1047         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1048
1049         menu_its = clock_menu_its;
1050
1051         int count = 0;
1052         count = sizeof(clock_menu_its) / sizeof(clock_menu_its[0]);
1053         for (idx = 0; idx < count; idx++) {
1054                 if (idx == 1) {
1055                         itc_tmp = itc_date_time;
1056                 } else {
1057                         itc_tmp = itc;
1058                 }
1059
1060                 Item_Data *id = calloc(sizeof(Item_Data), 1);
1061                 if (id) {
1062                         id->index = idx;
1063                         id->item = elm_genlist_item_append(
1064                                                    genlist,                     /* genlist object */
1065                                                    itc_tmp,                             /* item class */
1066                                                    id,                      /* data */
1067                                                    NULL,
1068                                                    ELM_GENLIST_ITEM_NONE,
1069                                                    menu_its[idx].func,  /* call back */
1070                                                    ad);
1071                 }
1072         }
1073         elm_genlist_item_class_free(itc);
1074         elm_genlist_item_class_free(itc_date_time);
1075
1076         g_clock_genlist = genlist;
1077
1078         elm_object_part_content_set(layout, "elm.genlist", genlist);
1079
1080         return layout;
1081 }
1082
1083 char *_get_str_from_icu(const char *pattern)
1084 {
1085         char *locale_tmp = vconf_get_str(VCONFKEY_REGIONFORMAT);
1086         char locale[32] = {0,};
1087         char *p = NULL;
1088
1089         if (strlen(locale_tmp) < 32)
1090                 strcpy(locale, locale_tmp);
1091
1092         if (locale[0] != '\0') {
1093                 p = strstr(locale, ".UTF-8");
1094                 if (p) {
1095                         *p = 0;
1096                 }
1097         }
1098
1099         char *ret_str = NULL;
1100         UChar Pattern[256] = { 0, };
1101         UErrorCode status = U_ZERO_ERROR;
1102         UDateFormat *formatter = NULL;
1103
1104         UChar formatted[256] = { 0, };
1105         char formattedString[256] = { 0, };
1106
1107         u_uastrncpy(Pattern, pattern, strlen(pattern));
1108
1109         UDate date = ucal_getNow();
1110         formatter =
1111                 udat_open(UDAT_IGNORE, UDAT_IGNORE, locale_tmp, NULL, -1, Pattern, -1, &status);
1112         int32_t formattedCapacity = (int32_t)(sizeof(formatted) / sizeof((formatted)[0]));
1113         (void)udat_format(formatter, date, formatted, formattedCapacity, NULL, &status);
1114         u_austrcpy(formattedString, formatted);
1115         DBG("str from icu is %s", formattedString);
1116
1117         udat_close(formatter);
1118
1119         ret_str = strdup(formattedString);
1120         return ret_str;
1121 }
1122
1123 char *_get_date_str()
1124 {
1125         int ret = 0;
1126         int date_val = 0;
1127
1128         char *date_fmt[] = { "dd/MM/y", "MM/dd/y", "y/MM/dd", "y/dd/MM" };
1129
1130         ret = vconf_get_int(VCONFKEY_SETAPPL_DATE_FORMAT_INT, &date_val);
1131
1132         return _get_str_from_icu(date_fmt[date_val]);
1133 }
1134
1135 char *_get_time_str()
1136 {
1137         int ret = 0;
1138         int is_hour24 = 0;
1139         int time_val = 0;
1140         char *time_fmt[] = { "hh:mm a", "HH:mm" };
1141
1142         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
1143
1144         if (ret < 0)
1145                 is_hour24 = 0;
1146         else if (time_val == VCONFKEY_TIME_FORMAT_12 || time_val == VCONFKEY_TIME_FORMAT_24)
1147                 is_hour24 = time_val - 1;
1148
1149         return _get_str_from_icu(time_fmt[is_hour24]);
1150 }
1151
1152 char *_gl_date_and_time_title_get(void *data, Evas_Object *obj, const char *part)
1153 {
1154         char buf[1024] = {0,};
1155         Item_Data *id = data;
1156         int index = id->index;
1157
1158         char  expression[32];
1159         int auto_update = 0;
1160         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &auto_update);
1161
1162         if (!strcmp(part, "elm.text.1")) {
1163                 if (index == 0) {
1164                         snprintf(buf, sizeof(buf) - 1, "%s", _(dt_menu_its[index % 3].name));
1165                 } else {
1166                         if (auto_update) {
1167                                 strcpy(expression, "<font color=#515151>%s</font>");
1168                         } else {
1169                                 strcpy(expression, "%s");
1170                         }
1171                         snprintf(buf, sizeof(buf) - 1, expression, _(dt_menu_its[index % 3].name));
1172                 }
1173         } else if (!strcmp(part, "elm.text.2")) {
1174                 if (index == 0) {
1175                         snprintf(buf, sizeof(buf) - 1, "%s", _(dt_menu_its[index % 3].date_or_time));
1176                 } else {
1177                         if (auto_update) {
1178                                 strcpy(expression, "<font color=#515151>%s</font>");
1179                         } else {
1180                                 strcpy(expression, "%s");
1181                         }
1182
1183                         if (index == 1) {       /* Date */
1184                                 char *date_buf = NULL;
1185                                 date_buf = _get_date_str();
1186                                 snprintf(buf, sizeof(buf) - 1, expression, date_buf);
1187                                 free(date_buf);
1188                         } else if (index == 2) {        /* Time */
1189                                 char *time_buf = NULL;
1190                                 time_buf = _get_time_str();
1191                                 snprintf(buf, sizeof(buf) - 1, expression, time_buf);
1192                                 free(time_buf);
1193                         }
1194                 }
1195                 index++;
1196         }
1197         return strdup(buf);
1198 }
1199
1200 static Evas_Object *_gl_dt_auto_sync_check_get(void *data, Evas_Object *obj, const char *part)
1201 {
1202         Evas_Object *check = NULL;
1203         appdata *ad = data;
1204         int is_auto_update = 0;
1205
1206         DT_Item_Data *id = data;
1207         int index = id->index;
1208
1209         if (!strcmp(part, "elm.icon")) {
1210                 if (index == 0) {
1211                         check = elm_check_add(obj);
1212                         if (vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_update) < 0) {
1213                                 DBG("Setting - auto time update's vconf get fail");
1214                         }
1215                         elm_check_state_set(check, (is_auto_update) ? EINA_TRUE : EINA_FALSE);
1216                         evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
1217                         evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1218
1219                         auto_sync_check = check;
1220                 }
1221                 index++;
1222         }
1223
1224         return check;
1225 }
1226
1227 static void _dt_gl_del(void *data, Evas_Object *obj)
1228 {
1229         DT_Item_Data *id = data;
1230         if (id)
1231                 free(id);
1232
1233         auto_sync_check = NULL;
1234         auto_sync_item = NULL;
1235         date_item = NULL;
1236         time_item = NULL;
1237 }
1238
1239 static void change_datetime_format_cb(keynode_t *key, void *data)
1240 {
1241         int ret = 0;
1242         int time_val = 0;
1243         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
1244         if (ret < 0)
1245                 return;
1246
1247         DBG("Setting - time_format : %d", time_val);
1248         ICU_set_timezone(get_timezone_str());
1249
1250         int is_auto_sync = 0;
1251         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1252
1253         if (date_item) {
1254                 elm_genlist_item_update(date_item);
1255                 /*elm_object_item_disabled_set(date_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1256         }
1257         if (time_item) {
1258                 elm_genlist_item_update(time_item);
1259                 /*elm_object_item_disabled_set(time_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1260         }
1261 }
1262
1263 static Eina_Bool _clear_datetime_changed_cb(void *data, Elm_Object_Item *it)
1264 {
1265         unregister_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, change_datetime_format_cb);
1266         unregister_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, change_datetime_format_cb);
1267         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, change_datetime_format_cb);
1268
1269         return EINA_TRUE;
1270 }
1271
1272 void _show_date_and_time_list(void *data)
1273 {
1274         appdata *ad = data;
1275         if (ad == NULL) {
1276                 DBG("%s", "_create_dt_list - appdata is null");
1277                 return;
1278         }
1279         Evas_Object *genlist  = NULL;
1280         Evas_Object *layout = NULL;
1281         Elm_Object_Item *nf_it = NULL;
1282         struct _dt_menu_item *menu_its = NULL;
1283         int idx = 0;
1284         int auto_sync = 0;
1285
1286         ICU_set_timezone(get_timezone_str());
1287
1288         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &auto_sync);
1289
1290         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1291         itc->item_style = "2text.1icon.1";
1292         itc->func.text_get = _gl_date_and_time_title_get;
1293         itc->func.content_get = _gl_dt_auto_sync_check_get;
1294         itc->func.del = _dt_gl_del;
1295
1296         layout = elm_layout_add(ad->nf);
1297         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1298         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1299
1300         genlist = elm_genlist_add(layout);
1301         elm_genlist_block_count_set(genlist, 14);
1302         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1303         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1304
1305         menu_its = dt_menu_its;
1306
1307         for (idx = 0; idx < CLOCK_DATE_AND_TIME_COUNT; idx++) {
1308                 DT_Item_Data *id = calloc(sizeof(DT_Item_Data), 1);
1309                 if (id) {
1310                         id->index = idx;
1311                         id->item = elm_genlist_item_append(
1312                                                    genlist,                     /* genlist object */
1313                                                    itc,                         /* item class */
1314                                                    id,                      /* data */
1315                                                    NULL,
1316                                                    ELM_GENLIST_ITEM_NONE,
1317                                                    menu_its[idx].func,  /* call back */
1318                                                    ad);
1319
1320                         switch (idx) {
1321                         case 0:
1322                                 auto_sync_item = id->item;
1323                                 break;
1324                         case 1:
1325                                 date_item = id->item;
1326                                 break;
1327                         case 2:
1328                                 time_item = id->item;
1329                                 break;
1330                         }
1331                 }
1332         }
1333         elm_genlist_item_class_free(itc);
1334
1335         g_date_time_genlist = genlist;
1336
1337         elm_object_part_content_set(layout, "elm.genlist", genlist);
1338
1339         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout, NULL);
1340         elm_naviframe_item_pop_cb_set(nf_it, _clear_datetime_changed_cb, ad);
1341         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1342
1343         /* time format changing cb */
1344         register_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, change_datetime_format_cb, NULL);
1345         register_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, change_datetime_format_cb, NULL);
1346         register_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, change_datetime_format_cb, NULL);
1347 }
1348
1349 static void _set_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1350 {
1351         if (!data || !obj) return;
1352
1353         appdata *ad = data;
1354         struct tm currtime;
1355
1356         elm_datetime_value_get(ad->datetime, &currtime);
1357
1358         currtime.tm_isdst = -1;
1359         currtime.tm_sec = 0;
1360
1361         time_t t = mktime(&currtime);
1362
1363         int ret = deviced_set_datetime(t);
1364
1365         elm_naviframe_item_pop(ad->nf);
1366
1367         /* automatic freed!! */
1368         Toast_Data *toast = _create_toast(ad, _("IDS_ST_TPOP_CHANGING_TIME_AND_DATE_SETTINGS_MAY_AFFECT_SOME_FUNCTIONS"));
1369         if (toast) {
1370                 _show_toast(ad, toast);
1371         }
1372
1373         if (g_date_time_genlist) {
1374                 elm_genlist_realized_items_update(g_date_time_genlist);
1375         }
1376 }
1377
1378 static void _cancle_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1379 {
1380         appdata *ad = data;
1381
1382         if (!ad)
1383                 return;
1384
1385         elm_naviframe_item_pop(ad->nf);
1386
1387         if (ad->dt_genlist_item_of_time != NULL) {
1388                 elm_genlist_item_update(ad->dt_genlist_item_of_time);
1389         }
1390
1391         if (ad->dt_genlist_item_of_date != NULL) {
1392                 elm_genlist_item_update(ad->dt_genlist_item_of_date);
1393         }
1394 }
1395
1396 static void _datetime_auto_sync_cb(void *data, Evas_Object *obj, void *event_info)
1397 {
1398         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1399
1400         int is_auto_sync = 0;
1401
1402         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1403
1404         is_auto_sync = !is_auto_sync;
1405
1406         vconf_set_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, is_auto_sync);
1407
1408         DBG("Setting - Auto sync : %s", is_auto_sync ? "TRUE" : "FALSE");
1409
1410         if (auto_sync_check) {
1411                 elm_check_state_set(auto_sync_check, (is_auto_sync) ? EINA_TRUE : EINA_FALSE);
1412         }
1413
1414         if (date_item) {
1415                 elm_genlist_item_update(date_item);
1416                 /*elm_object_item_disabled_set(date_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1417         }
1418         if (time_item) {
1419                 elm_genlist_item_update(time_item);
1420                 /*elm_object_item_disabled_set(time_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1421         }
1422 }
1423
1424 static void _datetime_date_cb(void *data, Evas_Object *obj, void *event_info)
1425 {
1426         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1427
1428         int is_auto_sync = 0;
1429         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1430         if (is_auto_sync) {
1431                 return;
1432         }
1433
1434         Evas_Object *scroller;
1435         Evas_Object *layout, *btn;
1436         Evas_Object *datetime, *datetime_field, *datetime_button;
1437         Elm_Object_Item *it;
1438         char *dt_fmt;
1439         appdata *ad = (appdata *)data;
1440
1441         if (!ad || !obj)
1442                 return;
1443
1444         ad->dt_genlist_item_of_date = (Elm_Object_Item *)event_info;
1445
1446         scroller = _create_scroller(ad->nf);
1447         evas_object_data_set(scroller, "appdata", ad);
1448
1449         layout = elm_layout_add(scroller);
1450         elm_layout_file_set(layout, EDJE_PATH, "setting-test/datetime");
1451         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1452
1453         datetime = elm_datetime_add(layout);
1454         elm_object_style_set(datetime, "datepicker_layout");
1455         elm_object_part_content_set(layout, "content", datetime);
1456
1457         ad->datetime = datetime;
1458
1459 #ifndef DESKTOP
1460         dt_fmt = _date_format_get();
1461         elm_datetime_format_set(datetime, dt_fmt);
1462         free(dt_fmt);
1463         register_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, _vconf_date_format_changed_cb, datetime);
1464         register_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_date_format_changed_cb, datetime);
1465 #endif
1466
1467         btn = elm_button_add(layout);
1468         elm_object_text_set(btn, _("IDS_ST_BUTTON_CANCEL_ABB2"));
1469         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1470         elm_object_part_content_set(layout, "btn1", btn);
1471         evas_object_smart_callback_add(btn, "clicked", _cancle_clicked_cb, ad);
1472
1473         btn = elm_button_add(layout);
1474         elm_object_text_set(btn, _("IDS_COM_SK_SET_ABB"));
1475         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1476         elm_object_part_content_set(layout, "btn2", btn);
1477         evas_object_smart_callback_add(btn, "clicked", _set_clicked_cb, ad);
1478
1479         elm_object_content_set(scroller, layout);
1480
1481         it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, scroller, NULL);
1482         elm_naviframe_item_pop_cb_set(it, _clear_date_changed_cb, ad);
1483         elm_naviframe_item_title_enabled_set(it, EINA_FALSE, EINA_FALSE);
1484 }
1485
1486 static void _datetime_time_cb(void *data, Evas_Object *obj, void *event_info)
1487 {
1488         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1489
1490         int is_auto_sync = 0;
1491         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1492         if (is_auto_sync) {
1493                 return;
1494         }
1495
1496         Evas_Object *scroller;
1497         Evas_Object *layout, *btn;
1498         Evas_Object *datetime, *datetime_field, *datetime_button;
1499         Evas_Object *radio, *rdg;
1500         Elm_Object_Item *it;
1501         char *dt_fmt;
1502         appdata *ad = (appdata *)data;
1503
1504         if (!ad || !obj)
1505                 return;
1506
1507         ad->dt_genlist_item_of_time = (Elm_Object_Item *)event_info;
1508
1509         scroller = _create_scroller(ad->nf);
1510         evas_object_data_set(scroller, "appdata", ad);
1511
1512         layout = elm_layout_add(scroller);
1513         elm_layout_file_set(layout, EDJE_PATH, "setting-test/datetime");
1514         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1515
1516         datetime = elm_datetime_add(layout);
1517         elm_object_style_set(datetime, "timepicker_layout");
1518         elm_object_part_content_set(layout, "content", datetime);
1519
1520         ad->datetime = datetime;
1521
1522 #ifndef DESKTOP
1523         dt_fmt = _time_format_get();
1524         elm_datetime_format_set(datetime, dt_fmt);
1525         DBG("datetime time format : %s", dt_fmt);
1526         free(dt_fmt);
1527         register_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, _vconf_time_format_changed_cb, datetime);
1528         register_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_time_format_changed_cb, datetime);
1529 #endif
1530
1531         btn = elm_button_add(layout);
1532         elm_object_text_set(btn, _("IDS_ST_BUTTON_CANCEL_ABB2"));
1533         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1534         elm_object_part_content_set(layout, "btn1", btn);
1535         evas_object_smart_callback_add(btn, "clicked", _cancle_clicked_cb, ad);
1536
1537         btn = elm_button_add(layout);
1538         elm_object_text_set(btn, _("IDS_COM_SK_SET_ABB"));
1539         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1540         elm_object_part_content_set(layout, "btn2", btn);
1541         evas_object_smart_callback_add(btn, "clicked", _set_clicked_cb, ad);
1542
1543         elm_object_content_set(scroller, layout);
1544
1545         it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, scroller, NULL);
1546         elm_naviframe_item_pop_cb_set(it, _clear_time_changed_cb, ad);
1547         elm_naviframe_item_title_enabled_set(it, EINA_FALSE, EINA_FALSE);
1548 }
1549
1550 static void _alert_gl_del(void *data, Evas_Object *obj)
1551 {
1552         Alert_Item_Data *id = data;
1553         if (id)
1554                 free(id);
1555 }
1556
1557 char *_gl_alert_title_get(void *data, Evas_Object *obj, const char *part)
1558 {
1559         char buf[1024] = {0,};
1560         Alert_Item_Data *id = data;
1561         int index = id->index;
1562
1563         char *temps[] = { "IDS_ST_BODY_ON_M_STATUS", "IDS_ST_BODY_OFF_M_STATUS" };
1564
1565         if (!strcmp(part, "elm.text")) {
1566                 snprintf(buf, sizeof(buf) - 1, "%s", _(temps[index]));
1567                 index++;
1568         }
1569         return strdup(buf);
1570 }
1571
1572 Evas_Object *_gl_alert_ridio_get(void *data, Evas_Object *obj, const char *part)
1573 {
1574         Evas_Object *radio = NULL;
1575         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
1576         Alert_Item_Data *id = data;
1577         int index = id->index;
1578
1579         if (!strcmp(part, "elm.icon")) {
1580                 radio = elm_radio_add(obj);
1581                 elm_radio_state_value_set(radio, id->index);
1582                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
1583                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1584                 elm_radio_group_add(radio, radio_main);
1585
1586 #if 0
1587                 vconf_get_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, &is_alert_mode_type);
1588
1589                 is_alert_mode_type = !is_alert_mode_type;
1590
1591                 if (is_alert_mode_type == id->index) {
1592                         elm_radio_value_set(radio_main, is_alert_mode_type);
1593                 }
1594 #endif
1595                 index++;
1596         }
1597         return radio;
1598 }
1599
1600 static void _hourly_gl_cb(void *data, Evas_Object *obj, void *event_info)
1601 {
1602         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1603
1604         is_alert_mode_type = (int)data;
1605
1606         elm_naviframe_item_pop(temp_ad->nf);
1607         if (!temp_ad->alert_rdg) {
1608                 evas_object_del(temp_ad->alert_rdg);
1609                 temp_ad->alert_rdg = NULL;
1610         }
1611
1612 #if 0
1613         clock_menu_its[2].type_num = is_alert_mode_type;
1614         vconf_set_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, !is_alert_mode_type);
1615 #endif
1616         if (g_clock_genlist) {
1617                 elm_genlist_realized_items_update(g_clock_genlist);
1618         }
1619
1620         temp_ad = NULL;
1621 }
1622
1623 void _show_hourly_alert_list(void *data)
1624 {
1625         appdata *ad = data;
1626         if (ad == NULL) {
1627                 DBG("%s", "_create_alert_list - appdata is null");
1628                 return;
1629         }
1630         Evas_Object *genlist  = NULL;
1631         Elm_Object_Item *nf_it = NULL;
1632
1633         temp_ad = ad;
1634
1635         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1636         itc->item_style = "1text.1icon.1";
1637         itc->func.text_get = _gl_alert_title_get;
1638         itc->func.content_get = _gl_alert_ridio_get;
1639         itc->func.del = _alert_gl_del;
1640
1641         Evas_Object *layout = elm_layout_add(ad->nf);
1642         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1643         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1644
1645         genlist = elm_genlist_add(layout);
1646         elm_genlist_block_count_set(genlist, 14);
1647         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1648         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1649
1650         Alert_Item_Data *id = calloc(sizeof(Alert_Item_Data), 1);
1651         if (id) {
1652                 id->index = 0;
1653                 id->item = elm_genlist_item_append(genlist,     itc, id, NULL, ELM_GENLIST_ITEM_NONE, _hourly_gl_cb, (void *)0);
1654         }
1655
1656         Alert_Item_Data *id2 = calloc(sizeof(Alert_Item_Data), 1);
1657         if (id2) {
1658                 id2->index = 1;
1659                 id2->item = elm_genlist_item_append(genlist, itc, id2, NULL, ELM_GENLIST_ITEM_NONE, _hourly_gl_cb, (void *)1);
1660         }
1661
1662         ad->alert_rdg = elm_radio_add(genlist);
1663         elm_radio_state_value_set(ad->alert_rdg, 3);
1664         elm_radio_value_set(ad->alert_rdg, is_alert_mode_type);
1665
1666         evas_object_data_set(genlist, "radio_main", ad->alert_rdg);
1667
1668         elm_genlist_item_class_free(itc);
1669
1670         elm_object_part_content_set(layout, "elm.genlist", genlist);
1671
1672         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout, NULL);
1673         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1674 }
1675
1676
1677 void _clocklist_load()
1678 {
1679         if (g_clock_list[0] || g_clock_list[1] || g_clock_list[2]) {
1680                 _clocklist_destroy();
1681         }
1682
1683         pkgmgrinfo_appinfo_filter_h handle = NULL;
1684
1685         if (pkgmgrinfo_appinfo_filter_create(&handle) != PMINFO_R_OK) {
1686                 ERR("pkgmgrinfo_appinfo_filter_create error");
1687                 return;
1688         }
1689
1690         if (pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, IDLE_CLOCK_CATEGROY)
1691                 != PMINFO_R_OK) {
1692                 ERR("pkgmgrinfo_appinfo_filter_add_string error");
1693                 pkgmgrinfo_appinfo_filter_destroy(handle);
1694                 return;
1695         }
1696
1697         if (pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, IDLE_CLOCK_CATEGROY2)
1698                 != PMINFO_R_OK) {
1699                 ERR("pkgmgrinfo_appinfo_filter_add_string error");
1700                 pkgmgrinfo_appinfo_filter_destroy(handle);
1701                 return;
1702         }
1703
1704         if (pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, _category_app_list_cb, NULL)
1705                 != PMINFO_R_OK) {
1706                 ERR("pkgmgrinfo_appinfo_filter_foreach_appinfo error");
1707                 pkgmgrinfo_appinfo_filter_destroy(handle);
1708                 return;
1709         }
1710
1711         pkgmgrinfo_appinfo_filter_destroy(handle);
1712
1713         Clock_Type_Item *pitem = NULL;
1714         Eina_List *list = NULL;
1715         int i;
1716
1717         for (i = 0; i < 3; i++) {
1718                 EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
1719                         pitem->index = clock_idx++;
1720                 }
1721         }
1722
1723 }
1724
1725 void _clocklist_destroy()
1726 {
1727         Clock_Type_Item *pitem = NULL;
1728         Eina_List *list = NULL;
1729         clock_idx = 0;
1730         int i;
1731
1732         for (i = 0; i < 3; i++) {
1733                 EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
1734                         FREE(pitem->appid);
1735                         FREE(pitem->pkgid);
1736                         FREE(pitem->name);
1737                         FREE(pitem->icon);
1738                 }
1739         }
1740         g_clock_list[0] = eina_list_free(g_clock_list[0]);
1741         g_clock_list[1] = eina_list_free(g_clock_list[1]);
1742         g_clock_list[2] = eina_list_free(g_clock_list[2]);
1743 }
1744
1745 static int _clock_type_compare_cb(const void *d1, const void *d2)
1746 {
1747         UChar clock1[256] = { 0, };
1748         UChar clock2[256] = { 0, };
1749
1750         Clock_Type_Item *r1 = (Clock_Type_Item *) d1;
1751         Clock_Type_Item *r2 = (Clock_Type_Item *) d2;
1752
1753         u_uastrcpy(clock1, r1->name);
1754         u_uastrcpy(clock2, r2->name);
1755
1756         /*const char *lang = vconf_get_str(VCONFKEY_LANGSET); */
1757         /*UErrorCode status = U_ZERO_ERROR; */
1758         /*UCollator *coll = ucol_open(lang,  &status); */
1759         UCollationResult ret = ucol_strcoll(coll, clock1, -1, clock2, -1);
1760
1761         /*ucol_close(coll); */
1762
1763         switch (ret) {
1764         case UCOL_EQUAL:
1765                 return 0;
1766         case UCOL_GREATER:
1767                 return 1;
1768         case UCOL_LESS:
1769                 return -1;
1770         default:
1771                 return 0;
1772         }
1773 }
1774
1775 static char *get_timezone_str()
1776 {
1777         char buf[1024];
1778         ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf) - 1);
1779
1780         if (len != -1) {
1781                 buf[len] = '\0';
1782         } else {
1783                 /* handle error condition */
1784         }
1785         return strdup(buf + 20);
1786 }
1787
1788 static UChar *uastrcpy(const char *chars)
1789 {
1790         int len = 0;
1791         UChar *str = NULL;
1792
1793         if (!chars) return NULL;
1794
1795         len = strlen(chars);
1796         str = (UChar *) malloc(sizeof(UChar) * (len + 1));
1797         if (!str)
1798                 return NULL;
1799         u_uastrcpy(str, chars);
1800         return str;
1801 }
1802
1803 static void ICU_set_timezone(const char *timezone)
1804 {
1805         DBG("ICU_set_timezone = %s ", timezone);
1806         UErrorCode ec = U_ZERO_ERROR;
1807         UChar *str = uastrcpy(timezone);
1808
1809         ucal_setDefaultTimeZone(str, &ec);
1810         if (U_SUCCESS(ec)) {
1811                 DBG("ucal_setDefaultTimeZone() SUCCESS ");
1812         } else {
1813                 ERR("ucal_setDefaultTimeZone() FAILED : %s ", u_errorName(ec));
1814         }
1815         FREE(str);
1816 }