src/setting-clock.c

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