src/setting-clock.c

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