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         elm_object_part_text_set(layout, "clock.text22", _get_selected_clock()->name);
 625
 626         evas_object_show(layout);
 627         evas_object_event_callback_add(layout, EVAS_CALLBACK_DEL, _layout_del_cb, pd);
 628
 629         /* Create Scroller */
 630         scroller = elm_scroller_add(layout);
 631         elm_scroller_loop_set(scroller, EINA_FALSE, EINA_FALSE);
 632         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 633         evas_object_size_hint_align_set(scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
 634         elm_scroller_page_relative_set(scroller, 1.0, 0.0);
 635         elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_AUTO, ELM_SCROLLER_POLICY_OFF);
 636         elm_scroller_page_scroll_limit_set(scroller, 1, 0);
 637         elm_object_scroll_lock_y_set(scroller, EINA_TRUE);
 638         elm_object_part_content_set(layout, "scroller", scroller);
 639         elm_object_style_set(scroller, "effect");
 640         evas_object_show(scroller);
 641         g_clock_scroller = scroller;
 642
 643         /* Create Box */
 644         box = elm_box_add(scroller);
 645         elm_box_horizontal_set(box, EINA_TRUE);
 646         elm_object_content_set(scroller, box);
 647         evas_object_show(box);
 648         g_clock_box = box;
 649
 650         Clock_Type_Item *selected = _get_selected_clock();
 651         Clock_Type_Item *pitem = NULL;
 652         Eina_List *list = NULL;
 653         int i;
 654         for (i = 0; i < 3; i++) {
 655                 EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
 656                         /* Create Pages */
 657                         page_layout = elm_layout_add(box);
 658                         /*elm_layout_file_set(page_layout, EDJE_PATH, "setting/bg_thumbnail"); */
 659                         elm_layout_theme_set(page_layout, "layout", "body_thumbnail", "default");
 660                         evas_object_size_hint_weight_set(page_layout, 0, 0);
 661                         evas_object_size_hint_align_set(page_layout, 0, EVAS_HINT_FILL);
 662                         evas_object_show(page_layout);
 663
 664                         Evas_Object *clock_layout = elm_layout_add(page_layout);
 665                         elm_layout_file_set(clock_layout, EDJE_PATH, "setting-test/clock-type");
 666                         evas_object_size_hint_weight_set(clock_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 667                         evas_object_size_hint_align_set(clock_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 668
 669                         evas_object_show(clock_layout);
 670
 671                         /*clock bg wallpaper */
 672                         int bg_mode;
 673                         vconf_get_int("db/wms/home_bg_mode", &bg_mode);
 674                         if (!bg_mode) {
 675                                 char *bg_color = NULL;
 676                                 int R = 0x00, G = 0x00, B = 0x00;
 677                                 bg_color = vconf_get_str("db/wms/home_bg_palette");
 678                                 colorstr_to_decimal(bg_color, &R, &G, &B);
 679                                 DBG("R : [%d] G : [%d] B : [%d]", R, G, B);
 680                                 Evas_Object *color_page = evas_object_rectangle_add(evas_object_evas_get(page_layout));
 681                                 evas_object_color_set(color_page, R, G, B, 255);
 682                                 evas_object_size_hint_weight_set(color_page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 683                                 evas_object_size_hint_align_set(color_page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 684                                 elm_object_part_content_set(clock_layout, "clock-color", color_page);
 685                         } else {
 686                                 char *bg_wallpaper = NULL;
 687                                 bg_wallpaper = vconf_get_str(VCONFKEY_BGSET);
 688                                 Evas_Object *wall_page = elm_image_add(clock_layout);
 689                                 elm_image_file_set(wall_page, bg_wallpaper, NULL);
 690                                 evas_object_size_hint_weight_set(wall_page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 691                                 evas_object_size_hint_align_set(wall_page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 692                                 elm_object_part_content_set(clock_layout, "clock-wallpaper", wall_page);
 693                         }
 694
 695                         /*clock image */
 696                         Evas_Object *page = elm_image_add(clock_layout);
 697                         elm_image_file_set(page, pitem->icon, NULL);
 698                         evas_object_size_hint_weight_set(page, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 699                         evas_object_size_hint_align_set(page, EVAS_HINT_FILL, EVAS_HINT_FILL);
 700
 701                         /* touch event */
 702                         evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, NULL);
 703                         evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, (void *)pitem->pkgid);
 704                         evas_object_event_callback_add(page, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb, NULL);
 705
 706                         elm_object_part_content_set(clock_layout, "clock-image", page);
 707                         if (pitem == selected) {
 708                                 elm_object_signal_emit(page_layout, "elm,state,thumbnail,focus", "*");
 709                         } else {
 710                                 elm_object_signal_emit(page_layout, "elm,state,thumbnail,unfocus", "*");
 711                         }
 712
 713                         elm_object_part_content_set(page_layout, "elm.icon", clock_layout);
 714
 715 #if 0
 716                         /* mapbuf for page 1 */
 717                         mapbuf = elm_mapbuf_add(box);
 718                         evas_object_size_hint_weight_set(mapbuf, 0, 0);
 719                         evas_object_size_hint_align_set(mapbuf, 0, EVAS_HINT_FILL);
 720                         evas_object_show(mapbuf);
 721                         elm_object_content_set(mapbuf, page_layout);
 722                         pd->mapbuf[pitem->index] = mapbuf;
 723 #endif
 724                         elm_win_screen_size_get(elm_widget_top_get(parent), NULL, NULL, &w, &h);
 725                         table = _elm_min_set(page_layout, box, w, h);
 726                         evas_object_size_hint_weight_set(table, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 727                         evas_object_size_hint_align_set(table, EVAS_HINT_FILL, EVAS_HINT_FILL);
 728                         evas_object_show(table);
 729                         elm_box_pack_end(box, table);
 730                 }
 731         }
 732
 733         evas_object_event_callback_add(scroller, EVAS_CALLBACK_RESIZE, _page_show, NULL);
 734
 735         int ret;
 736         ret = feedback_initialize();
 737         if (ret != FEEDBACK_ERROR_NONE) {
 738                 DBG("feedback_initialize failed");
 739         }
 740
 741         /*ecore_animator_add(animator_cb, pd); */
 742
 743         return layout;
 744 }
 745
 746 static int _category_app_list_cb(pkgmgrinfo_appinfo_h handle, void *user_data)
 747 {
 748         char *appid = NULL;
 749         char *name = NULL;
 750         char *pkgid = NULL;
 751         char *icon = NULL;
 752         int ret = 0;
 753         int preload = 0;
 754         char *m_value = NULL;
 755         int type = CLOCKTYPE_INVALID;
 756
 757         pkgmgrinfo_appinfo_h tmp_handle;
 758
 759         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
 760
 761         if (ret < 0 || !appid) {
 762                 ERR("pkgmgrinfo_appinfo_get_appid error");
 763                 return -1;
 764         } else {
 765                 ret = pkgmgrinfo_appinfo_get_appinfo(appid, &tmp_handle);
 766                 if (ret != PMINFO_R_OK) {
 767                         ERR("pkgmgrinfo_appinfo_get_appinfo error");
 768                         return -1;
 769                 }
 770                 ret = pkgmgrinfo_appinfo_get_pkgid(tmp_handle, &pkgid);
 771                 if (ret != PMINFO_R_OK) {
 772                         ERR("pkgmgrinfo_appinfo_get_pkgid error");
 773                         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 774                         return -1;
 775                 }
 776                 ret = pkgmgrinfo_appinfo_get_label(tmp_handle, &name);
 777                 if (ret != PMINFO_R_OK) {
 778                         INFO("pkgmgrinfo_appinfo_get_label error");
 779                         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 780                 }
 781                 ret = pkgmgrinfo_appinfo_get_icon(tmp_handle, &icon);
 782                 if (ret != PMINFO_R_OK) {
 783                         INFO("pkgmgrinfo_appinfo_get_icon error");
 784                         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 785                 }
 786                 ret = pkgmgrinfo_appinfo_is_preload(tmp_handle, &preload);
 787                 if (ret != PMINFO_R_OK) {
 788                         INFO("pkgmgrinfo_appinfo_is_preload error or 3rd party");
 789                 }
 790                 ret = pkgmgrinfo_appinfo_get_metadata_value(tmp_handle, "clocktype", &m_value);
 791                 if (ret != PMINFO_R_OK) {
 792                         INFO("pkgmgrinfo_appinfo_get_metadata_value error or 3rd party");
 793                 }
 794
 795                 Clock_Type_Item *pitem = NULL;
 796                 pitem = (Clock_Type_Item *)calloc(1, sizeof(Clock_Type_Item));
 797                 setting_retvm_if(NULL == pitem, SETTING_RETURN_FAIL, "pitem is NULL");
 798                 memset(pitem, 0x0, sizeof(Clock_Type_Item));
 799
 800                 pitem->appid = strdup(appid);
 801                 pitem->pkgid = strdup(pkgid);
 802                 pitem->name = strdup(name);
 803                 pitem->icon = strdup(icon);
 804
 805                 if (m_value && strlen(m_value) > 0) {
 806                         if (!strcmp(m_value, "function")) {
 807                                 type = CLOCKTYPE_FUNCTION;
 808                         } else if (!strcmp(m_value, "style")) {
 809                                 type = CLOCKTYPE_STYLE;
 810                         }
 811                 } else {
 812                         type = CLOCKTYPE_3RD;
 813                 }
 814
 815                 if (preload) {
 816                         switch (type) {
 817                         case CLOCKTYPE_FUNCTION:
 818                                 g_clock_list[0] = eina_list_sorted_insert(g_clock_list[0], _clock_type_compare_cb, pitem);
 819                                 break;
 820                         case CLOCKTYPE_STYLE:
 821                                 g_clock_list[1] = eina_list_sorted_insert(g_clock_list[1], _clock_type_compare_cb, pitem);
 822                                 break;
 823                         default:
 824                                 g_clock_list[2] = eina_list_sorted_insert(g_clock_list[2], _clock_type_compare_cb, pitem);
 825                         }
 826                 } else {
 827                         g_clock_list[2] = eina_list_sorted_insert(g_clock_list[2], _clock_type_compare_cb, pitem);
 828                 }
 829         }
 830
 831         pkgmgrinfo_appinfo_destroy_appinfo(tmp_handle);
 832         return 0;
 833 }
 834
 835 Evas_Object *_clock_type_cb(void *data)
 836 {
 837         /*elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE); */
 838
 839         appdata *ad = NULL;
 840         Evas_Object *layout_inner = NULL;
 841         Elm_Object_Item *it = NULL;
 842
 843         ad = (appdata *)data;
 844         if (ad == NULL)
 845                 return NULL;
 846
 847         temp_ad = ad;
 848
 849         layout_inner = _create_index(ad->nf);
 850         /*it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout_inner, NULL); */
 851         /*elm_naviframe_item_title_enabled_set(it, EINA_FALSE, EINA_FALSE); */
 852
 853         return layout_inner;
 854 }
 855
 856 void _hourly_alert_cb(void *data, Evas_Object *obj, void *event_info)
 857 {
 858         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 859
 860         _show_hourly_alert_list(data);
 861 }
 862
 863 static char *_date_format_get()
 864 {
 865         int ret = 0;
 866         int date_val = 0;
 867
 868         char *date_fmt[] = { "%d%m%Y", "%m%d%Y", "%Y%m%d", "%Y%d%m" };
 869
 870         ret = vconf_get_int(VCONFKEY_SETAPPL_DATE_FORMAT_INT, &date_val);
 871
 872         return strdup(date_fmt[date_val]);
 873 }
 874
 875 static char *_time_format_get()
 876 {
 877         int ret = 0;
 878         int is_hour24 = 0;
 879         int time_val = 0;
 880         char *time_fmt[] = { "%d%m%Y%I:%M%p", "%d%m%Y%H:%M" };
 881
 882         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
 883
 884         if (ret < 0)
 885                 is_hour24 = 0;
 886         else if (time_val == VCONFKEY_TIME_FORMAT_12 || time_val == VCONFKEY_TIME_FORMAT_24)
 887                 is_hour24 = time_val - 1;
 888
 889         return strdup(time_fmt[is_hour24]);
 890 }
 891
 892 static char *_datetime_format_get()
 893 {
 894         char *dt_fmt, *region_fmt, *lang, *temp_fmt = NULL;
 895         char buf[256] = {0,};
 896         int time_val = 0, is_hour24 = 0, ret;
 897
 898         lang = getenv("LANGUAGE");
 899         setenv("LANGUAGE", "en_US", 1);
 900
 901         temp_fmt = vconf_get_str(VCONFKEY_REGIONFORMAT);
 902
 903         DBG("Setting - %s", temp_fmt);
 904
 905         region_fmt = replace(temp_fmt, "utf8", "UTF-8");
 906
 907         DBG("Setting - %s", region_fmt);
 908
 909         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
 910         if (ret < 0)
 911                 is_hour24 = 0;
 912         else if (time_val == VCONFKEY_TIME_FORMAT_12 || time_val == VCONFKEY_TIME_FORMAT_24)
 913                 is_hour24 = time_val - 1;
 914
 915         if (is_hour24)
 916                 snprintf(buf, sizeof(buf), "%s_DTFMT_24HR", region_fmt);
 917         else
 918                 snprintf(buf, sizeof(buf), "%s_DTFMT_12HR", region_fmt);
 919
 920         dt_fmt = dgettext("dt_fmt", buf);
 921
 922         if (!lang || !strcmp(lang, ""))
 923                 unsetenv("LANGUAGE");
 924         else
 925                 setenv("LANGUAGE", lang, 1);
 926
 927         return strdup(dt_fmt);
 928 }
 929
 930 static void _vconf_date_format_changed_cb(keynode_t *node, void *data)
 931 {
 932         ICU_set_timezone(get_timezone_str());
 933         Evas_Object *datetime = (Evas_Object *) data;
 934         char *dt_fmt = _date_format_get();
 935         elm_datetime_format_set(datetime, dt_fmt);
 936         free(dt_fmt);
 937 }
 938
 939 static void _vconf_time_format_changed_cb(keynode_t *node, void *data)
 940 {
 941         ICU_set_timezone(get_timezone_str());
 942         Evas_Object *datetime = (Evas_Object *) data;
 943         char *dt_fmt = _time_format_get();
 944         elm_datetime_format_set(datetime, dt_fmt);
 945         free(dt_fmt);
 946 }
 947
 948 static void _vconf_datetime_format_changed_cb(keynode_t *node, void *data)
 949 {
 950         Evas_Object *datetime = (Evas_Object *) data;
 951         char *dt_fmt = _datetime_format_get();
 952         elm_datetime_format_set(datetime, dt_fmt);
 953         free(dt_fmt);
 954 }
 955
 956 static Eina_Bool _clear_date_changed_cb(void *data, Elm_Object_Item *it)
 957 {
 958         unregister_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, _vconf_date_format_changed_cb);
 959         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_date_format_changed_cb);
 960
 961         return EINA_TRUE;
 962 }
 963
 964 static Eina_Bool _clear_time_changed_cb(void *data, Elm_Object_Item *it)
 965 {
 966         unregister_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, _vconf_time_format_changed_cb);
 967         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_date_format_changed_cb);
 968
 969         return EINA_TRUE;
 970 }
 971
 972 static Evas_Object *_create_scroller(Evas_Object *parent)
 973 {
 974         Evas_Object *scroller = elm_scroller_add(parent);
 975         elm_scroller_bounce_set(scroller, EINA_FALSE, EINA_TRUE);
 976         elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 977         evas_object_show(scroller);
 978
 979         return scroller;
 980 }
 981
 982 void _dt_cb(void *data, Evas_Object *obj, void *event_info)
 983 {
 984         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 985
 986         _show_date_and_time_list(data);
 987 }
 988
 989 char *_gl_clock_title_get(void *data, Evas_Object *obj, const char *part)
 990 {
 991         char buf[1024] = {0, };
 992         Item_Data *id = data;
 993         int index = id->index;
 994
 995         if (!strcmp(part, "elm.text") || !strcmp(part, "elm.text.1")) {
 996                 snprintf(buf, sizeof(buf) - 1, "%s", _(clock_menu_its[index % 3].name));
 997         } else if (!strcmp(part, "elm.text.2")) {
 998                 if (index == 0) {
 999                         Clock_Type_Item *selected_clock = _get_selected_clock();
1000                         if (selected_clock) {
1001                                 snprintf(buf, sizeof(buf) - 1, "%s", selected_clock->name);
1002                         }
1003                 } else if (index == 1) {
1004                         return NULL;
1005                 } else if (index == 2) {
1006                         char *_houly_alert_str[] = { "IDS_ST_BODY_OFF_M_STATUS", "IDS_ST_BODY_ON_M_STATUS" };
1007
1008                         vconf_get_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, &clock_menu_its[index % 3].type_num);
1009                         snprintf(buf, sizeof(buf) - 1, "%s", _(_houly_alert_str[clock_menu_its[index % 3].type_num]));
1010                 }
1011                 index++;
1012         }
1013         return strdup(buf);
1014 }
1015
1016 static void _clock_gl_del(void *data, Evas_Object *obj)
1017 {
1018         Item_Data *id = data;
1019         if (id)
1020                 free(id);
1021 }
1022
1023 Evas_Object *_create_clock_list(void *data)
1024 {
1025         appdata *ad = data;
1026         if (ad == NULL) {
1027                 DBG("%s", "_create_clock_list - appdata is null");
1028                 return NULL;
1029         }
1030         Evas_Object *genlist  = NULL;
1031         Elm_Genlist_Item_Class *itc_tmp;
1032         struct _clock_menu_item *menu_its = NULL;
1033         int idx = 0;
1034
1035         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1036         itc->item_style = "2text";
1037         itc->func.text_get = _gl_clock_title_get;
1038         itc->func.del = _clock_gl_del;
1039
1040         Elm_Genlist_Item_Class *itc_date_time = elm_genlist_item_class_new();
1041         itc_date_time->item_style = "1text";
1042         itc_date_time->func.text_get = _gl_clock_title_get;
1043         itc_date_time->func.del = _clock_gl_del;
1044
1045         Evas_Object *layout = elm_layout_add(ad->nf);
1046         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1047         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1048
1049         genlist = elm_genlist_add(layout);
1050         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1051
1052         menu_its = clock_menu_its;
1053
1054         int count = 0;
1055         count = sizeof(clock_menu_its) / sizeof(clock_menu_its[0]);
1056         for (idx = 0; idx < count; idx++) {
1057                 if (idx == 1) {
1058                         itc_tmp = itc_date_time;
1059                 } else {
1060                         itc_tmp = itc;
1061                 }
1062
1063                 Item_Data *id = calloc(sizeof(Item_Data), 1);
1064                 if (id) {
1065                         id->index = idx;
1066                         id->item = elm_genlist_item_append(
1067                                                    genlist,                     /* genlist object */
1068                                                    itc_tmp,                             /* item class */
1069                                                    id,                      /* data */
1070                                                    NULL,
1071                                                    ELM_GENLIST_ITEM_NONE,
1072                                                    menu_its[idx].func,  /* call back */
1073                                                    ad);
1074                 }
1075         }
1076         elm_genlist_item_class_free(itc);
1077         elm_genlist_item_class_free(itc_date_time);
1078
1079         g_clock_genlist = genlist;
1080
1081         elm_object_part_content_set(layout, "elm.genlist", genlist);
1082
1083         return layout;
1084 }
1085
1086 char *_get_str_from_icu(const char *pattern)
1087 {
1088         char *locale_tmp = vconf_get_str(VCONFKEY_REGIONFORMAT);
1089         char locale[32] = {0,};
1090         char *p = NULL;
1091
1092         if (strlen(locale_tmp) < 32)
1093                 strcpy(locale, locale_tmp);
1094
1095         if (locale[0] != '\0') {
1096                 p = strstr(locale, ".UTF-8");
1097                 if (p) {
1098                         *p = 0;
1099                 }
1100         }
1101
1102         char *ret_str = NULL;
1103         UChar Pattern[256] = { 0, };
1104         UErrorCode status = U_ZERO_ERROR;
1105         UDateFormat *formatter = NULL;
1106
1107         UChar formatted[256] = { 0, };
1108         char formattedString[256] = { 0, };
1109
1110         u_uastrncpy(Pattern, pattern, strlen(pattern));
1111
1112         UDate date = ucal_getNow();
1113         formatter =
1114                 udat_open(UDAT_IGNORE, UDAT_IGNORE, locale_tmp, NULL, -1, Pattern, -1, &status);
1115         int32_t formattedCapacity = (int32_t)(sizeof(formatted) / sizeof((formatted)[0]));
1116         (void)udat_format(formatter, date, formatted, formattedCapacity, NULL, &status);
1117         u_austrcpy(formattedString, formatted);
1118         DBG("str from icu is %s", formattedString);
1119
1120         udat_close(formatter);
1121
1122         ret_str = strdup(formattedString);
1123         return ret_str;
1124 }
1125
1126 char *_get_date_str()
1127 {
1128         int ret = 0;
1129         int date_val = 0;
1130
1131         char *date_fmt[] = { "dd/MM/y", "MM/dd/y", "y/MM/dd", "y/dd/MM" };
1132
1133         ret = vconf_get_int(VCONFKEY_SETAPPL_DATE_FORMAT_INT, &date_val);
1134
1135         return _get_str_from_icu(date_fmt[date_val]);
1136 }
1137
1138 char *_get_time_str()
1139 {
1140         int ret = 0;
1141         int is_hour24 = 0;
1142         int time_val = 0;
1143         char *time_fmt[] = { "hh:mm a", "HH:mm" };
1144
1145         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
1146
1147         if (ret < 0)
1148                 is_hour24 = 0;
1149         else if (time_val == VCONFKEY_TIME_FORMAT_12 || time_val == VCONFKEY_TIME_FORMAT_24)
1150                 is_hour24 = time_val - 1;
1151
1152         return _get_str_from_icu(time_fmt[is_hour24]);
1153 }
1154
1155 char *_gl_date_and_time_title_get(void *data, Evas_Object *obj, const char *part)
1156 {
1157         char buf[1024] = {0,};
1158         Item_Data *id = data;
1159         int index = id->index;
1160
1161         char  expression[32];
1162         int auto_update = 0;
1163         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &auto_update);
1164
1165         if (!strcmp(part, "elm.text.1")) {
1166                 if (index == 0) {
1167                         snprintf(buf, sizeof(buf) - 1, "%s", _(dt_menu_its[index % 3].name));
1168                 } else {
1169                         if (auto_update) {
1170                                 strcpy(expression, "<font color=#515151>%s</font>");
1171                         } else {
1172                                 strcpy(expression, "%s");
1173                         }
1174                         snprintf(buf, sizeof(buf) - 1, expression, _(dt_menu_its[index % 3].name));
1175                 }
1176         } else if (!strcmp(part, "elm.text.2")) {
1177                 if (index == 0) {
1178                         snprintf(buf, sizeof(buf) - 1, "%s", _(dt_menu_its[index % 3].date_or_time));
1179                 } else {
1180                         if (auto_update) {
1181                                 strcpy(expression, "<font color=#515151>%s</font>");
1182                         } else {
1183                                 strcpy(expression, "%s");
1184                         }
1185
1186                         if (index == 1) {       /* Date */
1187                                 char *date_buf = NULL;
1188                                 date_buf = _get_date_str();
1189                                 snprintf(buf, sizeof(buf) - 1, expression, date_buf);
1190                                 free(date_buf);
1191                         } else if (index == 2) {        /* Time */
1192                                 char *time_buf = NULL;
1193                                 time_buf = _get_time_str();
1194                                 snprintf(buf, sizeof(buf) - 1, expression, time_buf);
1195                                 free(time_buf);
1196                         }
1197                 }
1198                 index++;
1199         }
1200         return strdup(buf);
1201 }
1202
1203 static Evas_Object *_gl_dt_auto_sync_check_get(void *data, Evas_Object *obj, const char *part)
1204 {
1205         Evas_Object *check = NULL;
1206         appdata *ad = data;
1207         int is_auto_update = 0;
1208
1209         DT_Item_Data *id = data;
1210         int index = id->index;
1211
1212         if (!strcmp(part, "elm.icon")) {
1213                 if (index == 0) {
1214                         check = elm_check_add(obj);
1215                         if (vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_update) < 0) {
1216                                 DBG("Setting - auto time update's vconf get fail");
1217                         }
1218                         elm_check_state_set(check, (is_auto_update) ? EINA_TRUE : EINA_FALSE);
1219                         evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
1220                         evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1221
1222                         auto_sync_check = check;
1223                 }
1224                 index++;
1225         }
1226
1227         return check;
1228 }
1229
1230 static void _dt_gl_del(void *data, Evas_Object *obj)
1231 {
1232         DT_Item_Data *id = data;
1233         if (id)
1234                 free(id);
1235
1236         auto_sync_check = NULL;
1237         auto_sync_item = NULL;
1238         date_item = NULL;
1239         time_item = NULL;
1240 }
1241
1242 static void change_datetime_format_cb(keynode_t *key, void *data)
1243 {
1244         int ret = 0;
1245         int time_val = 0;
1246         ret = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &time_val);
1247         if (ret < 0)
1248                 return;
1249
1250         DBG("Setting - time_format : %d", time_val);
1251         ICU_set_timezone(get_timezone_str());
1252
1253         int is_auto_sync = 0;
1254         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1255
1256         if (date_item) {
1257                 elm_genlist_item_update(date_item);
1258                 /*elm_object_item_disabled_set(date_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1259         }
1260         if (time_item) {
1261                 elm_genlist_item_update(time_item);
1262                 /*elm_object_item_disabled_set(time_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1263         }
1264 }
1265
1266 static Eina_Bool _clear_datetime_changed_cb(void *data, Elm_Object_Item *it)
1267 {
1268         unregister_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, change_datetime_format_cb);
1269         unregister_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, change_datetime_format_cb);
1270         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, change_datetime_format_cb);
1271
1272         return EINA_TRUE;
1273 }
1274
1275 void _show_date_and_time_list(void *data)
1276 {
1277         appdata *ad = data;
1278         if (ad == NULL) {
1279                 DBG("%s", "_create_dt_list - appdata is null");
1280                 return;
1281         }
1282         Evas_Object *genlist  = NULL;
1283         Evas_Object *layout = NULL;
1284         Elm_Object_Item *nf_it = NULL;
1285         struct _dt_menu_item *menu_its = NULL;
1286         int idx = 0;
1287         int auto_sync = 0;
1288
1289         ICU_set_timezone(get_timezone_str());
1290
1291         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &auto_sync);
1292
1293         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1294         itc->item_style = "2text.1icon.1";
1295         itc->func.text_get = _gl_date_and_time_title_get;
1296         itc->func.content_get = _gl_dt_auto_sync_check_get;
1297         itc->func.del = _dt_gl_del;
1298
1299         layout = elm_layout_add(ad->nf);
1300         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1301         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1302
1303         genlist = elm_genlist_add(layout);
1304         elm_genlist_block_count_set(genlist, 14);
1305         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1306         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1307
1308         menu_its = dt_menu_its;
1309
1310         for (idx = 0; idx < CLOCK_DATE_AND_TIME_COUNT; idx++) {
1311                 DT_Item_Data *id = calloc(sizeof(DT_Item_Data), 1);
1312                 if (id) {
1313                         id->index = idx;
1314                         id->item = elm_genlist_item_append(
1315                                                    genlist,                     /* genlist object */
1316                                                    itc,                         /* item class */
1317                                                    id,                      /* data */
1318                                                    NULL,
1319                                                    ELM_GENLIST_ITEM_NONE,
1320                                                    menu_its[idx].func,  /* call back */
1321                                                    ad);
1322
1323                         switch (idx) {
1324                         case 0:
1325                                 auto_sync_item = id->item;
1326                                 break;
1327                         case 1:
1328                                 date_item = id->item;
1329                                 break;
1330                         case 2:
1331                                 time_item = id->item;
1332                                 break;
1333                         }
1334                 }
1335         }
1336         elm_genlist_item_class_free(itc);
1337
1338         g_date_time_genlist = genlist;
1339
1340         elm_object_part_content_set(layout, "elm.genlist", genlist);
1341
1342         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout, NULL);
1343         elm_naviframe_item_pop_cb_set(nf_it, _clear_datetime_changed_cb, ad);
1344         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1345
1346         /* time format changing cb */
1347         register_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, change_datetime_format_cb, NULL);
1348         register_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, change_datetime_format_cb, NULL);
1349         register_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, change_datetime_format_cb, NULL);
1350 }
1351
1352 static void _set_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1353 {
1354         if (!data || !obj) return;
1355
1356         appdata *ad = data;
1357         struct tm currtime;
1358
1359         elm_datetime_value_get(ad->datetime, &currtime);
1360
1361         currtime.tm_isdst = -1;
1362         currtime.tm_sec = 0;
1363
1364         time_t t = mktime(&currtime);
1365
1366         int ret = deviced_set_datetime(t);
1367
1368         elm_naviframe_item_pop(ad->nf);
1369
1370         /* automatic freed!! */
1371         Toast_Data *toast = _create_toast(ad, _("IDS_ST_TPOP_CHANGING_TIME_AND_DATE_SETTINGS_MAY_AFFECT_SOME_FUNCTIONS"));
1372         if (toast) {
1373                 _show_toast(ad, toast);
1374         }
1375
1376         if (g_date_time_genlist) {
1377                 elm_genlist_realized_items_update(g_date_time_genlist);
1378         }
1379 }
1380
1381 static void _cancle_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1382 {
1383         appdata *ad = data;
1384
1385         if (!ad)
1386                 return;
1387
1388         elm_naviframe_item_pop(ad->nf);
1389
1390         if (ad->dt_genlist_item_of_time != NULL) {
1391                 elm_genlist_item_update(ad->dt_genlist_item_of_time);
1392         }
1393
1394         if (ad->dt_genlist_item_of_date != NULL) {
1395                 elm_genlist_item_update(ad->dt_genlist_item_of_date);
1396         }
1397 }
1398
1399 static void _datetime_auto_sync_cb(void *data, Evas_Object *obj, void *event_info)
1400 {
1401         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1402
1403         int is_auto_sync = 0;
1404
1405         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1406
1407         is_auto_sync = !is_auto_sync;
1408
1409         vconf_set_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, is_auto_sync);
1410
1411         DBG("Setting - Auto sync : %s", is_auto_sync ? "TRUE" : "FALSE");
1412
1413         if (auto_sync_check) {
1414                 elm_check_state_set(auto_sync_check, (is_auto_sync) ? EINA_TRUE : EINA_FALSE);
1415         }
1416
1417         if (date_item) {
1418                 elm_genlist_item_update(date_item);
1419                 /*elm_object_item_disabled_set(date_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1420         }
1421         if (time_item) {
1422                 elm_genlist_item_update(time_item);
1423                 /*elm_object_item_disabled_set(time_item, (is_auto_sync) ? EINA_TRUE : EINA_FALSE ); */
1424         }
1425 }
1426
1427 static void _datetime_date_cb(void *data, Evas_Object *obj, void *event_info)
1428 {
1429         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1430
1431         int is_auto_sync = 0;
1432         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1433         if (is_auto_sync) {
1434                 return;
1435         }
1436
1437         Evas_Object *scroller;
1438         Evas_Object *layout, *btn;
1439         Evas_Object *datetime, *datetime_field, *datetime_button;
1440         Elm_Object_Item *it;
1441         char *dt_fmt;
1442         appdata *ad = (appdata *)data;
1443
1444         if (!ad || !obj)
1445                 return;
1446
1447         ad->dt_genlist_item_of_date = (Elm_Object_Item *)event_info;
1448
1449         scroller = _create_scroller(ad->nf);
1450         evas_object_data_set(scroller, "appdata", ad);
1451
1452         layout = elm_layout_add(scroller);
1453         elm_layout_file_set(layout, EDJE_PATH, "setting-test/datetime");
1454         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1455
1456         datetime = elm_datetime_add(layout);
1457         elm_object_style_set(datetime, "datepicker_layout");
1458         elm_object_part_content_set(layout, "content", datetime);
1459
1460         ad->datetime = datetime;
1461
1462 #ifndef DESKTOP
1463         dt_fmt = _date_format_get();
1464         elm_datetime_format_set(datetime, dt_fmt);
1465         free(dt_fmt);
1466         register_vconf_changing(VCONFKEY_SETAPPL_DATE_FORMAT_INT, _vconf_date_format_changed_cb, datetime);
1467         register_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_date_format_changed_cb, datetime);
1468 #endif
1469
1470         btn = elm_button_add(layout);
1471         elm_object_text_set(btn, _("IDS_ST_BUTTON_CANCEL_ABB2"));
1472         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1473         elm_object_part_content_set(layout, "btn1", btn);
1474         evas_object_smart_callback_add(btn, "clicked", _cancle_clicked_cb, ad);
1475
1476         btn = elm_button_add(layout);
1477         elm_object_text_set(btn, _("IDS_COM_SK_SET_ABB"));
1478         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1479         elm_object_part_content_set(layout, "btn2", btn);
1480         evas_object_smart_callback_add(btn, "clicked", _set_clicked_cb, ad);
1481
1482         elm_object_content_set(scroller, layout);
1483
1484         it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, scroller, NULL);
1485         elm_naviframe_item_pop_cb_set(it, _clear_date_changed_cb, ad);
1486         elm_naviframe_item_title_enabled_set(it, EINA_FALSE, EINA_FALSE);
1487 }
1488
1489 static void _datetime_time_cb(void *data, Evas_Object *obj, void *event_info)
1490 {
1491         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1492
1493         int is_auto_sync = 0;
1494         vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &is_auto_sync);
1495         if (is_auto_sync) {
1496                 return;
1497         }
1498
1499         Evas_Object *scroller;
1500         Evas_Object *layout, *btn;
1501         Evas_Object *datetime, *datetime_field, *datetime_button;
1502         Evas_Object *radio, *rdg;
1503         Elm_Object_Item *it;
1504         char *dt_fmt;
1505         appdata *ad = (appdata *)data;
1506
1507         if (!ad || !obj)
1508                 return;
1509
1510         ad->dt_genlist_item_of_time = (Elm_Object_Item *)event_info;
1511
1512         scroller = _create_scroller(ad->nf);
1513         evas_object_data_set(scroller, "appdata", ad);
1514
1515         layout = elm_layout_add(scroller);
1516         elm_layout_file_set(layout, EDJE_PATH, "setting-test/datetime");
1517         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1518
1519         datetime = elm_datetime_add(layout);
1520         elm_object_style_set(datetime, "timepicker_layout");
1521         elm_object_part_content_set(layout, "content", datetime);
1522
1523         ad->datetime = datetime;
1524
1525 #ifndef DESKTOP
1526         dt_fmt = _time_format_get();
1527         elm_datetime_format_set(datetime, dt_fmt);
1528         DBG("datetime time format : %s", dt_fmt);
1529         free(dt_fmt);
1530         register_vconf_changing(VCONFKEY_REGIONFORMAT_TIME1224, _vconf_time_format_changed_cb, datetime);
1531         register_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, _vconf_time_format_changed_cb, datetime);
1532 #endif
1533
1534         btn = elm_button_add(layout);
1535         elm_object_text_set(btn, _("IDS_ST_BUTTON_CANCEL_ABB2"));
1536         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1537         elm_object_part_content_set(layout, "btn1", btn);
1538         evas_object_smart_callback_add(btn, "clicked", _cancle_clicked_cb, ad);
1539
1540         btn = elm_button_add(layout);
1541         elm_object_text_set(btn, _("IDS_COM_SK_SET_ABB"));
1542         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1543         elm_object_part_content_set(layout, "btn2", btn);
1544         evas_object_smart_callback_add(btn, "clicked", _set_clicked_cb, ad);
1545
1546         elm_object_content_set(scroller, layout);
1547
1548         it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, scroller, NULL);
1549         elm_naviframe_item_pop_cb_set(it, _clear_time_changed_cb, ad);
1550         elm_naviframe_item_title_enabled_set(it, EINA_FALSE, EINA_FALSE);
1551 }
1552
1553 static void _alert_gl_del(void *data, Evas_Object *obj)
1554 {
1555         Alert_Item_Data *id = data;
1556         if (id)
1557                 free(id);
1558 }
1559
1560 char *_gl_alert_title_get(void *data, Evas_Object *obj, const char *part)
1561 {
1562         char buf[1024] = {0,};
1563         Alert_Item_Data *id = data;
1564         int index = id->index;
1565
1566         char *temps[] = { "IDS_ST_BODY_ON_M_STATUS", "IDS_ST_BODY_OFF_M_STATUS" };
1567
1568         if (!strcmp(part, "elm.text")) {
1569                 snprintf(buf, sizeof(buf) - 1, "%s", _(temps[index]));
1570                 index++;
1571         }
1572         return strdup(buf);
1573 }
1574
1575 Evas_Object *_gl_alert_ridio_get(void *data, Evas_Object *obj, const char *part)
1576 {
1577         Evas_Object *radio = NULL;
1578         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
1579         Alert_Item_Data *id = data;
1580         int index = id->index;
1581
1582         if (!strcmp(part, "elm.icon")) {
1583                 radio = elm_radio_add(obj);
1584                 elm_radio_state_value_set(radio, id->index);
1585                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
1586                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1587                 elm_radio_group_add(radio, radio_main);
1588
1589 #if 0
1590                 vconf_get_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, &is_alert_mode_type);
1591
1592                 is_alert_mode_type = !is_alert_mode_type;
1593
1594                 if (is_alert_mode_type == id->index) {
1595                         elm_radio_value_set(radio_main, is_alert_mode_type);
1596                 }
1597 #endif
1598                 index++;
1599         }
1600         return radio;
1601 }
1602
1603 static void _hourly_gl_cb(void *data, Evas_Object *obj, void *event_info)
1604 {
1605         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
1606
1607         is_alert_mode_type = (int)data;
1608
1609         elm_naviframe_item_pop(temp_ad->nf);
1610         if (!temp_ad->alert_rdg) {
1611                 evas_object_del(temp_ad->alert_rdg);
1612                 temp_ad->alert_rdg = NULL;
1613         }
1614
1615 #if 0
1616         clock_menu_its[2].type_num = is_alert_mode_type;
1617         vconf_set_bool(VCONFKEY_SETAPPL_HOURLY_ALERT_BOOL, !is_alert_mode_type);
1618 #endif
1619         if (g_clock_genlist) {
1620                 elm_genlist_realized_items_update(g_clock_genlist);
1621         }
1622
1623         temp_ad = NULL;
1624 }
1625
1626 void _show_hourly_alert_list(void *data)
1627 {
1628         appdata *ad = data;
1629         if (ad == NULL) {
1630                 DBG("%s", "_create_alert_list - appdata is null");
1631                 return;
1632         }
1633         Evas_Object *genlist  = NULL;
1634         Elm_Object_Item *nf_it = NULL;
1635
1636         temp_ad = ad;
1637
1638         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
1639         itc->item_style = "1text.1icon.1";
1640         itc->func.text_get = _gl_alert_title_get;
1641         itc->func.content_get = _gl_alert_ridio_get;
1642         itc->func.del = _alert_gl_del;
1643
1644         Evas_Object *layout = elm_layout_add(ad->nf);
1645         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
1646         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1647
1648         genlist = elm_genlist_add(layout);
1649         elm_genlist_block_count_set(genlist, 14);
1650         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1651         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1652
1653         Alert_Item_Data *id = calloc(sizeof(Alert_Item_Data), 1);
1654         if (id) {
1655                 id->index = 0;
1656                 id->item = elm_genlist_item_append(genlist,     itc, id, NULL, ELM_GENLIST_ITEM_NONE, _hourly_gl_cb, (void *)0);
1657         }
1658
1659         Alert_Item_Data *id2 = calloc(sizeof(Alert_Item_Data), 1);
1660         if (id2) {
1661                 id2->index = 1;
1662                 id2->item = elm_genlist_item_append(genlist, itc, id2, NULL, ELM_GENLIST_ITEM_NONE, _hourly_gl_cb, (void *)1);
1663         }
1664
1665         ad->alert_rdg = elm_radio_add(genlist);
1666         elm_radio_state_value_set(ad->alert_rdg, 3);
1667         elm_radio_value_set(ad->alert_rdg, is_alert_mode_type);
1668
1669         evas_object_data_set(genlist, "radio_main", ad->alert_rdg);
1670
1671         elm_genlist_item_class_free(itc);
1672
1673         elm_object_part_content_set(layout, "elm.genlist", genlist);
1674
1675         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout, NULL);
1676         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
1677 }
1678
1679
1680 void _clocklist_load()
1681 {
1682         if (g_clock_list[0] || g_clock_list[1] || g_clock_list[2]) {
1683                 _clocklist_destroy();
1684         }
1685
1686         pkgmgrinfo_appinfo_filter_h handle = NULL;
1687
1688         if (pkgmgrinfo_appinfo_filter_create(&handle) != PMINFO_R_OK) {
1689                 ERR("pkgmgrinfo_appinfo_filter_create error");
1690                 return;
1691         }
1692
1693         if (pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, IDLE_CLOCK_CATEGROY)
1694                 != PMINFO_R_OK) {
1695                 ERR("pkgmgrinfo_appinfo_filter_add_string error");
1696                 pkgmgrinfo_appinfo_filter_destroy(handle);
1697                 return;
1698         }
1699
1700         if (pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, IDLE_CLOCK_CATEGROY2)
1701                 != PMINFO_R_OK) {
1702                 ERR("pkgmgrinfo_appinfo_filter_add_string error");
1703                 pkgmgrinfo_appinfo_filter_destroy(handle);
1704                 return;
1705         }
1706
1707         if (pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, _category_app_list_cb, NULL)
1708                 != PMINFO_R_OK) {
1709                 ERR("pkgmgrinfo_appinfo_filter_foreach_appinfo error");
1710                 pkgmgrinfo_appinfo_filter_destroy(handle);
1711                 return;
1712         }
1713
1714         pkgmgrinfo_appinfo_filter_destroy(handle);
1715
1716         Clock_Type_Item *pitem = NULL;
1717         Eina_List *list = NULL;
1718         int i;
1719
1720         for (i = 0; i < 3; i++) {
1721                 EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
1722                         pitem->index = clock_idx++;
1723                 }
1724         }
1725
1726 }
1727
1728 void _clocklist_destroy()
1729 {
1730         Clock_Type_Item *pitem = NULL;
1731         Eina_List *list = NULL;
1732         clock_idx = 0;
1733         int i;
1734
1735         for (i = 0; i < 3; i++) {
1736                 EINA_LIST_FOREACH(g_clock_list[i], list, pitem) {
1737                         FREE(pitem->appid);
1738                         FREE(pitem->pkgid);
1739                         FREE(pitem->name);
1740                         FREE(pitem->icon);
1741                 }
1742         }
1743         g_clock_list[0] = eina_list_free(g_clock_list[0]);
1744         g_clock_list[1] = eina_list_free(g_clock_list[1]);
1745         g_clock_list[2] = eina_list_free(g_clock_list[2]);
1746 }
1747
1748 static int _clock_type_compare_cb(const void *d1, const void *d2)
1749 {
1750         UChar clock1[256] = { 0, };
1751         UChar clock2[256] = { 0, };
1752
1753         Clock_Type_Item *r1 = (Clock_Type_Item *) d1;
1754         Clock_Type_Item *r2 = (Clock_Type_Item *) d2;
1755
1756         u_uastrcpy(clock1, r1->name);
1757         u_uastrcpy(clock2, r2->name);
1758
1759         /*const char *lang = vconf_get_str(VCONFKEY_LANGSET); */
1760         /*UErrorCode status = U_ZERO_ERROR; */
1761         /*UCollator *coll = ucol_open(lang,  &status); */
1762         UCollationResult ret = ucol_strcoll(coll, clock1, -1, clock2, -1);
1763
1764         /*ucol_close(coll); */
1765
1766         switch (ret) {
1767         case UCOL_EQUAL:
1768                 return 0;
1769         case UCOL_GREATER:
1770                 return 1;
1771         case UCOL_LESS:
1772                 return -1;
1773         default:
1774                 return 0;
1775         }
1776 }
1777
1778 static char *get_timezone_str()
1779 {
1780         char buf[1024];
1781         ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf) - 1);
1782
1783         if (len != -1) {
1784                 buf[len] = '\0';
1785         } else {
1786                 /* handle error condition */
1787         }
1788         return strdup(buf + 20);
1789 }
1790
1791 static UChar *uastrcpy(const char *chars)
1792 {
1793         int len = 0;
1794         UChar *str = NULL;
1795
1796         if (!chars) return NULL;
1797
1798         len = strlen(chars);
1799         str = (UChar *) malloc(sizeof(UChar) * (len + 1));
1800         if (!str)
1801                 return NULL;
1802         u_uastrcpy(str, chars);
1803         return str;
1804 }
1805
1806 static void ICU_set_timezone(const char *timezone)
1807 {
1808         DBG("ICU_set_timezone = %s ", timezone);
1809         UErrorCode ec = U_ZERO_ERROR;
1810         UChar *str = uastrcpy(timezone);
1811
1812         ucal_setDefaultTimeZone(str, &ec);
1813         if (U_SUCCESS(ec)) {
1814                 DBG("ucal_setDefaultTimeZone() SUCCESS ");
1815         } else {
1816                 ERR("ucal_setDefaultTimeZone() FAILED : %s ", u_errorName(ec));
1817         }
1818         FREE(str);
1819 }