src/view-edit.c

   1 /*
   2
   3 Copyright (c) 2000-2012 Samsung Electronics Co., Ltd All Rights Reserved
   4
   5 This file is part of org.tizen.efl-calendar
   6 Written by Taeho Kang <taeho84.kang@samsung.com>
   7
   8 PROPRIETARY/CONFIDENTIAL
   9
  10 This software is the confidential and proprietary information of
  11 SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  12 disclose such Confidential Information and shall use it only in
  13 accordance with the terms of the license agreement you entered
  14 into with SAMSUNG ELECTRONICS.
  15
  16 SAMSUNG make no representations or warranties about the suitability
  17 of the software, either express or implied, including but not limited
  18 to the implied warranties of merchantability, fitness for a particular
  19 purpose, or non-infringement. SAMSUNG shall not be liable for any
  20 damages suffered by licensee as a result of using, modifying or
  21 distributing this software or its derivatives.
  22
  23 */
  24
  25
  26 #include <ui-gadget-module.h>
  27 #include <appcore-efl.h>
  28 #include <vconf.h>
  29
  30 #include "view.h"
  31 #include "edit-alarm.h"
  32 #include "edit-repeat.h"
  33 #include "alm-mgr.h"
  34 #include "acct-svc.h"
  35
  36 #define INVALID_TIMEZONE_VALUE (100)
  37
  38 typedef struct {
  39         struct appdata *ad;
  40         Evas_Object *parent;
  41         Evas_Object *ly; // self
  42         Evas_Object *genlist;
  43         Evas_Object *nv; // navigatino bar
  44         Evas_Object *win;
  45         Evas_Object *popup;
  46
  47         Evas_Object *e_title; // entry title
  48         Evas_Object *entry_loc; // entry location
  49         Evas_Object *l_start; // layout start
  50         Evas_Object *l_end; // layout end
  51         Evas_Object *l_alarm; // layout alarm
  52         Evas_Object *l_repeat; // layout repeat
  53         Evas_Object *l_saveto; // layout save event to
  54         Evas_Object *e_note; // entry note
  55         Elm_Object_Item *timezone_item; // timezone item
  56
  57         struct tm stm; // start
  58         struct tm etm; // end
  59         Eina_Bool allday;
  60         Evas_Object *ly_date;
  61
  62         int timezone;
  63         Eina_Bool is_selected_timezone;
  64         char * timezone_path;
  65         char * timezone_city;
  66         char * timezone_offset;
  67
  68         int repeat_occurrences;
  69         struct tm repeat_end_date_time;
  70
  71         GList  *list_alm_min;
  72         Evas_Object *ly_alarm;
  73
  74         cal_repeat_term_t repeat; // repeat off, daily, ...
  75         int repeat_end_date_num;
  76         int repeat_week; // for weekly
  77         Evas_Object *ly_repeat;
  78
  79         int event_id;
  80         int calid;
  81         int accid;
  82         Evas_Object *ly_saveto;
  83
  84         Evas_Object *sdt;
  85         Evas_Object *edt;
  86         int cid;
  87
  88         Evas_Object *c_allday;
  89         char *stitle;
  90         char *slocation;
  91         const char *snote;
  92         int n_attenders;
  93
  94         struct ui_gadget *ug_worldclock;
  95
  96         Ecore_Idler* idler;
  97
  98         Eina_List *calendar_list; //For save to
  99         int alarm_count;
 100         Elm_Object_Item *alarm_first_it;
 101         Elm_Object_Item *alarm_last_it;
 102         Evas_Object  *add_button;
 103
 104 }cal_edit_data;
 105
 106 enum cal_edit_alarm_value {
 107         CAL_EDIT_ALARM_OFF = -1,
 108         CAL_EDIT_ALARM_ON_TIME,
 109 };
 110
 111 enum genlist_item_type{
 112         _GTYPE_TITLE = 1,
 113         _GTYPE_LOC,
 114         _GTYPE_START,
 115         _GTYPE_END,
 116         _GTYPE_ALLDAY,
 117         _GTYPE_TIME_ZONE,
 118         _GTYPE_ALARM,
 119         _GTYPE_REPEAT,
 120         _GTYPE_NOTE,
 121         _GTYPE_LINKED_CAL,
 122         _GTYPE_MAX
 123 };
 124
 125 typedef struct
 126 {
 127         cal_edit_data *p;
 128         int type;
 129         Elm_Object_Item *it;
 130         struct _acct *at;
 131         cal_struct* cs;
 132         int alarm_value;
 133         Evas_Object *obj;
 134 }Item_Data;
 135
 136 static Elm_Object_Item* it; // To update
 137 static Elm_Genlist_Item_Class itc_seperator, itc_1icon, itc_1text_1icon, itc_2text_1btn, itc_2text, itc_2text_1icon_2, itc_2text_1icon_4, itc_2text_2icon_4;
 138 static Elm_Object_Item* __cal_edit_add_genlist_item(Evas_Object *genlist, Elm_Genlist_Item_Class *itc, int type, cal_edit_data *p);
 139 static Elm_Object_Item* __cal_edit_add_genlist_alarm_item(Evas_Object *genlist, Elm_Genlist_Item_Class *itc, int type, cal_edit_data *p, int alarm);
 140 static void __cal_edit_genlist_item_select_callback(void *data, Evas_Object *obj, void *event_info);
 141
 142
 143 static void __cal_edit_delete_layout(void *data, Evas *e, Evas_Object *obj, void *ei)
 144 {
 145         CAL_FN_START;
 146
 147         c_retm_if(!data, "data is null");
 148
 149         cal_edit_data *p = data;
 150
 151         struct appdata* ad = p->ad;
 152         c_retm_if(!ad, "ad is null");
 153
 154         Eina_List* list;
 155         cal_struct* cs;
 156
 157         if (p->idler) {
 158                 ecore_idler_del(p->idler);
 159                 p->idler = NULL;
 160         }
 161
 162         if (p->timezone_city)
 163                 free(p->timezone_city);
 164         if (p->timezone_path)
 165                 free(p->timezone_path);
 166         if (p->timezone_offset)
 167                 free(p->timezone_offset);
 168
 169         if (p->calendar_list) {
 170                 EINA_LIST_FOREACH(p->calendar_list, list, cs) {
 171                         if (cs)
 172                                 CALENDAR_SVC_STRUCT_FREE(&cs);
 173                 }
 174                 eina_list_free(p->calendar_list);
 175         }
 176
 177         if (ad->edit_special_one)
 178                 ad->edit_special_one = EINA_FALSE;
 179
 180         free(p);
 181 }
 182
 183 static void __cal_edit_cancel_button_callback(void *data, Evas_Object *obj, void *ei)
 184 {
 185         elm_naviframe_item_pop(data);
 186 }
 187
 188 static inline void __cal_edit_set_time_text(cal_edit_data *p)
 189 {
 190         const char* date = NULL;
 191         const char* time = NULL;
 192
 193         date = CAL_UTIL_DATE_FORMAT_1;
 194
 195         if (!p->allday)
 196         {
 197                 if (p->ad->is_hour24)
 198                         time = CAL_UTIL_TIME_FORMAT_6;
 199                 else
 200                         time = CAL_UTIL_TIME_FORMAT_1;
 201         }
 202
 203         cal_util_set_time_text(CAL_UTIL_GET_EDJ_DATA(p->l_start), "text", date, time, &p->stm);
 204         cal_util_set_time_text(CAL_UTIL_GET_EDJ_DATA(p->l_end), "text", date, time, &p->etm);
 205 }
 206
 207 static inline void __cal_edit_set_repeat_text(cal_edit_data *p)
 208 {
 209         char buf[1024] = {0};
 210
 211         cal_edit_repeat_get_repeat_str(p->repeat, p->repeat_week, buf, sizeof(buf));
 212         edje_object_part_text_set(CAL_UTIL_GET_EDJ_DATA(p->l_repeat), "text", buf);
 213 }
 214
 215 static void __cal_edit_change_wday(cal_edit_data *p)
 216 {
 217         int i;
 218         int wday;
 219
 220         wday = 7;
 221         for (i = 0; i < 7; i++) {
 222                 if ( ((p->repeat_week >> i) & 1) &&
 223                                 (wday > CAL_UTIL_GET_WDAY(i - p->stm.tm_wday))) {
 224                         wday = CAL_UTIL_GET_WDAY(i - p->stm.tm_wday);
 225                 }
 226         }
 227
 228         wday = CAL_UTIL_GET_WDAY(wday);
 229
 230         cal_util_update_tm_day(&p->stm, wday);
 231         cal_util_update_tm_day(&p->etm, wday);
 232         __cal_edit_set_time_text(p);
 233 }
 234
 235 static inline cal_edit_data* __cal_edit_check_layout(Evas_Object *sc)
 236 {
 237         cal_edit_data *p;
 238
 239         p = CAL_UTIL_GET_PRIV_DATA(sc);
 240         if (!p)
 241                 return NULL;
 242
 243         return p;
 244 }
 245
 246 static inline void __cal_edit_fill_entry(char **str, cal_struct *cs, const char *field)
 247 {
 248         c_retm_if(!str, "str is null");
 249         c_retm_if(!cs, "cs is null");
 250
 251         free(*str);
 252
 253         *str = CALENDAR_SVC_STRUCT_GET_STR(cs, field);
 254
 255         if (*str)
 256                 *str = elm_entry_utf8_to_markup((*str));
 257 }
 258
 259 static inline void __cal_edit_fill_title(cal_edit_data *p, cal_struct *cs)
 260 {
 261         __cal_edit_fill_entry(&(p->stitle), cs, CAL_VALUE_TXT_SUMMARY);
 262
 263 }
 264
 265 static inline void __cal_edit_fill_location(cal_edit_data *p, cal_struct *cs)
 266 {
 267         __cal_edit_fill_entry(&(p->slocation), cs, CAL_VALUE_TXT_LOCATION);
 268 }
 269
 270 static void __cal_edit_fill_note(cal_edit_data *p, cal_struct *cs)
 271 {
 272         c_retm_if(!p, "p is null");
 273         c_retm_if(!cs, "cs is null");
 274
 275         char *str = CALENDAR_SVC_STRUCT_GET_STR(cs,CAL_VALUE_TXT_DESCRIPTION);
 276         if (str)
 277                 p->snote = strdup(str);
 278 }
 279
 280 static void __cal_edit_fill_time(cal_edit_data *p, cal_struct *cs)
 281 {
 282         c_retm_if(!p, "p is null");
 283         c_retm_if(!cs, "cs is null");
 284
 285         time_t st = mktime(CALENDAR_SVC_STRUCT_GET_TM(cs, CAL_VALUE_GMT_START_DATE_TIME, CAL_TZ_FLAG_LOCAL));
 286         time_t et = mktime(CALENDAR_SVC_STRUCT_GET_TM(cs, CAL_VALUE_GMT_END_DATE_TIME, CAL_TZ_FLAG_LOCAL));
 287
 288         p->allday = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ALL_DAY_EVENT);
 289
 290         localtime_r(&st, &p->stm);
 291         localtime_r(&et, &p->etm);
 292
 293         if (CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_VALUE_INT_REPEAT_TERM)) {
 294                 st = p->ad->tm->st;
 295                 et = p->ad->tm->et;
 296                 localtime_r(&st, &p->stm);
 297                 localtime_r(&et, &p->etm);
 298         }
 299
 300         p->timezone_city = CAL_STRDUP(CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_TZ_CITY_NAME));
 301         c_warn_if(!p->timezone_city, "p->timezone_city is null");
 302
 303         p->timezone_path = CAL_STRDUP(CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_TZ_NAME));
 304         c_warn_if(!p->timezone_path, "p->timezone_path is null");
 305
 306         p->timezone = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_TIMEZONE);
 307
 308         if (!p->timezone_city || !p->timezone_path) {
 309                 cal_util_get_timezone_info(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
 310                 if (p->timezone_offset) {
 311                         char *text = strstr(p->timezone_offset, "T");
 312                         p->timezone = atoi(text+2);
 313                 }
 314         }
 315 }
 316
 317 static void __cal_edit_fill_alarm(cal_edit_data *p, cal_struct *cs)
 318 {
 319         c_retm_if(!p, "p is null");
 320         c_retm_if(!cs, "cs is null");
 321
 322         if (p->list_alm_min) {
 323                 g_list_free(p->list_alm_min);
 324                 p->list_alm_min = NULL;
 325         }
 326
 327         GList *al = NULL;
 328
 329         int r = CALENDAR_SVC_STRUCT_GET_LIST(cs, CAL_VALUE_LST_ALARM, &al);
 330         c_retm_if(r!=CAL_SUCCESS, "CALENDAR_SVC_STRUCT_GET_LIST(CAL_VALUE_LST_ALARM) is failed(%d)", r);
 331         if (!al) {
 332                 p->alarm_count = 1;
 333                 return;
 334         }
 335
 336         p->alarm_count = 0;
 337
 338         while (al) {
 339
 340                 cal_value *val = al->data;
 341                 c_retm_if(!val, "val is null");
 342
 343                 p->alarm_count++;
 344
 345                 int tick = CALENDAR_SVC_VALUE_GET_INT(val, CAL_VALUE_INT_ALARMS_TICK);
 346                 cal_sch_remind_tick_unit_t unit = CALENDAR_SVC_VALUE_GET_INT(val, CAL_VALUE_INT_ALARMS_TICK_UNIT);
 347
 348                 int min = cal_edit_alarm_get_min(tick, unit);
 349                 p->list_alm_min = g_list_append(p->list_alm_min,(void *)min);
 350
 351                 al = g_list_next(al);
 352         }
 353
 354         p->list_alm_min = g_list_first(p->list_alm_min);
 355 }
 356
 357 static void __cal_edit_fill_repeat(cal_edit_data *p, cal_struct *cs)
 358 {
 359         c_retm_if(!p, "p is null");
 360         c_retm_if(!cs, "cs is null");
 361
 362         int flag = 0;
 363         cal_repeat_term_t term = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_REPEAT_TERM);
 364         if (term == CAL_REPEAT_EVERY_WEEK) {
 365                 char *sflag = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_WEEK_FLAG);
 366                 flag = cal_util_get_week_flag(sflag);
 367         }
 368
 369         p->repeat = term;
 370         p->repeat_week = flag;
 371
 372         struct tm *tm_tm = CALENDAR_SVC_STRUCT_GET_TM(cs, CAL_VALUE_GMT_REPEAT_END_DATE,        CAL_TZ_FLAG_LOCAL);
 373         CAL_MEMCPY(&(p->repeat_end_date_time),tm_tm, struct tm);
 374
 375
 376         p->repeat_occurrences = CALENDAR_SVC_STRUCT_GET_INT(cs,"repeat_occurrences");
 377
 378         if (CAL_REPEAT_NONE != p->repeat) {
 379                 if (0 == p->repeat_occurrences)
 380                         p->repeat_end_date_num = 2;
 381                 else
 382                         p->repeat_end_date_num = 1;
 383         }
 384
 385 }
 386
 387 static void __cal_edit_fill_save_to(cal_edit_data *p, cal_struct *cs)
 388 {
 389         int calid;
 390         int acct_id;
 391
 392         calid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_CALENDAR_ID);
 393         if (calid < 1)
 394                 calid = DEFAULT_CALENDAR_ID;
 395
 396         acct_id = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID);
 397         if(acct_id < ALL_VISIBILITY_ACCOUNT)
 398                 acct_id = LOCAL_ACCOUNT_ID;
 399
 400         p->calid = calid;
 401         p->accid = acct_id;
 402 }
 403
 404 static void __cal_edit_fill_vcs_information(cal_edit_data *p)
 405 {
 406         CAL_ASSERT(p);
 407         struct appdata* ad = p->ad;
 408         CAL_ASSERT(ad);
 409
 410         cal_struct* cs = p->ad->ical;
 411
 412         __cal_edit_fill_title(p, cs);
 413         __cal_edit_fill_location(p, cs);
 414         __cal_edit_fill_time(p, cs);
 415         __cal_edit_fill_alarm(p, cs);
 416         __cal_edit_fill_repeat(p, cs);
 417         __cal_edit_fill_save_to(p, cs);
 418         __cal_edit_fill_note(p, cs);
 419
 420         return;
 421 }
 422
 423
 424 static void __cal_edit_fill_detail_information(cal_edit_data *p, int cid)
 425 {
 426         int r;
 427         cal_struct *cs;
 428
 429         p->event_id = cid;
 430
 431         cs = NULL;
 432         r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, p->event_id, NULL, &cs);
 433         if (r != CAL_SUCCESS)
 434         {
 435                 if (cs)
 436                         CALENDAR_SVC_STRUCT_FREE(&cs);
 437
 438                 return;
 439         }
 440
 441         __cal_edit_fill_title(p, cs);
 442         __cal_edit_fill_location(p, cs);
 443         __cal_edit_fill_time(p, cs);
 444         __cal_edit_fill_alarm(p, cs);
 445         __cal_edit_fill_repeat(p, cs);
 446         __cal_edit_fill_save_to(p, cs);
 447         __cal_edit_fill_note(p, cs);
 448
 449         p->accid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID);
 450
 451         CALENDAR_SVC_STRUCT_FREE(&cs);
 452
 453         return;
 454 }
 455
 456 static inline cal_struct* __cal_edit_get_cs(int cid)
 457 {
 458         cal_struct *cs;
 459
 460         if (cid == 0)
 461                 cs = CALENDAR_SVC_STRUCT_NEW(CAL_STRUCT_SCHEDULE);
 462         else
 463         {
 464                 int r;
 465                 cs = NULL;
 466                 r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, cid, NULL, &cs);
 467                 if (r != CAL_SUCCESS)
 468                 {
 469                         if(cs)
 470                                 CALENDAR_SVC_STRUCT_FREE(&cs);
 471
 472                         cs = NULL;
 473                 }
 474         }
 475
 476         return cs;
 477 }
 478
 479 static inline void __cal_edit_fill_cs_title(cal_edit_data *p, cal_struct *cs)
 480 {
 481         if(p->stitle)
 482                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_SUMMARY, p->stitle);
 483         else
 484                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_SUMMARY, C_("IDS_CLD_BODY_NO_TITLE"));
 485 }
 486
 487 static inline void __cal_edit_fill_cs_location(cal_edit_data *p, cal_struct *cs)
 488 {
 489         if (p->slocation)
 490                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_LOCATION, p->slocation);
 491         else
 492                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_LOCATION, "");
 493 }
 494
 495 static inline void __cal_edit_fill_cs_note(cal_edit_data *p, cal_struct *cs)
 496 {
 497         if (p->snote)
 498                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_DESCRIPTION, p->snote);
 499         else
 500                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_DESCRIPTION, "");
 501 }
 502
 503 static void __cal_edit_fill_cs_time(cal_edit_data *p, cal_struct *cs)
 504 {
 505         CAL_ASSERT(p);
 506         CAL_ASSERT(cs);
 507
 508         struct tm stm,etm;
 509
 510         if (p->allday) {
 511                 p->stm.tm_hour = 0;
 512                 p->stm.tm_min = 0;
 513                 p->stm.tm_sec = 0;
 514
 515                 p->etm.tm_hour = 23;
 516                 p->etm.tm_min = 59;
 517                 p->etm.tm_sec = 59;
 518                 memcpy(&stm,&p->stm,sizeof(struct tm));
 519                 memcpy(&etm,&p->etm,sizeof(struct tm));
 520         }
 521         else if (p->is_selected_timezone) {
 522                 char *local_tz_path = NULL;
 523
 524                 local_tz_path = vconf_get_str(CAL_VCONFKEY_LOCK_TIMEZONE_PATH);
 525                 if (!local_tz_path) {
 526                         local_tz_path = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
 527                         if (!local_tz_path) {
 528                                 ERR("vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID) is failed");
 529                                 local_tz_path = "Asia/Seoul";
 530                         }
 531                 }
 532
 533                 CALENDAR_SVC_UTIL_CONVERT_DB_TIME(&p->stm,local_tz_path, &stm,p->timezone_path);
 534                 CALENDAR_SVC_UTIL_CONVERT_DB_TIME(&p->etm,local_tz_path, &etm,p->timezone_path);
 535         }
 536         else {
 537                 memcpy(&stm,&p->stm,sizeof(struct tm));
 538                 memcpy(&etm,&p->etm,sizeof(struct tm));
 539         }
 540
 541         if (p->timezone_path)
 542                 CALENDAR_SVC_STRUCT_SET_STR(cs,CAL_VALUE_TXT_TZ_NAME,p->timezone_path);
 543         if (p->timezone_city)
 544                 CALENDAR_SVC_STRUCT_SET_STR(cs,CAL_VALUE_TXT_TZ_CITY_NAME,p->timezone_city);
 545
 546         CALENDAR_SVC_STRUCT_SET_INT(cs,CAL_VALUE_INT_TIMEZONE,p->timezone);
 547
 548         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_ALL_DAY_EVENT, p->allday);
 549
 550         CALENDAR_SVC_STRUCT_SET_TM(cs, CAL_VALUE_GMT_START_DATE_TIME, CAL_TZ_FLAG_LOCAL, &stm);
 551         CALENDAR_SVC_STRUCT_SET_TM(cs, CAL_VALUE_GMT_END_DATE_TIME, CAL_TZ_FLAG_LOCAL, &etm);
 552
 553 }
 554
 555 static int __cal_edit_g_list_compare(const void* data1, const void* data2)
 556 {
 557         return (int)data1 - (int)data2;
 558 }
 559
 560 static int __cal_edit_g_list_compare_with_data(const void* data1, const void* data2, void* user_data)
 561 {
 562         return (int)data1 - (int)data2;
 563 }
 564
 565 static void __cal_edit_fill_cs_alarm(cal_edit_data *p, cal_struct *cs)
 566 {
 567         c_retm_if(!p, "p is null");
 568         c_retm_if(!cs, "cs is null");
 569
 570         int tick;
 571         cal_sch_remind_tick_unit_t unit;
 572         GList *al = NULL, *temp  = NULL;
 573
 574         int count = 1;
 575
 576         Elm_Object_Item *it = p->alarm_first_it;
 577         while (it && (count++ <= p->alarm_count)) {
 578
 579                 Item_Data *item_data = elm_object_item_data_get(it);
 580                 c_retm_if(!item_data, "item_data is null");
 581
 582                 if (g_list_find_custom(temp, (const void*)item_data->alarm_value, __cal_edit_g_list_compare))
 583                         continue;
 584
 585                 temp = g_list_insert_sorted_with_data(temp, (void*)item_data->alarm_value, __cal_edit_g_list_compare_with_data, NULL);
 586
 587                 cal_edit_alarm_get_tick(item_data->alarm_value, &tick, &unit);
 588
 589                 if (tick != -1) {
 590                         cal_value *val = CALENDAR_SVC_VALUE_NEW(CAL_VALUE_LST_ALARM);
 591                         c_retm_if(!val, "calendar_svc_value_new is failed");
 592
 593                         CALENDAR_SVC_VALUE_SET_INT(val, CAL_VALUE_INT_ALARMS_TICK, tick);
 594                         CALENDAR_SVC_VALUE_SET_INT(val, CAL_VALUE_INT_ALARMS_TICK_UNIT, unit);
 595                         al = g_list_append(al, val);
 596                 }
 597
 598                 if (count-1 == p->alarm_count)
 599                         p->alarm_last_it = it;
 600
 601                 it = elm_genlist_item_next_get(it);
 602         }
 603
 604         CALENDAR_SVC_STRUCT_SET_LIST(cs, CAL_VALUE_LST_ALARM, al);
 605 }
 606
 607 static inline void __cal_edit_get_week_string(int week, char *week_s)
 608 {
 609         c_retm_if(!week_s,"week_s is null");
 610
 611         int i;
 612
 613         memset(week_s, 0, 7);
 614         week_s[7] = '\0';
 615
 616         for (i = 0; i < 7; i++) {
 617                 if ((week >> i) & 1)
 618                         week_s[i] = '1';
 619                 else
 620                         week_s[i] = '0';
 621         }
 622 }
 623
 624 static void __cal_edit_fill_cs_repeat(cal_edit_data *p, cal_struct *cs)
 625 {
 626         char sflag[8];
 627
 628         switch (p->repeat) {
 629         case CAL_REPEAT_EVERY_WEEK:
 630                 __cal_edit_get_week_string(p->repeat_week, sflag);
 631                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_WEEK_FLAG, sflag);
 632         case CAL_REPEAT_EVERY_DAY:
 633         case CAL_REPEAT_EVERY_MONTH:
 634         case CAL_REPEAT_EVERY_YEAR:
 635                 CALENDAR_SVC_STRUCT_SET_TIME(cs, CAL_VALUE_GMT_REPEAT_END_DATE, CAL_TZ_FLAG_LOCAL, cal_util_get_max_time());
 636                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_REPEAT_INTERVAL, 1);
 637                 break;
 638         default:
 639                 break;
 640         }
 641
 642         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_REPEAT_TERM, p->repeat);
 643
 644         if (CAL_REPEAT_NONE != p->repeat)
 645         {
 646                 p->repeat_end_date_time.tm_hour = p->stm.tm_hour;
 647                 p->repeat_end_date_time.tm_min = p->stm.tm_min;
 648                 p->repeat_end_date_time.tm_sec = p->stm.tm_sec;
 649
 650                 if (1 == p->repeat_end_date_num)
 651                         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_REPEAT_OCCURRENCES, p->repeat_occurrences);
 652                 else if (2 == p->repeat_end_date_num)
 653                         CALENDAR_SVC_STRUCT_SET_TM(cs,CAL_VALUE_GMT_REPEAT_END_DATE,CAL_TZ_FLAG_LOCAL,&p->repeat_end_date_time);
 654         }
 655 }
 656
 657 static void __cal_edit_fill_cs_save_to(cal_edit_data *p, cal_struct *cs)
 658 {
 659         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_CALENDAR_ID, p->calid);
 660
 661         if (p->accid == ALL_ACCOUNT_ID)
 662                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID, LOCAL_ACCOUNT_ID);
 663         else
 664                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID, p->accid);
 665 }
 666
 667 static inline void __cal_edit_mark_deleted(GList *al)
 668 {
 669         GList *p;
 670         cal_value *val;
 671
 672         p = al;
 673         while (p) {
 674                 val = p->data;
 675                 CALENDAR_SVC_VALUE_SET_INT(val, CAL_VALUE_INT_DETAIL_DELETE, 1);
 676                 p = g_list_next(p);
 677         }
 678 }
 679
 680 Eina_Bool cal_edit_check_email_vailidity(const char* email)
 681 {
 682         c_retvm_if(!email, EINA_FALSE, "email is null");
 683
 684         const char* temp = strchr(email, '@');
 685         c_retvm_if(!temp, EINA_FALSE, "%s is invalid address", email);
 686         c_retvm_if(*(temp+1) == '.', EINA_FALSE, "%s is invalid address", email);
 687
 688         temp = strchr(temp, '.');
 689         c_retvm_if(!temp, EINA_FALSE, "%s is invalid address", email);
 690         c_retvm_if(strlen(temp) <= 1, EINA_FALSE, "%s is invalid address", email);
 691
 692         return EINA_TRUE;
 693 }
 694
 695 static inline void __cal_edit_fill_cs(cal_edit_data *p, cal_struct *cs)
 696 {
 697         __cal_edit_fill_cs_title(p, cs);
 698         __cal_edit_fill_cs_location(p, cs);
 699         __cal_edit_fill_cs_time(p, cs);
 700         __cal_edit_fill_cs_alarm(p, cs);
 701         __cal_edit_fill_cs_repeat(p, cs);
 702         __cal_edit_fill_cs_note(p, cs);
 703         __cal_edit_fill_cs_save_to(p, cs);
 704 }
 705
 706 static void __cal_edit_reponse_event_callback(void *data, Evas_Object *obj, void *ei)
 707 {
 708         c_retm_if(!data, "data is null");
 709
 710         Evas_Object *popup = data;
 711         evas_object_del(popup);
 712 }
 713
 714 static int __cal_edit_get_date(Evas_Object *df, struct tm *res)
 715 {
 716         int r;
 717         struct tm tm;
 718         time_t t;
 719
 720         t = time(NULL);
 721         localtime_r(&t, &tm); // to fill hidden field
 722
 723         elm_datetime_value_get(df, &tm);
 724
 725         r = mktime(&tm);
 726         if (r == (time_t)-1)
 727                 return  -1;
 728
 729         *res = tm;
 730
 731         return 0;
 732 }
 733
 734 static void __cal_edit_title_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
 735 {
 736         const char *str;
 737         Item_Data *item_data = (Item_Data *)data;
 738         cal_edit_data *p = item_data->p;
 739
 740         free(p->stitle);
 741
 742
 743         str = elm_entry_entry_get(p->e_title);
 744         if (!str || str[0] == '\0')
 745                 p->stitle = NULL;
 746         else
 747                 p->stitle = elm_entry_markup_to_utf8(str);
 748 }
 749
 750
 751 static Evas_Object * __cal_edit_add_title_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
 752 {
 753         c_retvm_if(!obj, NULL, "obj is null");
 754         c_retvm_if(!part, NULL, "part is null");
 755         c_retvm_if(!item_data, NULL, "item_data is null");
 756
 757         cal_edit_data *p = item_data->p;
 758         c_retvm_if(!p, NULL, "p is null");
 759
 760         if (!CAL_STRCMP(part, "elm.icon")) {
 761                 Evas_Object *ef = cal_util_add_edit_field(obj, C_("IDS_COM_BODY_DETAILS_TITLE"), C_("IDS_CLD_BODY_TAP_TO_ENTER_TITLE"), EINA_TRUE, EINA_TRUE);
 762                 c_retvm_if(!ef, NULL, "ef is null");
 763
 764                 Evas_Object *entry = elm_object_part_content_get(ef, "elm.swallow.content");
 765                 c_retvm_if(!entry, ef, "entry is null");
 766
 767                 p->e_title = entry;
 768                 if (p->stitle)
 769                         elm_entry_entry_set(p->e_title, p->stitle);
 770
 771                 evas_object_smart_callback_add(p->e_title, "changed", __cal_edit_title_entry_changed_callback, item_data);
 772
 773                 return ef;
 774         }
 775
 776         return NULL;
 777 }
 778
 779 static inline int _edit_safe_strcmp(char *s1, char *s2)
 780 {
 781         if (NULL == s1 || NULL == s2)
 782                 return !(s1 == s2);
 783         else
 784                 return strcmp(s1, s2);
 785 }
 786
 787 static void _edit_location_entry_changed_cb(void *data, Evas_Object *obj, void *event_info)
 788 {
 789         char *str;
 790         Item_Data *item_data = (Item_Data *)data;
 791         cal_edit_data *p = item_data->p;
 792
 793         str = elm_entry_markup_to_utf8(elm_entry_entry_get(obj));
 794         if (str && *str) {
 795                 if (!_edit_safe_strcmp(str, p->slocation)) {
 796                         free(str);
 797                         return;
 798                 } else {
 799                         free(p->slocation);
 800                         p->slocation = str;
 801                 }
 802         } else {
 803                 free(p->slocation);
 804                 p->slocation = NULL;
 805         }
 806 }
 807
 808
 809 static Evas_Object * __cal_edit_add_location_icon(Evas_Object *obj, const char *part,  Item_Data *item_data)
 810 {
 811         Evas_Object *ly = NULL;
 812         Evas_Object *ef;
 813         Evas_Object *en;
 814
 815         if (!CAL_STRCMP(part, "elm.icon"))
 816         {
 817                 ly = cal_util_add_layout(obj, "dialoguegroup/location");
 818                 if (!ly)
 819                         return NULL;
 820
 821                 ef = cal_util_add_edit_field(ly, C_("IDS_COM_BODY_DETAILS_LOCATION"), C_("IDS_CLD_BODY_TAP_TO_ENTER_LOCATION"), EINA_TRUE, EINA_TRUE);
 822                 if (!ef) {
 823                         ERR("ef is null");
 824                         evas_object_del(ly);
 825                         return NULL;
 826                 }
 827
 828                 elm_object_part_content_set(ly, "editfield/sw", ef);
 829
 830                 en = elm_object_part_content_get(ef, "elm.swallow.content");
 831
 832                 if (item_data->p->slocation)
 833                         elm_entry_entry_set(en, item_data->p->slocation);
 834
 835                 evas_object_smart_callback_add(en, "changed", _edit_location_entry_changed_cb, item_data);
 836                 elm_entry_cnp_mode_set(en, ELM_CNP_MODE_PLAINTEXT);
 837         }
 838
 839         return ly;
 840 }
 841
 842 static Evas_Object* __cal_edit_add_date_field(Evas_Object *dg, cal_edit_data *p, struct tm *tm)
 843 {
 844         c_retvm_if(!dg, NULL, "dg is null");
 845         c_retvm_if(!p, NULL, "p is null");
 846         c_retvm_if(!tm, NULL, "tm is null");
 847
 848         struct appdata* ad = p->ad;
 849         c_retvm_if(!ad, NULL, "ad is null");
 850
 851         Evas_Object *layout = cal_util_add_datetime(dg, NULL, tm);
 852         c_retvm_if(!layout, NULL, "layout is null");
 853
 854         Evas_Object *dt = elm_object_part_content_get(layout, "elm.icon");
 855         if (!dt) {
 856                 ERR("dt is null");
 857                 evas_object_del(layout);
 858                 return NULL;
 859         }
 860
 861         if (!p->allday)
 862         {
 863                 elm_datetime_field_visible_set(dt, ELM_DATETIME_HOUR, EINA_TRUE);
 864                 elm_datetime_field_visible_set(dt, ELM_DATETIME_MINUTE, EINA_TRUE);
 865
 866                 if (ad->is_hour24)
 867                 {
 868                         elm_datetime_format_set(dt, "%b %d , %Y %H : %M");
 869                         elm_datetime_field_visible_set(dt, ELM_DATETIME_AMPM, EINA_FALSE);
 870                 }
 871                 else
 872                 {
 873                         elm_datetime_format_set(dt, "%b %d , %Y %I : %M %p");
 874                         elm_datetime_field_visible_set(dt, ELM_DATETIME_AMPM, EINA_TRUE);
 875                 }
 876         }
 877         else
 878         {
 879                 elm_datetime_field_visible_set(dt, ELM_DATETIME_HOUR, EINA_FALSE);
 880                 elm_datetime_field_visible_set(dt, ELM_DATETIME_MINUTE, EINA_FALSE);
 881                 elm_datetime_field_visible_set(dt, ELM_DATETIME_AMPM, EINA_FALSE);
 882         }
 883
 884         elm_datetime_field_limit_set(dt, ELM_DATETIME_YEAR, 70, 137);
 885
 886         return layout;
 887 }
 888
 889 static void __cal_edit_start_date_changed_callback(void *data, Evas_Object *obj, void *ei)
 890 {
 891         c_retm_if(!data, "data is null");
 892         cal_edit_data *p = data;
 893
 894         c_retm_if(!p->sdt, "p->sdt is null");
 895         c_retm_if(!p->edt, "p->edt is null");
 896
 897         struct tm tm;
 898
 899         __cal_edit_get_date(p->sdt, &(p->stm));
 900         __cal_edit_get_date(p->edt, &(p->etm));
 901
 902         elm_datetime_value_get(p->sdt, &tm);
 903
 904         cal_util_update_tm_hour(&tm, 1);
 905
 906         elm_datetime_value_set(p->edt, &tm);
 907
 908         __cal_edit_get_date(p->sdt, &(p->stm));
 909         __cal_edit_get_date(p->edt, &(p->etm));
 910 }
 911
 912
 913 static Evas_Object * __cal_edit_add_start_date_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
 914 {
 915         Evas_Object *icon_obj = NULL;
 916         if (!CAL_STRCMP(part, "elm.icon"))
 917         {
 918                 cal_edit_data *p = item_data->p;
 919                 icon_obj = __cal_edit_add_date_field(obj, p, &p->stm);
 920                 elm_object_part_text_set(icon_obj, "elm.text", S_("IDS_COM_BODY_START"));
 921
 922                 p->sdt = elm_object_part_content_get(icon_obj, "elm.icon");
 923                 c_warn_if(!p->sdt, "p->sdt is null");
 924
 925                 evas_object_smart_callback_add(p->sdt, "changed", __cal_edit_start_date_changed_callback, p);
 926         }
 927
 928         return icon_obj;
 929 }
 930
 931 static void __cal_edit_end_date_changed_callback(void *data, Evas_Object *obj, void *ei)
 932 {
 933         CAL_FN_START;
 934
 935         cal_edit_data *p = data;
 936
 937         __cal_edit_get_date(p->edt, &(p->etm));
 938 }
 939
 940 static Evas_Object * __cal_edit_add_end_date_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
 941 {
 942         Evas_Object *icon_obj = NULL;
 943         if (!CAL_STRCMP(part, "elm.icon"))
 944         {
 945                 cal_edit_data *p = item_data->p;
 946                 icon_obj = __cal_edit_add_date_field(obj, p, &p->etm);
 947                 elm_object_part_text_set(icon_obj, "elm.text", S_("IDS_COM_BODY_END"));
 948
 949                 p->edt = elm_object_part_content_get(icon_obj, "elm.icon");
 950                 c_warn_if(!p->edt, "p->edt is null");
 951
 952                 evas_object_smart_callback_add(p->edt,"changed", __cal_edit_end_date_changed_callback, p);
 953         }
 954         return icon_obj;
 955 }
 956
 957 static void __cal_edit_all_day_changed_callback(void *data, Evas_Object *obj, void *ei)
 958 {
 959         CAL_ASSERT(data);
 960         cal_edit_data *p = data;
 961
 962         CAL_ASSERT(p->ad);
 963
 964         p->allday = elm_check_state_get(obj);
 965         if (!p->allday) {
 966
 967                 elm_datetime_field_visible_set(p->sdt, ELM_DATETIME_HOUR, EINA_TRUE);
 968                 elm_datetime_field_visible_set(p->edt, ELM_DATETIME_HOUR, EINA_TRUE);
 969                 elm_datetime_field_visible_set(p->sdt, ELM_DATETIME_MINUTE, EINA_TRUE);
 970                 elm_datetime_field_visible_set(p->edt, ELM_DATETIME_MINUTE, EINA_TRUE);
 971
 972                 if (!p->ad->is_hour24) {
 973                         elm_datetime_field_visible_set(p->sdt, ELM_DATETIME_AMPM, EINA_TRUE);
 974                         elm_datetime_field_visible_set(p->edt, ELM_DATETIME_AMPM, EINA_TRUE);
 975                 }
 976         }
 977         else    {
 978
 979                 elm_datetime_field_visible_set(p->sdt, ELM_DATETIME_HOUR, EINA_FALSE);
 980                 elm_datetime_field_visible_set(p->edt, ELM_DATETIME_HOUR, EINA_FALSE);
 981                 elm_datetime_field_visible_set(p->sdt, ELM_DATETIME_MINUTE, EINA_FALSE);
 982                 elm_datetime_field_visible_set(p->edt, ELM_DATETIME_MINUTE, EINA_FALSE);
 983                 elm_datetime_field_visible_set(p->sdt, ELM_DATETIME_AMPM, EINA_FALSE);
 984                 elm_datetime_field_visible_set(p->edt, ELM_DATETIME_AMPM, EINA_FALSE);
 985         }
 986 }
 987
 988 static Evas_Object * __cal_edit_add_all_day_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
 989 {
 990         CAL_ASSERT(obj);
 991         CAL_ASSERT(item_data);
 992
 993         if (!CAL_STRCMP(part, "elm.icon"))
 994         {
 995                 cal_edit_data *p = item_data->p;
 996                 Evas_Object *rd;
 997
 998                 rd = elm_check_add(obj);
 999                 elm_check_state_set(rd, p->allday);
1000                 elm_object_style_set(rd, "on&off");
1001                 p->c_allday = rd;
1002                 evas_object_smart_callback_add(rd, "changed", __cal_edit_all_day_changed_callback, p);
1003                 elm_check_state_set(p->c_allday, p->allday);
1004                 evas_object_propagate_events_set(rd, EINA_FALSE);
1005
1006                 return rd;
1007         }
1008
1009         return NULL;
1010 }
1011
1012 static void __cal_edit_note_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
1013 {
1014         c_retm_if(!data, "data is null");
1015
1016         Item_Data *item_data = data;
1017         cal_edit_data *p = item_data->p;
1018         c_retm_if(!p, "p is null");
1019
1020         const char *str = elm_entry_markup_to_utf8(elm_entry_entry_get(p->e_note));
1021
1022         if (!CAL_STRLEN(str))
1023                 p->snote = NULL;
1024         else
1025                 p->snote = str;
1026 }
1027
1028
1029 static Evas_Object * __cal_edit_add_note_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
1030 {
1031         c_retvm_if(!obj , NULL, "obj is null");
1032         c_retvm_if(!part , NULL, "part is null");
1033         c_retvm_if(!item_data , NULL, "item_data is null");
1034
1035         cal_edit_data *p = item_data->p;
1036         c_retvm_if(!p , NULL, "p is null");
1037
1038         if (!CAL_STRCMP(part, "elm.icon")) {
1039                 Evas_Object *ef = cal_util_add_edit_field(obj, C_("IDS_COM_BODY_NOTE"), C_("IDS_CLD_BODY_TAP_TO_ENTER_NOTE"), EINA_FALSE, EINA_TRUE );
1040                 if (ef) {
1041                         Evas_Object *entry = elm_object_part_content_get(ef, "elm.swallow.content");
1042                         c_retvm_if(!entry, ef, "entry is null");
1043
1044                         evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1045                         evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_EXPAND);
1046                         elm_entry_autocapital_type_set(entry, EINA_TRUE);
1047                         elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
1048
1049                         p->e_note = entry;
1050
1051                         if (p->snote)
1052                                 elm_entry_entry_set(p->e_note, elm_entry_utf8_to_markup(p->snote));
1053
1054                         evas_object_smart_callback_add(p->e_note, "changed", __cal_edit_note_entry_changed_callback, item_data);
1055
1056                         return ef;
1057                 }
1058         }
1059         return NULL;
1060 }
1061
1062 static void __cal_edit_set_default_information(cal_edit_data *p)
1063 {
1064         time_t now;
1065
1066         now = time(NULL);
1067         localtime_r(&now, &p->stm);
1068         p->stm.tm_sec = 0;
1069         localtime_r(&now, &p->etm);
1070         p->etm.tm_sec = 0;
1071         p->allday = 0;
1072
1073         p->repeat = CAL_REPEAT_NONE;
1074         p->repeat_week = 0;
1075
1076         p->calid = DEFAULT_CALENDAR_ID;
1077         p->accid = ALL_ACCOUNT_ID;
1078
1079         p->repeat_occurrences = 10;
1080
1081         cal_util_get_timezone_info(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
1082         if (p->timezone_offset) {
1083                 char *text = strstr(p->timezone_offset, "T");
1084                 p->timezone = atoi(text+2);
1085         }
1086 }
1087
1088
1089 static Evas_Object* __cal_edit_add_save_to_icon(void *item_data, Evas_Object *obj, const char *part)
1090 {
1091         if (!item_data)
1092         {
1093                 ERR("item_data is null");
1094                 return NULL;
1095         }
1096
1097         Evas_Object *icon = NULL;
1098         char* default_icon_path = "/opt/apps/org.tizen.efl-calendar/res/icons/all_calendar.png";
1099         char* icon_path = NULL;
1100         cal_struct* cs = (cal_struct*)item_data;
1101         Eina_Bool r = EINA_FALSE;
1102         int cid = 0;
1103         int aid = 0;
1104
1105         cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
1106         aid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_ACCOUNT_ID);
1107
1108         if (!CAL_STRCMP(part, "elm.icon"))
1109         {
1110                 icon = elm_icon_add(obj);
1111
1112                 if (!icon)
1113                 {
1114                         ERR("elm_icon_add fail");
1115                         return NULL;
1116                 }
1117
1118                 if ( cid == DEFAULT_CALENDAR_ID) {
1119                         r = elm_icon_file_set(icon, default_icon_path, NULL);
1120                         c_warn_if(!r, "elm_icon_file_set(%s) is failed", default_icon_path);
1121                 }
1122                 else {
1123                         icon_path = cal_account_svc_get_account_icon_path(aid);
1124                         if (icon_path) {
1125                                 r = elm_icon_file_set(icon, icon_path, NULL);
1126                                 c_warn_if(!r, "elm_icon_file_set(%s) is failed", default_icon_path);
1127                                 free(icon_path);
1128                         }
1129                         else {
1130                                 r = elm_icon_file_set(icon, default_icon_path, NULL);
1131                                 c_warn_if(!r, "elm_icon_file_set(%s) is failed", default_icon_path);
1132                         }
1133
1134                 }
1135
1136                 if (!r) {
1137                         ERR("");
1138                         evas_object_del(icon);
1139                         icon = NULL;
1140                 }
1141                 else
1142                         evas_object_show(icon);
1143         }
1144
1145         return icon;
1146 }
1147
1148 static Evas_Object *__cal_edit_get_genlist_item_icon(void *data, Evas_Object *obj, const char *part)
1149 {
1150         Evas_Object *e_obj = NULL;
1151         Item_Data *item_data = (Item_Data*)data;
1152
1153         switch ( item_data->type)
1154         {
1155         case _GTYPE_TITLE:
1156                 e_obj = __cal_edit_add_title_icon(obj, part, item_data);
1157                 break;
1158         case _GTYPE_LOC:
1159                 e_obj = __cal_edit_add_location_icon(obj, part, item_data);
1160                 break;
1161         case _GTYPE_START:
1162                 e_obj = __cal_edit_add_start_date_icon(obj, part, item_data);
1163                 break;
1164         case _GTYPE_END:
1165                 e_obj = __cal_edit_add_end_date_icon(obj, part, item_data);
1166                 break;
1167         case _GTYPE_ALLDAY:
1168                 e_obj = __cal_edit_add_all_day_icon(obj, part, item_data);
1169                 break;
1170         case _GTYPE_NOTE:
1171                 e_obj = __cal_edit_add_note_icon(obj, part, item_data);
1172                 break;
1173         default:
1174                 break;
1175         }
1176
1177         return e_obj;
1178 }
1179
1180 static char* __cal_edit_add_start_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1181 {
1182         if (!CAL_STRCMP(part, "elm.text.1"))
1183         {
1184                 return strdup(S_("IDS_COM_BODY_START"));
1185         }
1186
1187         return NULL;
1188 }
1189
1190 static char* __cal_edit_add_end_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1191 {
1192         if (!CAL_STRCMP(part, "elm.text.1"))
1193         {
1194                 return strdup(S_("IDS_COM_BODY_END"));
1195         }
1196
1197         return NULL;
1198 }
1199
1200 static void __cal_edit_get_alarm_text(Item_Data *data, char* buf, int buf_size)
1201 {
1202         c_retm_if(!data, "data is null");
1203         cal_edit_alarm_get_alarm_str(data->alarm_value, buf, buf_size);
1204 }
1205
1206 static Eina_Bool __cal_edit_check_alarm_time_passed(cal_edit_data *p, cal_struct *cs)
1207 {
1208         time_t alarm;
1209         time_t current_time = time(NULL);
1210         struct tm start_tm;
1211         char buf[32] = {0};
1212         Item_Data *item_data = NULL;
1213         Elm_Object_Item *it;
1214         c_retvm_if(!p, EINA_FALSE, "p is null");
1215         c_retvm_if(!p->genlist, EINA_FALSE, "genlist is null");
1216
1217         start_tm = p->stm;
1218         if (p->allday) {
1219                 start_tm.tm_hour = 0;
1220                 start_tm.tm_min = 0;
1221                 start_tm.tm_sec = 0;
1222         }
1223
1224         int count = 1;
1225
1226         it = p->alarm_first_it;
1227         while (it && (count++ <= p->alarm_count)) {
1228
1229                 item_data = elm_object_item_data_get(it);
1230                 c_retvm_if(!item_data, EINA_FALSE, "item_data is null");
1231
1232                 cal_edit_alarm_get_alarm_str(item_data->alarm_value, buf, sizeof(buf));
1233                 if (!strcmp(buf, S_("IDS_COM_BODY_OFF"))) {
1234                         it = elm_genlist_item_next_get(it);
1235                         continue;
1236                 }
1237
1238                 alarm = mktime(&start_tm)-item_data->alarm_value*60;
1239                 if (alarm < current_time)
1240                         return EINA_TRUE;
1241
1242                 it = elm_genlist_item_next_get(it);
1243         }
1244
1245         return EINA_FALSE;
1246 }
1247
1248 static void __cal_edit_show_result_popup(cal_edit_data *p,int result)
1249 {
1250         char buf[100]={0,};
1251
1252         switch(result)
1253         {
1254         case CAL_ERR_EVENT_START_DATE:
1255                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Start date is invalid!",
1256                         __cal_edit_reponse_event_callback, NULL, NULL);
1257                 break;
1258         case CAL_ERR_EVENT_END_DATE:
1259                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "End date is invalid!",
1260                         __cal_edit_reponse_event_callback, NULL, NULL);
1261                 break;
1262         case CAL_ERR_EVENT_REPEAT_END_DATE:
1263                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Repeat end date is invalid!",
1264                         __cal_edit_reponse_event_callback, NULL, NULL);
1265                 break;
1266         case CAL_ERR_EVENT_DURATION:
1267                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Event duration is invalid!",
1268                         __cal_edit_reponse_event_callback, NULL, NULL);
1269                 break;
1270         case CAL_ERR_EVENT_REPEAT_DURATION_TOO_SHORT:
1271                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Event duration is longer than repeat duration!",
1272                         __cal_edit_reponse_event_callback, NULL, NULL);
1273                 break;
1274         case CAL_ERR_DB_LOCK:
1275                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Sync in progress, try later.",
1276                         __cal_edit_reponse_event_callback, NULL, NULL);
1277                 break;
1278         default:
1279                 snprintf(buf,100,"not saved(internal error-%d)!",result);
1280                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), buf,
1281                         __cal_edit_reponse_event_callback, NULL, NULL);
1282                 break;
1283         }
1284 }
1285
1286 int __cal_edit_save(cal_edit_data *p)
1287 {
1288         CAL_FN_START;
1289
1290         int r;
1291         cal_struct *cs;
1292         cal_struct *cs_temp;
1293
1294         cs = __cal_edit_get_cs(p->event_id);
1295         if (!cs)
1296                 return -1;
1297
1298         cs_temp = __cal_edit_get_cs(p->event_id);
1299         if (!cs_temp)
1300         {
1301                 if(cs)
1302                         CALENDAR_SVC_STRUCT_FREE(&cs);
1303
1304                 return -1;
1305         }
1306
1307         if (__cal_edit_check_alarm_time_passed(p,cs) && p->repeat == CAL_REPEAT_NONE)
1308         {
1309                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Alarm time already passed!",
1310                         __cal_edit_reponse_event_callback, NULL, NULL);
1311
1312                 if (cs)
1313                         CALENDAR_SVC_STRUCT_FREE(&cs);
1314
1315                 if (cs_temp)
1316                         CALENDAR_SVC_STRUCT_FREE(&cs_temp);
1317
1318                 return -1;
1319         }
1320
1321         __cal_edit_fill_cs(p, cs);
1322
1323         if (p->event_id)
1324         {
1325                 if (p->ad->edit_special_one)
1326                 {
1327                         GList* list = NULL;
1328                         cal_value* value = NULL;
1329                         time_t t = 0;
1330
1331                         CALENDAR_SVC_STRUCT_SET_INT(cs,"original_event_id",CALENDAR_SVC_STRUCT_GET_INT(cs,"index"));
1332                         CALENDAR_SVC_STRUCT_SET_INT(cs,CAL_VALUE_INT_REPEAT_TERM,0);
1333                         p->ad->cid = CALENDAR_SVC_INSERT(cs);
1334
1335                         t = p->ad->tm->st;
1336                         value = CALENDAR_SVC_VALUE_NEW(CAL_VALUE_LST_EXCEPTION_DATE);
1337                         CALENDAR_SVC_VALUE_SET_TIME(value,CAL_VALUE_GMT_EXCEPTION_DATE_TIME,CAL_TZ_FLAG_GMT,t);
1338                         CALENDAR_SVC_VALUE_SET_INT(value,  CAL_VALUE_INT_EXCEPTION_DATE_ID, p->ad->cid);
1339                         CALENDAR_SVC_STRUCT_GET_LIST(cs_temp,CAL_VALUE_LST_EXCEPTION_DATE,&list);
1340                         list = g_list_append(list,value);
1341                         CALENDAR_SVC_STRUCT_SET_LIST(cs_temp,CAL_VALUE_LST_EXCEPTION_DATE,list);
1342
1343                         CALENDAR_SVC_STRUCT_SET_INT(cs_temp,CAL_VALUE_INT_ACCOUNT_ID,p->accid);
1344
1345                         CALENDAR_SVC_UPDATE(cs_temp);
1346                 }
1347                 else
1348                 {
1349                         r = CALENDAR_SVC_UPDATE(cs);
1350                         if (r != CAL_SUCCESS)
1351                         {
1352                                 __cal_edit_show_result_popup(p,r);
1353
1354                                 if (cs)
1355                                         CALENDAR_SVC_STRUCT_FREE(&cs);
1356
1357                                 if (cs_temp)
1358                                         CALENDAR_SVC_STRUCT_FREE(&cs_temp);
1359
1360                                 return -1;
1361                         }
1362                 }
1363         }
1364         else
1365         {
1366
1367                 r = CALENDAR_SVC_INSERT(cs);
1368                 if (r <= 0)
1369                 {
1370                         __cal_edit_show_result_popup(p,r);
1371
1372                         if (cs)
1373                                 CALENDAR_SVC_STRUCT_FREE(&cs);
1374
1375                         if (cs_temp)
1376                                 CALENDAR_SVC_STRUCT_FREE(&cs_temp);
1377
1378                         return -1;
1379                 }
1380         }
1381
1382         CALENDAR_SVC_STRUCT_FREE(&cs);
1383         CALENDAR_SVC_STRUCT_FREE(&cs_temp);
1384
1385         return 0;
1386 }
1387
1388 static void __cal_edit_save_button_callback(void *data, Evas_Object *obj, void *ei)
1389 {
1390         CAL_FN_START;
1391
1392         c_retm_if(!data, "data is null");
1393
1394         Evas_Object *ly = data;
1395         Elm_Object_Item* navi_item = NULL;
1396         int r;
1397         cal_edit_data *p = CAL_UTIL_GET_PRIV_DATA(ly);
1398         c_retm_if(!p, "p is null");
1399
1400         r = __cal_edit_save(p);
1401         c_retm_if(r, "cal_edit_save() is failed");
1402
1403         if ((NULL != p->ad->ug) && (UG_EDIT == p->ad->u_type))
1404         {
1405                 ug_destroy_me(p->ad->ug);
1406                 return;
1407         }
1408         else if (p->ad->request_view == CV_EDIT)
1409         {
1410                 if (elm_naviframe_top_item_get(p->ad->nv) != elm_naviframe_bottom_item_get(p->ad->nv))
1411                 {
1412                         p->ad->request_view = CV_UNKNOWN;
1413                         elm_win_lower(p->ad->win);
1414                 }
1415                 else
1416                         elm_exit();
1417         }
1418
1419         elm_naviframe_prev_btn_auto_pushed_set(p->ad->nv, EINA_TRUE);
1420         elm_naviframe_item_pop(p->ad->nv);
1421         navi_item = elm_naviframe_top_item_get(p->ad->nv);
1422 }
1423
1424 static char* __cal_edit_add_allday_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1425 {
1426         if (!CAL_STRCMP(part, "elm.text"))
1427         {
1428                 return strdup(C_("IDS_COM_BODY_ALL_DAY"));
1429         }
1430
1431         return NULL;
1432 }
1433
1434 static char* __cal_edit_add_timezone_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1435 {
1436         CAL_ASSERT(item_data);
1437
1438         cal_edit_data *p = item_data->p;
1439
1440         if (!CAL_STRCMP(part, "elm.text.1"))
1441                 return strdup(C_("IDS_CLD_BODY_TIME_ZONE"));
1442
1443         if (!CAL_STRCMP(part, "elm.text.2")) {
1444                 if (!p->timezone_offset) {
1445                         ERR("p->timezone_offset is null");
1446                         return NULL;
1447                 }
1448
1449                 return g_strdup_printf("%s, %s", C_(p->timezone_city), p->timezone_offset);
1450         }
1451
1452         return NULL;
1453 }
1454
1455 static char* __cal_edit_add_alarm_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1456 {
1457         CAL_ASSERT(item_data);
1458
1459         cal_edit_data *p = item_data->p;
1460         CAL_ASSERT(p);
1461
1462         char buf[1024];
1463
1464         if (!CAL_STRCMP(part, "elm.text.1"))
1465         {
1466                 return strdup(S_("IDS_COM_BODY_ALARM"));
1467         }
1468         if (!CAL_STRCMP(part, "elm.text.2"))
1469         {
1470                 __cal_edit_get_alarm_text(item_data, buf, sizeof(buf));
1471                 return strdup(buf);
1472         }
1473         return NULL;
1474 }
1475
1476 static void __cal_edit_get_repeat_text(cal_edit_data *p, char* buf, int buf_size)
1477 {
1478         cal_edit_repeat_get_repeat_str(p->repeat, p->repeat_week, buf, buf_size);
1479 }
1480
1481 static char* __cal_edit_add_repeat_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1482 {
1483         char buf[1024] = {0};
1484         CAL_ASSERT(item_data);
1485
1486         cal_edit_data *p = item_data->p;
1487         CAL_ASSERT(p);
1488
1489         if (!CAL_STRCMP(part, "elm.text.1"))
1490         {
1491                 return strdup(C_("IDS_CLD_BODY_REPEAT"));
1492         }
1493         if (!CAL_STRCMP(part, "elm.text.2"))
1494         {
1495                 __cal_edit_get_repeat_text(p, buf, sizeof(buf));
1496                 return strdup(buf);
1497         }
1498         return NULL;
1499 }
1500
1501 static void __cal_edit_get_save_to_str(int calid, char *buf, int sz)
1502 {
1503         cal_struct *cs = NULL;
1504         const char *str;
1505         int r;
1506
1507         r = CALENDAR_SVC_GET(CAL_STRUCT_CALENDAR, calid, NULL, &cs);
1508         if (r != CAL_SUCCESS)
1509         {
1510                 snprintf(buf, sz, "%s", _("Phone"));
1511                 if (cs)
1512                         CALENDAR_SVC_STRUCT_FREE(&cs);
1513
1514                 return;
1515         }
1516
1517         if (calid == DEFAULT_CALENDAR_ID)
1518                 str = C_("IDS_CLD_OPT_PHONE_CALENDAR");
1519         else
1520         {
1521                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_TABLE_TXT_NAME);
1522                 if (!str)
1523                         str = C_("IDS_CLD_OPT_PHONE_CALENDAR");
1524         }
1525
1526         snprintf(buf, sz, "%s", str);
1527
1528         CALENDAR_SVC_STRUCT_FREE(&cs);
1529 }
1530
1531 static char* __cal_edit_add_save_to_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1532 {
1533         CAL_FN_START;
1534
1535         char buf[1024];
1536         CAL_ASSERT(item_data);
1537
1538         cal_edit_data *p = item_data->p;
1539         CAL_ASSERT(p);
1540
1541         if (!CAL_STRCMP(part, "elm.text.1"))
1542         {
1543                 return strdup(C_("IDS_ST_BODY_SAVE_TO"));
1544         }
1545
1546         if (!CAL_STRCMP(part, "elm.text.2"))
1547         {
1548                 if ( p->calid == DEFAULT_CALENDAR_ID)
1549                         return strdup(C_("IDS_CLD_OPT_PHONE_CALENDAR"));
1550                 else
1551                 {
1552                         __cal_edit_get_save_to_str(p->calid, buf, sizeof(buf));
1553                         return strdup(buf);
1554                 }
1555         }
1556         return NULL;
1557 }
1558
1559 static char* __cal_edit_add_note_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1560 {
1561         cal_edit_data *p = item_data->p;
1562         if (!CAL_STRCMP(part, "elm.text.1"))
1563         {
1564                 return strdup(S_("IDS_COM_BODY_NOTE"));
1565         }
1566
1567         if (!CAL_STRCMP(part, "elm.text.2") && p->snote)
1568         {
1569                 return strdup(p->snote);
1570         }
1571
1572         return NULL;
1573 }
1574
1575 static char *__cal_edit_get_genlist_item_label(void *data, Evas_Object *obj, const char *part)
1576 {
1577         Item_Data *item_data = (Item_Data*)data;
1578         int type = (int)item_data->type;
1579
1580         switch ( type )
1581         {
1582         case _GTYPE_TITLE:
1583                 break;
1584         case _GTYPE_LOC:
1585                 break;
1586         case _GTYPE_START:
1587                 return __cal_edit_add_start_text(obj, part, item_data);
1588         case _GTYPE_END:
1589                 return __cal_edit_add_end_text(obj, part, item_data);
1590         case _GTYPE_ALLDAY:
1591                 return __cal_edit_add_allday_text(obj, part, item_data);
1592         case _GTYPE_TIME_ZONE:
1593                 return __cal_edit_add_timezone_text(obj, part, item_data);
1594         case _GTYPE_ALARM:
1595                 return __cal_edit_add_alarm_text(obj, part, item_data);
1596         case _GTYPE_REPEAT:
1597                 return __cal_edit_add_repeat_text(obj, part, item_data);
1598         case _GTYPE_LINKED_CAL:
1599                 return __cal_edit_add_save_to_text(obj, part, item_data);
1600         case _GTYPE_NOTE:
1601                 return __cal_edit_add_note_text(obj, part, item_data);
1602         default:
1603                 break;
1604         }
1605
1606         return NULL;
1607 }
1608
1609 static void __cal_edit_genlist_item_delete(void *data, Evas_Object *obj)
1610 {
1611         Item_Data *item_data = (Item_Data*)data;
1612         free(item_data);
1613
1614         return;
1615 }
1616
1617 static Eina_Bool __cal_edit_get_genlist_item_state(void *data, Evas_Object *obj, const char *part)
1618 {
1619         return EINA_FALSE;
1620 }
1621
1622
1623 static void __cal_edit_alarm_callback(void *data, Evas_Object *obj, void *ei)
1624 {
1625         c_retm_if(!data, "data is null");
1626
1627         Item_Data * item_data = data;
1628
1629         cal_edit_data *p = item_data->p;
1630         c_retm_if(!p, "p is null");
1631
1632         item_data->alarm_value = cal_edit_alarm_get_alarm(p->ly_alarm);
1633
1634         if (item_data->it)
1635                 elm_genlist_item_update(item_data->it);
1636
1637         elm_naviframe_item_pop(p->nv);
1638 }
1639
1640 static void __cal_edit_repeat_callback(void *data, Evas_Object *obj, void *ei)
1641 {
1642         cal_edit_data *p = data;
1643
1644         p->repeat = cal_edit_repeat_get_repeat(p->ly_repeat, &p->repeat_week, &(p->repeat_end_date_num), &(p->repeat_end_date_time),&(p->repeat_occurrences));
1645
1646         if(CAL_REPEAT_NONE != p->repeat)
1647         {
1648                 if (p->repeat == CAL_REPEAT_EVERY_WEEK)
1649                         __cal_edit_change_wday(p);
1650
1651                 if(1 != p->repeat_end_date_num)
1652                 {
1653                         if(timegm(&(p->repeat_end_date_time)) <= timegm(&p->stm))
1654                         {
1655                                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Repeat end time is invalid!",
1656                                         __cal_edit_reponse_event_callback, NULL, NULL);
1657                                 return;
1658                         }
1659                 }
1660                 else
1661                 {
1662                         DBG("p->repeat_occurrences is %d\n",p->repeat_occurrences);
1663                         if(p->repeat_occurrences == 0)
1664                         {
1665                                 cal_util_add_popup(p->win, S_("IDS_COM_POP_WARNING"), "Repeat occurrence is invalid!",
1666                                         __cal_edit_reponse_event_callback, NULL, NULL);
1667                                 return;
1668                         }
1669
1670                         time_t now;
1671                         time(&now);
1672                         struct tm *tm = localtime(&now);
1673                         if(NULL != tm)
1674                         {
1675                                 tm->tm_mon += 1;
1676                                 CAL_MEMCPY(&p->repeat_end_date_time, tm, struct tm);
1677                         }
1678                 }
1679                 __cal_edit_set_repeat_text(p);
1680         }
1681
1682         if(it)
1683         {
1684                 elm_genlist_item_update(it);
1685                 it = NULL;
1686         }
1687
1688         elm_naviframe_item_pop(p->nv);
1689
1690 }
1691
1692 static void __cal_edit_repeat_select_callback(Item_Data *item_data)
1693 {
1694         cal_edit_data *p = item_data->p;
1695         Evas_Object *btn_save;
1696         Evas_Object *btn_cancel;
1697         Elm_Object_Item* navi_item;
1698
1699         if (!p->nv)
1700                 p->nv = elm_naviframe_add(p->genlist);
1701
1702         p->ly_repeat = cal_edit_repeat_create_view(p->parent, p->ad, p->repeat, p->repeat_end_date_num, &(p->stm), &(p->repeat_end_date_time),&(p->repeat_occurrences), (int*)&(p->allday), p->repeat_week);
1703         CAL_ASSERT(p->ly_repeat);
1704
1705         it = item_data->it;
1706
1707         navi_item = elm_naviframe_item_push(p->nv, C_("IDS_CLD_BODY_REPEAT"), NULL, NULL, p->ly_repeat, NULL);
1708
1709         btn_save = elm_button_add(p->nv);
1710         cal_util_set_controlbar_button(btn_save, S_("IDS_COM_OPT_SAVE"), "naviframe/title/default", __cal_edit_repeat_callback, p);
1711         elm_object_item_part_content_set(navi_item, "title_right_btn", btn_save);
1712
1713         btn_cancel = elm_button_add(p->nv);
1714         cal_util_set_controlbar_button(btn_cancel,S_("IDS_COM_SK_CANCEL"),
1715                         "naviframe/title/default", __cal_edit_cancel_button_callback, p->nv);
1716         elm_object_item_part_content_set(navi_item, "title_left_btn", btn_cancel);
1717 }
1718
1719
1720 static void __cal_edit_ug_destroy_callback(struct ui_gadget *ug, void *priv)
1721 {
1722         CAL_FN_START;
1723
1724         cal_edit_data* p = (cal_edit_data*) priv;
1725
1726         if (p->ug_worldclock) {
1727                 ug_destroy(p->ug_worldclock);
1728                 p->ug_worldclock= NULL;
1729         }
1730
1731         Elm_Object_Item* navi_item = elm_naviframe_top_item_get(p->nv);
1732         Evas_Object *back_btn = elm_object_item_part_content_get(navi_item, "prev_btn");
1733         if (back_btn != NULL) {
1734                 elm_object_style_set(back_btn, "naviframe/back_btn/default");   /* take into effect */
1735         }
1736 }
1737
1738 static void __cal_edit_ug_result_callback(struct ui_gadget *ug, bundle *result, void *priv)
1739 {
1740         CAL_FN_START;
1741
1742         c_retm_if(!priv, "priv is null");
1743         c_retm_if(!result, "result is null");
1744
1745         cal_edit_data *p = priv;
1746
1747         const char* city = bundle_get_val(result, "city");
1748         c_retm_if(!city, "city is null");
1749
1750         const char* timezone = bundle_get_val(result, "timezone");
1751         c_retm_if(!timezone, "timezone is null");
1752
1753         const char* tzpath = bundle_get_val(result, "tzpath");
1754         c_retm_if(!tzpath, "tzpath is null");
1755
1756         if (timezone)
1757                 p->timezone = atoi(timezone);
1758
1759         if (p->timezone_city)
1760                 free(p->timezone_city);
1761
1762         p->timezone_city = strdup(C_(city));
1763
1764         if (p->timezone_path)
1765                 free(p->timezone_path);
1766
1767         p->timezone_path= strdup(tzpath);
1768
1769         if (p->timezone_offset)
1770                 free(p->timezone_offset);
1771
1772         p->timezone_offset= g_strdup_printf("GMT%s",timezone);
1773
1774         p->is_selected_timezone = EINA_TRUE;
1775
1776         elm_genlist_item_update(p->timezone_item);
1777 }
1778
1779 static void __cal_edit_ug_layout_callback(struct ui_gadget *ug, enum ug_mode mode, void *priv)
1780 {
1781         CAL_FN_START;
1782
1783         c_retm_if(!ug, "ug is null");
1784
1785         Evas_Object *base = ug_get_layout(ug);
1786         if (!base) {
1787                 ug_destroy(ug);
1788                 return;
1789         }
1790
1791         switch (mode)
1792         {
1793         case UG_MODE_FULLVIEW:
1794                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
1795                                 EVAS_HINT_EXPAND);
1796                 elm_win_resize_object_add(ug_get_window(), base);
1797                 evas_object_show(base);
1798                 break;
1799         default:
1800                 DBG("Unsupported ug layout");
1801                 break;
1802         }
1803
1804 }
1805
1806 static void __cal_edit_timezone_select_callback(Item_Data *item_data)
1807 {
1808         c_retm_if(!item_data, "item_data is null");
1809
1810         cal_edit_data *p = item_data->p;
1811         struct ug_cbs uc;
1812         struct ui_gadget *ug;
1813         memset(&uc, 0, sizeof(struct ug_cbs));
1814         uc.destroy_cb = __cal_edit_ug_destroy_callback;
1815         uc.layout_cb = __cal_edit_ug_layout_callback;
1816         uc.result_cb = __cal_edit_ug_result_callback;
1817         uc.priv = p;
1818
1819         ug = ug_create(NULL, "worldclock-efl", UG_MODE_FULLVIEW, NULL, &uc);
1820         p->ug_worldclock = ug;
1821 }
1822
1823 static void __cal_edit_alarm_select_callback(Item_Data *item_data)
1824 {
1825         c_retm_if(!item_data, "item_data is null");
1826
1827         Evas_Object *btn_save;
1828         Evas_Object *btn_cancel;
1829         Elm_Object_Item* navi_item;
1830         cal_edit_data *p = item_data->p;
1831
1832         c_retm_if(!p, "p is null");
1833         c_retm_if(!p->nv, "p->nv is null");
1834
1835         p->ly_alarm = cal_edit_alarm_create_view(p->win, item_data->alarm_value, p->ad);
1836         c_retm_if(!p->ly_alarm, "p->ly_alarm is null");
1837
1838         it = item_data->it;
1839
1840         navi_item = elm_naviframe_item_push(p->nv, S_("IDS_COM_BODY_ALARM"), NULL, NULL, p->ly_alarm, NULL);
1841
1842         btn_save = elm_button_add(p->nv);
1843         cal_util_set_controlbar_button(btn_save,S_("IDS_COM_OPT_SAVE"), "naviframe/title/default", __cal_edit_alarm_callback, item_data);
1844         elm_object_item_part_content_set(navi_item, "title_right_btn", btn_save);
1845
1846         btn_cancel = elm_button_add(p->nv);
1847         cal_util_set_controlbar_button(btn_cancel,S_("IDS_COM_SK_CANCEL"), "naviframe/title/default", __cal_edit_cancel_button_callback, p->nv);
1848         elm_object_item_part_content_set(navi_item, "title_left_btn", btn_cancel);
1849 }
1850
1851 static void __cal_edit_save_to_popup_list_sel(void *data, Evas_Object *obj, void *event_info)
1852 {
1853         c_retm_if(!data, "data is null");
1854         c_retm_if(!obj, "obj is null");
1855
1856         cal_struct* cs = data;
1857
1858         cal_edit_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
1859         c_retm_if(!p, "p is null");
1860
1861         Elm_Object_Item *item = elm_genlist_selected_item_get(obj);
1862         c_retm_if(!item, "elm_genlist_selected_item_get() returned null");
1863
1864         elm_genlist_item_selected_set(item, EINA_FALSE);
1865
1866         if (cs)
1867         {
1868                 p->calid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
1869                 p->accid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_ACCOUNT_ID);
1870         }
1871         else
1872         {
1873                 p->calid = DEFAULT_CALENDAR_ID;
1874                 p->accid = LOCAL_ACCOUNT_ID;
1875         }
1876
1877         elm_genlist_item_update(it);
1878
1879         evas_object_del(p->popup);
1880         p->popup = NULL;
1881 }
1882
1883 static void  __cal_edit_save_to_popup_hide_cb(void *data, Evas_Object *obj, void *event_info)
1884 {
1885         c_retm_if(!data, "data is null");
1886         c_retm_if(!obj, "obj is null");
1887
1888         Evas_Object *popup = data;
1889
1890         cal_edit_data *p = evas_object_data_get(popup, "data");
1891
1892         evas_object_del(popup);
1893
1894         c_retm_if(!p, "p is null");
1895
1896         p->popup = NULL;
1897 }
1898
1899 static Evas_Object* __cal_edit_create_save_to_popup(Item_Data *item_data)
1900 {
1901         c_retvm_if(!item_data, NULL, "item_data is null");
1902
1903         Evas_Object *popup = NULL;
1904         Evas_Object *genlist = NULL;
1905         cal_edit_data *p = item_data->p;
1906         c_retvm_if(!p, NULL, "p is null");
1907
1908         cal_struct *cs;
1909         Eina_List *l;
1910
1911         if (!p->calendar_list)
1912         {
1913                 p->calendar_list = CALENDAR_SVC_GET_CALENDARS(p->accid);
1914                 c_retvm_if(!p->calendar_list, NULL, "p->calendar_list is null");
1915         }
1916
1917         popup = cal_util_add_popup(p->ad->win, C_("IDS_ST_BODY_SAVE_TO"), NULL,
1918                 __cal_edit_save_to_popup_hide_cb, p, S_("IDS_COM_BODY_CLOSE"), NULL);
1919         c_retvm_if(!popup, NULL, "popup is null");
1920         elm_object_style_set(popup, "liststyle");
1921
1922         genlist = elm_genlist_add(popup);
1923         if (!genlist) {
1924                 ERR("elm_genlist_add(popup) returned null");
1925                 evas_object_del(popup);
1926                 return NULL;
1927         }
1928
1929         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1930         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
1931         evas_object_data_set(genlist, "priv", p);
1932
1933         EINA_LIST_FOREACH(p->calendar_list, l, cs)
1934         {
1935                 if (cs)
1936                         elm_genlist_item_append(genlist, &itc_2text_1icon_2, cs, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_save_to_popup_list_sel, cs);
1937         }
1938
1939         elm_object_content_set(popup, genlist);
1940         evas_object_show(genlist);
1941
1942         return popup;
1943 }
1944
1945 static void __cal_edit_show_save_to_popup(Item_Data *item_data)
1946 {
1947         c_retm_if(!item_data, "item_data is null");
1948
1949         it = item_data->it;
1950         c_retm_if(!it, "selected item is null");
1951
1952         cal_edit_data *p = item_data->p;
1953         c_retm_if(!p, "p is null");
1954
1955         Evas_Object *popup = __cal_edit_create_save_to_popup(item_data);
1956         c_retm_if(!popup, "popup is NULL");
1957
1958         p->popup = popup;
1959 }
1960
1961 static void __cal_edit_genlist_item_select_callback(void *data, Evas_Object *obj, void *event_info)
1962 {
1963         c_retm_if(!obj, "obj is null");
1964
1965         Elm_Object_Item *it = elm_genlist_selected_item_get(obj);
1966         c_retm_if(!it, "elm_genlist_selected_item_get() returned null");
1967
1968         Item_Data *item_data = (Item_Data *)elm_object_item_data_get(it);
1969         c_retm_if(!it, "elm_object_item_data_get() returned null");
1970
1971         int type = item_data->type;
1972
1973         cal_edit_data *p = item_data->p;
1974         c_retm_if(!p, "p is null");
1975
1976         switch ( type )
1977         {
1978         case _GTYPE_TITLE:
1979                 break;
1980         case _GTYPE_LOC:
1981                 break;
1982         case _GTYPE_START:
1983                 elm_object_focus_set(p->sdt, EINA_TRUE);
1984                 break;
1985         case _GTYPE_END:
1986                 elm_object_focus_set(p->edt, EINA_TRUE);
1987                 break;
1988         case _GTYPE_ALLDAY:
1989                 elm_check_state_set(p->c_allday, !elm_check_state_get(p->c_allday));
1990                 __cal_edit_all_day_changed_callback(p, p->c_allday, event_info);
1991                 break;
1992         case _GTYPE_TIME_ZONE:
1993                 __cal_edit_timezone_select_callback(item_data);
1994                 break;
1995         case _GTYPE_ALARM:
1996                 __cal_edit_alarm_select_callback(item_data);
1997                 break;
1998         case _GTYPE_REPEAT:
1999                 __cal_edit_repeat_select_callback(item_data);
2000                 break;
2001         case _GTYPE_NOTE:
2002                 break;
2003         case _GTYPE_LINKED_CAL:
2004                 __cal_edit_show_save_to_popup(item_data);
2005                 break;
2006         default:
2007                 break;
2008         }
2009
2010         elm_genlist_item_selected_set(it, EINA_FALSE);
2011
2012         return;
2013 }
2014
2015 static char *__cal_edit_get_genlist_save_to_item_label(void *data, Evas_Object *obj, const char *part)
2016 {
2017         c_retvm_if(!data, NULL, "data is null");
2018         c_retvm_if(!part, NULL, "part is null");
2019
2020         cal_struct *cs = (cal_struct*)data;
2021         const char *name;
2022         int cid;
2023         char* description;
2024
2025         if (!CAL_STRCMP(part,"elm.text.1")) {
2026                 if (!cs)
2027                         return strdup(C_("IDS_CLD_OPT_PHONE_CALENDAR"));
2028
2029                 cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
2030                 if (cid == DEFAULT_CALENDAR_ID)
2031                         return strdup(C_("IDS_CLD_OPT_PHONE_CALENDAR"));
2032
2033                 name = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_TABLE_TXT_NAME);
2034                 if (name)
2035                         return strdup(name);
2036
2037                 return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
2038         }
2039         else if (!CAL_STRCMP(part,"elm.text.2")) {
2040                 if (!cs)
2041                         return strdup(S_("IDS_COM_POP_NO_ACCOUNTS"));
2042
2043                 cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
2044                 if (cid == DEFAULT_CALENDAR_ID)
2045                         return strdup(C_("IDS_EMAIL_BODY_DEFAULT_ACCOUNT"));
2046
2047                 description = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_TABLE_TXT_DESCRIPTION);
2048                 if (description)
2049                         return strdup(description);
2050
2051                 return strdup(S_("IDS_COM_POP_NO_ACCOUNTS"));
2052         }
2053
2054         return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
2055 }
2056
2057 static Elm_Object_Item* __cal_edit_add_genlist_item(Evas_Object *genlist, Elm_Genlist_Item_Class *itc, int type, cal_edit_data *p)
2058 {
2059         c_retvm_if(!genlist, NULL, "genlist is null");
2060         c_retvm_if(!itc, NULL, "itc is null");
2061         c_retvm_if(!p, NULL, "p is null");
2062
2063         Item_Data *item_data = calloc(1, sizeof(Item_Data));
2064         c_retvm_if(!item_data, NULL, "calloc is failed");
2065
2066         item_data->p = p;
2067         item_data->type = type;
2068
2069         item_data->it = elm_genlist_item_append(genlist, itc, item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
2070         if (!item_data->it)
2071         {
2072                 ERR("elm_genlist_item_append returned null");
2073                 free(item_data);
2074                 return NULL;
2075         }
2076
2077         if ( type == _GTYPE_START || type == _GTYPE_END )
2078                 elm_genlist_item_select_mode_set( item_data->it, ELM_OBJECT_SELECT_MODE_NONE );
2079
2080         return item_data->it;
2081 }
2082
2083 static Elm_Object_Item* __cal_edit_add_genlist_alarm_item(Evas_Object *genlist, Elm_Genlist_Item_Class *itc, int type, cal_edit_data *p, int alarm)
2084 {
2085         c_retvm_if(!genlist, NULL, "genlist is null");
2086         c_retvm_if(!itc, NULL, "itc is null");
2087         c_retvm_if(!p, NULL, "p is null");
2088
2089         Item_Data *item_data = calloc(1, sizeof(Item_Data));
2090         c_retvm_if(!item_data, NULL, "calloc is failed");
2091
2092         item_data->p = p;
2093         item_data->type = type;
2094         item_data->alarm_value = alarm;
2095
2096         if (!p->alarm_first_it) {
2097                 item_data->it = elm_genlist_item_append(genlist, &itc_2text, item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
2098                 p->alarm_first_it = p->alarm_last_it = item_data->it;
2099         } else {
2100                 item_data->it = elm_genlist_item_insert_after(genlist, itc, item_data, NULL,p->alarm_last_it, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
2101                 p->alarm_last_it = item_data->it;
2102         }
2103
2104         if (!item_data->it)
2105         {
2106                 ERR("elm_genlist_item_append returned null");
2107                 free(item_data);
2108                 return NULL;
2109         }
2110
2111         return item_data->it;
2112 }
2113
2114
2115 static Elm_Object_Item* __cal_edit_add_separator(Evas_Object *genlist, cal_edit_data *p)
2116 {
2117         c_retvm_if(!genlist, NULL, "genlist is null");
2118         c_retvm_if(!p, NULL, "p is null");
2119
2120         Elm_Object_Item *git = __cal_edit_add_genlist_item(genlist, &itc_seperator, 0, p);
2121         c_retvm_if(!git, NULL, "__cal_edit_add_genlist_item returned null");
2122
2123         elm_genlist_item_select_mode_set(git, ELM_OBJECT_SELECT_MODE_NONE);
2124
2125         return git;
2126 }
2127
2128 static Elm_Object_Item* __cal_edit_set_title(Evas_Object *genlist, cal_edit_data *p)
2129 {
2130         __cal_edit_add_separator(genlist, p);
2131
2132         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_TITLE, p);
2133 }
2134
2135 static Elm_Object_Item* __cal_edit_set_location(Evas_Object *genlist, cal_edit_data *p)
2136 {
2137         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_LOC, p);
2138 }
2139
2140 static Elm_Object_Item* __cal_edit_set_start_date(Evas_Object *genlist, cal_edit_data *p)
2141 {
2142         __cal_edit_add_separator(genlist, p);
2143
2144         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_START, p);
2145 }
2146
2147 static Elm_Object_Item* __cal_edit_set_end_date(Evas_Object *genlist, cal_edit_data *p)
2148 {
2149         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_END, p);
2150 }
2151
2152 static Elm_Object_Item* __cal_edit_set_all_day(Evas_Object *genlist, cal_edit_data *p)
2153 {
2154         return __cal_edit_add_genlist_item(genlist, &itc_1text_1icon, _GTYPE_ALLDAY, p);
2155 }
2156
2157 static Elm_Object_Item* __cal_edit_set_time_zone(Evas_Object *genlist, cal_edit_data *p)
2158 {
2159         __cal_edit_add_separator(genlist, p);
2160
2161         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_TIME_ZONE, p);
2162 }
2163
2164 static void __cal_edit_set_alarm(Evas_Object *genlist, cal_edit_data *p)
2165 {
2166         __cal_edit_add_separator(genlist, p);
2167
2168         GList *temp = p->list_alm_min;
2169
2170         if (!temp)
2171                 p->alarm_first_it = p->alarm_last_it =
2172                         __cal_edit_add_genlist_alarm_item(genlist, &itc_2text_1btn, _GTYPE_ALARM, p,
2173                                                                                         (p->event_id?CAL_EDIT_ALARM_OFF:CAL_EDIT_ALARM_ON_TIME));
2174         else {
2175                 while (temp) {
2176                         __cal_edit_add_genlist_alarm_item(genlist, &itc_2text_1btn, _GTYPE_ALARM, p, (int)temp->data);
2177
2178                         temp = g_list_next(temp);
2179                 }
2180         }
2181 }
2182
2183 static Elm_Object_Item* __cal_edit_set_repeat(Evas_Object *genlist, cal_edit_data *p)
2184 {
2185         __cal_edit_add_separator(genlist, p);
2186
2187         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_REPEAT, p);
2188 }
2189
2190 static Elm_Object_Item* __cal_edit_set_note(Evas_Object *genlist, cal_edit_data *p)
2191 {
2192         __cal_edit_add_separator(genlist, p);
2193
2194         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_NOTE, p);
2195 }
2196
2197 static Elm_Object_Item* __cal_edit_set_save_to(Evas_Object *genlist, cal_edit_data *p)
2198 {
2199         __cal_edit_add_separator(genlist, p);
2200
2201         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_LINKED_CAL, p);
2202
2203 }
2204
2205 static void __cal_edit_set_edit(cal_edit_data *p)
2206 {
2207         time_t t;
2208
2209         if (p->ad)
2210         {
2211                 p->stm.tm_year = p->ad->base_tm.tm_year;
2212                 p->stm.tm_mon = p->ad->base_tm.tm_mon;
2213                 p->stm.tm_mday = p->ad->base_tm.tm_mday;
2214
2215                 if (-1 != p->ad->base_hour)
2216                 {
2217                         p->stm.tm_hour = p->ad->base_hour;
2218                         p->stm.tm_min = 0;
2219                 }
2220         }
2221
2222         if (p->stm.tm_min)
2223                 cal_util_update_tm_hour(&p->stm,1);
2224
2225         p->stm.tm_min = p->stm.tm_sec = 0;
2226
2227         t = mktime(&p->stm);
2228         t += 60 * 60; // add 1 hour
2229         localtime_r(&t, &p->etm);
2230
2231         p->allday = EINA_FALSE;
2232 }
2233
2234 static Eina_Bool __cal_edit_append_widget_idler(void* data)
2235 {
2236         c_retvm_if(!data, ECORE_CALLBACK_CANCEL, "data is null");
2237
2238         cal_edit_data *p = (cal_edit_data *)data;
2239         Evas_Object *genlist = p->genlist;
2240
2241         __cal_edit_set_note(genlist, p);
2242
2243         __cal_edit_set_save_to(genlist, p);
2244
2245         p->idler = NULL;
2246
2247         return ECORE_CALLBACK_CANCEL;
2248 }
2249
2250 static Evas_Object* __cal_edit_create_genlist(cal_edit_data* p)
2251 {
2252         Elm_Object_Item* item = NULL;
2253         Evas_Object *genlist = elm_genlist_add(p->ly);
2254         c_retvm_if(!genlist, NULL, "elm_genlist_add() is failed");
2255
2256         evas_object_data_set(genlist, "priv", p);
2257
2258         if (p->ad->theme)
2259                 elm_object_theme_set(genlist, p->ad->theme);
2260
2261         itc_seperator.item_style = "dialogue/separator/21/with_line";
2262         itc_seperator.func.text_get = NULL;
2263         itc_seperator.func.state_get = __cal_edit_get_genlist_item_state;
2264         itc_seperator.func.del = __cal_edit_genlist_item_delete;
2265
2266         itc_1icon.item_style = "dialogue/1icon";
2267         itc_1icon.func.text_get = __cal_edit_get_genlist_item_label;
2268         itc_1icon.func.del = __cal_edit_genlist_item_delete;
2269         itc_1icon.func.content_get = __cal_edit_get_genlist_item_icon;
2270
2271         itc_1text_1icon.item_style = "dialogue/1text.1icon";
2272         itc_1text_1icon.func.text_get = __cal_edit_get_genlist_item_label;
2273         itc_1text_1icon.func.del = __cal_edit_genlist_item_delete;
2274         itc_1text_1icon.func.content_get = __cal_edit_get_genlist_item_icon;
2275
2276         itc_2text.item_style = "dialogue/2text.3";
2277         itc_2text.func.text_get = __cal_edit_get_genlist_item_label;
2278         itc_2text.func.del = __cal_edit_genlist_item_delete;
2279         itc_2text.func.content_get = __cal_edit_get_genlist_item_icon;
2280         itc_2text.func.state_get = NULL;
2281
2282         itc_2text_1btn.item_style = "dialogue/2text.1icon.6";
2283         itc_2text_1btn.func.text_get = __cal_edit_get_genlist_item_label;
2284         itc_2text_1btn.func.content_get = __cal_edit_get_genlist_item_icon;
2285         itc_2text_1btn.func.state_get = NULL;
2286         itc_2text_1btn.func.del = __cal_edit_genlist_item_delete;
2287         itc_2text_1btn.decorate_item_style = "dialogue/edit/contact";
2288
2289         itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
2290         itc_2text_1icon_4.func.text_get = __cal_edit_get_genlist_item_label;
2291         itc_2text_1icon_4.func.del = __cal_edit_genlist_item_delete;
2292         itc_2text_1icon_4.func.content_get = __cal_edit_get_genlist_item_icon;
2293
2294         itc_2text_1icon_2.item_style = "dialogue/2text.1icon.2";
2295         itc_2text_1icon_2.func.text_get = __cal_edit_get_genlist_save_to_item_label;
2296         itc_2text_1icon_2.func.content_get = __cal_edit_add_save_to_icon;
2297
2298         itc_2text_2icon_4.item_style = "dialogue/2text.2icon.4";
2299         itc_2text_2icon_4.func.text_get = __cal_edit_get_genlist_item_label;
2300         itc_2text_2icon_4.func.del = __cal_edit_genlist_item_delete;
2301         itc_2text_2icon_4.func.content_get = __cal_edit_get_genlist_item_icon;
2302
2303         __cal_edit_set_title(genlist, p);
2304         __cal_edit_set_location(genlist, p);
2305         __cal_edit_set_start_date(genlist, p);
2306         __cal_edit_set_end_date(genlist, p);
2307         __cal_edit_set_all_day(genlist, p);
2308
2309         p->timezone_item = __cal_edit_set_time_zone(genlist, p);
2310
2311         __cal_edit_set_alarm(genlist, p);
2312
2313         item = __cal_edit_set_repeat(genlist, p);
2314         if (p->ad->edit_special_one)
2315                 elm_object_item_disabled_set(item, EINA_TRUE);
2316
2317         evas_object_show(genlist);
2318
2319         return genlist;
2320 }
2321
2322 static void __cal_edit_layout_rendering_callback(void *data, Evas *e, void *event_info)
2323 {
2324         CAL_FN_START;
2325
2326         c_retm_if(!data, "data is null");
2327
2328         cal_edit_data* p = data;
2329
2330         evas_event_callback_del(e, EVAS_CALLBACK_RENDER_FLUSH_POST, __cal_edit_layout_rendering_callback);
2331
2332         if (p->idler)
2333                 return;
2334
2335         if (!p->idler)
2336                 p->idler = ecore_idler_add(__cal_edit_append_widget_idler,p);
2337
2338         CAL_FN_END;
2339 }
2340
2341 static Evas_Object *__cal_edit_create_layout(struct appdata *ad, Evas_Object *parent)
2342 {
2343         c_retvm_if(!ad, NULL, "ad is null");
2344         c_retvm_if(!parent, NULL, "parent is null");
2345
2346         Evas *e;
2347         Evas_Object *ly;
2348         Evas_Object *cf;
2349         struct tm tm = {0};
2350         cal_edit_data *p = calloc(1, sizeof(cal_edit_data));
2351         c_retvm_if(!p, NULL, "calloc(1, sizeof(cal_edit_data)) returned null");
2352
2353         p->parent = parent;
2354         p->nv = ad->nv;
2355         p->win = ad->win;
2356         p->snote = ad->strnote;
2357         p->is_selected_timezone = EINA_FALSE;
2358         p->popup = NULL;
2359         p->alarm_count = 1;
2360         p->alarm_last_it = NULL;
2361         p->alarm_first_it = NULL;
2362         p->list_alm_min = NULL;
2363         p->add_button = NULL;
2364         time_t t = time(NULL);
2365         localtime_r(&t,&tm);
2366         tm.tm_mon += 1;
2367         CAL_MEMCPY(&p->repeat_end_date_time, &tm, struct tm);
2368
2369         ly = cal_util_add_layout(ad->nv, "edit");
2370         if (!ly)
2371         {
2372                 ERR("cal_util_add_layout return null");
2373                 free(p);
2374                 return NULL;
2375         }
2376
2377         e = evas_object_evas_get(ly);
2378         p->ad = ad;
2379         p->ly = ly;
2380         p->event_id = ad->cid;
2381         evas_object_data_set(ly, "priv", p);
2382
2383         if (ad->is_aul && ad->ical)
2384                 __cal_edit_fill_vcs_information(p);
2385         else {
2386                 if (p->event_id)
2387                         __cal_edit_fill_detail_information(p, p->event_id);
2388                 else {
2389                         __cal_edit_set_default_information(p);
2390                         __cal_edit_set_edit(p);
2391                 }
2392         }
2393
2394         p->genlist = __cal_edit_create_genlist(p);
2395         if (!p->genlist)
2396         {
2397                 evas_object_del(ly);
2398                 free(p);
2399                 return NULL;
2400         }
2401
2402         cf = elm_conformant_add(ad->win);
2403         if (!cf)
2404         {
2405                 ERR("elm_conformant_add(ad->win) is failed");
2406                 evas_object_del(ly);
2407                 free(p);
2408                 return NULL;
2409         }
2410
2411         evas_object_size_hint_weight_set(cf, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2412         evas_object_show(cf);
2413         elm_object_content_set(cf, p->genlist);
2414         elm_object_style_set(cf, "internal_layout");
2415         elm_object_part_content_set(ly, "sw", cf);
2416
2417         evas_object_event_callback_add(ly, EVAS_CALLBACK_DEL, __cal_edit_delete_layout, p);
2418         evas_event_callback_add(e, EVAS_CALLBACK_RENDER_FLUSH_POST, __cal_edit_layout_rendering_callback, p);
2419
2420         return ly;
2421 }
2422
2423 static void __cal_edit_back_button_callback(void *data, Evas_Object *obj, void *ei)
2424 {
2425         CAL_FN_START;
2426
2427         c_retm_if(!data, "data is null");
2428
2429         cal_edit_data *p = data;
2430         Elm_Object_Item* navi_item = NULL;
2431
2432         if ((NULL != p->ad->ug) && (UG_EDIT == p->ad->u_type))
2433         {
2434                 ug_destroy_me(p->ad->ug);
2435         }
2436         else
2437         {
2438                 if (p->ad->request_view == CV_EDIT)
2439                 {
2440                         if (elm_naviframe_top_item_get(p->ad->nv) != elm_naviframe_bottom_item_get(p->ad->nv))
2441                         {
2442                                 p->ad->request_view = CV_UNKNOWN;
2443                                 elm_win_lower(p->ad->win);
2444                         }
2445                         else
2446                                 elm_exit();
2447                 }
2448
2449                 elm_naviframe_prev_btn_auto_pushed_set(p->ad->nv, EINA_TRUE);
2450                 elm_naviframe_item_pop(p->ad->nv);
2451                 navi_item = elm_naviframe_top_item_get(p->ad->nv);
2452
2453                 if (p->ad->is_update_view)
2454                         edje_object_signal_emit(CAL_UTIL_GET_EDJ_DATA(p->parent), "update", "prog");
2455         }
2456 }
2457
2458 static void __cal_edit_add_controlbar( struct appdata *ad, Evas_Object *ly)
2459 {
2460         c_retm_if(!ad, "ad is null");
2461         c_retm_if(!ly, "ly is null");
2462
2463         Elm_Object_Item* navi_item;
2464         const char *title;
2465         Evas_Object *btn_save;
2466         Evas_Object *btn_cancel;
2467
2468         if (ad->cid)
2469                 title = S_("IDS_COM_SK_EDIT");
2470         else
2471                 title = S_("IDS_COM_SK_NEW");
2472
2473         elm_naviframe_prev_btn_auto_pushed_set(ad->nv, EINA_FALSE);
2474
2475         navi_item = elm_naviframe_item_push(ad->nv, title, NULL, NULL, ly, NULL);
2476         c_retm_if(!navi_item, "elm_naviframe_item_push returned null");
2477
2478         btn_save = elm_button_add(ad->nv);
2479         c_retm_if(!btn_save, "elm_button_add(ad->nv) returned null");
2480         cal_util_set_controlbar_button(btn_save, S_("IDS_COM_OPT_SAVE"), "naviframe/title/default", __cal_edit_save_button_callback, ly);
2481         elm_object_item_part_content_set(navi_item, "title_right_btn", btn_save);
2482
2483         btn_cancel = elm_button_add(ad->nv);
2484         c_retm_if(!btn_cancel, "elm_button_add(ad->nv) returned null");
2485         cal_util_set_controlbar_button(btn_cancel, S_("IDS_COM_SK_CANCEL"), "naviframe/title/default", __cal_edit_back_button_callback, CAL_UTIL_GET_PRIV_DATA(ly));
2486         elm_object_item_part_content_set(navi_item, "title_left_btn", btn_cancel);
2487 }
2488
2489 void cal_edit_create_view(struct appdata *ad, Evas_Object *parent)
2490 {
2491         CAL_FN_START;
2492
2493         c_retm_if(!ad, "ad is null");
2494         c_retm_if(!parent, "parent is null");
2495
2496         Evas_Object *ly = __cal_edit_create_layout(ad, parent);
2497         c_retm_if(!ly, "__cal_edit_create_layout(ad, parent) returned null");
2498
2499         __cal_edit_add_controlbar(ad, ly);
2500
2501         CAL_FN_END;
2502 }