src/view-edit.c

   1 /*
   2   *
   3   *  Copyright 2012  Samsung Electronics Co., Ltd
   4   *
   5   *  Licensed under the Flora License, Version 1.0 (the "License");
   6   *  you may not use this file except in compliance with the License.
   7   *  You may obtain a copy of the License at
   8   *
   9   *       http://www.tizenopensource.org/license
  10   *
  11   *  Unless required by applicable law or agreed to in writing, software
  12   *  distributed under the License is distributed on an "AS IS" BASIS,
  13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14   *  See the License for the specific language governing permissions and
  15   *  limitations under the License.
  16   */
  17
  18
  19 #include <ui-gadget-module.h>
  20 #include <appcore-efl.h>
  21 #include <vconf.h>
  22
  23 #include "view.h"
  24 #include "edit-alarm.h"
  25 #include "edit-repeat.h"
  26 #include "edit-map.h"
  27
  28 #include "acct-svc.h"
  29 #include "gi-timepicker.h"
  30
  31 #define INVALID_TIMEZONE_VALUE (100)
  32 #define CAL_REPEAT_EVERY_2_WEEK (CALS_FREQ_SECONDLY+1)
  33 #define CAL_REPEAT_EVERY_3_DAY (CAL_REPEAT_EVERY_2_WEEK+1)
  34
  35
  36 typedef struct {
  37         struct appdata *ad;
  38         Evas_Object *parent;
  39         Evas_Object *ly; // self
  40         Evas_Object *genlist;
  41         Evas_Object *nv; // navigatino bar
  42         Evas_Object *win;
  43         Evas_Object *popup;
  44
  45         Evas_Object *e_title; // entry title
  46         Evas_Object *entry_loc; // entry location
  47         Evas_Object *l_start; // layout start
  48         Evas_Object *l_end; // layout end
  49         Evas_Object *l_alarm; // layout alarm
  50         Evas_Object *l_repeat; // layout repeat_freq
  51         Evas_Object *l_saveto; // layout save event to
  52         Evas_Object *e_note; // entry note
  53         Evas_Object *mbe_part; // entry participants
  54         Elm_Object_Item *timezone_item; // timezone item
  55
  56         struct tm stm; // start
  57         struct tm etm; // end
  58         Eina_Bool allday;
  59         Evas_Object *ly_date;
  60
  61         Eina_Bool is_selected_timezone;
  62         char * timezone_path;
  63         char * timezone_city;
  64         char * timezone_offset;
  65
  66         int repeat_count;
  67         struct tm repeat_until;
  68
  69         GList  *list_alm_min;
  70         Evas_Object *ly_alarm;
  71
  72         int original_event_id;
  73         int repeat_freq; // repeat_freq off, daily, ...
  74         enum cals_range repeat_range;
  75         Evas_Object *ly_repeat;
  76
  77         int event_id;
  78         int calid;
  79         int accid;
  80         Evas_Object *ly_saveto;
  81
  82         cal_edit_data_loc loc_data;
  83
  84         Elm_Object_Item *sdt;
  85         Elm_Object_Item *edt;
  86         int cid;
  87
  88         Evas_Object *c_allday;
  89         char *stitle;
  90         const char *snote;
  91         int n_attenders;
  92
  93         ui_gadget_h ug_worldclock;
  94
  95         Ecore_Idler* idler;
  96
  97         Eina_List *calendar_list; //For save to
  98         int alarm_count;
  99         Elm_Object_Item *alarm_first_it;
 100         Elm_Object_Item *alarm_last_it;
 101         Evas_Object  *add_button;
 102         Elm_Object_Item *due_date;
 103         Evas_Object *due_check;
 104         Eina_Bool is_no_due_date;
 105
 106         Eina_Bool send_option;
 107         Evas_Object *c_send_option;
 108
 109         Eina_Bool is_todo_mode;
 110         cal_priority_type_t priority;
 111         int todo_status;
 112 }cal_edit_data;
 113
 114 enum cal_edit_alarm_value {
 115         CAL_EDIT_ALARM_OFF = -1,
 116         CAL_EDIT_ALARM_ON_TIME,
 117 };
 118
 119 enum genlist_item_type{
 120         _GTYPE_TITLE = 1,
 121         _GTYPE_LOC,
 122         _GTYPE_ALLDAY,
 123         _GTYPE_TIME_ZONE,
 124         _GTYPE_ALARM,
 125         _GTYPE_REPEAT,
 126         _GTYPE_NOTE,
 127
 128         _GTYPE_LINKED_CAL,
 129         _GTYPE_CHECK_DUE_DATE,
 130         _GTYPE_PRIORITY,
 131         _GTYPE_PRIORITY_ITEM,
 132         _GTYPE_MAX
 133 };
 134
 135 enum __cal_edit_wday {
 136         CAL_EDIT_WDAY_SUNDAY,
 137         CAL_EDIT_WDAY_MONDAY,
 138         CAL_EDIT_WDAY_TUESDAY,
 139         CAL_EDIT_WDAY_WEDNESDAY,
 140         CAL_EDIT_WDAY_THURSDAY,
 141         CAL_EDIT_WDAY_FRIDAY,
 142         CAL_EDIT_WDAY_SATURDAY,
 143         CAL_EDIT_WDAY_NODAY,
 144 };
 145
 146 typedef struct
 147 {
 148         cal_edit_data *p;
 149         int type;
 150         Elm_Object_Item *it;
 151         struct _acct *at;
 152         cal_struct* cs;
 153         int alarm_value;
 154         Evas_Object *obj;
 155         int priority_value;
 156 }Item_Data;
 157
 158 static Elm_Object_Item* it; // To update
 159 static Elm_Genlist_Item_Class itc_seperator, itc_1icon, itc_1text_1icon, itc_2text_1btn,itc_2text_plus_btn,itc_2text, itc_2text_1icon_2, itc_2text_1icon_4, itc_2text_2icon_4, itc_1text_1icon_2, itc_1text;
 160 static Elm_Object_Item* __cal_edit_add_genlist_item(Evas_Object *genlist, Elm_Genlist_Item_Class *itc, int type, cal_edit_data *p);
 161 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);
 162 static void __cal_edit_genlist_item_select_callback(void *data, Evas_Object *obj, void *event_info);
 163 static int __cal_edit_save_todo(cal_edit_data *p);
 164
 165
 166 static void __cal_edit_delete_layout(void *data, Evas *e, Evas_Object *obj, void *ei)
 167 {
 168         CAL_FN_START;
 169
 170         c_retm_if(!data, "data is null");
 171
 172         cal_edit_data *p = data;
 173
 174         struct appdata* ad = p->ad;
 175         c_retm_if(!ad, "ad is null");
 176
 177         Eina_List* list;
 178         cal_struct* cs;
 179         if (p->idler) {
 180                 ecore_idler_del(p->idler);
 181                 p->idler = NULL;
 182         }
 183
 184         if (p->timezone_city)
 185                 free(p->timezone_city);
 186         if (p->timezone_path)
 187                 free(p->timezone_path);
 188         if (p->timezone_offset)
 189                 free(p->timezone_offset);
 190
 191         if (p->calendar_list) {
 192                 EINA_LIST_FOREACH(p->calendar_list, list, cs) {
 193                         if (cs)
 194                                 CALENDAR_SVC_STRUCT_FREE(&cs);
 195                 }
 196                 eina_list_free(p->calendar_list);
 197         }
 198
 199         free(p->loc_data.addr);
 200
 201         if (ad->edit_special_one)
 202                 ad->edit_special_one = EINA_FALSE;
 203
 204         free(p);
 205 }
 206
 207 static void __cal_edit_cancel_button_callback(void *data, Evas_Object *obj, void *ei)
 208 {
 209         elm_naviframe_item_pop(data);
 210 }
 211
 212 static void __cal_edit_hide_imf(Evas_Object *entry)
 213 {
 214         Ecore_IMF_Context *imf;
 215
 216         imf = elm_entry_imf_context_get(entry);
 217         if (imf)
 218                 ecore_imf_context_input_panel_hide(imf);
 219 }
 220
 221 static inline void __cal_edit_set_time_text(cal_edit_data *p)
 222 {
 223         const char* date = NULL;
 224         const char* time = NULL;
 225
 226         date = CAL_UTIL_DATE_FORMAT_1;
 227
 228         if (!p->allday)
 229         {
 230                 if (p->ad->is_hour24)
 231                         time = CAL_UTIL_TIME_FORMAT_6;
 232                 else
 233                         time = CAL_UTIL_TIME_FORMAT_1;
 234         }
 235
 236         cal_util_set_time_text(CAL_UTIL_GET_EDJ_DATA(p->l_start), "text", date, time, &p->stm);
 237         cal_util_set_time_text(CAL_UTIL_GET_EDJ_DATA(p->l_end), "text", date, time, &p->etm);
 238 }
 239
 240 static inline cal_edit_data* __cal_edit_check_layout(Evas_Object *sc)
 241 {
 242         cal_edit_data *p;
 243
 244         p = CAL_UTIL_GET_PRIV_DATA(sc);
 245         if (!p)
 246                 return NULL;
 247
 248         return p;
 249 }
 250
 251 static inline void __cal_edit_fill_entry(char **str, cal_struct *cs, const char *field)
 252 {
 253         c_retm_if(!str, "str is null");
 254         c_retm_if(!cs, "cs is null");
 255
 256         free(*str);
 257
 258         *str = CALENDAR_SVC_STRUCT_GET_STR(cs, field);
 259
 260         if (*str)
 261                 *str = elm_entry_utf8_to_markup((*str));
 262 }
 263
 264 static inline void __cal_edit_fill_title(cal_edit_data *p, cal_struct *cs)
 265 {
 266         __cal_edit_fill_entry(&(p->stitle), cs, CAL_VALUE_TXT_SUMMARY);
 267
 268 }
 269
 270 static inline void __cal_edit_fill_location(cal_edit_data *p, cal_struct *cs)
 271 {
 272         __cal_edit_fill_entry(&(p->loc_data.addr), cs, CAL_VALUE_TXT_LOCATION);
 273
 274         p->loc_data.lat = CALENDAR_SVC_STRUCT_GET_DOUBLE(cs, CAL_VALUE_DBL_LATITUDE);
 275         p->loc_data.lon = CALENDAR_SVC_STRUCT_GET_DOUBLE(cs, CAL_VALUE_DBL_LONGITUDE);
 276 }
 277
 278 static void __cal_edit_fill_note(cal_edit_data *p, cal_struct *cs)
 279 {
 280         c_retm_if(!p, "p is null");
 281         c_retm_if(!cs, "cs is null");
 282
 283         char *str = CALENDAR_SVC_STRUCT_GET_STR(cs,CAL_VALUE_TXT_DESCRIPTION);
 284         if (str)
 285                 p->snote = strdup(str);
 286 }
 287
 288 static void __cal_edit_fill_time(cal_edit_data *p, cal_struct *cs)
 289 {
 290         c_retm_if(!p, "p is null");
 291         c_retm_if(!cs, "cs is null");
 292
 293         cal_main_set_cs(p->ad, cs);
 294
 295         p->stm = p->ad->tm_start;
 296         p->etm = p->ad->tm_end;
 297
 298         if (CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_TYPE) == CALS_TIME_LOCALTIME)
 299                 p->allday = 1;
 300
 301         p->timezone_path = CAL_STRDUP(CALENDAR_SVC_STRUCT_GET_STR(cs, CALS_VALUE_TXT_DTSTART_TZID));
 302         if (!CAL_STRLEN(p->timezone_path)) {
 303                 int timezone_table_index = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_TIMEZONE);
 304                 c_ret_if(timezone_table_index < 0);
 305
 306                 cal_struct *timezone = NULL;
 307                 cal_error err = CALENDAR_SVC_GET(CAL_STRUCT_TIMEZONE, timezone_table_index, NULL, &timezone);
 308                 c_retm_if(err != CAL_SUCCESS, "CALENDAR_SVC_GET() is failed(%d)", err);
 309
 310                 int timezone_offset = (-1)*CALENDAR_SVC_STRUCT_GET_INT(timezone, CAL_TZ_VALUE_INT_TZ_OFFSET);
 311
 312                 CALENDAR_SVC_STRUCT_FREE(&timezone);
 313
 314                 cal_util_get_timezone_id(timezone_offset, &p->timezone_path);
 315                 c_ret_if(!CAL_STRLEN(p->timezone_path));
 316
 317                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_DTSTART_TZID, p->timezone_path);
 318                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_DTEND_TZID, p->timezone_path);
 319         }
 320
 321         cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
 322 }
 323
 324 static void __cal_edit_fill_alarm(cal_edit_data *p, cal_struct *cs)
 325 {
 326         c_retm_if(!p, "p is null");
 327         c_retm_if(!cs, "cs is null");
 328
 329         if (p->list_alm_min) {
 330                 g_list_free(p->list_alm_min);
 331                 p->list_alm_min = NULL;
 332         }
 333
 334         GList *al = NULL;
 335
 336         int r = CALENDAR_SVC_STRUCT_GET_LIST(cs, CAL_VALUE_LST_ALARM, &al);
 337         c_retm_if(r != CAL_SUCCESS, "CALENDAR_SVC_STRUCT_GET_LIST(CAL_VALUE_LST_ALARM) is failed(%d)", r);
 338         if (!al) {
 339                 p->alarm_count = 1;
 340                 return;
 341         }
 342
 343         p->alarm_count = 0;
 344
 345         while (al) {
 346
 347                 cal_value *val = al->data;
 348                 c_retm_if(!val, "val is null");
 349
 350                 p->alarm_count++;
 351
 352                 int tick = CALENDAR_SVC_VALUE_GET_INT(val, CAL_VALUE_INT_ALARMS_TICK);
 353                 cal_sch_remind_tick_unit_t unit = CALENDAR_SVC_VALUE_GET_INT(val, CAL_VALUE_INT_ALARMS_TICK_UNIT);
 354
 355                 int min = cal_edit_alarm_get_min(tick, unit);
 356                 p->list_alm_min = g_list_append(p->list_alm_min,(void *)min);
 357
 358                 al = g_list_next(al);
 359         }
 360
 361         p->list_alm_min = g_list_first(p->list_alm_min);
 362 }
 363
 364 static void __cal_edit_fill_repeat(cal_edit_data *p, cal_struct *cs)
 365 {
 366         c_ret_if(!p);
 367         c_ret_if(!cs);
 368
 369         cal_struct *original_cs = NULL;
 370
 371         p->original_event_id = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ORIGINAL_EVENT_ID);
 372         if (0 < p->original_event_id) {
 373                 int r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, p->original_event_id, NULL, &original_cs);
 374                 c_retm_if(r != CAL_SUCCESS, "CALENDAR_SVC_GET(%d) is failed(%d)", p->original_event_id, r);
 375         }
 376
 377         if (!original_cs)
 378                 original_cs = cs;
 379
 380         p->repeat_freq = CALENDAR_SVC_STRUCT_GET_INT(original_cs, CALS_VALUE_INT_RRULE_FREQ);
 381
 382         if (p->repeat_freq == CALS_FREQ_WEEKLY) {
 383
 384                 int interval = CALENDAR_SVC_STRUCT_GET_INT(original_cs, CALS_VALUE_INT_RRULE_INTERVAL);
 385                 if (2 == interval)
 386                         p->repeat_freq = CAL_REPEAT_EVERY_2_WEEK;
 387
 388         } else if (p->repeat_freq == CALS_FREQ_DAILY) {
 389
 390                 int interval = CALENDAR_SVC_STRUCT_GET_INT(original_cs, CALS_VALUE_INT_RRULE_INTERVAL);
 391                 if (3 == interval)
 392                         p->repeat_freq = CAL_REPEAT_EVERY_3_DAY;
 393         }
 394
 395         p->repeat_range = CALENDAR_SVC_STRUCT_GET_INT(original_cs, CALS_VALUE_INT_RRULE_RANGE_TYPE);
 396
 397         p->repeat_count = CALENDAR_SVC_STRUCT_GET_INT(original_cs,CALS_VALUE_INT_RRULE_COUNT);
 398
 399         cal_util_convert_lli_to_tm(NULL, CALENDAR_SVC_STRUCT_GET_LLI(original_cs, CALS_VALUE_LLI_RRULE_UNTIL_UTIME), &p->repeat_until);
 400
 401         if (original_cs != cs)
 402                 CALENDAR_SVC_STRUCT_FREE(&original_cs);
 403 }
 404
 405 static void __cal_edit_fill_save_to(cal_edit_data *p, cal_struct *cs)
 406 {
 407         int index = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_CALENDAR_ID);
 408         if (index < 1)
 409                 p->calid = DEFAULT_CALENDAR_ID;
 410         else
 411                 p->calid = index;
 412
 413         index = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID);
 414         if (index < ALL_VISIBILITY_ACCOUNT)
 415                 p->accid = LOCAL_ACCOUNT_ID;
 416         else
 417                 p->accid = index;
 418 }
 419
 420 static void __cal_edit_fill_vcs_information(cal_edit_data *p)
 421 {
 422         CAL_ASSERT(p);
 423         struct appdata* ad = p->ad;
 424         CAL_ASSERT(ad);
 425
 426         cal_struct* cs = p->ad->ical;
 427
 428         __cal_edit_fill_title(p, cs);
 429         __cal_edit_fill_location(p, cs);
 430         __cal_edit_fill_time(p, cs);
 431         __cal_edit_fill_alarm(p, cs);
 432         __cal_edit_fill_repeat(p, cs);
 433         __cal_edit_fill_save_to(p, cs);
 434         __cal_edit_fill_note(p, cs);
 435
 436         return;
 437 }
 438
 439
 440 static void __cal_edit_fill_detail_information(cal_edit_data *p, int cid)
 441 {
 442         int r;
 443         cal_struct *cs;
 444
 445         p->event_id = cid;
 446
 447         cs = NULL;
 448         r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, p->event_id, NULL, &cs);
 449         if (r != CAL_SUCCESS)
 450         {
 451                 if (cs)
 452                         CALENDAR_SVC_STRUCT_FREE(&cs);
 453
 454                 return;
 455         }
 456
 457         __cal_edit_fill_title(p, cs);
 458         __cal_edit_fill_location(p, cs);
 459         __cal_edit_fill_time(p, cs);
 460         __cal_edit_fill_alarm(p, cs);
 461         __cal_edit_fill_repeat(p, cs);
 462         __cal_edit_fill_save_to(p, cs);
 463         __cal_edit_fill_note(p, cs);
 464
 465         p->accid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID);
 466
 467         CALENDAR_SVC_STRUCT_FREE(&cs);
 468
 469         return;
 470 }
 471
 472 static inline cal_struct* __cal_edit_get_cs(int cid)
 473 {
 474         cal_struct *cs;
 475
 476         if (cid == 0)
 477                 cs = CALENDAR_SVC_STRUCT_NEW(CAL_STRUCT_SCHEDULE);
 478         else
 479         {
 480                 int r;
 481                 cs = NULL;
 482                 r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, cid, NULL, &cs);
 483                 if (r != CAL_SUCCESS)
 484                 {
 485                         if(cs)
 486                                 CALENDAR_SVC_STRUCT_FREE(&cs);
 487
 488                         cs = NULL;
 489                 }
 490         }
 491
 492         return cs;
 493 }
 494
 495 static inline void __cal_edit_fill_cs_title(cal_edit_data *p, cal_struct *cs)
 496 {
 497         if(p->stitle)
 498                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_SUMMARY, p->stitle);
 499         else
 500                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_SUMMARY, "");
 501 }
 502
 503 static inline void __cal_edit_fill_cs_location(cal_edit_data *p, cal_struct *cs)
 504 {
 505         if (p->loc_data.addr)
 506                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_LOCATION, p->loc_data.addr);
 507         else
 508                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_LOCATION, "");
 509
 510         CALENDAR_SVC_STRUCT_SET_DOUBLE(cs, CAL_VALUE_DBL_LATITUDE, p->loc_data.lat);
 511         CALENDAR_SVC_STRUCT_SET_DOUBLE(cs, CAL_VALUE_DBL_LONGITUDE, p->loc_data.lon);
 512 }
 513
 514 static inline void __cal_edit_fill_cs_note(cal_edit_data *p, cal_struct *cs)
 515 {
 516         if (p->snote)
 517                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_DESCRIPTION, p->snote);
 518         else
 519                 CALENDAR_SVC_STRUCT_SET_STR(cs, CAL_VALUE_TXT_DESCRIPTION, "");
 520 }
 521
 522 static void __cal_edit_fill_cs_time(cal_edit_data *p, cal_struct *cs)
 523 {
 524         c_ret_if(!p);
 525         c_ret_if(!p->timezone_path);
 526         c_ret_if(!cs);
 527
 528         CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_DTSTART_TZID, p->timezone_path);
 529         CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_DTEND_TZID, p->timezone_path);
 530
 531         long long int lli_start, lli_end;
 532
 533         cal_util_convert_tm_to_lli(p->timezone_path, &p->stm, &lli_start);
 534         cal_util_convert_tm_to_lli(p->timezone_path, &p->etm, &lli_end);
 535
 536         if (p->allday) {
 537
 538                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTSTART_TYPE, p->allday);
 539                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTEND_TYPE, p->allday);
 540
 541                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTSTART_YEAR, p->stm.tm_year + 1900);
 542                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTSTART_MONTH, p->stm.tm_mon + 1);
 543                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTSTART_MDAY, p->stm.tm_mday);
 544
 545                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTEND_YEAR, p->etm.tm_year + 1900);
 546                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTEND_MONTH, p->etm.tm_mon + 1);
 547                 CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_DTEND_MDAY, p->etm.tm_mday);
 548
 549         } else {
 550
 551                 CALENDAR_SVC_STRUCT_SET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME, lli_start);
 552                 CALENDAR_SVC_STRUCT_SET_LLI(cs, CALS_VALUE_LLI_DTEND_UTIME, lli_end);
 553         }
 554
 555 }
 556
 557 static int __cal_edit_g_list_compare(const void* data1, const void* data2)
 558 {
 559         return (int)data1 - (int)data2;
 560 }
 561
 562 static int __cal_edit_g_list_compare_with_data(const void* data1, const void* data2, void* user_data)
 563 {
 564         return (int)data1 - (int)data2;
 565 }
 566
 567 static void __cal_edit_fill_cs_alarm(cal_edit_data *p, cal_struct *cs)
 568 {
 569         c_retm_if(!p, "p is null");
 570         c_retm_if(!cs, "cs is null");
 571
 572         int tick;
 573         cal_sch_remind_tick_unit_t unit;
 574         GList *al = NULL, *temp  = NULL;
 575
 576         int count = 1;
 577
 578         Elm_Object_Item *it = p->alarm_first_it;
 579         while (it && (count++ <= p->alarm_count)) {
 580
 581                 Item_Data *item_data = elm_object_item_data_get(it);
 582                 c_retm_if(!item_data, "item_data is null");
 583
 584                 if (g_list_find_custom(temp, (const void*)item_data->alarm_value, __cal_edit_g_list_compare))
 585                         continue;
 586
 587                 temp = g_list_insert_sorted_with_data(temp, (void*)item_data->alarm_value, __cal_edit_g_list_compare_with_data, NULL);
 588
 589                 cal_edit_alarm_get_tick(item_data->alarm_value, &tick, &unit);
 590
 591                 if (tick != -1) {
 592                         cal_value *val = CALENDAR_SVC_VALUE_NEW(CAL_VALUE_LST_ALARM);
 593                         c_retm_if(!val, "CALENDAR_SVC_VALUE_NEW is failed");
 594
 595                         CALENDAR_SVC_VALUE_SET_INT(val, CAL_VALUE_INT_ALARMS_TICK, tick);
 596                         CALENDAR_SVC_VALUE_SET_INT(val, CAL_VALUE_INT_ALARMS_TICK_UNIT, unit);
 597                         al = g_list_append(al, val);
 598                 }
 599
 600                 if (count-1 == p->alarm_count)
 601                         p->alarm_last_it = it;
 602
 603                 it = elm_genlist_item_next_get(it);
 604         }
 605
 606         CALENDAR_SVC_STRUCT_SET_LIST(cs, CAL_VALUE_LST_ALARM, al);
 607 }
 608
 609 static inline void __cal_edit_get_week_string(int week, char *week_s)
 610 {
 611         c_retm_if(!week_s,"week_s is null");
 612
 613         int i;
 614
 615         memset(week_s, 0, 7);
 616         week_s[7] = '\0';
 617
 618         for (i = 0; i < 7; i++) {
 619                 if ((week >> i) & 1)
 620                         week_s[i] = '1';
 621                 else
 622                         week_s[i] = '0';
 623         }
 624 }
 625
 626 static void __cal_edit_set_rrule_wday(cal_struct *cs, enum __cal_edit_wday tm_wday)
 627 {
 628         c_ret_if(!cs);
 629
 630         switch (tm_wday) {
 631         case CAL_EDIT_WDAY_SUNDAY:
 632                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "SU");
 633                 break;
 634         case CAL_EDIT_WDAY_MONDAY:
 635                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "MO");
 636                 break;
 637         case CAL_EDIT_WDAY_TUESDAY:
 638                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "TU");
 639                 break;
 640         case CAL_EDIT_WDAY_WEDNESDAY:
 641                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "WE");
 642                 break;
 643         case CAL_EDIT_WDAY_THURSDAY:
 644                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "TH");
 645                 break;
 646         case CAL_EDIT_WDAY_FRIDAY:
 647                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "FR");
 648                 break;
 649         case CAL_EDIT_WDAY_SATURDAY:
 650                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "SA");
 651                 break;
 652         default:
 653                 ERR("Error!!");
 654                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYDAY, "SU");
 655                 break;
 656         }
 657 }
 658
 659 static void __cal_edit_set_rrule_month(cal_struct *cs, int tm_mon)
 660 {
 661         c_ret_if(!cs);
 662
 663         char buffer[8] = {0};
 664
 665         snprintf(buffer, sizeof(buffer), "%d", tm_mon + 1);
 666
 667         CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYMONTH, buffer);
 668 }
 669
 670 static void __cal_edit_set_rrule_mday(cal_struct *cs, int tm_mday)
 671 {
 672         c_ret_if(!cs);
 673
 674         char buffer[8] = {0};
 675
 676         snprintf(buffer, sizeof(buffer), "%d", tm_mday);
 677
 678         CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_RRULE_BYMONTHDAY, buffer);
 679 }
 680
 681 static void __cal_edit_fill_cs_repeat(cal_edit_data *p, cal_struct *cs)
 682 {
 683         c_retm_if(!p, "p is null");
 684         c_retm_if(!cs, "cs is null");
 685
 686         switch (p->repeat_freq) {
 687                 case CALS_FREQ_ONCE:
 688                         break;
 689
 690                 case CALS_FREQ_DAILY:
 691                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_INTERVAL, 1);
 692                         break;
 693
 694                 case CAL_REPEAT_EVERY_3_DAY:
 695                         p->repeat_freq = CALS_FREQ_DAILY;
 696                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_INTERVAL, 3);
 697                         break;
 698
 699                 case CALS_FREQ_WEEKLY:
 700                         __cal_edit_set_rrule_wday(cs, p->stm.tm_wday);
 701                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_INTERVAL, 1);
 702                         break;
 703
 704                 case CAL_REPEAT_EVERY_2_WEEK:
 705                         p->repeat_freq = CALS_FREQ_WEEKLY;
 706                         __cal_edit_set_rrule_wday(cs, p->stm.tm_wday);
 707                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_INTERVAL, 2);
 708                         break;
 709
 710                 case CALS_FREQ_YEARLY:
 711                 case CALS_FREQ_MONTHLY:
 712                         __cal_edit_set_rrule_month(cs, p->stm.tm_mon);
 713                         __cal_edit_set_rrule_mday(cs, p->stm.tm_mday);
 714
 715                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_INTERVAL, 1);
 716                         break;
 717
 718                 default:
 719                         break;
 720         }
 721
 722         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_FREQ, p->repeat_freq);
 723
 724         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_RANGE_TYPE, p->repeat_range);
 725
 726         if (CALS_FREQ_ONCE != p->repeat_freq) {
 727
 728                 if (p->repeat_range == CALS_RANGE_COUNT)
 729                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_COUNT, p->repeat_count);
 730                 else if (p->repeat_range == CALS_RANGE_UNTIL) {
 731
 732                         CALENDAR_SVC_STRUCT_SET_INT(cs, CALS_VALUE_INT_RRULE_COUNT, 0);
 733
 734                         long long int lli;
 735                         cal_util_convert_tm_to_lli(NULL, &p->repeat_until, &lli);
 736                         CALENDAR_SVC_STRUCT_SET_LLI(cs, CALS_VALUE_LLI_RRULE_UNTIL_UTIME, lli);
 737                 }
 738         }
 739 }
 740
 741 static void __cal_edit_fill_cs_save_to(cal_edit_data *p, cal_struct *cs)
 742 {
 743         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_CALENDAR_ID, p->calid);
 744
 745         if (p->accid == ALL_ACCOUNT_ID)
 746                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID, LOCAL_ACCOUNT_ID);
 747         else
 748                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID, p->accid);
 749 }
 750
 751 static inline void __cal_edit_mark_deleted(GList *al)
 752 {
 753         GList *p;
 754         cal_value *val;
 755
 756         p = al;
 757         while (p) {
 758                 val = p->data;
 759                 CALENDAR_SVC_VALUE_SET_INT(val, CAL_VALUE_INT_DETAIL_DELETE, 1);
 760                 p = g_list_next(p);
 761         }
 762 }
 763
 764 Eina_Bool cal_edit_check_email_vailidity(const char* email)
 765 {
 766         c_retvm_if(!email, EINA_FALSE, "email is null");
 767
 768         const char* temp = strchr(email, '@');
 769         c_retvm_if(!temp, EINA_FALSE, "%s is invalid address", email);
 770         c_retvm_if(*(temp+1) == '.', EINA_FALSE, "%s is invalid address", email);
 771
 772         temp = strchr(temp, '.');
 773         c_retvm_if(!temp, EINA_FALSE, "%s is invalid address", email);
 774         c_retvm_if(strlen(temp) <= 1, EINA_FALSE, "%s is invalid address", email);
 775
 776         return EINA_TRUE;
 777 }
 778
 779 static inline void __cal_edit_fill_cs(cal_edit_data *p, cal_struct *cs)
 780 {
 781         __cal_edit_fill_cs_title(p, cs);
 782         __cal_edit_fill_cs_location(p, cs);
 783         __cal_edit_fill_cs_time(p, cs);
 784         __cal_edit_fill_cs_alarm(p, cs);
 785
 786         if (!p->ad->edit_special_one)
 787                 __cal_edit_fill_cs_repeat(p, cs);
 788
 789         __cal_edit_fill_cs_note(p, cs);
 790         __cal_edit_fill_cs_save_to(p, cs);
 791 }
 792
 793 static void __cal_edit_reponse_event_callback(void *data, Evas_Object *obj, void *ei)
 794 {
 795         c_retm_if(!data, "data is null");
 796
 797         Evas_Object *popup = data;
 798         evas_object_del(popup);
 799 }
 800
 801 static void __cal_edit_title_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
 802 {
 803         const char *str;
 804         Item_Data *item_data = (Item_Data *)data;
 805         cal_edit_data *p = item_data->p;
 806
 807         free(p->stitle);
 808
 809
 810         str = elm_entry_entry_get(p->e_title);
 811         if (!str || str[0] == '\0')
 812                 p->stitle = NULL;
 813         else
 814                 p->stitle = elm_entry_markup_to_utf8(str);
 815 }
 816
 817
 818 static Evas_Object * __cal_edit_add_title_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
 819 {
 820         c_retvm_if(!obj, NULL, "obj is null");
 821         c_retvm_if(!part, NULL, "part is null");
 822         c_retvm_if(!item_data, NULL, "item_data is null");
 823
 824         cal_edit_data *p = item_data->p;
 825         c_retvm_if(!p, NULL, "p is null");
 826
 827         if (!CAL_STRCMP(part, "elm.icon")) {
 828                 Evas_Object *ef = cal_util_add_edit_field(obj, S_("IDS_COM_BODY_DETAILS_TITLE"), C_("IDS_CLD_BODY_TAP_TO_ENTER_TITLE"), EINA_TRUE, EINA_TRUE);
 829                 c_retvm_if(!ef, NULL, "ef is null");
 830
 831                 Evas_Object *entry = elm_object_part_content_get(ef, "elm.swallow.content");
 832                 c_retvm_if(!entry, ef, "entry is null");
 833
 834                 p->e_title = entry;
 835                 if (p->stitle)
 836                         elm_entry_entry_set(p->e_title, p->stitle);
 837
 838                 evas_object_smart_callback_add(p->e_title, "changed", __cal_edit_title_entry_changed_callback, item_data);
 839
 840                 return ef;
 841         }
 842
 843         return NULL;
 844 }
 845
 846 static inline int _edit_safe_strcmp(char *s1, char *s2)
 847 {
 848         if (NULL == s1 || NULL == s2)
 849                 return !(s1 == s2);
 850         else
 851                 return strcmp(s1, s2);
 852 }
 853
 854 static void _edit_location_entry_changed_cb(void *data, Evas_Object *obj, void *event_info)
 855 {
 856         char *str;
 857         Item_Data *item_data = (Item_Data *)data;
 858         cal_edit_data *p = item_data->p;
 859
 860         str = elm_entry_markup_to_utf8(elm_entry_entry_get(p->entry_loc));
 861         if (str && *str) {
 862                 if (!_edit_safe_strcmp(str, p->loc_data.addr)) {
 863                         free(str);
 864                         return;
 865                 } else {
 866                         free(p->loc_data.addr);
 867                         p->loc_data.addr = str;
 868                 }
 869         } else {
 870                 free(p->loc_data.addr);
 871                 p->loc_data.addr = NULL;
 872         }
 873
 874         p->loc_data.lon = p->loc_data.lat = 0;
 875 }
 876
 877
 878 static Evas_Object * __cal_edit_add_location_icon(Evas_Object *obj, const char *part,  Item_Data *item_data)
 879 {
 880         Evas_Object *ly = NULL;
 881         Evas_Object *ef;
 882         Evas_Object *bt;
 883
 884         if (!CAL_STRCMP(part, "elm.icon"))
 885         {
 886                 ly = cal_util_add_layout(obj, "dialoguegroup/location");
 887                 if (!ly)
 888                         return NULL;
 889
 890                 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);
 891                 if (!ef) {
 892                         ERR("ef is null");
 893                         evas_object_del(ly);
 894                         return NULL;
 895                 }
 896
 897                 elm_object_part_content_set(ly, "editfield/sw", ef);
 898
 899                 item_data->p->entry_loc = elm_object_part_content_get(ef, "elm.swallow.content");
 900
 901                 if(item_data->p->loc_data.addr)
 902                         elm_entry_entry_set(item_data->p->entry_loc, item_data->p->loc_data.addr);
 903
 904                 evas_object_smart_callback_add(item_data->p->entry_loc, "changed", _edit_location_entry_changed_cb, item_data);
 905                 elm_entry_cnp_mode_set(item_data->p->entry_loc, ELM_CNP_MODE_PLAINTEXT);
 906         }
 907
 908         return ly;
 909 }
 910
 911 static void __cal_edit_start_date_changed_callback(void *data, struct tm* updated_tm)
 912 {
 913         c_retm_if(data == NULL, "data is null");
 914         cal_edit_data *p = data;
 915
 916         // Remember the time difference in before updating start time
 917         time_t start_t = mktime(&p->stm);
 918         time_t end_t = mktime(&p->etm);
 919         time_t diff = end_t - start_t;
 920
 921         // Update start time variable
 922         p->stm = *updated_tm;
 923
 924         // Calculate end time from start time to retain the time difference
 925         end_t = mktime(&p->stm) + diff;
 926         localtime_r(&end_t, &p->etm);
 927
 928         // Update end time on the screen
 929         cal_genlist_item_timepicker_update_value(p->edt, &p->etm);
 930 }
 931
 932 static void __cal_edit_end_date_changed_callback(void *data, struct tm* updated_tm)
 933 {
 934         c_retm_if(!data, "data is null");
 935         cal_edit_data *p = data;
 936
 937         p->etm = *updated_tm;
 938 }
 939
 940 static void __cal_edit_all_day_changed_callback(void *data, Evas_Object *obj, void *ei)
 941 {
 942         CAL_ASSERT(data);
 943         cal_edit_data *p = data;
 944
 945         CAL_ASSERT(p->ad);
 946
 947         p->allday = elm_check_state_get(obj);
 948
 949         cal_genlist_item_timepicker_update_mode(p->sdt, p->allday, p->ad->is_hour24);
 950         cal_genlist_item_timepicker_update_mode(p->edt, p->allday, p->ad->is_hour24);
 951 }
 952
 953 static Evas_Object * __cal_edit_add_all_day_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
 954 {
 955         CAL_ASSERT(obj);
 956         CAL_ASSERT(item_data);
 957
 958         if (!CAL_STRCMP(part, "elm.icon"))
 959         {
 960                 cal_edit_data *p = item_data->p;
 961                 Evas_Object *rd;
 962
 963                 rd = elm_check_add(obj);
 964                 elm_check_state_set(rd, p->allday);
 965                 elm_object_style_set(rd, "on&off");
 966                 p->c_allday = rd;
 967                 evas_object_smart_callback_add(rd, "changed", __cal_edit_all_day_changed_callback, p);
 968                 elm_check_state_set(p->c_allday, p->allday);
 969                 evas_object_propagate_events_set(rd, EINA_FALSE);
 970
 971                 return rd;
 972         }
 973
 974         return NULL;
 975 }
 976
 977 static void __cal_edit_note_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
 978 {
 979         const char *str;
 980         char *email_link = NULL;
 981         Item_Data *item_data = (Item_Data *)data;
 982         cal_edit_data *p = item_data->p;
 983         str = elm_entry_markup_to_utf8(elm_entry_entry_get(p->e_note));
 984
 985         if (NULL != p->snote && '\0' != p->snote[0])
 986         {
 987                 email_link = strstr(p->snote, EMAIL_LINK_FLAG);
 988         }
 989         if ((NULL != email_link)  && (NULL != str && str[0] != '\0') && (NULL != strstr(p->snote, str)))
 990         {
 991                 char *strnote = NULL;
 992                 int strnote_len = 0;
 993                 strnote_len = strlen(str) + strlen(email_link);
 994                 CAL_CALLOC(strnote, strnote_len+1, char);
 995                 if (NULL != strnote)
 996                 {
 997                         snprintf(strnote, strnote_len + 1, "%s%s", str, email_link);
 998                         p->snote = strdup(strnote);
 999
1000                         free(strnote);
1001                 }
1002                 else
1003                 {
1004                         p->snote = NULL;
1005                 }
1006
1007         }
1008         else
1009         {
1010                 if (!str || str[0] == '\0')
1011                         p->snote = NULL;
1012                 else
1013                         p->snote = str;
1014         }
1015 }
1016
1017
1018 static Evas_Object * __cal_edit_add_note_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
1019 {
1020         c_retvm_if(!obj , NULL, "obj is null");
1021         c_retvm_if(!part , NULL, "part is null");
1022         c_retvm_if(!item_data , NULL, "item_data is null");
1023
1024         cal_edit_data *p = item_data->p;
1025         c_retvm_if(!p , NULL, "p is null");
1026
1027         if (!CAL_STRCMP(part, "elm.icon")) {
1028                 Evas_Object *ef = cal_util_add_edit_field(obj, S_("IDS_COM_BODY_NOTE"), C_("IDS_CLD_BODY_TAP_TO_ENTER_NOTE"), EINA_FALSE, EINA_TRUE );
1029                 if (ef) {
1030                         Evas_Object *entry = elm_object_part_content_get(ef, "elm.swallow.content");
1031                         c_retvm_if(!entry, ef, "entry is null");
1032
1033                         evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1034                         evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_EXPAND);
1035                         //elm_entry_autocapital_type_set(entry, EINA_TRUE);
1036                         elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
1037
1038                         p->e_note = entry;
1039
1040                         if (p->snote) {
1041
1042                                 char *email_link = NULL;
1043                                 email_link = strstr(p->snote, EMAIL_LINK_FLAG);
1044                                 if(!email_link)
1045                                         elm_entry_entry_set(p->e_note, elm_entry_utf8_to_markup(p->snote));
1046                                 else {
1047
1048                                         char *snote_display = NULL;
1049                                         int nsize = email_link - p->snote + 1;
1050                                         snote_display = calloc(nsize, sizeof(char));
1051                                         c_retvm_if(!snote_display , NULL, "calloc(nsize, sizeof(char)) is failed");
1052
1053                                         CAL_STRNCPY(snote_display, p->snote, nsize-1);
1054
1055                                         elm_entry_entry_set(p->e_note, elm_entry_utf8_to_markup(snote_display));
1056                                         free(snote_display);
1057                                 }
1058                         }
1059
1060                         evas_object_smart_callback_add(p->e_note, "changed", __cal_edit_note_entry_changed_callback, item_data);
1061
1062                         return ef;
1063                 }
1064         }
1065
1066         return NULL;
1067 }
1068
1069 static void __cal_edit_set_default_information(cal_edit_data *p)
1070 {
1071         c_retm_if(!p, "p is null");
1072
1073         struct appdata *ad = p->ad;
1074         c_retm_if(!ad, "ad is null");
1075
1076         p->stm = ad->base_tm;
1077
1078         p->stm.tm_min = p->stm.tm_sec = 0;
1079
1080         if (0 <= ad->base_hour)
1081                 p->stm.tm_hour = ad->base_hour;
1082         else
1083                 cal_util_update_tm_hour(&p->stm,1);
1084
1085         p->etm = p->stm;
1086         cal_util_update_tm_hour(&p->etm,1);
1087
1088         p->allday = EINA_FALSE;
1089
1090         cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
1091
1092         p->repeat_freq = CALS_FREQ_ONCE;
1093         p->repeat_range = CALS_RANGE_NONE;
1094         p->repeat_count = 10;
1095         p->repeat_until = p->stm;
1096         cal_util_update_tm_month (&p->repeat_until, 1);
1097
1098         p->calid = DEFAULT_CALENDAR_ID;
1099         p->accid = ALL_ACCOUNT_ID;
1100 }
1101
1102 static Evas_Object* __cal_edit_add_save_to_icon(void *item_data, Evas_Object *obj, const char *part)
1103 {
1104         if (!item_data)
1105         {
1106                 ERR("item_data is null");
1107                 return NULL;
1108         }
1109
1110         Evas_Object *icon = NULL;
1111         char* default_icon_path = "/opt/apps/org.tizen.calendar/res/icons/all_calendar.png";
1112         char* icon_path = NULL;
1113         cal_struct* cs = (cal_struct*)item_data;
1114         Eina_Bool r = EINA_FALSE;
1115         int cid = 0;
1116         int aid = 0;
1117
1118         cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
1119         aid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_ACCOUNT_ID);
1120
1121         if (!CAL_STRCMP(part, "elm.icon"))
1122         {
1123                 icon = elm_icon_add(obj);
1124
1125                 if (!icon)
1126                 {
1127                         ERR("elm_icon_add fail");
1128                         return NULL;
1129                 }
1130
1131                 if ( cid == DEFAULT_CALENDAR_ID) {
1132                         r = elm_icon_file_set(icon, default_icon_path, NULL);
1133                         c_warn_if(!r, "elm_icon_file_set(%s) is failed", default_icon_path);
1134                 }
1135                 else {
1136                         icon_path = cal_account_svc_get_account_icon_path(aid);
1137                         if (icon_path) {
1138                                 r = elm_icon_file_set(icon, icon_path, NULL);
1139                                 c_warn_if(!r, "elm_icon_file_set(%s) is failed", default_icon_path);
1140                                 free(icon_path);
1141                         }
1142                         else {
1143                                 r = elm_icon_file_set(icon, default_icon_path, NULL);
1144                                 c_warn_if(!r, "elm_icon_file_set(%s) is failed", default_icon_path);
1145                         }
1146
1147                 }
1148
1149                 if (!r) {
1150                         ERR("");
1151                         evas_object_del(icon);
1152                         icon = NULL;
1153                 }
1154                 else
1155                         evas_object_show(icon);
1156         }
1157
1158         return icon;
1159 }
1160
1161 static void __cal_edit_alarm_plus_button_callback(void *data, Evas_Object *obj, void *event_info)
1162 {
1163         c_retm_if(!data, "data is null");
1164         c_retm_if(!obj, "obj is null");
1165         Item_Data * pData = data;
1166         Evas_Object *object = NULL;
1167         Evas_Object *button = NULL;
1168         Evas_Object *genlist = NULL;
1169
1170         c_retm_if(!pData->p, "pData->p is NULL");
1171         c_retm_if(!pData->p->genlist, "pData->p->genlist is NULL");
1172
1173         genlist = pData->p->genlist;
1174         pData->p->alarm_count++;
1175         if (pData->p->alarm_count >= 5) {
1176                 elm_object_disabled_set(pData->p->add_button, EINA_TRUE);
1177         }
1178
1179         Item_Data *new_item_data = calloc(1, sizeof(Item_Data));
1180         c_retm_if(!new_item_data, "calloc is failed");
1181
1182         new_item_data->p = pData->p;
1183         new_item_data->type = _GTYPE_ALARM;
1184         new_item_data->alarm_value = 0;
1185
1186         new_item_data->it = elm_genlist_item_insert_after(genlist, &itc_2text_1btn, new_item_data, NULL,pData->p->alarm_last_it, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
1187         if (!new_item_data->it)
1188         {
1189                 ERR("elm_genlist_item_append returned null");
1190                 free(new_item_data);
1191                 new_item_data = NULL;
1192                 return ;
1193         }
1194         pData->p->alarm_last_it = new_item_data->it;
1195
1196         object = new_item_data->obj;
1197         button = elm_button_add(object);
1198         c_retm_if(!button, "elm_button_add() is failed");
1199
1200         elm_object_style_set(button, "icon_minus");
1201         elm_object_part_content_set(object,"elm.icon",button);
1202         evas_object_data_set(object, "button", button);
1203         evas_object_propagate_events_set(button, EINA_FALSE);
1204         evas_object_smart_callback_add(button, "clicked", __cal_edit_alarm_plus_button_callback, new_item_data);
1205         evas_object_show(object);
1206 }
1207
1208 static void __cal_edit_alarm_minus_button_callback(void *data, Evas_Object *obj, void *event_info)
1209 {
1210         c_retm_if(!data, "data is null");
1211         c_retm_if(!obj, "obj is null");
1212         Item_Data * pData = (Item_Data *)data;
1213         Elm_Object_Item *it = NULL;
1214         c_retm_if(!pData->p, "pData->p is NULL");
1215
1216         pData->p->alarm_count--;
1217         if (elm_object_disabled_get(pData->p->add_button)) {
1218                 elm_object_disabled_set(pData->p->add_button, EINA_FALSE);
1219         }
1220         if (pData->it == pData->p->alarm_last_it) {
1221                 it = elm_genlist_item_prev_get(pData->it);
1222                 pData->p->alarm_last_it = it;
1223         }
1224         evas_object_smart_callback_del(obj, "clicked", __cal_edit_alarm_minus_button_callback);
1225         if (pData->it) {
1226                 elm_object_item_del(pData->it);
1227         }
1228 }
1229
1230 static Evas_Object *__cal_edit_add_alarm_button_plus_icon(Evas_Object *obj, const char *part, void * data)
1231 {
1232         Evas_Object *button = NULL;
1233
1234         c_retvm_if(!data, NULL, "data is null");
1235         cal_edit_data * p = ((Item_Data *)data)->p;
1236         ((Item_Data *)data)->obj = obj;
1237         c_retvm_if(!p, NULL, "p is null");
1238
1239         if (!strcmp(part, "elm.icon")) {
1240                 button = elm_button_add(obj);
1241                 c_retvm_if(!button, NULL, "elm_button_add() is failed");
1242
1243                 elm_object_style_set(button, "icon_plus");
1244                 evas_object_data_set(obj, "button", button);
1245                 evas_object_propagate_events_set(button, EINA_FALSE);
1246                 evas_object_smart_callback_add(button, "clicked", __cal_edit_alarm_plus_button_callback, data);
1247                 evas_object_show(button);
1248                 p->add_button = button;
1249                 if (p->alarm_count >= 5) {
1250                         elm_object_disabled_set(p->add_button, EINA_TRUE);
1251                 }
1252                 return button;
1253         }
1254         return NULL;
1255 }
1256
1257
1258 static Evas_Object *__cal_edit_add_alarm_button_icon(Evas_Object *obj, const char *part, void * data)
1259 {
1260         Evas_Object *button = NULL;
1261
1262         c_retvm_if(!data, NULL, "data is null");
1263         cal_edit_data * p = ((Item_Data *)data)->p;
1264         ((Item_Data *)data)->obj = obj;
1265         c_retvm_if(!p, NULL, "p is null");
1266
1267         if (p->is_todo_mode) {
1268                 return NULL;
1269         }
1270         if (!strcmp(part, "elm.icon")) {
1271                 button = elm_button_add(obj);
1272                 c_retvm_if(!button, NULL, "elm_button_add() is failed");
1273
1274                 elm_object_style_set(button, "icon_minus");
1275                 evas_object_data_set(obj, "button", button);
1276                 evas_object_propagate_events_set(button, EINA_FALSE);
1277                 evas_object_smart_callback_add(button, "clicked", __cal_edit_alarm_minus_button_callback, data);
1278                 evas_object_show(button);
1279                 return button;
1280         }
1281         return NULL;
1282 }
1283
1284 static Evas_Object *__cal_edit_get_genlist_item_plus_icon(void *data, Evas_Object *obj, const char *part)
1285 {
1286         Evas_Object *e_obj = NULL;
1287         Item_Data *item_data = (Item_Data*)data;
1288
1289         e_obj = __cal_edit_add_alarm_button_plus_icon(obj,part,item_data);
1290         return e_obj;
1291 }
1292
1293 static void __cal_edit_no_due_date_changed_callback(void *data, Evas_Object *obj, void *ei)
1294 {
1295         c_retm_if(!data, "data is NULL.");
1296         c_retm_if(!obj, "obj is NULL.");
1297
1298         cal_edit_data *p = data;
1299
1300         p->is_no_due_date = elm_check_state_get(obj);
1301
1302         c_retm_if(!p->due_date, "p->due_date is NULL.");
1303
1304         elm_object_item_disabled_set(p->due_date, p->is_no_due_date);
1305         cal_genlist_item_timepicker_disabled_set(p->due_date, p->is_no_due_date);
1306 }
1307
1308 static Evas_Object *__cal_edit_add_check_duedate_icon(Evas_Object *obj, const char *part, Item_Data *item_data)
1309 {
1310         c_retvm_if(!item_data, NULL, "item_data is NULL.");
1311         Evas_Object *icon_obj = NULL;
1312         if (!CAL_STRCMP(part, "elm.icon"))
1313         {
1314                 cal_edit_data *p = item_data->p;
1315                 c_retvm_if(!p, NULL, "p is NULL.");
1316                 icon_obj = elm_check_add(obj);
1317                 c_retvm_if(!icon_obj, NULL, "elm_check_add returned null");
1318                 p->due_check = icon_obj;
1319
1320                 evas_object_smart_callback_add(icon_obj, "changed", __cal_edit_no_due_date_changed_callback, p);
1321                 evas_object_propagate_events_set(icon_obj, p->is_no_due_date);
1322                 evas_object_data_set(icon_obj, "priv", p);
1323         }
1324         return icon_obj;
1325 }
1326
1327 static Evas_Object *__cal_edit_get_genlist_item_icon(void *data, Evas_Object *obj, const char *part)
1328 {
1329         Evas_Object *e_obj = NULL;
1330         Item_Data *item_data = (Item_Data*)data;
1331
1332         switch ( item_data->type)
1333         {
1334         case _GTYPE_TITLE:
1335                 e_obj = __cal_edit_add_title_icon(obj, part, item_data);
1336                 break;
1337         case _GTYPE_LOC:
1338                 e_obj = __cal_edit_add_location_icon(obj, part, item_data);
1339                 break;
1340         case _GTYPE_ALLDAY:
1341                 e_obj = __cal_edit_add_all_day_icon(obj, part, item_data);
1342                 break;
1343         case _GTYPE_NOTE:
1344                 e_obj = __cal_edit_add_note_icon(obj, part, item_data);
1345                 break;
1346
1347         case _GTYPE_ALARM:
1348                 e_obj = __cal_edit_add_alarm_button_icon(obj,part,item_data);
1349                 break;
1350         case _GTYPE_CHECK_DUE_DATE:
1351                 e_obj = __cal_edit_add_check_duedate_icon(obj, part, item_data);
1352                 break;
1353         default:
1354                 break;
1355         }
1356
1357         return e_obj;
1358 }
1359
1360 static void __cal_edit_get_alarm_text(Item_Data *data, char* buf, int buf_size)
1361 {
1362         c_retm_if(!data, "data is null");
1363         cal_edit_alarm_get_alarm_str(data->alarm_value, buf, buf_size);
1364 }
1365
1366 static Eina_Bool __cal_edit_check_alarm_time_passed(cal_edit_data *p, cal_struct *cs)
1367 {
1368         time_t alarm;
1369         time_t current_time = time(NULL);
1370         struct tm start_tm;
1371         char buf[32] = {0};
1372         Item_Data *item_data = NULL;
1373         Elm_Object_Item *it;
1374         c_retvm_if(!p, EINA_FALSE, "p is null");
1375         c_retvm_if(!p->genlist, EINA_FALSE, "genlist is null");
1376
1377         start_tm = p->stm;
1378         if (p->allday) {
1379                 start_tm.tm_hour = 0;
1380                 start_tm.tm_min = 0;
1381                 start_tm.tm_sec = 0;
1382         }
1383
1384         int count = 1;
1385
1386         it = p->alarm_first_it;
1387         while (it && (count++ <= p->alarm_count)) {
1388
1389                 item_data = elm_object_item_data_get(it);
1390                 c_retvm_if(!item_data, EINA_FALSE, "item_data is null");
1391
1392                 cal_edit_alarm_get_alarm_str(item_data->alarm_value, buf, sizeof(buf));
1393                 if (!strcmp(buf, S_("IDS_COM_BODY_OFF"))) {
1394                         it = elm_genlist_item_next_get(it);
1395                         continue;
1396                 }
1397
1398                 alarm = mktime(&start_tm)-item_data->alarm_value*60;
1399                 if (alarm < current_time)
1400                         return EINA_TRUE;
1401
1402                 it = elm_genlist_item_next_get(it);
1403         }
1404
1405         return EINA_FALSE;
1406 }
1407
1408 static void __cal_edit_show_result_popup(cal_edit_data *p,int result)
1409 {
1410         char buf[100]={0,};
1411
1412         // TODO: i18n
1413         switch(result)
1414         {
1415         case CAL_ERR_EVENT_START_DATE:
1416                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_INVALID_TIME"),
1417                         __cal_edit_reponse_event_callback, NULL, NULL);
1418                 break;
1419         case CAL_ERR_EVENT_END_DATE:
1420                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_END_TIME_SHOULD_BE_SET_AFTER_START_TIME"),
1421                         __cal_edit_reponse_event_callback, NULL, NULL);
1422                 break;
1423         case CAL_ERR_EVENT_REPEAT_END_DATE:
1424                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_INVALID_TIME"),
1425                         __cal_edit_reponse_event_callback, NULL, NULL);
1426                 break;
1427         case CAL_ERR_EVENT_DURATION:
1428                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_INVALID_TIME"),
1429                         __cal_edit_reponse_event_callback, NULL, NULL);
1430                 break;
1431         case CAL_ERR_EVENT_REPEAT_DURATION_TOO_SHORT:
1432                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_INVALID_TIME"),
1433                         __cal_edit_reponse_event_callback, NULL, NULL);
1434                 break;
1435         case CAL_ERR_DB_LOCK:
1436                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_CALENDAR_SYNC_IN_PROGRESS"),
1437                         __cal_edit_reponse_event_callback, NULL, NULL);
1438                 break;
1439         default:
1440                 snprintf(buf,100,"not saved(internal error-%d)!",result);
1441                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), buf,
1442                         __cal_edit_reponse_event_callback, NULL, NULL);
1443                 break;
1444         }
1445 }
1446
1447 int __cal_edit_save(cal_edit_data *p)
1448 {
1449         CAL_FN_START;
1450
1451         int r;
1452         cal_struct *cs = __cal_edit_get_cs(p->event_id);
1453         c_retv_if(!cs, -1);
1454
1455 //      if (__cal_edit_check_alarm_time_passed(p, cs) && p->repeat_freq == CALS_FREQ_ONCE) {
1456 //
1457 //              cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_BODY_ALARMTIME_WARNING"),
1458 //                      __cal_edit_reponse_event_callback, NULL, NULL);
1459 //
1460 //              CALENDAR_SVC_STRUCT_FREE(&cs);
1461 //
1462 //              return -1;
1463 //      }
1464
1465         if (mktime(&p->etm) < mktime(&p->stm)) {
1466                 __cal_edit_show_result_popup(p, CAL_ERR_EVENT_END_DATE);
1467                 return -1;
1468         }
1469
1470         __cal_edit_fill_cs(p, cs);
1471
1472         if (p->event_id) {
1473                 if (p->ad->edit_special_one) {
1474
1475                         long long int lli_start;
1476
1477                         cal_util_convert_tm_to_lli(NULL, &p->stm, &lli_start);
1478
1479                         r = calendar_svc_event_delete_normal_instance(p->event_id, lli_start);
1480                         c_retvm_if(r != CAL_SUCCESS, -1, "calendar_svc_event_delete_normal_instance(%d, %ld) is failed(%d)", p->event_id, lli_start, r);
1481
1482                         cal_struct *exception_cs = CALENDAR_SVC_STRUCT_NEW(CAL_STRUCT_SCHEDULE);
1483                         c_retv_if(!exception_cs, -1);
1484
1485                         CALENDAR_SVC_STRUCT_SET_INT(exception_cs, CAL_VALUE_INT_ORIGINAL_EVENT_ID, p->event_id);
1486
1487                         __cal_edit_fill_cs(p, exception_cs);
1488
1489                         r = CALENDAR_SVC_INSERT(exception_cs);
1490                         if (r <= 0) {
1491                                 __cal_edit_show_result_popup(p,r);
1492
1493                                 CALENDAR_SVC_STRUCT_FREE(&cs);
1494
1495                                 CALENDAR_SVC_STRUCT_FREE(&exception_cs);
1496
1497                                 return -1;
1498                         }
1499
1500                         cal_main_set_cs(p->ad, exception_cs);
1501
1502                         CALENDAR_SVC_STRUCT_FREE(&exception_cs);
1503
1504                 } else {
1505
1506                         r = CALENDAR_SVC_UPDATE(cs);
1507                         if (r != CAL_SUCCESS) {
1508
1509                                 __cal_edit_show_result_popup(p,r);
1510
1511                                 CALENDAR_SVC_STRUCT_FREE(&cs);
1512
1513                                 return -1;
1514                         }
1515                 }
1516
1517         } else {
1518
1519                 r = CALENDAR_SVC_INSERT(cs);
1520                 if (r <= 0) {
1521                         __cal_edit_show_result_popup(p,r);
1522
1523                         CALENDAR_SVC_STRUCT_FREE(&cs);
1524
1525                         return -1;
1526                 }
1527         }
1528
1529         CALENDAR_SVC_STRUCT_FREE(&cs);
1530
1531         return 0;
1532 }
1533
1534 static void __cal_edit_save_button_callback(void *data, Evas_Object *obj, void *ei)
1535 {
1536         CAL_FN_START;
1537
1538         c_retm_if(!data, "data is null");
1539
1540         Evas_Object *ly = data;
1541         Elm_Object_Item* navi_item = NULL;
1542         int r;
1543         cal_edit_data *p = CAL_UTIL_GET_PRIV_DATA(ly);
1544         c_retm_if(!p, "p is null");
1545
1546         if (!p->is_todo_mode)
1547                 r = __cal_edit_save(p);
1548         else
1549                 r = __cal_edit_save_todo(p);
1550
1551         c_retm_if(r, "cal_edit_save() is failed");
1552
1553         if ((NULL != p->ad->ug) && (UG_EDIT == p->ad->u_type))
1554         {
1555                 ug_destroy_me(p->ad->ug);
1556                 return;
1557         }
1558         else if (p->ad->request_view == CV_EDIT)
1559         {
1560                 if (elm_naviframe_top_item_get(p->ad->nv) != elm_naviframe_bottom_item_get(p->ad->nv))
1561                 {
1562                         p->ad->request_view = CV_UNKNOWN;
1563                         elm_win_lower(p->ad->win);
1564                 }
1565                 else
1566                         elm_exit();
1567         }
1568
1569         elm_naviframe_prev_btn_auto_pushed_set(p->ad->nv, EINA_TRUE);
1570         elm_naviframe_item_pop(p->ad->nv);
1571         navi_item = elm_naviframe_top_item_get(p->ad->nv);
1572
1573         struct appdata * ad = p->ad;
1574         c_retm_if(!ad, "ad is null");
1575
1576         ad->current_view = CV_UNKNOWN;
1577 }
1578
1579 static char* __cal_edit_add_allday_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1580 {
1581         if (!CAL_STRCMP(part, "elm.text"))
1582         {
1583                 return strdup(C_("IDS_COM_BODY_ALL_DAY"));
1584         }
1585
1586         return NULL;
1587 }
1588
1589 static char* __cal_edit_add_timezone_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1590 {
1591         CAL_ASSERT(item_data);
1592
1593         cal_edit_data *p = item_data->p;
1594
1595         if (!CAL_STRCMP(part, "elm.text.1"))
1596                 return strdup(C_("IDS_CLD_BODY_TIME_ZONE"));
1597
1598         if (!CAL_STRCMP(part, "elm.text.2")) {
1599                 if (!p->timezone_offset) {
1600                         ERR("p->timezone_offset is null");
1601                         return NULL;
1602                 }
1603
1604                 return g_strdup_printf("%s, %s", S_(p->timezone_city), p->timezone_offset);
1605         }
1606
1607         return NULL;
1608 }
1609
1610 static char* __cal_edit_add_alarm_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1611 {
1612         CAL_ASSERT(item_data);
1613
1614         cal_edit_data *p = item_data->p;
1615         CAL_ASSERT(p);
1616
1617         char buf[1024];
1618
1619         if (!CAL_STRCMP(part, "elm.text.1"))
1620         {
1621                 return strdup(C_("IDS_CLD_BODY_REMINDER"));
1622         }
1623         if (!CAL_STRCMP(part, "elm.text.2"))
1624         {
1625                 __cal_edit_get_alarm_text(item_data, buf, sizeof(buf));
1626                 return strdup(buf);
1627         }
1628
1629         return NULL;
1630 }
1631
1632 static void __cal_edit_get_freq_text(cal_edit_data *p, char* buf, int buf_size)
1633 {
1634         _cal_edit_repeat_get_freq_str(p->repeat_freq, buf, buf_size);
1635 }
1636
1637 static char* __cal_edit_add_repeat_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1638 {
1639         c_retv_if(!item_data ,NULL);
1640
1641         cal_edit_data *p = item_data->p;
1642         c_retv_if(!p, NULL);
1643
1644         if (!CAL_STRCMP(part, "elm.text.1")) {
1645                 return strdup(C_("IDS_CLD_BODY_REPEAT"));
1646         }
1647
1648         if (!CAL_STRCMP(part, "elm.text.2")) {
1649
1650                 char buf[1024] = {0};
1651
1652                 __cal_edit_get_freq_text(p, buf, sizeof(buf));
1653
1654                 return strdup(buf);
1655         }
1656
1657         return NULL;
1658 }
1659
1660 static void __cal_edit_get_save_to_str(int calid, char *buf, int sz)
1661 {
1662         cal_struct *cs = NULL;
1663         const char *str;
1664         int r;
1665
1666         r = CALENDAR_SVC_GET(CAL_STRUCT_CALENDAR, calid, NULL, &cs);
1667         if (r != CAL_SUCCESS)
1668         {
1669                 snprintf(buf, sz, "%s", _("Phone"));
1670                 if (cs)
1671                         CALENDAR_SVC_STRUCT_FREE(&cs);
1672
1673                 return;
1674         }
1675
1676         if (calid == DEFAULT_CALENDAR_ID)
1677                 str = C_("IDS_CLD_OPT_PHONE_CALENDAR");
1678         else
1679         {
1680                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_TABLE_TXT_NAME);
1681                 if (!str)
1682                         str = C_("IDS_CLD_OPT_PHONE_CALENDAR");
1683         }
1684
1685         snprintf(buf, sz, "%s", str);
1686
1687         CALENDAR_SVC_STRUCT_FREE(&cs);
1688 }
1689
1690 static char* __cal_edit_add_save_to_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1691 {
1692         CAL_FN_START;
1693
1694         char buf[1024];
1695         CAL_ASSERT(item_data);
1696
1697         cal_edit_data *p = item_data->p;
1698         CAL_ASSERT(p);
1699
1700         if (!CAL_STRCMP(part, "elm.text.1"))
1701         {
1702                 return strdup(C_("IDS_ST_BODY_SAVE_TO"));
1703         }
1704
1705         if (!CAL_STRCMP(part, "elm.text.2"))
1706         {
1707                 if ( p->calid == DEFAULT_CALENDAR_ID)
1708                         return strdup(C_("IDS_CLD_OPT_PHONE_CALENDAR"));
1709                 else
1710                 {
1711                         __cal_edit_get_save_to_str(p->calid, buf, sizeof(buf));
1712                         return strdup(buf);
1713                 }
1714         }
1715         return NULL;
1716 }
1717
1718 static char* __cal_edit_add_note_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1719 {
1720         cal_edit_data *p = item_data->p;
1721         if (!CAL_STRCMP(part, "elm.text.1"))
1722         {
1723                 return strdup(S_("IDS_COM_BODY_NOTE"));
1724         }
1725
1726         if (!CAL_STRCMP(part, "elm.text.2") && p->snote)
1727         {
1728                 return strdup(p->snote);
1729         }
1730
1731         return NULL;
1732 }
1733
1734 static char* __cal_edit_add_duedate_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1735 {
1736         if (!CAL_STRCMP(part, "elm.text.1"))
1737         {
1738                 return strdup(C_("IDS_CLD_BODY_DUE_DATE"));
1739         }
1740         return NULL;
1741 }
1742
1743 static char* __cal_edit_add_check_duedate_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1744 {
1745         if (!CAL_STRCMP(part, "elm.text")) {
1746                 return strdup(C_("IDS_TASK_MBODY_NO_DUE_DATE"));
1747         }
1748
1749         return NULL;
1750 }
1751
1752 static char* __cal_edit_add_priority_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1753 {
1754         c_retvm_if(!item_data, NULL, "item_data is null");
1755         cal_edit_data *p = item_data->p;
1756         c_retvm_if(!p, NULL, "p is null");
1757
1758
1759         if (!CAL_STRCMP(part, "elm.text.1")) {
1760                 return strdup(C_("IDS_CLD_BODY_PRIORITY"));
1761         }
1762
1763         if (!CAL_STRCMP(part, "elm.text.2")) {
1764                 switch (p->priority) {
1765                         case EVENT_PRIORITY_LOW:
1766                                 return strdup(S_("IDS_COM_BODY_LOW"));
1767                         case EVENT_PRIORITY_NORMAL:
1768                                 return strdup(C_("IDS_IDLE_BODY_NORMAL"));
1769                         case EVENT_PRIORITY_HIGH:
1770                                 return strdup(S_("IDS_COM_OPT_HIGH_M_QUALITY"));
1771                         default:
1772                                 return NULL;
1773                 }
1774         }
1775         return NULL;
1776 }
1777
1778 static char* __cal_edit_add_priority_item_text(Evas_Object *obj, const char *part, Item_Data *item_data)
1779 {
1780         c_retvm_if(!item_data, NULL, "item_data is null");
1781
1782         if (!CAL_STRCMP(part, "elm.text")) {
1783                 switch (item_data->priority_value) {
1784                         case EVENT_PRIORITY_LOW:
1785                                 return strdup(S_("IDS_COM_BODY_LOW"));
1786                         case EVENT_PRIORITY_NORMAL:
1787                                 return strdup(C_("IDS_IDLE_BODY_NORMAL"));
1788                         case EVENT_PRIORITY_HIGH:
1789                                 return strdup(S_("IDS_COM_OPT_HIGH_M_QUALITY"));
1790                         default:
1791                                 return NULL;
1792                 }
1793         }
1794         return NULL;
1795 }
1796
1797 static char *__cal_edit_get_genlist_item_label(void *data, Evas_Object *obj, const char *part)
1798 {
1799         Item_Data *item_data = (Item_Data*)data;
1800         int type = (int)item_data->type;
1801
1802         switch ( type ) {
1803                 case _GTYPE_TITLE:
1804                         break;
1805                 case _GTYPE_LOC:
1806                         break;
1807                 case _GTYPE_ALLDAY:
1808                         return __cal_edit_add_allday_text(obj, part, item_data);
1809                 case _GTYPE_TIME_ZONE:
1810                         return __cal_edit_add_timezone_text(obj, part, item_data);
1811                 case _GTYPE_ALARM:
1812                         return __cal_edit_add_alarm_text(obj, part, item_data);
1813                 case _GTYPE_REPEAT:
1814                         return __cal_edit_add_repeat_text(obj, part, item_data);
1815
1816                 case _GTYPE_LINKED_CAL:
1817                         return __cal_edit_add_save_to_text(obj, part, item_data);
1818                 case _GTYPE_NOTE:
1819                         return __cal_edit_add_note_text(obj, part, item_data);
1820                 case _GTYPE_CHECK_DUE_DATE:
1821                         return __cal_edit_add_check_duedate_text(obj, part, item_data);
1822                 case _GTYPE_PRIORITY:
1823                         return __cal_edit_add_priority_text(obj, part, item_data);
1824                 case _GTYPE_PRIORITY_ITEM:
1825                         return __cal_edit_add_priority_item_text(obj, part, item_data);
1826                 default:
1827                         break;
1828         }
1829
1830         return NULL;
1831 }
1832
1833 static void __cal_edit_genlist_item_delete(void *data, Evas_Object *obj)
1834 {
1835         Item_Data *item_data = (Item_Data*)data;
1836         free(item_data);
1837
1838         return;
1839 }
1840
1841 static Eina_Bool __cal_edit_get_genlist_item_state(void *data, Evas_Object *obj, const char *part)
1842 {
1843         return EINA_FALSE;
1844 }
1845
1846
1847 static void __cal_edit_alarm_callback(void *data, Evas_Object *obj, void *ei)
1848 {
1849         c_retm_if(!data, "data is null");
1850
1851         Item_Data * item_data = data;
1852
1853         cal_edit_data *p = item_data->p;
1854         c_retm_if(!p, "p is null");
1855
1856         item_data->alarm_value = cal_edit_alarm_get_alarm(p->ly_alarm);
1857
1858         if (item_data->it)
1859                 elm_genlist_item_update(item_data->it);
1860
1861         elm_naviframe_item_pop(p->nv);
1862 }
1863
1864 static void __cal_edit_repeat_callback(void *data, Evas_Object *obj, void *ei)
1865 {
1866         cal_edit_data *p = data;
1867
1868         enum cals_range range = CALS_RANGE_NONE;
1869         struct tm until = {0};
1870         int count = 0;
1871
1872         int repeat = cal_edit_repeat_get_repeat(p->ly_repeat, &range, &until, &count);
1873
1874         if (CALS_FREQ_ONCE != repeat) {
1875
1876                 if (range == CALS_RANGE_UNTIL) {
1877
1878                         if (timegm(&until) <= timegm(&p->stm)) {
1879                                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_BODY_REPEAT_WARNING"),
1880                                         __cal_edit_reponse_event_callback, NULL, NULL);
1881                                 return;
1882                         }
1883                 }
1884                 else if (range == CALS_RANGE_COUNT) {
1885
1886                         if (!count) {
1887                                 cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_BODY_REPEAT_WARNING"),
1888                                         __cal_edit_reponse_event_callback, NULL, NULL);
1889                                 return;
1890                         }
1891                 }
1892         }
1893
1894         p->repeat_freq = repeat;
1895         p->repeat_range = range;
1896         p->repeat_until = until;
1897         p->repeat_count = count;
1898
1899         if (it) {
1900                 elm_genlist_item_update(it);
1901                 it = NULL;
1902         }
1903
1904         elm_naviframe_item_pop(p->nv);
1905 }
1906
1907 static void __cal_edit_repeat_select_callback(Item_Data *item_data)
1908 {
1909         c_retm_if(!item_data, "item_data is null");
1910
1911         cal_edit_data *p = item_data->p;
1912         c_retm_if(!p, "p is null");
1913
1914         if (!p->nv)
1915                 p->nv = elm_naviframe_add(p->genlist);
1916
1917         p->ly_repeat = cal_edit_repeat_create_view(p->parent, p->ad, p->repeat_freq, p->repeat_range, &(p->stm), &(p->repeat_until),&(p->repeat_count));
1918         c_retm_if(!p->ly_repeat, "p->ly_repeat is null");
1919
1920         it = item_data->it;
1921
1922         Elm_Object_Item* navi_item = elm_naviframe_item_push(p->nv, C_("IDS_CLD_BODY_REPEAT"), NULL, NULL, p->ly_repeat, NULL);
1923
1924         Evas_Object *btn_save = elm_button_add(p->nv);
1925         cal_util_set_controlbar_button(btn_save, S_("IDS_COM_OPT_SAVE"), "naviframe/title/default", __cal_edit_repeat_callback, p);
1926         elm_object_item_part_content_set(navi_item, "title_left_btn", btn_save);
1927
1928         Evas_Object *btn_cancel = elm_button_add(p->nv);
1929         cal_util_set_controlbar_button(btn_cancel,S_("IDS_COM_SK_CANCEL"),
1930                         "naviframe/title/default", __cal_edit_cancel_button_callback, p->nv);
1931         elm_object_item_part_content_set(navi_item, "title_right_btn", btn_cancel);
1932 }
1933
1934
1935 static void __cal_edit_ug_destroy_callback(ui_gadget_h ug, void *priv)
1936 {
1937         CAL_FN_START;
1938
1939         cal_edit_data* p = (cal_edit_data*) priv;
1940
1941         if (p->ug_worldclock) {
1942                 ug_destroy(p->ug_worldclock);
1943                 p->ug_worldclock= NULL;
1944         }
1945
1946         Elm_Object_Item* navi_item = elm_naviframe_top_item_get(p->nv);
1947         Evas_Object *back_btn = elm_object_item_part_content_get(navi_item, "prev_btn");
1948         if (back_btn != NULL) {
1949                 elm_object_style_set(back_btn, "naviframe/back_btn/default");   /* take into effect */
1950         }
1951 }
1952
1953 static void __cal_edit_ug_result_callback(ui_gadget_h ug, service_h result, void *priv)
1954 {
1955         CAL_FN_START;
1956
1957         c_retm_if(!priv, "priv is null");
1958         c_retm_if(!result, "result is null");
1959
1960         cal_edit_data *p = priv;
1961
1962         if (p->timezone_city)
1963                 free(p->timezone_city);
1964
1965         if (p->timezone_path)
1966                 free(p->timezone_path);
1967
1968         if (p->timezone_offset)
1969                 free(p->timezone_offset);
1970
1971         char *tzpath = NULL;
1972
1973         int r = service_get_extra_data(result, "tzpath", &tzpath);
1974         c_ret_if(r != SERVICE_ERROR_NONE);
1975
1976         p->timezone_path= tzpath;
1977
1978         cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
1979
1980         p->is_selected_timezone = EINA_TRUE;
1981
1982         elm_genlist_item_update(p->timezone_item);
1983 }
1984
1985 static void __cal_edit_ug_layout_callback(ui_gadget_h ug, enum ug_mode mode, void *priv)
1986 {
1987         CAL_FN_START;
1988
1989         c_retm_if(!ug, "ug is null");
1990
1991         Evas_Object *base = ug_get_layout(ug);
1992         if (!base) {
1993                 ug_destroy(ug);
1994                 return;
1995         }
1996
1997         switch (mode)
1998         {
1999         case UG_MODE_FULLVIEW:
2000                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
2001                                 EVAS_HINT_EXPAND);
2002                 elm_win_resize_object_add(ug_get_window(), base);
2003                 evas_object_show(base);
2004                 break;
2005         default:
2006                 DBG("Unsupported ug layout");
2007                 break;
2008         }
2009
2010 }
2011
2012 static void __cal_edit_timezone_select_callback(Item_Data *item_data)
2013 {
2014         c_retm_if(!item_data, "item_data is null");
2015
2016         cal_edit_data *p = item_data->p;
2017         struct ug_cbs uc;
2018         ui_gadget_h ug;
2019         memset(&uc, 0, sizeof(struct ug_cbs));
2020         uc.destroy_cb = __cal_edit_ug_destroy_callback;
2021         uc.layout_cb = __cal_edit_ug_layout_callback;
2022         uc.result_cb = __cal_edit_ug_result_callback;
2023         uc.priv = p;
2024
2025         ug = ug_create(NULL, "worldclock-efl", UG_MODE_FULLVIEW, NULL, &uc);
2026         p->ug_worldclock = ug;
2027 }
2028
2029 static void __cal_edit_alarm_select_callback(Item_Data *item_data)
2030 {
2031         c_retm_if(!item_data, "item_data is null");
2032
2033         Evas_Object *btn_save;
2034         Evas_Object *btn_cancel;
2035         Elm_Object_Item* navi_item;
2036         cal_edit_data *p = item_data->p;
2037
2038         c_retm_if(!p, "p is null");
2039         c_retm_if(!p->nv, "p->nv is null");
2040
2041         p->ly_alarm = cal_edit_alarm_create_view(p->win, item_data->alarm_value, p->ad);
2042         c_retm_if(!p->ly_alarm, "p->ly_alarm is null");
2043
2044         it = item_data->it;
2045
2046         navi_item = elm_naviframe_item_push(p->nv, C_("IDS_CLD_BODY_REMINDER"), NULL, NULL, p->ly_alarm, NULL);
2047
2048         btn_save = elm_button_add(p->nv);
2049         cal_util_set_controlbar_button(btn_save,S_("IDS_COM_OPT_SAVE"), "naviframe/title/default", __cal_edit_alarm_callback, item_data);
2050         elm_object_item_part_content_set(navi_item, "title_left_btn", btn_save);
2051
2052         btn_cancel = elm_button_add(p->nv);
2053         cal_util_set_controlbar_button(btn_cancel,S_("IDS_COM_SK_CANCEL"), "naviframe/title/default", __cal_edit_cancel_button_callback, p->nv);
2054         elm_object_item_part_content_set(navi_item, "title_right_btn", btn_cancel);
2055 }
2056
2057
2058 static void __cal_edit_save_to_popup_list_sel(void *data, Evas_Object *obj, void *event_info)
2059 {
2060         c_retm_if(!data, "data is null");
2061         c_retm_if(!obj, "obj is null");
2062
2063         cal_struct* cs = data;
2064
2065         cal_edit_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
2066         c_retm_if(!p, "p is null");
2067
2068         Elm_Object_Item *item = elm_genlist_selected_item_get(obj);
2069         c_retm_if(!item, "elm_genlist_selected_item_get() returned null");
2070
2071         elm_genlist_item_selected_set(item, EINA_FALSE);
2072
2073         if (cs)
2074         {
2075                 p->calid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
2076                 p->accid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_ACCOUNT_ID);
2077         }
2078         else
2079         {
2080                 p->calid = DEFAULT_CALENDAR_ID;
2081                 p->accid = LOCAL_ACCOUNT_ID;
2082         }
2083
2084         elm_genlist_item_update(it);
2085
2086         evas_object_del(p->popup);
2087         p->popup = NULL;
2088 }
2089
2090 static void  __cal_edit_save_to_popup_hide_cb(void *data, Evas_Object *obj, void *event_info)
2091 {
2092         c_retm_if(!data, "data is null");
2093         c_retm_if(!obj, "obj is null");
2094
2095         Evas_Object *popup = data;
2096
2097         cal_edit_data *p = evas_object_data_get(popup, "data");
2098
2099         evas_object_del(popup);
2100
2101         c_retm_if(!p, "p is null");
2102
2103         p->popup = NULL;
2104 }
2105
2106 static Evas_Object* __cal_edit_create_save_to_popup(Item_Data *item_data)
2107 {
2108         c_retvm_if(!item_data, NULL, "item_data is null");
2109
2110         Evas_Object *popup = NULL;
2111         Evas_Object *genlist = NULL;
2112         cal_edit_data *p = item_data->p;
2113         c_retvm_if(!p, NULL, "p is null");
2114
2115         cal_struct *cs;
2116         Eina_List *l;
2117
2118         if (!p->calendar_list)
2119         {
2120                 p->calendar_list = CALENDAR_SVC_GET_ALL(p->accid, ALL_CALENDAR_ID, CAL_STRUCT_CALENDAR);
2121                 c_retvm_if(!p->calendar_list, NULL, "p->calendar_list is null");
2122         }
2123
2124         popup = cal_util_add_popup(p->ad->win, "liststyle", C_("IDS_ST_BODY_SAVE_TO"), NULL,
2125                 __cal_edit_save_to_popup_hide_cb, p, S_("IDS_COM_BODY_CLOSE"), NULL);
2126         c_retvm_if(!popup, NULL, "popup is null");
2127
2128         genlist = elm_genlist_add(popup);
2129         if (!genlist) {
2130                 ERR("elm_genlist_add(popup) returned null");
2131                 evas_object_del(popup);
2132                 return NULL;
2133         }
2134
2135         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2136         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
2137         evas_object_data_set(genlist, "priv", p);
2138
2139         EINA_LIST_FOREACH(p->calendar_list, l, cs)
2140         {
2141                 if (cs) {
2142                         cals_calendar_store_type cs_type = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_STORE_TYPE);
2143                         if (p->is_todo_mode) {
2144                                 if (CALS_CALENDAR_TYPE_TODO & cs_type)
2145                                         elm_genlist_item_append(genlist, &itc_2text_1icon_2, cs, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_save_to_popup_list_sel, cs);
2146                         } else {
2147                                 if (CALS_CALENDAR_TYPE_EVENT & cs_type)
2148                                         elm_genlist_item_append(genlist, &itc_2text_1icon_2, cs, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_save_to_popup_list_sel, cs);
2149                         }
2150                 }
2151         }
2152
2153         elm_object_content_set(popup, genlist);
2154         evas_object_show(genlist);
2155
2156         return popup;
2157 }
2158
2159 static void __cal_edit_show_save_to_popup(Item_Data *item_data)
2160 {
2161         c_retm_if(!item_data, "item_data is null");
2162
2163         it = item_data->it;
2164         c_retm_if(!it, "selected item is null");
2165
2166         cal_edit_data *p = item_data->p;
2167         c_retm_if(!p, "p is null");
2168
2169         Evas_Object *popup = __cal_edit_create_save_to_popup(item_data);
2170         c_retm_if(!popup, "popup is NULL");
2171
2172         p->popup = popup;
2173 }
2174
2175 static void __cal_edit_priority_popup_list_sel(void *data, Evas_Object *obj, void *event_info)
2176 {
2177         c_retm_if(!data, "data is null");
2178         c_retm_if(!obj, "obj is null");
2179
2180         Item_Data *item_data = data;
2181
2182         cal_edit_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
2183         c_retm_if(!p, "p is null");
2184
2185         Elm_Object_Item *item = elm_genlist_selected_item_get(obj);
2186         c_retm_if(!item, "elm_genlist_selected_item_get() returned null");
2187
2188         elm_genlist_item_selected_set(item, EINA_FALSE);
2189
2190         p->priority = item_data->priority_value;
2191
2192         elm_genlist_item_update(it);
2193
2194         evas_object_del(p->popup);
2195         p->popup = NULL;
2196 }
2197
2198 static Evas_Object* __cal_edit_create_priority_popup(Item_Data *item_data)
2199 {
2200         c_retvm_if(!item_data, NULL, "item_data is null");
2201
2202         Evas_Object *popup = NULL;
2203         Evas_Object *genlist = NULL;
2204         Item_Data *list_item_data = NULL;
2205         cal_edit_data *p = item_data->p;
2206         c_retvm_if(!p, NULL, "p is null");
2207
2208         popup = cal_util_add_popup(p->ad->win, "liststyle", C_("IDS_CLD_BODY_PRIORITY"), NULL,
2209                 __cal_edit_save_to_popup_hide_cb, p, S_("IDS_COM_BODY_CLOSE"), NULL);
2210         c_retvm_if(!popup, NULL, "popup is null");
2211
2212         genlist = elm_genlist_add(popup);
2213         if (!genlist) {
2214                 ERR("elm_genlist_add(popup) returned null");
2215                 evas_object_del(popup);
2216                 return NULL;
2217         }
2218
2219         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2220         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
2221         evas_object_data_set(genlist, "priv", p);
2222
2223         list_item_data = calloc(1, sizeof(Item_Data));
2224         c_retvm_if(!list_item_data, NULL, "calloc is failed");
2225         list_item_data->type = _GTYPE_PRIORITY_ITEM;
2226         list_item_data->priority_value = EVENT_PRIORITY_LOW;
2227         elm_genlist_item_append(genlist, &itc_1text, list_item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_priority_popup_list_sel, list_item_data);
2228
2229         list_item_data = calloc(1, sizeof(Item_Data));
2230         c_retvm_if(!list_item_data, NULL, "calloc is failed");
2231         list_item_data->type = _GTYPE_PRIORITY_ITEM;
2232         list_item_data->priority_value = EVENT_PRIORITY_NORMAL;
2233         elm_genlist_item_append(genlist, &itc_1text, list_item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_priority_popup_list_sel, list_item_data);
2234
2235         list_item_data = calloc(1, sizeof(Item_Data));
2236         c_retvm_if(!list_item_data, NULL, "calloc is failed");
2237         list_item_data->type = _GTYPE_PRIORITY_ITEM;
2238         list_item_data->priority_value = EVENT_PRIORITY_HIGH;
2239         elm_genlist_item_append(genlist, &itc_1text, list_item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_priority_popup_list_sel, list_item_data);
2240
2241         elm_object_content_set(popup, genlist);
2242         evas_object_show(genlist);
2243
2244         return popup;
2245 }
2246
2247 static void __cal_edit_show_priority_popup(Item_Data *item_data)
2248 {
2249         c_retm_if(!item_data, "item_data is null");
2250
2251         it = item_data->it;
2252         c_retm_if(!it, "selected item is null");
2253
2254         cal_edit_data *p = item_data->p;
2255         c_retm_if(!p, "p is null");
2256
2257         Evas_Object *popup = __cal_edit_create_priority_popup(item_data);
2258         c_retm_if(!popup, "popup is NULL");
2259
2260         p->popup = popup;
2261 }
2262
2263
2264 static void __cal_edit_genlist_item_select_callback(void *data, Evas_Object *obj, void *event_info)
2265 {
2266         c_retm_if(!obj, "obj is null");
2267
2268         Elm_Object_Item *it = elm_genlist_selected_item_get(obj);
2269         c_retm_if(!it, "elm_genlist_selected_item_get() returned null");
2270
2271         Item_Data *item_data = (Item_Data *)elm_object_item_data_get(it);
2272         c_retm_if(!it, "elm_object_item_data_get() returned null");
2273
2274         int type = item_data->type;
2275
2276         cal_edit_data *p = item_data->p;
2277         c_retm_if(!p, "p is null");
2278
2279         switch ( type )
2280         {
2281         case _GTYPE_TITLE:
2282                 break;
2283         case _GTYPE_LOC:
2284                 break;
2285         case _GTYPE_ALLDAY:
2286                 elm_check_state_set(p->c_allday, !elm_check_state_get(p->c_allday));
2287                 __cal_edit_all_day_changed_callback(p, p->c_allday, event_info);
2288                 break;
2289         case _GTYPE_TIME_ZONE:
2290                 __cal_edit_timezone_select_callback(item_data);
2291                 break;
2292         case _GTYPE_ALARM:
2293                 __cal_edit_alarm_select_callback(item_data);
2294                 break;
2295         case _GTYPE_REPEAT:
2296                 __cal_edit_repeat_select_callback(item_data);
2297                 break;
2298         case _GTYPE_NOTE:
2299                 break;
2300
2301         case _GTYPE_LINKED_CAL:
2302                 __cal_edit_show_save_to_popup(item_data);
2303                 break;
2304         case _GTYPE_PRIORITY:
2305                 __cal_edit_show_priority_popup(item_data);
2306                 break;
2307         case _GTYPE_CHECK_DUE_DATE:
2308                 elm_check_state_set(p->due_check, !elm_check_state_get(p->due_check));
2309                 __cal_edit_no_due_date_changed_callback(p, p->due_check, event_info);
2310                 break;
2311         default:
2312                 break;
2313         }
2314
2315         elm_genlist_item_selected_set(it, EINA_FALSE);
2316
2317         return;
2318 }
2319
2320 static char *__cal_edit_get_genlist_save_to_item_label(void *data, Evas_Object *obj, const char *part)
2321 {
2322         c_retvm_if(!data, NULL, "data is null");
2323         c_retvm_if(!part, NULL, "part is null");
2324
2325         cal_struct *cs = (cal_struct*)data;
2326         const char *name;
2327         int cid;
2328         char* description;
2329
2330         if (!CAL_STRCMP(part,"elm.text.1")) {
2331                 if (!cs)
2332                         return strdup(C_("IDS_CLD_OPT_PHONE_CALENDAR"));
2333
2334                 cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
2335                 if (cid == DEFAULT_CALENDAR_ID)
2336                         return strdup(C_("IDS_CLD_OPT_PHONE_CALENDAR"));
2337
2338                 name = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_TABLE_TXT_NAME);
2339                 if (name)
2340                         return strdup(name);
2341
2342                 return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
2343         }
2344         else if (!CAL_STRCMP(part,"elm.text.2")) {
2345                 if (!cs)
2346                         return strdup(S_("IDS_COM_POP_NO_ACCOUNTS"));
2347
2348                 cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_TABLE_INT_INDEX);
2349                 if (cid == DEFAULT_CALENDAR_ID)
2350                         return strdup(C_("IDS_EMAIL_BODY_DEFAULT_ACCOUNT"));
2351
2352                 description = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_TABLE_TXT_DESCRIPTION);
2353                 if (description)
2354                         return strdup(description);
2355
2356                 return strdup(S_("IDS_COM_POP_NO_ACCOUNTS"));
2357         }
2358
2359         return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
2360 }
2361
2362 static Elm_Object_Item* __cal_edit_add_genlist_item(Evas_Object *genlist, Elm_Genlist_Item_Class *itc, int type, cal_edit_data *p)
2363 {
2364         c_retvm_if(!genlist, NULL, "genlist is null");
2365         c_retvm_if(!itc, NULL, "itc is null");
2366         c_retvm_if(!p, NULL, "p is null");
2367
2368         Item_Data *item_data = calloc(1, sizeof(Item_Data));
2369         c_retvm_if(!item_data, NULL, "calloc is failed");
2370
2371         item_data->p = p;
2372         item_data->type = type;
2373
2374         item_data->it = elm_genlist_item_append(genlist, itc, item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
2375         if (!item_data->it)
2376         {
2377                 ERR("elm_genlist_item_append returned null");
2378                 free(item_data);
2379                 return NULL;
2380         }
2381
2382         return item_data->it;
2383 }
2384
2385 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)
2386 {
2387         c_retvm_if(!genlist, NULL, "genlist is null");
2388         c_retvm_if(!itc, NULL, "itc is null");
2389         c_retvm_if(!p, NULL, "p is null");
2390
2391         Item_Data *item_data = calloc(1, sizeof(Item_Data));
2392         c_retvm_if(!item_data, NULL, "calloc is failed");
2393
2394         item_data->p = p;
2395         item_data->type = type;
2396         item_data->alarm_value = alarm;
2397
2398         if (p->is_todo_mode) {
2399                 item_data->it = elm_genlist_item_append(genlist, itc, item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
2400                 return item_data->it;
2401         }
2402
2403         if (!p->alarm_first_it) {
2404                 item_data->it = elm_genlist_item_append(genlist, &itc_2text_plus_btn, item_data, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_genlist_item_select_callback, NULL);
2405                 p->alarm_first_it = p->alarm_last_it = item_data->it;
2406         } else {
2407                 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);
2408                 p->alarm_last_it = item_data->it;
2409         }
2410
2411         if (!item_data->it)
2412         {
2413                 ERR("elm_genlist_item_append returned null");
2414                 free(item_data);
2415                 return NULL;
2416         }
2417
2418         return item_data->it;
2419 }
2420
2421
2422 static Elm_Object_Item* __cal_edit_add_separator(Evas_Object *genlist, cal_edit_data *p)
2423 {
2424         c_retvm_if(!genlist, NULL, "genlist is null");
2425         c_retvm_if(!p, NULL, "p is null");
2426
2427         Elm_Object_Item *git = __cal_edit_add_genlist_item(genlist, &itc_seperator, 0, p);
2428         c_retvm_if(!git, NULL, "__cal_edit_add_genlist_item returned null");
2429
2430         elm_genlist_item_select_mode_set(git, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2431         return git;
2432 }
2433
2434 static Elm_Object_Item* __cal_edit_set_title(Evas_Object *genlist, cal_edit_data *p)
2435 {
2436         __cal_edit_add_separator(genlist, p);
2437
2438         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_TITLE, p);
2439 }
2440
2441 static Elm_Object_Item* __cal_edit_set_location(Evas_Object *genlist, cal_edit_data *p)
2442 {
2443         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_LOC, p);
2444 }
2445
2446 static Elm_Object_Item* __cal_edit_set_all_day(Evas_Object *genlist, cal_edit_data *p)
2447 {
2448         return __cal_edit_add_genlist_item(genlist, &itc_1text_1icon, _GTYPE_ALLDAY, p);
2449 }
2450
2451 static Elm_Object_Item* __cal_edit_set_time_zone(Evas_Object *genlist, cal_edit_data *p)
2452 {
2453         __cal_edit_add_separator(genlist, p);
2454
2455         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_TIME_ZONE, p);
2456 }
2457
2458 static void __cal_edit_set_alarm(Evas_Object *genlist, cal_edit_data *p)
2459 {
2460         __cal_edit_add_separator(genlist, p);
2461
2462         GList *temp = p->list_alm_min;
2463
2464         if (!temp)
2465                 p->alarm_first_it = p->alarm_last_it =
2466                         __cal_edit_add_genlist_alarm_item(genlist, &itc_2text_1btn, _GTYPE_ALARM, p,
2467                                                                                         (p->event_id?CAL_EDIT_ALARM_OFF:CAL_EDIT_ALARM_ON_TIME));
2468         else {
2469                 while (temp) {
2470                         __cal_edit_add_genlist_alarm_item(genlist, &itc_2text_1btn, _GTYPE_ALARM, p, (int)temp->data);
2471
2472                         temp = g_list_next(temp);
2473                 }
2474         }
2475 }
2476
2477 static Elm_Object_Item* __cal_edit_set_repeat(Evas_Object *genlist, cal_edit_data *p)
2478 {
2479         __cal_edit_add_separator(genlist, p);
2480
2481         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_REPEAT, p);
2482 }
2483
2484 static Elm_Object_Item* __cal_edit_set_note(Evas_Object *genlist, cal_edit_data *p)
2485 {
2486         __cal_edit_add_separator(genlist, p);
2487
2488         return __cal_edit_add_genlist_item(genlist, &itc_1icon, _GTYPE_NOTE, p);
2489 }
2490
2491 static Elm_Object_Item* __cal_edit_set_save_to(Evas_Object *genlist, cal_edit_data *p)
2492 {
2493         __cal_edit_add_separator(genlist, p);
2494
2495         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_LINKED_CAL, p);
2496
2497 }
2498
2499 static Eina_Bool __cal_edit_append_widget_idler(void* data)
2500 {
2501         c_retvm_if(!data, ECORE_CALLBACK_CANCEL, "data is null");
2502
2503         cal_edit_data *p = (cal_edit_data *)data;
2504         Evas_Object *genlist = p->genlist;
2505
2506         __cal_edit_set_note(genlist, p);
2507
2508         __cal_edit_set_save_to(genlist, p);
2509
2510         p->idler = NULL;
2511
2512         return ECORE_CALLBACK_CANCEL;
2513 }
2514
2515 static Evas_Object* __cal_edit_create_genlist(cal_edit_data* p)
2516 {
2517         Elm_Object_Item* item = NULL;
2518         Evas_Object *genlist = elm_genlist_add(p->ly);
2519         c_retvm_if(!genlist, NULL, "elm_genlist_add() is failed");
2520
2521         evas_object_data_set(genlist, "priv", p);
2522
2523         if (p->ad->theme)
2524                 elm_object_theme_set(genlist, p->ad->theme);
2525
2526         itc_seperator.item_style = "dialogue/separator/21/with_line";
2527         itc_seperator.func.text_get = NULL;
2528         itc_seperator.func.state_get = __cal_edit_get_genlist_item_state;
2529         itc_seperator.func.del = __cal_edit_genlist_item_delete;
2530
2531         itc_1icon.item_style = "dialogue/1icon";
2532         itc_1icon.func.text_get = __cal_edit_get_genlist_item_label;
2533         itc_1icon.func.del = __cal_edit_genlist_item_delete;
2534         itc_1icon.func.content_get = __cal_edit_get_genlist_item_icon;
2535
2536         itc_1text_1icon.item_style = "dialogue/1text.1icon";
2537         itc_1text_1icon.func.text_get = __cal_edit_get_genlist_item_label;
2538         itc_1text_1icon.func.del = __cal_edit_genlist_item_delete;
2539         itc_1text_1icon.func.content_get = __cal_edit_get_genlist_item_icon;
2540
2541         itc_2text.item_style = "dialogue/2text.3";
2542         itc_2text.func.text_get = __cal_edit_get_genlist_item_label;
2543         itc_2text.func.del = __cal_edit_genlist_item_delete;
2544         itc_2text.func.content_get = __cal_edit_get_genlist_item_icon;
2545         itc_2text.func.state_get = NULL;
2546
2547         itc_2text_1btn.item_style = "dialogue/2text.1icon.6";
2548         itc_2text_1btn.func.text_get = __cal_edit_get_genlist_item_label;
2549         itc_2text_1btn.func.content_get = __cal_edit_get_genlist_item_icon;
2550         itc_2text_1btn.func.state_get = NULL;
2551         itc_2text_1btn.func.del = __cal_edit_genlist_item_delete;
2552         itc_2text_1btn.decorate_item_style = "dialogue/edit/contact";
2553
2554         itc_2text_plus_btn.item_style = "dialogue/2text.1icon.6";
2555         itc_2text_plus_btn.func.text_get = __cal_edit_get_genlist_item_label;
2556         itc_2text_plus_btn.func.content_get = __cal_edit_get_genlist_item_plus_icon;
2557         itc_2text_plus_btn.func.state_get = NULL;
2558         itc_2text_plus_btn.func.del = __cal_edit_genlist_item_delete;
2559         itc_2text_plus_btn.decorate_item_style = "dialogue/edit/contact";
2560
2561         itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
2562         itc_2text_1icon_4.func.text_get = __cal_edit_get_genlist_item_label;
2563         itc_2text_1icon_4.func.del = __cal_edit_genlist_item_delete;
2564         itc_2text_1icon_4.func.content_get = __cal_edit_get_genlist_item_icon;
2565
2566         itc_2text_1icon_2.item_style = "dialogue/2text.1icon.2";
2567         itc_2text_1icon_2.func.text_get = __cal_edit_get_genlist_save_to_item_label;
2568         itc_2text_1icon_2.func.content_get = __cal_edit_add_save_to_icon;
2569
2570         itc_2text_2icon_4.item_style = "dialogue/2text.2icon.4";
2571         itc_2text_2icon_4.func.text_get = __cal_edit_get_genlist_item_label;
2572         itc_2text_2icon_4.func.del = __cal_edit_genlist_item_delete;
2573         itc_2text_2icon_4.func.content_get = __cal_edit_get_genlist_item_icon;
2574
2575         __cal_edit_set_title(genlist, p);
2576
2577         __cal_edit_set_location(genlist, p);
2578
2579         p->sdt = cal_genlist_item_timepicker_add(genlist,
2580                         S_("IDS_COM_BODY_START"), &p->stm, p->allday, p->ad->is_hour24,
2581                         __cal_edit_start_date_changed_callback, p);
2582
2583         p->edt = cal_genlist_item_timepicker_add(genlist,
2584                         S_("IDS_COM_BODY_END"), &p->etm, p->allday, p->ad->is_hour24,
2585                         __cal_edit_end_date_changed_callback, p);
2586
2587         __cal_edit_set_all_day(genlist, p);
2588
2589         p->timezone_item = __cal_edit_set_time_zone(genlist, p);
2590
2591         __cal_edit_set_alarm(genlist, p);
2592
2593         item = __cal_edit_set_repeat(genlist, p);
2594         if (p->ad->edit_special_one || 0 < p->original_event_id)
2595                 elm_object_item_disabled_set(item, EINA_TRUE);
2596
2597         evas_object_show(genlist);
2598         return genlist;
2599 }
2600
2601 static void __cal_edit_layout_rendering_callback(void *data, Evas *e, void *event_info)
2602 {
2603         CAL_FN_START;
2604
2605         c_retm_if(!data, "data is null");
2606
2607         cal_edit_data* p = data;
2608
2609         evas_event_callback_del(e, EVAS_CALLBACK_RENDER_FLUSH_POST, __cal_edit_layout_rendering_callback);
2610
2611         if (p->idler)
2612                 return;
2613
2614         if (!p->idler)
2615                 p->idler = ecore_idler_add(__cal_edit_append_widget_idler,p);
2616
2617         CAL_FN_END;
2618 }
2619
2620 static Evas_Object *__cal_edit_create_layout(struct appdata *ad, Evas_Object *parent)
2621 {
2622         c_retvm_if(!ad, NULL, "ad is null");
2623         c_retvm_if(!parent, NULL, "parent is null");
2624
2625         Evas *e;
2626         Evas_Object *ly;
2627         Evas_Object *cf;
2628         cal_edit_data *p = calloc(1, sizeof(cal_edit_data));
2629         c_retvm_if(!p, NULL, "calloc(1, sizeof(cal_edit_data)) returned null");
2630
2631         p->parent = parent;
2632         p->nv = ad->nv;
2633         p->win = ad->win;
2634         p->snote = ad->strnote;
2635         p->is_selected_timezone = EINA_FALSE;
2636         p->alarm_count = 1;
2637         p->is_todo_mode = EINA_FALSE;
2638
2639         ly = cal_util_add_layout(ad->nv, "edit");
2640         if (!ly)
2641         {
2642                 ERR("cal_util_add_layout return null");
2643                 free(p);
2644                 return NULL;
2645         }
2646
2647         e = evas_object_evas_get(ly);
2648         p->ad = ad;
2649         p->ly = ly;
2650         p->event_id = ad->cid;
2651         evas_object_data_set(ly, "priv", p);
2652
2653         if (ad->is_aul && ad->ical)
2654                 __cal_edit_fill_vcs_information(p);
2655         else {
2656                 if (p->event_id)
2657                         __cal_edit_fill_detail_information(p, p->event_id);
2658                 else
2659                         __cal_edit_set_default_information(p);
2660         }
2661
2662         p->genlist = __cal_edit_create_genlist(p);
2663         if (!p->genlist)
2664         {
2665                 evas_object_del(ly);
2666                 free(p);
2667                 return NULL;
2668         }
2669
2670         cf = elm_conformant_add(ad->win);
2671         if (!cf)
2672         {
2673                 ERR("elm_conformant_add(ad->win) is failed");
2674                 evas_object_del(ly);
2675                 free(p);
2676                 return NULL;
2677         }
2678
2679         evas_object_size_hint_weight_set(cf, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2680         evas_object_show(cf);
2681         elm_object_content_set(cf, p->genlist);
2682         elm_object_style_set(cf, "internal_layout");
2683         elm_object_part_content_set(ly, "sw", cf);
2684
2685         evas_object_event_callback_add(ly, EVAS_CALLBACK_DEL, __cal_edit_delete_layout, p);
2686         evas_event_callback_add(e, EVAS_CALLBACK_RENDER_FLUSH_POST, __cal_edit_layout_rendering_callback, p);
2687
2688         return ly;
2689 }
2690
2691 static void __cal_edit_back_button_callback(void *data, Evas_Object *obj, void *ei)
2692 {
2693         CAL_FN_START;
2694
2695         c_retm_if(!data, "data is null");
2696
2697         cal_edit_data *p = data;
2698         Elm_Object_Item* navi_item = NULL;
2699
2700         if ((NULL != p->ad->ug) && (UG_EDIT == p->ad->u_type))
2701         {
2702                 ug_destroy_me(p->ad->ug);
2703         }
2704         else
2705         {
2706                 if (p->ad->request_view == CV_EDIT)
2707                 {
2708                         if (elm_naviframe_top_item_get(p->ad->nv) != elm_naviframe_bottom_item_get(p->ad->nv))
2709                         {
2710                                 p->ad->request_view = CV_UNKNOWN;
2711                                 elm_win_lower(p->ad->win);
2712                         }
2713                         else
2714                                 elm_exit();
2715                 }
2716
2717                 elm_naviframe_prev_btn_auto_pushed_set(p->ad->nv, EINA_TRUE);
2718                 elm_naviframe_item_pop(p->ad->nv);
2719                 navi_item = elm_naviframe_top_item_get(p->ad->nv);
2720
2721                 if (p->ad->is_update_view)
2722                         edje_object_signal_emit(CAL_UTIL_GET_EDJ_DATA(p->parent), "update", "prog");
2723         }
2724
2725         struct appdata * ad = p->ad;
2726         c_retm_if(!ad, "ad is null");
2727
2728         ad->current_view = CV_UNKNOWN;
2729 }
2730
2731 static void __cal_edit_add_controlbar( struct appdata *ad, Evas_Object *ly)
2732 {
2733         c_retm_if(!ad, "ad is null");
2734         c_retm_if(!ly, "ly is null");
2735
2736         cal_edit_data *p = evas_object_data_get(ly, "priv");
2737         c_retm_if(!p, "p is null");
2738
2739         Elm_Object_Item* navi_item;
2740         const char *title;
2741         Evas_Object *btn_save;
2742         Evas_Object *btn_cancel;
2743
2744         if (ad->cid) {
2745                 if (p->is_todo_mode) {
2746                         title = C_("IDS_TASK_HEADER_EDIT_TASK");
2747                 } else {
2748                         title = C_("IDS_CLD_HEADER_EDIT_EVENT");
2749                 }
2750         } else {
2751                 if (p->is_todo_mode) {
2752                         title = C_("IDS_TASK_HEADER_NEW_TASK");
2753                 } else {
2754                         title = C_("IDS_CLD_HEADER_NEW_EVENT");
2755                 }
2756         }
2757
2758         elm_naviframe_prev_btn_auto_pushed_set(ad->nv, EINA_FALSE);
2759
2760         navi_item = elm_naviframe_item_push(ad->nv, title, NULL, NULL, ly, NULL);
2761         c_retm_if(!navi_item, "elm_naviframe_item_push returned null");
2762
2763         btn_save = elm_button_add(ad->nv);
2764         c_retm_if(!btn_save, "elm_button_add(ad->nv) returned null");
2765         cal_util_set_controlbar_button(btn_save, S_("IDS_COM_OPT_SAVE"), "naviframe/title/default", __cal_edit_save_button_callback, ly);
2766         elm_object_item_part_content_set(navi_item, "title_left_btn", btn_save);
2767
2768         btn_cancel = elm_button_add(ad->nv);
2769         c_retm_if(!btn_cancel, "elm_button_add(ad->nv) returned null");
2770         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));
2771         elm_object_item_part_content_set(navi_item, "title_right_btn", btn_cancel);
2772 }
2773
2774 void cal_edit_create_view(struct appdata *ad, Evas_Object *parent)
2775 {
2776         CAL_FN_START;
2777
2778         c_retm_if(!ad, "ad is null");
2779         c_retm_if(!parent, "parent is null");
2780
2781         if (ad->current_view == CV_EDIT)
2782                 return;
2783
2784         Evas_Object *ly = __cal_edit_create_layout(ad, parent);
2785         c_retm_if(!ly, "__cal_edit_create_layout(ad, parent) returned null");
2786
2787         __cal_edit_add_controlbar(ad, ly);
2788
2789         ad->current_view = CV_EDIT;
2790
2791         CAL_FN_END;
2792 }
2793
2794 static inline cal_struct* __cal_edit_get_cs_todo(int cid)
2795 {
2796         cal_struct *cs = NULL;
2797
2798         if (!cid) {
2799                 cs = CALENDAR_SVC_STRUCT_NEW(CAL_STRUCT_TODO);
2800                 c_retvm_if(!cs, NULL, "CALENDAR_SVC_STRUCT_NEW is failed.");
2801         }
2802         else {
2803                 int r = CALENDAR_SVC_GET(CAL_STRUCT_TODO, cid, NULL, &cs);
2804                 if (r != CAL_SUCCESS) {
2805                         if (cs)
2806                                 CALENDAR_SVC_STRUCT_FREE(&cs);
2807
2808                         ERR("CALENDAR_SVC_GET(CAL_STRUCT_TODO, %d) is failed(%d)", cid, r);
2809                 }
2810         }
2811
2812         return cs;
2813 }
2814
2815 static void __cal_edit_fill_cs_time_todo(cal_edit_data *p, cal_struct *cs)
2816 {
2817         c_ret_if(!p);
2818         c_ret_if(!cs);
2819
2820         if (p->timezone_path)
2821                 CALENDAR_SVC_STRUCT_SET_STR(cs, CALS_VALUE_TXT_DTSTART_TZID, p->timezone_path);
2822
2823         if (p->is_no_due_date)  {
2824                 CALENDAR_SVC_STRUCT_SET_LLI(cs, CALS_LIST_PERIOD_NORMAL_BASIC_LLI_DTEND_UTIME, CALS_TODO_NO_DUE_DATE);
2825         }
2826         else {
2827
2828                 long long int lli_end;
2829
2830                 cal_util_convert_tm_to_lli(NULL, &p->etm, &lli_end);
2831
2832                 CALENDAR_SVC_STRUCT_SET_LLI(cs, CALS_LIST_PERIOD_NORMAL_BASIC_LLI_DTEND_UTIME, lli_end);
2833         }
2834 }
2835
2836 static void __cal_edit_fill_cs_priority(cal_edit_data *p, cal_struct *cs)
2837 {
2838         c_retm_if(!p, "p is null");
2839         c_retm_if(!cs, "cs is null");
2840         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_PRIORITY, p->priority);
2841 }
2842
2843 static void __cal_edit_fill_cs_status_todo(cal_edit_data *p, cal_struct *cs)
2844 {
2845         c_retm_if(!p, "p is null");
2846         c_retm_if(!cs, "cs is null");
2847         CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_TASK_STATUS, p->todo_status);
2848 }
2849
2850 static inline void __cal_edit_fill_cs_todo(cal_edit_data *p, cal_struct *cs)
2851 {
2852         __cal_edit_fill_cs_title(p, cs);
2853         __cal_edit_fill_cs_time_todo(p, cs);
2854         __cal_edit_fill_cs_location(p, cs);
2855         __cal_edit_fill_cs_priority(p, cs);
2856         __cal_edit_fill_cs_alarm(p, cs);
2857         __cal_edit_fill_cs_note(p, cs);
2858         __cal_edit_fill_cs_save_to(p, cs);
2859         __cal_edit_fill_cs_status_todo(p, cs);
2860 }
2861
2862 static Eina_Bool __cal_edit_check_alarm_time_passed_todo(cal_edit_data *p, cal_struct *cs)
2863 {
2864         time_t alarm;
2865         time_t current_time = time(NULL);
2866         char buf[32] = {0};
2867         Item_Data *item_data = NULL;
2868         Elm_Object_Item *it;
2869         c_retvm_if(!p, EINA_FALSE, "p is null");
2870         c_retvm_if(!p->genlist, EINA_FALSE, "genlist is null");
2871
2872         int count = 1;
2873
2874         it = p->alarm_first_it;
2875         while (it && (count++ <= p->alarm_count)) {
2876
2877                 item_data = elm_object_item_data_get(it);
2878                 c_retvm_if(!item_data, EINA_FALSE, "item_data is null");
2879
2880                 cal_edit_alarm_get_alarm_str(item_data->alarm_value, buf, sizeof(buf));
2881                 if (!strcmp(buf, S_("IDS_COM_BODY_OFF"))) {
2882                         it = elm_genlist_item_next_get(it);
2883                         continue;
2884                 }
2885
2886                 alarm = mktime(&p->etm)-item_data->alarm_value*60;
2887                 if (alarm < current_time)
2888                         return EINA_TRUE;
2889
2890                 it = elm_genlist_item_next_get(it);
2891         }
2892
2893         return EINA_FALSE;
2894 }
2895
2896 static int __cal_edit_save_todo(cal_edit_data *p)
2897 {
2898         CAL_FN_START;
2899
2900         c_retvm_if(!p, -1, "p is null");
2901
2902         int r;
2903         cal_struct *cs_temp = NULL;
2904         cal_struct *cs = __cal_edit_get_cs_todo(p->event_id);
2905         c_retvm_if(!cs, -1, "cs is null");
2906
2907         cs_temp = __cal_edit_get_cs_todo(p->event_id);
2908         if (!cs_temp) {
2909                 if(cs)
2910                         CALENDAR_SVC_STRUCT_FREE(&cs);
2911
2912                 return -1;
2913         }
2914
2915 //      if (__cal_edit_check_alarm_time_passed_todo(p,cs) && p->repeat_freq == CALS_FREQ_ONCE) {
2916 //              cal_util_add_popup(p->win, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_BODY_ALARMTIME_WARNING"),
2917 //                      __cal_edit_reponse_event_callback, NULL, NULL);
2918 //
2919 //              if (cs)
2920 //                      CALENDAR_SVC_STRUCT_FREE(&cs);
2921 //
2922 //              if (cs_temp)
2923 //                      CALENDAR_SVC_STRUCT_FREE(&cs_temp);
2924 //
2925 //              return -1;
2926 //      }
2927
2928         __cal_edit_fill_cs_todo(p, cs);
2929
2930         if (p->event_id) {
2931                 if (p->ad->edit_special_one) {
2932
2933 // TODO: copy exception_cs from cs
2934 /*
2935                         cal_struct *exception_cs = calloc(1, sizeof(cal_struct));
2936                         c_retv_if(!exception_cs, -1);
2937
2938                         memcpy(exception_cs, cs, sizeof(cal_struct));
2939
2940                         r = calendar_svc_event_delete_normal_instance(p->event_id, CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME));
2941                         c_retv_if(r != CAL_SUCCESS, "calendar_svc_event_delete_normal_instance() is failed(%d)", r);
2942
2943                         CALENDAR_SVC_STRUCT_SET_INT(exception_cs, CALS_VALUE_INT_RRULE_ID, 0);
2944                         CALENDAR_SVC_STRUCT_SET_INT(exception_cs, CALS_VALUE_INT_RRULE_FREQ, CALS_FREQ_ONCE);
2945
2946                         r = CALENDAR_SVC_DELETE (CAL_STRUCT_TODO, p->event_id);
2947                         c_retv_if(r != CAL_SUCCESS, "CALENDAR_SVC_DELETE() is failed(%d)", r);
2948 */
2949                 } else {
2950                         r = CALENDAR_SVC_UPDATE(cs);
2951                         if (r != CAL_SUCCESS) {
2952                                 __cal_edit_show_result_popup(p,r);
2953
2954                                 if (cs)
2955                                         CALENDAR_SVC_STRUCT_FREE(&cs);
2956
2957                                 if (cs_temp)
2958                                         CALENDAR_SVC_STRUCT_FREE(&cs_temp);
2959
2960                                 return -1;
2961                         }
2962                 }
2963         } else {
2964                 r = CALENDAR_SVC_INSERT(cs);
2965
2966                 if (r <= 0) {
2967                         __cal_edit_show_result_popup(p,r);
2968
2969                         if (cs)
2970                                 CALENDAR_SVC_STRUCT_FREE(&cs);
2971
2972                         if (cs_temp)
2973                                 CALENDAR_SVC_STRUCT_FREE(&cs_temp);
2974
2975                         return -1;
2976                 }
2977         }
2978         CALENDAR_SVC_STRUCT_FREE(&cs);
2979         CALENDAR_SVC_STRUCT_FREE(&cs_temp);
2980         return 0;
2981 }
2982
2983 static Elm_Object_Item* __cal_edit_set_check_due_date(Evas_Object *genlist, cal_edit_data *p)
2984 {
2985         return __cal_edit_add_genlist_item(genlist, &itc_1text_1icon_2, _GTYPE_CHECK_DUE_DATE, p);
2986 }
2987
2988 static Elm_Object_Item* __cal_edit_set_priority(Evas_Object *genlist, cal_edit_data *p)
2989 {
2990         return __cal_edit_add_genlist_item(genlist, &itc_2text, _GTYPE_PRIORITY, p);
2991 }
2992
2993 static void __cal_edit_set_alarm_todo(Evas_Object *genlist, cal_edit_data *p)
2994 {
2995         __cal_edit_add_genlist_alarm_item(genlist, &itc_2text, _GTYPE_ALARM, p, 0);
2996 }
2997
2998 static Evas_Object* __cal_edit_create_genlist_todo(cal_edit_data* p)
2999 {
3000         Evas_Object *genlist = elm_genlist_add(p->ly);
3001         c_retvm_if(!genlist, NULL, "elm_genlist_add() is failed");
3002
3003         evas_object_data_set(genlist, "priv", p);
3004
3005         if (p->ad->theme)
3006                 elm_object_theme_set(genlist, p->ad->theme);
3007
3008         itc_seperator.item_style = "dialogue/separator/21/with_line";
3009         itc_seperator.func.text_get = NULL;
3010         itc_seperator.func.state_get = __cal_edit_get_genlist_item_state;
3011         itc_seperator.func.del = __cal_edit_genlist_item_delete;
3012
3013         itc_1icon.item_style = "dialogue/1icon";
3014         itc_1icon.func.text_get = __cal_edit_get_genlist_item_label;
3015         itc_1icon.func.del = __cal_edit_genlist_item_delete;
3016         itc_1icon.func.content_get = __cal_edit_get_genlist_item_icon;
3017
3018         itc_1text_1icon_2.item_style = "dialogue/1text.1icon.2";
3019         itc_1text_1icon_2.func.text_get = __cal_edit_get_genlist_item_label;
3020         itc_1text_1icon_2.func.del = __cal_edit_genlist_item_delete;
3021         itc_1text_1icon_2.func.content_get = __cal_edit_get_genlist_item_icon;
3022
3023         itc_2text.item_style = "dialogue/2text.3";
3024         itc_2text.func.text_get = __cal_edit_get_genlist_item_label;
3025         itc_2text.func.del = __cal_edit_genlist_item_delete;
3026         itc_2text.func.content_get = __cal_edit_get_genlist_item_icon;
3027         itc_2text.func.state_get = NULL;
3028
3029         itc_2text_1btn.item_style = "dialogue/2text.1icon.6";
3030         itc_2text_1btn.func.text_get = __cal_edit_get_genlist_item_label;
3031         itc_2text_1btn.func.content_get = __cal_edit_get_genlist_item_icon;
3032         itc_2text_1btn.func.state_get = NULL;
3033         itc_2text_1btn.func.del = __cal_edit_genlist_item_delete;
3034         itc_2text_1btn.decorate_item_style = "dialogue/edit/contact";
3035
3036         itc_2text_plus_btn.item_style = "dialogue/2text.1icon.6";
3037         itc_2text_plus_btn.func.text_get = __cal_edit_get_genlist_item_label;
3038         itc_2text_plus_btn.func.content_get = __cal_edit_get_genlist_item_plus_icon;
3039         itc_2text_plus_btn.func.state_get = NULL;
3040         itc_2text_plus_btn.func.del = __cal_edit_genlist_item_delete;
3041         itc_2text_plus_btn.decorate_item_style = "dialogue/edit/contact";
3042
3043         itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
3044         itc_2text_1icon_4.func.text_get = __cal_edit_get_genlist_item_label;
3045         itc_2text_1icon_4.func.del = __cal_edit_genlist_item_delete;
3046         itc_2text_1icon_4.func.content_get = __cal_edit_get_genlist_item_icon;
3047
3048         itc_2text_1icon_2.item_style = "dialogue/2text.1icon.2";
3049         itc_2text_1icon_2.func.text_get = __cal_edit_get_genlist_save_to_item_label;
3050         itc_2text_1icon_2.func.content_get = __cal_edit_add_save_to_icon;
3051
3052         itc_1text.item_style = "1text";
3053         itc_1text.func.text_get = __cal_edit_get_genlist_item_label;
3054         itc_1text.func.del = __cal_edit_genlist_item_delete;
3055
3056         __cal_edit_set_title(genlist, p);
3057
3058         p->due_date = cal_genlist_item_timepicker_add(genlist,
3059                                                 C_("IDS_CLD_BODY_DUE_DATE"), &p->etm, p->allday, p->ad->is_hour24,
3060                                                 __cal_edit_end_date_changed_callback, (void*)p);
3061         __cal_edit_set_check_due_date(genlist, p);
3062         __cal_edit_add_separator(genlist, p);
3063
3064         __cal_edit_set_location(genlist, p);
3065         __cal_edit_add_separator(genlist, p);
3066
3067         __cal_edit_set_priority(genlist, p);
3068         __cal_edit_set_alarm_todo(genlist, p);
3069         __cal_edit_set_note(genlist, p);
3070         __cal_edit_set_save_to(genlist, p);
3071
3072         evas_object_show(genlist);
3073         return genlist;
3074 }
3075
3076 static void __cal_edit_fill_time_todo(cal_edit_data *p, cal_struct *cs)
3077 {
3078         c_retm_if(!p, "p is null");
3079         c_retm_if(!cs, "cs is null");
3080
3081         cal_util_convert_lli_to_tm(NULL, CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTEND_UTIME), &p->etm);
3082
3083         if(CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTEND_UTIME) == CALS_TODO_NO_DUE_DATE)
3084         {
3085                 p->is_no_due_date = EINA_TRUE;
3086                 p->etm = p->ad->base_tm;
3087         }
3088
3089         p->timezone_path = CAL_STRDUP(CALENDAR_SVC_STRUCT_GET_STR(cs, CALS_VALUE_TXT_DTSTART_TZID));
3090         c_ret_if(!p->timezone_path);
3091
3092         cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
3093 }
3094
3095 static void __cal_edit_fill_no_due_date(cal_edit_data *p, cal_struct *cs)
3096 {
3097
3098 }
3099
3100 static void __cal_edit_fill_priority(cal_edit_data *p, cal_struct *cs)
3101 {
3102         c_retm_if(!p, "p is null");
3103         c_retm_if(!cs, "cs is null");
3104         p->priority = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_PRIORITY);
3105 }
3106
3107
3108 static void __cal_edit_fill_vcs_information_todo(cal_edit_data *p)
3109 {
3110         CAL_ASSERT(p);
3111         struct appdata* ad = p->ad;
3112         CAL_ASSERT(ad);
3113
3114         cal_struct* cs = p->ad->ical;
3115
3116         __cal_edit_fill_title(p, cs);
3117         __cal_edit_fill_time_todo(p, cs);
3118         __cal_edit_fill_no_due_date(p, cs);
3119         __cal_edit_fill_location(p, cs);
3120         __cal_edit_fill_priority(p, cs);
3121         __cal_edit_fill_alarm(p, cs);
3122         __cal_edit_fill_repeat(p, cs);
3123         __cal_edit_fill_note(p, cs);
3124
3125         return;
3126 }
3127
3128 static void __cal_edit_fill_status_todo(cal_edit_data *p, cal_struct *cs)
3129 {
3130         c_retm_if(!p, "p is null");
3131         c_retm_if(!cs, "cs is null");
3132         p->todo_status = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_TASK_STATUS);
3133 }
3134
3135 static void __cal_edit_fill_detail_information_todo(cal_edit_data *p, int cid)
3136 {
3137         int r;
3138         cal_struct *cs;
3139
3140         p->event_id = cid;
3141
3142         cs = NULL;
3143         r = CALENDAR_SVC_GET(CAL_STRUCT_TODO, p->event_id, NULL, &cs);
3144         if (r != CAL_SUCCESS)
3145         {
3146                 if (cs)
3147                         CALENDAR_SVC_STRUCT_FREE(&cs);
3148
3149                 return;
3150         }
3151
3152         __cal_edit_fill_title(p, cs);
3153         __cal_edit_fill_time_todo(p, cs);
3154         __cal_edit_fill_no_due_date(p, cs);
3155         __cal_edit_fill_location(p, cs);
3156         __cal_edit_fill_priority(p, cs);
3157         __cal_edit_fill_alarm(p, cs);
3158         __cal_edit_fill_repeat(p, cs);
3159         __cal_edit_fill_save_to(p, cs);
3160         __cal_edit_fill_note(p, cs);
3161         __cal_edit_fill_status_todo(p, cs);
3162
3163         p->accid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_ACCOUNT_ID);
3164
3165         CALENDAR_SVC_STRUCT_FREE(&cs);
3166
3167         return;
3168 }
3169
3170 static void __cal_edit_set_default_information_todo(cal_edit_data *p)
3171 {
3172         time_t now;
3173
3174         now = time(NULL);
3175         localtime_r(&now, &p->etm);
3176         p->etm.tm_sec = 0;
3177
3178         p->calid = DEFAULT_CALENDAR_ID;
3179         p->accid = ALL_ACCOUNT_ID;
3180
3181         p->priority = EVENT_PRIORITY_LOW;
3182         p->todo_status = CALS_TODO_STATUS_IN_PROCESS;
3183
3184         cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
3185
3186         p->repeat_freq = CALS_FREQ_ONCE;
3187         p->repeat_count = 10;
3188         p->repeat_until = p->stm;
3189         cal_util_update_tm_month (&p->repeat_until, 1);
3190
3191 }
3192
3193 static void __cal_edit_set_edit_todo(cal_edit_data *p)
3194 {
3195         c_retm_if(!p, "p is null");
3196         if (p->ad)
3197         {
3198                 p->etm.tm_year = p->ad->base_tm.tm_year;
3199                 p->etm.tm_mon = p->ad->base_tm.tm_mon;
3200                 p->etm.tm_mday = p->ad->base_tm.tm_mday;
3201
3202                 if (-1 != p->ad->base_hour)
3203                 {
3204                         p->etm.tm_hour = p->ad->base_hour;
3205                         p->etm.tm_min = 0;
3206                 }
3207         }
3208
3209         if (p->etm.tm_min)
3210                 cal_util_update_tm_hour(&p->etm,1);
3211
3212         p->etm.tm_min = p->etm.tm_sec = 0;
3213 }
3214
3215 static Evas_Object *__cal_edit_create_layout_todo(struct appdata *ad, Evas_Object *parent)
3216 {
3217         c_retvm_if(!ad, NULL, "ad is null");
3218         c_retvm_if(!parent, NULL, "parent is null");
3219
3220         Evas *e;
3221         Evas_Object *ly;
3222         Evas_Object *cf;
3223         cal_edit_data *p = calloc(1, sizeof(cal_edit_data));
3224         c_retvm_if(!p, NULL, "calloc(1, sizeof(cal_edit_data)) returned null");
3225
3226         p->parent = parent;
3227         p->nv = ad->nv;
3228         p->win = ad->win;
3229         p->snote = ad->strnote;
3230         p->is_selected_timezone = EINA_FALSE;
3231         p->alarm_count = 1;
3232         p->is_todo_mode = EINA_TRUE;
3233
3234         ly = cal_util_add_layout(ad->nv, "edit");
3235         if (!ly) {
3236                 ERR("cal_util_add_layout return null");
3237                 free(p);
3238                 return NULL;
3239         }
3240
3241         e = evas_object_evas_get(ly);
3242         p->ad = ad;
3243         p->ly = ly;
3244         p->event_id = ad->cid;
3245         evas_object_data_set(ly, "priv", p);
3246
3247         if (ad->is_aul && ad->ical) {
3248                 __cal_edit_fill_vcs_information_todo(p);
3249         } else {
3250                 if (p->event_id) {
3251                         __cal_edit_fill_detail_information_todo(p, p->event_id);
3252                 } else {
3253                         __cal_edit_set_default_information_todo(p);
3254                         __cal_edit_set_edit_todo(p);
3255                 }
3256         }
3257
3258         p->genlist = __cal_edit_create_genlist_todo(p);
3259         if (!p->genlist) {
3260                 evas_object_del(ly);
3261                 free(p);
3262                 return NULL;
3263         }
3264
3265         cf = elm_conformant_add(ad->win);
3266         if (!cf) {
3267                 ERR("elm_conformant_add(ad->win) is failed");
3268                 evas_object_del(ly);
3269                 free(p);
3270                 return NULL;
3271         }
3272
3273         evas_object_size_hint_weight_set(cf, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3274         evas_object_show(cf);
3275         elm_object_content_set(cf, p->genlist);
3276         elm_object_style_set(cf, "internal_layout");
3277         elm_object_part_content_set(ly, "sw", cf);
3278
3279         evas_object_event_callback_add(ly, EVAS_CALLBACK_DEL, __cal_edit_delete_layout, p);
3280
3281         return ly;
3282 }
3283
3284 void cal_edit_create_view_todo(struct appdata *ad, Evas_Object *parent)
3285 {
3286         CAL_FN_START;
3287
3288         c_retm_if(!ad, "ad is null");
3289         c_retm_if(!parent, "parent is null");
3290
3291         Evas_Object *ly = __cal_edit_create_layout_todo(ad, parent);
3292         c_retm_if(!ly, "__cal_edit_create_layout(ad, parent) returned null");
3293
3294
3295         __cal_edit_add_controlbar(ad, ly);
3296
3297         CAL_FN_END;
3298 }
3299