+/*
+ *
+ * Copyright 2012 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ui-gadget-module.h>
+#include <vconf.h>
+#include <libintl.h>
+
+#include "view.h"
+#include "dialogue.h"
+#include "edit-alarm.h"
+#include "edit-repeat.h"
+#include "reminder.h"
+#include "acct-svc.h"
+#include "gi-timepicker.h"
+#include "save-cancel.h"
+#include "external-ug.h"
+#include "cld-images.h"
+#include "dialogue.h"
+
+#define INVALID_TIMEZONE_VALUE (100)
+#define CAL_EDIT_UG_MAX_ATTACHMENT_COUNT 6
+
+typedef struct {
+
+ ui_gadget_h ug;
+ cal_appcontrol_item_type item_type;
+
+ struct tm base_time;
+ Evas_Object *base_layout;
+ Evas_Object *naviframe;
+ Evas_Object *window;
+
+ Evas_Object *parent;
+ Evas_Object *popup;
+ Ecore_Idler *idler;
+
+ calendar_record_h event;
+ calendar_record_h todo;
+ calendar_record_h record;
+ calendar_record_h instance;
+
+ Eina_Bool is_edit_mode;
+
+ Evas_Object *dialogue;
+
+ Evas_Object *title_entry;
+ Evas_Object *title;
+ Evas_Object *start_date;
+ Evas_Object *start_date_title;
+ Evas_Object *end_date;
+ Evas_Object *end_date_title;
+ Evas_Object *allday;
+ Evas_Object *timezone;
+ Evas_Object *location;
+ Evas_Object *location_entry;
+
+ Evas_Object *note;
+ Evas_Object *note_entry;
+ Eina_List *alarm_item_list;
+ Evas_Object *alarm_plus_button;
+
+ Evas_Object *repeat;
+ Evas_Object *repeat_layout;
+
+ Evas_Object *saveto;
+
+ Evas_Object *multibuttonentry; // entry participants
+
+ Evas_Object *due_date;
+ Evas_Object *due_date_title;
+ Evas_Object *no_due_date;
+ Evas_Object *priority;
+
+ cal_save_cancel_h save_cancel;
+ Evas_Object *tabbar;
+
+ int repeat_freq; // repeat_freq off, daily, ...
+ calendar_range_type_e repeat_range;
+ int repeat_count;
+ struct tm repeat_until;
+
+ GList *alarm_list;
+
+ int account_id;
+
+ ui_gadget_h ug_worldclock;
+
+ Eina_Bool is_selected_timezone;
+ char * timezone_path; /* Asia/Seoul */
+ char * timezone_city; /* IDS_WCL_BODY_CITYNAME_SEOUL */
+ char * timezone_offset; /* GMT+9 */
+
+ Eina_List *calendar_book_list; //For save to
+
+ Elm_Object_Item *event_item;
+ Elm_Object_Item *todo_item;
+
+ char *title_str;
+ char *address;
+ double latitude;
+ double longitude;
+ char *note_str;
+
+ struct tm stm; // start
+ struct tm etm; // end
+
+ Eina_Bool is_no_due_date;
+
+}cal_edit_ug_data;
+
+enum __cal_edit_wday {
+ CAL_EDIT_WDAY_SUNDAY,
+ CAL_EDIT_WDAY_MONDAY,
+ CAL_EDIT_WDAY_TUESDAY,
+ CAL_EDIT_WDAY_WEDNESDAY,
+ CAL_EDIT_WDAY_THURSDAY,
+ CAL_EDIT_WDAY_FRIDAY,
+ CAL_EDIT_WDAY_SATURDAY,
+ CAL_EDIT_WDAY_NODAY,
+};
+
+static int __cal_edit_ug_initialize(cal_edit_ug_data *data)
+{
+ CAL_FN_START;
+
+ c_retv_if(!data, -1);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_connect();
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_connect() is failed(%x)", error);
+
+ _calendar_init_hash();
+
+ const char *path = bindtextdomain(CALENDAR, LOCALEDIR);
+ c_warn_if(!path, "bindtextdomain(%s, %s) is failed.", CALENDAR, LOCALEDIR);
+
+ cal_util_connect_pattern_generator();
+
+ return 0;
+}
+
+static int __cal_edit_ug_finish(cal_edit_ug_data *data)
+{
+ CAL_FN_START;
+
+ c_retv_if(!data, -1);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_disconnect();
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_disconnect() is failed(%x)", error);
+
+ elm_theme_extension_del(NULL, EDJDIR "/calendar_theme.edj");
+ elm_theme_extension_del(NULL, EDJDIR "/calendar_theme2.edj");
+
+ cal_util_disconnect_pattern_generator();
+
+ int ret = 0;
+
+ if(data->item_type == ITEM_TYPE_TODO)
+ ret = vconf_set_int(CAL_VCONFKEY_CREATE_EVENT_MODE, 0);
+ else
+ ret = vconf_set_int(CAL_VCONFKEY_CREATE_EVENT_MODE, 1);
+ c_warn_if(ret != 0,"vconf_set_int(CAL_VCONFKEY_CREATE_EVENT_MODE, %d) is failed(%d)", 0, ret);
+
+ return 0;
+
+}
+
+static inline void __cal_edit_ug_set_record_title(calendar_record_h record, const char *title_str)
+{
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (_calendar_is_task_record(record)) {
+ error = calendar_record_set_str(record, _calendar_todo.summary, title_str);
+ } else {
+ error = calendar_record_set_str(record, _calendar_event.summary, title_str);
+ }
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+}
+
+static inline void __cal_edit_ug_set_record_location(calendar_record_h record, const char *address, double latitude, double longitude)
+{
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (_calendar_is_task_record(record)) {
+
+ if (CAL_STRLEN(address))
+ error = calendar_record_set_str(record, _calendar_todo.location, address);
+ else
+ error = calendar_record_set_str(record, _calendar_todo.location, "");
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+
+ error = calendar_record_set_double(record, _calendar_todo.latitude, latitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_double() is failed(%x)", error);
+
+ error = calendar_record_set_double(record, _calendar_todo.longitude, longitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_double() is failed(%x)", error);
+ } else {
+
+ if (CAL_STRLEN(address))
+ error = calendar_record_set_str(record, _calendar_event.location, address);
+ else
+ error = calendar_record_set_str(record, _calendar_event.location, "");
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+
+
+ error = calendar_record_set_double(record, _calendar_event.latitude, latitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_double() is failed(%x)", error);
+
+ error = calendar_record_set_double(record, _calendar_event.longitude, longitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_double() is failed(%x)", error);
+ }
+}
+
+static inline void __cal_edit_ug_set_record_note(calendar_record_h record, const char *note_str)
+{
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (_calendar_is_task_record(record))
+ error = calendar_record_set_str(record, _calendar_todo.description, note_str);
+ else
+ error = calendar_record_set_str(record, _calendar_event.description, note_str);
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_set_record_time(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_ret_if(!p);
+ c_ret_if(!record);
+
+ if (!p->timezone_path)
+ cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
+
+ c_ret_if(!p->timezone_path);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_record_set_str(record, _calendar_event.start_tzid, p->timezone_path);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+
+ error = calendar_record_set_str(record, _calendar_event.end_tzid, p->timezone_path);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+
+ calendar_time_s start_time = {0};
+
+ _calendar_get_start_time(record, &start_time);
+
+ calendar_time_s end_time = {0};
+
+ _calendar_get_end_time(record, &end_time);
+
+ if (_calendar_is_allday_record(record)) {
+
+ start_time.time.date.year = p->stm.tm_year + 1900;
+ start_time.time.date.month = p->stm.tm_mon + 1;
+ start_time.time.date.mday = p->stm.tm_mday;
+
+ end_time.time.date.year = p->stm.tm_year + 1900;
+ end_time.time.date.month = p->stm.tm_mon + 1;
+ end_time.time.date.mday = p->stm.tm_mday;
+
+ } else {
+ cal_util_convert_tm_to_lli(NULL, &p->stm, &start_time.time.utime);
+ cal_util_convert_tm_to_lli(NULL, &p->etm, &end_time.time.utime);
+ }
+
+ error = calendar_record_set_caltime(record, _calendar_event.start_time, start_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_caltime() is failed(%x)", error);
+
+ error = calendar_record_set_caltime(record, _calendar_event.end_time, end_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_caltime() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_set_rrule_wday(calendar_record_h record, enum __cal_edit_wday tm_wday)
+{
+ c_ret_if(!record);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ switch (tm_wday) {
+ case CAL_EDIT_WDAY_SUNDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "SU");
+ break;
+
+ case CAL_EDIT_WDAY_MONDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "MO");
+ break;
+
+ case CAL_EDIT_WDAY_TUESDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "TU");
+ break;
+
+ case CAL_EDIT_WDAY_WEDNESDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "WE");
+ break;
+
+ case CAL_EDIT_WDAY_THURSDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "TH");
+ break;
+
+ case CAL_EDIT_WDAY_FRIDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "FR");
+ break;
+
+ case CAL_EDIT_WDAY_SATURDAY:
+ error = calendar_record_set_str(record, _calendar_event.byday, "SA");
+ break;
+ default:
+ ERR("Error!!");
+ error = calendar_record_set_str(record, _calendar_event.byday, "SU");
+ break;
+ }
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_set_rrule_month(calendar_record_h record, int tm_mon)
+{
+ c_ret_if(!record);
+
+ char buffer[8] = {0};
+
+ snprintf(buffer, sizeof(buffer), "%d", tm_mon + 1);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_record_set_str(record, _calendar_event.bymonth, buffer);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_set_rrule_mday(calendar_record_h record, int tm_mday)
+{
+ c_ret_if(!record);
+
+ char buffer[8] = {0};
+
+ snprintf(buffer, sizeof(buffer), "%d", tm_mday);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_record_set_str(record, _calendar_event.bymonthday, buffer);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+}
+
+static int __cal_edit_ug_g_list_compare(const void* data1, const void* data2)
+{
+ const Cal_Reminder* reminder1 = (Cal_Reminder*)data1;
+ const Cal_Reminder* reminder2 = (Cal_Reminder*)data2;
+
+ if (reminder1->tick_unit == CALENDAR_ALARM_TIME_UNIT_SPECIFIC) {
+ if (reminder2->tick_unit == CALENDAR_ALARM_TIME_UNIT_SPECIFIC) {
+ long long int dt1, dt2;
+ cal_util_convert_tm_to_lli(NULL, &reminder1->datetime, &dt1);
+ cal_util_convert_tm_to_lli(NULL, &reminder2->datetime, &dt2);
+ if (dt1 > dt2)
+ return 1;
+ else if (dt1 < dt2)
+ return -1;
+ else
+ return 0;
+ } else {
+ return 1;
+ }
+ } else {
+ if (reminder2->tick_unit == CALENDAR_ALARM_TIME_UNIT_SPECIFIC)
+ return -1;
+ else
+ return reminder1->alarm_value - reminder2->alarm_value;
+ }
+}
+
+static int __cal_edit_ug_g_list_compare_with_data(const void* data1, const void* data2, void* user_data)
+{
+ return __cal_edit_ug_g_list_compare(data1, data2);
+}
+
+
+static void __cal_edit_ug_set_record_alarm(cal_edit_ug_data *p, calendar_record_h record)
+{
+ CAL_FN_START;
+
+ c_retm_if(!p, "p is null");
+ c_retm_if(!record, "record is null");
+
+ GList *temp = NULL;
+
+ Eina_Bool is_task = _calendar_is_task_record(record);
+
+ if (is_task)
+ _calendar_clear_child_record(record, _calendar_todo.calendar_alarm);
+ else
+ _calendar_clear_child_record(record, _calendar_event.calendar_alarm);
+
+
+ Eina_List* list = NULL;
+ Evas_Object *item = NULL;
+ EINA_LIST_FOREACH(p->alarm_item_list, list, item) {
+ if(item) {
+ Cal_Reminder* reminder = evas_object_data_get(item, "data");
+
+ if (g_list_find_custom(temp, reminder, __cal_edit_ug_g_list_compare))
+ continue;
+
+ temp = g_list_insert_sorted_with_data(temp, reminder, __cal_edit_ug_g_list_compare_with_data, NULL);
+
+ calendar_record_h calendar_alarm = cal_reminder_get_cal_val(reminder);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (is_task)
+ error = calendar_record_add_child_record(record, _calendar_todo.calendar_alarm, calendar_alarm);
+ else
+ error = calendar_record_add_child_record(record, _calendar_event.calendar_alarm, calendar_alarm);
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_add_child_record() is failed(%x)", error);
+ }
+ }
+}
+
+static void __cal_edit_ug_set_record_repeat(cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ switch (p->repeat_freq) {
+ case CALENDAR_RECURRENCE_NONE:
+ break;
+
+ case CALENDAR_RECURRENCE_DAILY:
+ error = calendar_record_set_int(p->event, _calendar_event.interval, 1);
+ break;
+
+ case CAL_REPEAT_EVERY_3_DAY:
+ p->repeat_freq = CALENDAR_RECURRENCE_DAILY;
+ error = calendar_record_set_int(p->event, _calendar_event.interval, 3);
+ break;
+
+ case CALENDAR_RECURRENCE_WEEKLY:
+ __cal_edit_ug_set_rrule_wday(p->event, p->stm.tm_wday);
+ error = calendar_record_set_int(p->event, _calendar_event.interval, 1);
+ break;
+
+ case CAL_REPEAT_EVERY_2_WEEK:
+ p->repeat_freq = CALENDAR_RECURRENCE_WEEKLY;
+ __cal_edit_ug_set_rrule_wday(p->event, p->stm.tm_wday);
+ error = calendar_record_set_int(p->event, _calendar_event.interval, 2);
+ break;
+
+ case CALENDAR_RECURRENCE_YEARLY:
+ __cal_edit_ug_set_rrule_month(p->event, p->stm.tm_mon);
+ case CALENDAR_RECURRENCE_MONTHLY:
+ __cal_edit_ug_set_rrule_mday(p->event, p->stm.tm_mday);
+ error = calendar_record_set_int(p->event, _calendar_event.interval, 1);
+ break;
+
+ default:
+ break;
+ }
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+
+ error = calendar_record_set_int(p->event, _calendar_event.freq, p->repeat_freq);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+
+ error = calendar_record_set_int(p->event, _calendar_event.range_type, p->repeat_range);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+
+ if (CALENDAR_RECURRENCE_NONE != p->repeat_freq) {
+
+ if (p->repeat_range == CALENDAR_RANGE_COUNT) {
+ error = calendar_record_set_int(p->event, _calendar_event.count, p->repeat_count);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+ } else if (p->repeat_range == CALENDAR_RANGE_UNTIL) {
+
+ error = calendar_record_set_int(p->event, _calendar_event.count, 0);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+
+ calendar_time_s until_time = {0};
+
+ until_time.type = CALENDAR_TIME_UTIME;
+ cal_util_convert_tm_to_lli(NULL, &p->repeat_until, &until_time.time.utime);
+
+ error = calendar_record_set_caltime(p->event, _calendar_event.until_time, until_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+ }
+ }
+}
+
+static void __cal_edit_ug_set_record_save_to( calendar_record_h record, int calendar_book_id)
+{
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (_calendar_is_task_record(record)) {
+ error = calendar_record_set_int(record, _calendar_todo.calendar_book_id, calendar_book_id);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+ } else {
+ error = calendar_record_set_int(record, _calendar_event.calendar_book_id, calendar_book_id);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+
+ calendar_record_h calendar_book = NULL;
+
+ error = calendar_db_get_record(_calendar_book._uri, calendar_book_id, &calendar_book);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_db_get_record() is failed(%x)", error);
+
+ char *organizer_name = NULL;
+
+ error = calendar_record_get_str(calendar_book, _calendar_book.description, &organizer_name);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+
+ error = calendar_record_set_str(record, _calendar_event.organizer_name, organizer_name);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+
+ CAL_FREE(organizer_name);
+
+ error = calendar_record_destroy(calendar_book, true);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_destroy() is failed(%x)", error);
+ }
+}
+
+static void __cal_edit_ug_set_record_due_time(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_retm_if(!p, "p is null");
+ c_retm_if(!record, "record is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ calendar_time_s due_time = {0};
+
+ _calendar_get_end_time(record, &due_time);
+
+ error = calendar_record_set_str(record, _calendar_todo.due_tzid, p->timezone_path);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_str() is failed(%x)", error);
+
+ if (p->is_no_due_date) {
+ due_time.time.utime = CALENDAR_TODO_NO_DUE_DATE;
+ } else {
+ cal_util_convert_tm_to_lli(NULL, &p->etm, &due_time.time.utime);
+ }
+
+ error = calendar_record_set_caltime(record, _calendar_todo.due_time, due_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_caltime() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_set_record_priority(calendar_record_h record, int priority)
+{
+ c_retm_if(!record, "record is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_record_set_int(record, _calendar_todo.priority, priority);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_initialize_event_record(cal_edit_ug_data *p)
+{
+ CAL_FN_START;
+
+ c_retm_if(!p, "p is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if(!p->event) {
+ error = calendar_record_create(_calendar_event._uri, &p->event);
+ c_retm_if(error != CALENDAR_ERROR_NONE, "calendar_record_create() is failed(%x)", error);
+ }
+
+ p->stm = p->base_time;
+ p->stm.tm_min = p->stm.tm_sec = 0;
+
+ if (0 <= p->base_time.tm_hour)
+ p->stm.tm_hour = p->base_time.tm_hour;
+ else
+ cal_util_update_tm_hour(&p->stm,1);
+
+ p->etm = p->stm;
+ cal_util_update_tm_hour(&p->etm,1);
+
+ calendar_time_s start_time = {0};
+ calendar_time_s end_time = {0};
+
+ start_time.type = CALENDAR_TIME_UTIME;
+ end_time.type = CALENDAR_TIME_UTIME;
+
+ cal_util_convert_tm_to_lli(NULL, &p->stm, &start_time.time.utime);
+ cal_util_convert_tm_to_lli(NULL, &p->etm, &end_time.time.utime);
+
+ error = calendar_record_set_caltime(p->event, _calendar_event.start_time, start_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_caltime() is failed(%x)", error);
+
+ error = calendar_record_set_caltime(p->event, _calendar_event.end_time, end_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_caltime() is failed(%x)", error);
+
+ cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
+ __cal_edit_ug_set_record_time(p, p->event);
+
+ struct tm repeat_until = p->stm;
+ cal_util_update_tm_month (&repeat_until, 1);
+ p->repeat_freq = CALENDAR_RECURRENCE_NONE;
+ p->repeat_range = CALENDAR_RANGE_NONE;
+ p->repeat_count = 10;
+ __cal_edit_ug_set_record_repeat(p);
+
+ __cal_edit_ug_set_record_save_to(p->event, DEFAULT_EVENT_CALENDAR_BOOK_ID);
+
+ p->title_str = NULL;
+ p->note_str = NULL;
+ p->address = NULL;
+}
+
+static void __cal_edit_ug_initialize_todo_record(cal_edit_ug_data *p)
+{
+ CAL_FN_START;
+
+ c_retm_if(!p, "p is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if(!p->todo) {
+ error = calendar_record_create(_calendar_todo._uri, &p->todo);
+ c_retm_if(error != CALENDAR_ERROR_NONE, "calendar_record_create() is failed(%x)", error);
+ }
+
+ p->stm = p->base_time;
+ p->stm.tm_min = p->stm.tm_sec = 0;
+
+ if (0 <= p->base_time.tm_hour)
+ p->stm.tm_hour = p->base_time.tm_hour;
+ else
+ cal_util_update_tm_hour(&p->stm,1);
+
+ p->etm = p->stm;
+ cal_util_update_tm_hour(&p->etm,1);
+
+ calendar_time_s end_time = {0};
+ end_time.type = CALENDAR_TIME_UTIME;
+
+ cal_util_convert_tm_to_lli(NULL, &p->etm, &end_time.time.utime);
+
+ error = calendar_record_set_caltime(p->todo, _calendar_todo.due_time, end_time);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_caltime() is failed(%x)", error);
+
+ __cal_edit_ug_set_record_save_to(p->todo, DEFAULT_TODO_CALENDAR_BOOK_ID);
+
+ __cal_edit_ug_set_record_priority(p->todo, CALENDAR_TODO_PRIORITY_NORMAL);
+
+ p->title_str = NULL;
+ p->note_str = NULL;
+ p->address = NULL;
+}
+
+static inline char * __cal_edit_ug_get_record_title(calendar_record_h record)
+{
+ c_retvm_if(!record, NULL, "record is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+ char *summary = NULL;
+
+ if (_calendar_is_task_record(record))
+ error = calendar_record_get_str(record, _calendar_todo.summary, &summary);
+ else
+ error = calendar_record_get_str(record, _calendar_event.summary, &summary);
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+
+ return summary;
+}
+
+static inline void __cal_edit_ug_get_record_location(cal_edit_ug_data *p, calendar_record_h record)
+{
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ p->address = _calendar_get_location(record);
+
+ if (_calendar_is_task_record(record))
+ {
+ error = calendar_record_get_double(record, _calendar_todo.latitude, &p->latitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_double() is failed(%x)", error);
+ error = calendar_record_get_double(record, _calendar_todo.longitude, &p->longitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_double() is failed(%x)", error);
+ }
+ else
+ {
+ error = calendar_record_get_double(record, _calendar_event.latitude, &p->latitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_double() is failed(%x)", error);
+ error = calendar_record_get_double(record, _calendar_event.longitude, &p->longitude);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_double() is failed(%x)", error);
+ }
+}
+
+static inline char * __cal_edit_ug_get_record_note(calendar_record_h record)
+{
+ c_retvm_if(!record, NULL, "record is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+ char *note = NULL;
+
+ if (_calendar_is_task_record(record))
+ error = calendar_record_get_str(record, _calendar_todo.description, ¬e);
+ else
+ error = calendar_record_get_str(record, _calendar_event.description, ¬e);
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+
+ return note;
+}
+
+static int __cal_edit_ug_get_timezone_offset_with_standard_name(const char *standard_name)
+{
+ int timezone_offset = 0;
+
+ c_retv_if(!CAL_STRLEN(standard_name), timezone_offset);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ calendar_query_h query = NULL;
+
+ error = calendar_query_create(_calendar_timezone._uri, &query);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, timezone_offset, "calendar_query_create() is failed(%x)", error);
+
+ calendar_filter_h filter = NULL;
+
+ error = calendar_filter_create(_calendar_timezone._uri, &filter);
+ if (error != CALENDAR_ERROR_NONE) {
+
+ ERR("calendar_filter_create() is failed(%x)", error);
+ calendar_query_destroy(query);
+ return 0;
+ }
+
+ error = calendar_filter_add_str(filter, _calendar_timezone.standard_name, CALENDAR_MATCH_EXACTLY, standard_name);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_filter_add_str() is failed(%x)", error);
+
+ error = calendar_query_set_filter(query, filter);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_query_set_filter() is failed(%x)", error);
+
+ calendar_list_h list = NULL;
+
+ error = calendar_db_get_records_with_query(query, 0, 1, &list);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_db_get_records_with_query() is failed(%x)", error);
+
+ error = calendar_list_first(list);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_list_first() is failed(%x)", error);
+
+ calendar_record_h timezone = NULL;
+
+ error = calendar_list_get_current_record_p(list, &timezone);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_list_get_current_record_p() is failed(%x)", error);
+
+ error = calendar_record_get_int(timezone, _calendar_timezone.tz_offset_from_gmt, &timezone_offset);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_list_get_current_record_p() is failed(%x)", error);
+
+ error = calendar_list_destroy(list, true);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_list_destroy() is failed(%x)", error);
+
+ error = calendar_filter_destroy(filter);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_filter_destroy() is failed(%x)", error);
+
+ error = calendar_query_destroy(query);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_query_destroy() is failed(%x)", error);
+
+ return timezone_offset;
+}
+
+static void __cal_edit_ug_get_timezone_for_eas(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_ret_if(!p);
+ c_ret_if(!record);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ char *standard_name = NULL;
+
+ if (_calendar_is_task_record(record))
+ error = calendar_record_get_str_p(record, _calendar_todo.due_tzid, &standard_name);
+ else
+ error = calendar_record_get_str_p(record, _calendar_event.start_tzid, &standard_name);
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+
+ c_ret_if(!CAL_STRLEN(standard_name));
+
+ int timezone_offset = __cal_edit_ug_get_timezone_offset_with_standard_name(standard_name);
+
+ cal_util_get_timezone_id(timezone_offset, &p->timezone_path);
+}
+
+static void __cal_edit_ug_get_record_time_zone(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_ret_if(!p);
+ c_ret_if(!record);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (_calendar_is_eas_record(record))
+ __cal_edit_ug_get_timezone_for_eas(p, record);
+ else {
+ if (_calendar_is_task_record(record))
+ error = calendar_record_get_str(record, _calendar_todo.due_tzid, &p->timezone_path);
+ else
+ error = calendar_record_get_str(record, _calendar_event.start_tzid, &p->timezone_path);
+
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+ }
+
+ c_ret_if(!CAL_STRLEN(p->timezone_path));
+
+ cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
+}
+
+static void __cal_edit_ug_get_record_alarm(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_retm_if(!p, "p is null");
+ c_retm_if(!record, "record is null");
+
+ if (p->alarm_list) {
+ g_list_free(p->alarm_list);
+ p->alarm_list = NULL;
+ }
+
+ int alarm_count = 0;
+
+ Eina_Bool is_task = _calendar_is_task_record(record);
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (is_task)
+ {
+ error = calendar_record_get_child_record_count(record, _calendar_todo.calendar_alarm, (unsigned int *)&alarm_count);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_child_record_count() is failed(%x)", error);
+ }
+ else
+ {
+ error = calendar_record_get_child_record_count(record, _calendar_event.calendar_alarm, (unsigned int *)&alarm_count);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_child_record_count() is failed(%x)", error);
+ }
+
+ int i = 0;
+ for (i = 0; i < alarm_count; i++) {
+ calendar_record_h calendar_alarm = NULL;
+
+ if (is_task)
+ {
+ error = calendar_record_get_child_record_at_p(record, _calendar_todo.calendar_alarm, i, &calendar_alarm);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_child_record_at_p() is failed(%x)", error);
+ }
+ else
+ {
+ error = calendar_record_get_child_record_at_p(record, _calendar_event.calendar_alarm, i, &calendar_alarm);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_child_record_at_p() is failed(%x)", error);
+ }
+
+ Cal_Reminder* reminder = cal_reminder_create(calendar_alarm);
+ p->alarm_list = g_list_append(p->alarm_list,(void *)reminder);
+ }
+
+ p->alarm_list = g_list_first(p->alarm_list);
+}
+
+static void __cal_edit_ug_get_record_repeat(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_ret_if(!p);
+ c_ret_if(!record);
+
+ calendar_record_h original_record = NULL;
+ int original_event_id = 0;
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_record_get_int(record, _calendar_event.original_event_id, &original_event_id);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ if (0 < original_event_id) {
+
+ error = calendar_db_get_record(_calendar_event._uri, original_event_id, &original_record);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_db_get_record() is failed(%x)", error);
+ }
+
+ if (!original_record)
+ original_record = record;
+
+ error = calendar_record_get_int(record, _calendar_event.freq, &p->repeat_freq);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ if (p->repeat_freq == CALENDAR_RECURRENCE_WEEKLY) {
+
+ int interval = 0;
+
+ error = calendar_record_get_int(record, _calendar_event.interval, &interval);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ if (2 == interval)
+ p->repeat_freq = CAL_REPEAT_EVERY_2_WEEK;
+
+ } else if (p->repeat_freq == CALENDAR_RECURRENCE_DAILY) {
+
+ int interval = 0;
+
+ error = calendar_record_get_int(record, _calendar_event.interval, &interval);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ if (3 == interval)
+ p->repeat_freq = CAL_REPEAT_EVERY_3_DAY;
+ }
+
+ error = calendar_record_get_int(record, _calendar_event.range_type, (int *)&p->repeat_range);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ if (p->repeat_range == CALENDAR_RANGE_NONE) {
+ p->repeat_count = 10;
+
+ p->repeat_until = p->stm;
+ cal_util_update_tm_month (&p->repeat_until, 1);
+
+ } else {
+ error = calendar_record_get_int(record, _calendar_event.count, &p->repeat_count);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ calendar_time_s until_utime = {0};
+
+ error = calendar_record_get_caltime(record, _calendar_event.until_time, &until_utime);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_caltime() is failed(%x)", error);
+
+ cal_util_convert_lli_to_tm(NULL, until_utime.time.utime, &p->repeat_until);
+ }
+
+ if (original_record != record) {
+ error = calendar_record_destroy(original_record, true);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_destroy() is failed(%x)", error);
+ }
+}
+
+static int __cal_edit_ug_get_record_priority(calendar_record_h record)
+{
+ c_retv_if(!record, 0);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ int priority;
+
+ error = calendar_record_get_int(record, _calendar_todo.priority, (int *)&priority);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ return priority;
+}
+
+static void __cal_edit_ug_get_record_due_time(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_retm_if(!p, "p is null");
+ c_retm_if(!record, "record is null");
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ calendar_time_s due_time = {0};
+
+ _calendar_get_end_time(record, &due_time);
+
+ cal_util_convert_lli_to_tm(NULL, due_time.time.utime, &p->etm);
+
+ if (due_time.time.utime == CALENDAR_TODO_NO_DUE_DATE) {
+ p->is_no_due_date = EINA_TRUE;
+ //p->etm = p->base_time;
+ }
+
+ error = calendar_record_get_str(record, _calendar_todo.due_tzid, &p->timezone_path);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+
+ c_ret_if(!p->timezone_path);
+
+ cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
+}
+
+static void __cal_edit_ug_update_title_item(Evas_Object *entry, calendar_record_h record)
+{
+ c_retm_if(!entry, "entry is null");
+ c_retm_if(!record, "record is null");
+
+ char* title = __cal_edit_ug_get_record_title(record);
+
+ elm_entry_entry_set(entry, title);
+
+ CAL_FREE(title);
+}
+
+static void __cal_edit_ug_update_note_item(Evas_Object *entry, calendar_record_h record)
+{
+ c_retm_if(!entry, "entry is null");
+ c_retm_if(!record, "record is null");
+
+ char* note = __cal_edit_ug_get_record_note(record);
+
+ elm_entry_entry_set(entry, note);
+
+ CAL_FREE(note);
+}
+
+static void __cal_edit_ug_update_location_item(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_retm_if(!p, "p is null");
+ c_retm_if(!record, "record is null");
+
+ __cal_edit_ug_get_record_location(p, record);
+ elm_entry_entry_set(p->location_entry, p->address);
+}
+
+static void __cal_edit_ug_get_save_to_str(int calid, char *buf, int sz);
+
+static void __cal_edit_ug_update_save_to_item(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_retm_if(!p, "p is null");
+
+ int calendar_book_id = _calendar_get_calendar_index(record);
+
+ char buf[1024];
+ char* saveto_text = NULL;
+ if (calendar_book_id == DEFAULT_EVENT_CALENDAR_BOOK_ID)
+ saveto_text = strdup(C_("IDS_CLD_BODY_MY_CALENDAR"));
+ else if (calendar_book_id == DEFAULT_TODO_CALENDAR_BOOK_ID)
+ saveto_text = strdup(C_("IDS_TASK_BODY_MY_TASK"));
+ else {
+ __cal_edit_ug_get_save_to_str(calendar_book_id, buf, sizeof(buf));
+ saveto_text = strdup(buf);
+ }
+
+ elm_object_part_text_set(p->saveto, "elm.text.1", saveto_text);
+
+ CAL_FREE(saveto_text);
+}
+
+static void __cal_edit_ug_update_priority_item(cal_edit_ug_data *p, calendar_record_h record)
+{
+ c_retm_if(!p, "p is null");
+ c_retm_if(!record, "record is null");
+
+ char* priority_text = NULL;
+ int priority = __cal_edit_ug_get_record_priority(record);
+ switch (priority) {
+ case CALENDAR_TODO_PRIORITY_LOW:
+ priority_text = strdup(S_("IDS_COM_BODY_LOW"));
+ break;
+ case CALENDAR_TODO_PRIORITY_NORMAL:
+ priority_text =strdup(C_("IDS_IDLE_BODY_NORMAL"));
+ break;
+ case CALENDAR_TODO_PRIORITY_HIGH:
+ priority_text =strdup(S_("IDS_COM_OPT_HIGH_M_QUALITY"));
+ break;
+ default:
+ break;
+ }
+
+ elm_object_part_text_set(p->priority, "elm.text.1", priority_text);
+ CAL_FREE(priority_text);
+
+}
+
+static void __cal_edit_ug_update_start_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ elm_object_part_text_set(item, "elm.text", C_("IDS_CLD_BODY_FROM"));
+}
+
+static void __cal_edit_ug_update_end_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ elm_object_part_text_set(item, "elm.text", C_("IDS_CLD_BODY_TO"));
+}
+
+static void __cal_edit_ug_update_due_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ elm_object_part_text_set(item, "elm.text", C_("IDS_CLD_BODY_DUE_DATE"));
+}
+
+static Evas_Object *__cal_edit_ug_insert_padding_after(cal_edit_ug_data* p, const char* title, Evas_Object *after)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!after, NULL);
+
+ Evas_Object *item = cal_dialogue_insert_item_after(p->dialogue, "title", after, NULL, NULL);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ if (CAL_STRLEN(title))
+ elm_object_part_text_set(item, "elm.text", title);
+
+ return item;
+}
+
+static void __cal_edit_ug_title_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ const char *str;
+ cal_edit_ug_data* p = (cal_edit_ug_data *)data;
+
+ free(p->title_str);
+
+ str = elm_entry_entry_get(p->title_entry);
+ if (!str || str[0] == '\0')
+ p->title_str = NULL;
+ else
+ p->title_str = elm_entry_markup_to_utf8(str);
+
+ if(p->item_type == ITEM_TYPE_TODO)
+ __cal_edit_ug_set_record_title(p->todo, p->title_str);
+ else
+ __cal_edit_ug_set_record_title(p->event, p->title_str);
+}
+
+static Evas_Object * __cal_edit_ug_title_icon(cal_edit_ug_data* p, Evas_Object *obj)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!obj, NULL);
+
+ Evas_Object *ef = cal_util_add_edit_field(obj, S_("IDS_COM_BODY_DETAILS_TITLE"), EINA_FALSE, EINA_TRUE);
+ c_retvm_if(!ef, NULL, "ef is null");
+
+ Evas_Object *entry = elm_object_part_content_get(ef, "elm.swallow.content");
+ c_retvm_if(!entry, ef, "entry is null");
+
+ elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
+
+ p->title_entry = entry;
+
+ if (p->item_type == ITEM_TYPE_TODO)
+ __cal_edit_ug_update_title_item(p->title_entry, p->todo);
+ else
+ __cal_edit_ug_update_title_item(p->title_entry, p->event);
+
+ evas_object_smart_callback_add(p->title_entry, "changed", __cal_edit_ug_title_entry_changed_callback, p);
+ evas_object_smart_callback_add(p->title_entry, "preedit,changed", __cal_edit_ug_title_entry_changed_callback, p);
+
+ cal_save_cancel_set_input_panel_callback_for_ug(p->save_cancel, p->title_entry);
+
+ return ef;
+
+}
+
+static void __cal_edit_ug_update_title_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ Evas_Object *edit_field = elm_object_part_content_get(item, "elm.icon");
+ c_ret_if(!edit_field);
+
+ elm_object_part_text_set(edit_field, "elm.guidetext", S_("IDS_COM_BODY_DETAILS_TITLE"));
+}
+
+static Evas_Object *__cal_edit_ug_add_title(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_append_item(p->dialogue, "1icon", NULL, NULL);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ Evas_Object *editfield = __cal_edit_ug_title_icon(p, item);
+ c_retvm_if(!editfield, NULL, "__cal_edit_ug_title_icon() is failed");
+
+ elm_object_part_content_set(item, "elm.icon", editfield);
+
+ return item;
+}
+
+static void __cal_edit_ug_location_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ c_ret_if(!data);
+
+ cal_edit_ug_data *p = data;
+ c_ret_if(!p);
+
+ CAL_FREE(p->address);
+
+ p->address = elm_entry_markup_to_utf8(elm_entry_entry_get(p->location_entry));
+
+ if (!CAL_STRLEN(p->address)) {
+
+ p->longitude = p->latitude = CALENDAR_RECORD_NO_COORDINATE;
+
+ }
+
+ if (p->item_type == ITEM_TYPE_TODO)
+ __cal_edit_ug_set_record_location(p->todo, p->address, p->latitude, p->longitude);
+ else
+ __cal_edit_ug_set_record_location(p->event, p->address, p->latitude, p->longitude);
+}
+
+static Evas_Object * __cal_edit_ug_location_icon(cal_edit_ug_data* p, Evas_Object *obj)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!obj, NULL);
+
+ Evas_Object *ly = NULL;
+
+ Evas_Object *ef = cal_util_add_edit_field(obj, C_("IDS_COM_BODY_DETAILS_LOCATION"), EINA_FALSE, EINA_TRUE);
+ ly = ef;
+
+ p->location_entry = elm_object_part_content_get(ef, "elm.swallow.content");
+ c_retv_if(!p->location_entry, ly);
+
+ evas_object_smart_callback_add(p->location_entry, "changed", __cal_edit_ug_location_entry_changed_callback, p);
+ evas_object_smart_callback_add(p->location_entry, "preedit,changed", __cal_edit_ug_location_entry_changed_callback, p);
+ cal_save_cancel_set_input_panel_callback_for_ug(p->save_cancel, p->location_entry);
+
+ elm_entry_cnp_mode_set(p->location_entry, ELM_CNP_MODE_PLAINTEXT);
+
+ if (p->item_type == ITEM_TYPE_TODO)
+ __cal_edit_ug_update_location_item(p, p->todo);
+ else
+ __cal_edit_ug_update_location_item(p, p->event);
+
+ return ly;
+}
+
+static void __cal_edit_ug_update_location_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ Evas_Object *layout = elm_object_part_content_get(item, "elm.icon");
+ c_ret_if(!layout);
+
+ Evas_Object *edit_field = elm_object_part_content_get(layout, "editfield/sw");
+ c_ret_if(!edit_field);
+
+ elm_object_part_text_set(edit_field, "elm.guidetext", C_("IDS_COM_BODY_DETAILS_LOCATION"));
+
+ Evas_Object *button = elm_object_part_content_get(layout, "button/sw");
+ c_ret_if(!button);
+
+ elm_object_text_set(button, C_("IDS_LBS_BODY_MAP"));
+}
+
+static Evas_Object *__cal_edit_ug_add_location(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_append_item(p->dialogue, "1icon", NULL, NULL);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ Evas_Object *editfield = __cal_edit_ug_location_icon(p, item);
+ c_retvm_if(!editfield, NULL, "__cal_edit_ug_note_icon() is failed");
+
+ elm_object_part_content_set(item, "elm.icon", editfield);
+
+ __cal_edit_ug_insert_padding_after(p, NULL, item);
+
+ return item;
+}
+
+static void __cal_edit_ug_note_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ char *email_link = NULL;
+ cal_edit_ug_data *p = data;
+ char *str = elm_entry_markup_to_utf8(elm_entry_entry_get(p->note_entry));
+
+ if (CAL_STRLEN(p->note_str))
+ email_link = strstr(p->note_str, EMAIL_LINK_FLAG);
+
+ if ((NULL != email_link) && CAL_STRLEN(str) && (NULL != strstr(p->note_str, str))) {
+ char *strnote = NULL;
+ int strnote_len = 0;
+ strnote_len = strlen(str) + strlen(email_link);
+ CAL_CALLOC(strnote, strnote_len+1, char);
+ if (NULL != strnote)
+ {
+ snprintf(strnote, strnote_len + 1, "%s%s", str, email_link);
+ p->note_str = strdup(strnote);
+
+ free(strnote);
+ }
+ else
+ {
+ p->note_str = NULL;
+ }
+
+ } else {
+ p->note_str = CAL_STRDUP(str);
+ }
+
+ free(str);
+
+ if(p->item_type == ITEM_TYPE_TODO)
+ __cal_edit_ug_set_record_note(p->todo, p->note_str);
+ else
+ __cal_edit_ug_set_record_note(p->event, p->note_str);
+}
+
+
+static Evas_Object * __cal_edit_ug_note_icon(cal_edit_ug_data* p, Evas_Object *obj)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!obj, NULL);
+
+ Evas_Object *ef = cal_util_add_edit_field(obj, C_("IDS_CLD_BODY_CREATE_DESCRITION"), EINA_FALSE, EINA_TRUE );
+
+ if (ef) {
+ Evas_Object *entry = elm_object_part_content_get(ef, "elm.swallow.content");
+ c_retvm_if(!entry, ef, "entry is null");
+
+ evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_EXPAND);
+ //elm_entry_autocapital_type_set(entry, EINA_TRUE);
+ elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
+
+ p->note_entry = entry;
+
+ if (p->note_str) {
+
+ char *email_link = NULL;
+ email_link = strstr(p->note_str, EMAIL_LINK_FLAG);
+ if(!email_link)
+ elm_entry_entry_set(p->note_entry, elm_entry_utf8_to_markup(p->note_str));
+ else {
+
+ char *snote_display = NULL;
+ int nsize = email_link - p->note_str + 1;
+ snote_display = calloc(nsize, sizeof(char));
+ c_retvm_if(!snote_display , NULL, "calloc(nsize, sizeof(char)) is failed");
+
+ CAL_STRNCPY(snote_display, p->note_str, nsize-1);
+
+ elm_entry_entry_set(p->note_entry, elm_entry_utf8_to_markup(snote_display));
+ free(snote_display);
+ }
+ }
+
+ if (p->item_type == ITEM_TYPE_TODO)
+ __cal_edit_ug_update_note_item(p->note_entry, p->todo);
+ else
+ __cal_edit_ug_update_note_item(p->note_entry, p->event);
+
+ evas_object_smart_callback_add(p->note_entry, "changed", __cal_edit_ug_note_entry_changed_callback, p);
+ evas_object_smart_callback_add(p->note_entry, "preedit,changed", __cal_edit_ug_note_entry_changed_callback, p);
+ cal_save_cancel_set_input_panel_callback_for_ug(p->save_cancel, p->note_entry);
+
+ return ef;
+ }
+
+ return NULL;
+}
+
+static void __cal_edit_ug_update_description_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ Evas_Object *edit_field = elm_object_part_content_get(item, "elm.icon");
+ c_ret_if(!edit_field);
+
+ elm_object_part_text_set(edit_field, "elm.guidetext", C_("IDS_CLD_BODY_CREATE_DESCRITION"));
+}
+
+static Evas_Object *__cal_edit_ug_add_note(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_append_item(p->dialogue, "1icon", NULL, NULL);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ Evas_Object *editfield = __cal_edit_ug_note_icon(p, item);
+ c_retvm_if(!editfield, NULL, "__cal_edit_ug_location_icon() is failed");
+
+
+ elm_object_part_content_set(item, "elm.icon", editfield);
+
+ return item;
+}
+
+static Evas_Object * __cal_edit_ug_edit_time_icon(Evas_Object *obj, struct tm* value, Eina_Bool allday)
+{
+ c_retvm_if(!obj, NULL, "obj is null");
+
+ Evas_Object* icon_obj = cal_util_add_datetime(obj, NULL, value);
+ c_retvm_if(!icon_obj, NULL, "icon_obj is null");
+
+ elm_object_part_content_set(obj, "datefield", icon_obj);
+
+ if (is_hour24)
+ elm_datetime_format_set(icon_obj, "%b %d , %Y %H : %M");
+ else
+ elm_datetime_format_set(icon_obj, "%b %d , %Y %I : %M %p");
+
+ if (!allday)
+ {
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_HOUR, EINA_TRUE);
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_MINUTE, EINA_TRUE);
+ if (is_hour24)
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_AMPM, EINA_FALSE);
+ else
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_AMPM, EINA_TRUE);
+ }
+ else
+ {
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_HOUR, EINA_FALSE);
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_MINUTE, EINA_FALSE);
+ elm_datetime_field_visible_set(icon_obj, ELM_DATETIME_AMPM, EINA_FALSE);
+ }
+
+ elm_datetime_field_limit_set(icon_obj, ELM_DATETIME_YEAR, 70, 136);
+
+ return icon_obj;
+}
+
+static Eina_Bool __cal_edit_ug_check_date_validity(void *data)
+{
+ c_retv_if(!data, EINA_FALSE);
+ cal_edit_ug_data* p = data;
+
+ time_t start_t = mktime(&p->stm);
+ time_t end_t = mktime(&p->etm);
+
+ if(start_t > end_t)
+ return EINA_FALSE;
+
+ return EINA_TRUE;
+}
+
+static void __cal_edit_ug_start_date_changed_callback(void *data, Evas_Object* obj, void *ei)
+{
+ c_retm_if(data == NULL, "data is null");
+ cal_edit_ug_data *p = data;
+
+ struct tm value;
+ time_t t = time(NULL);
+ localtime_r(&t, &value); // to fill hidden field
+
+ elm_datetime_value_get(obj, &value);
+
+ // Remember the time difference in before updating start time
+ time_t start_t = mktime(&p->stm);
+ time_t end_t = mktime(&p->etm);
+ time_t diff = end_t - start_t;
+
+ // Update start time variable
+ p->stm = value;
+
+ Eina_Bool result =__cal_edit_ug_check_date_validity(p);
+ if(!result) {
+ // Calculate end time from start time to retain the time difference
+ end_t = mktime(&p->stm) + diff;
+ localtime_r(&end_t, &p->etm);
+
+ // Update end time on the screen
+ Evas_Object *end_date_obj = elm_object_part_content_get(p->end_date, "elm.icon");
+ elm_datetime_value_set(end_date_obj, &p->etm);
+ }
+
+ __cal_edit_ug_set_record_time(p, p->event);
+}
+
+static void __cal_edit_ug_end_date_changed_callback(void *data, Evas_Object* obj, void *ei)
+{
+ c_retm_if(!data, "data is null");
+ cal_edit_ug_data *p = data;
+
+ struct tm value;
+ time_t t = time(NULL);
+ localtime_r(&t, &value); // to fill hidden field
+
+ elm_datetime_value_get(obj, &value);
+
+ p->etm = value;
+
+ __cal_edit_ug_set_record_time(p, p->event);
+}
+
+static void __cal_edit_ug_due_date_changed_callback(void *data, Evas_Object* obj, void *ei)
+{
+ c_retm_if(!data, "data is null");
+ cal_edit_ug_data *p = data;
+
+ struct tm value;
+ time_t t = time(NULL);
+ localtime_r(&t, &value); // to fill hidden field
+
+ elm_datetime_value_get(obj, &value);
+
+ p->etm = value;
+
+ __cal_edit_ug_set_record_due_time(p, p->todo);
+
+}
+
+static void __cal_edit_ug_update_datetime_region(Evas_Object *item, struct tm *tm, Eina_Bool is_allday, Evas_Smart_Cb callback, void *callback_data)
+{
+ c_ret_if(!item);
+
+ Evas_Object *datetime = NULL;
+
+ datetime = elm_object_part_content_unset(item, "elm.icon");
+ if (datetime)
+ evas_object_del(datetime);
+
+ datetime = __cal_edit_ug_edit_time_icon(item, tm, is_allday);
+ c_ret_if(!datetime);
+
+ elm_object_part_content_set(item, "elm.icon", datetime);
+
+ evas_object_smart_callback_add(datetime, "changed", callback, callback_data);
+}
+
+static Evas_Object *__cal_edit_ug_insert_timepicker_after(cal_edit_ug_data* p, struct tm* value, Eina_Bool allday, Evas_Object *after, Evas_Smart_Cb callback)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!after, NULL);
+
+ Evas_Object *item = cal_dialogue_insert_item_after(p->dialogue, "1icon", after, NULL, NULL);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ __cal_edit_ug_update_datetime_region(item, value, allday, callback, p);
+
+ return item;
+}
+
+static void __cal_edit_ug_all_day_update(Evas_Object* date_obj, Eina_Bool allday)
+{
+ Evas_Object *edit_time_obj = elm_object_part_content_get(date_obj, "elm.icon");
+
+ if (!allday) {
+ elm_datetime_field_visible_set(edit_time_obj, ELM_DATETIME_HOUR, EINA_TRUE);
+ elm_datetime_field_visible_set(edit_time_obj, ELM_DATETIME_MINUTE, EINA_TRUE);
+ if (!is_hour24)
+ elm_datetime_field_visible_set(edit_time_obj, ELM_DATETIME_AMPM, EINA_TRUE);
+ } else {
+ elm_datetime_field_visible_set(edit_time_obj, ELM_DATETIME_HOUR, EINA_FALSE);
+ elm_datetime_field_visible_set(edit_time_obj, ELM_DATETIME_MINUTE, EINA_FALSE);
+ elm_datetime_field_visible_set(edit_time_obj, ELM_DATETIME_AMPM, EINA_FALSE);
+ }
+}
+
+static void __cal_edit_ug_set_record_allday(calendar_record_h record, Eina_Bool is_allday, cal_edit_ug_data *p)
+{
+ c_ret_if(!record);
+ c_ret_if(!p);
+
+ if (is_allday == _calendar_is_allday_record(record))
+ return;
+
+ calendar_time_s start_time = {0};
+
+ _calendar_get_start_time(record, &start_time);
+
+ calendar_time_s end_time = {0};
+
+ _calendar_get_end_time(record, &end_time);
+
+ struct tm start_tm = {0};
+ struct tm end_tm = {0};
+
+ if (is_allday) {
+
+ cal_util_convert_lli_to_tm(NULL, start_time.time.utime, &start_tm);
+ cal_util_convert_lli_to_tm(NULL, end_time.time.utime, &end_tm);
+
+ start_time.type = CALENDAR_TIME_LOCALTIME;
+ end_time.type = CALENDAR_TIME_LOCALTIME;
+
+ start_time.time.date.year = start_tm.tm_year + 1900;
+ start_time.time.date.month = start_tm.tm_mon + 1;
+ start_time.time.date.mday = start_tm.tm_mday;
+
+ end_time.time.date.year = end_tm.tm_year + 1900;
+ end_time.time.date.month = end_tm.tm_mon + 1;
+ end_time.time.date.mday = end_tm.tm_mday;
+
+ } else {
+
+ start_time.type = CALENDAR_TIME_UTIME;
+ end_time.type = CALENDAR_TIME_UTIME;
+
+ cal_util_convert_tm_to_lli(NULL, &p->stm, &start_time.time.utime);
+ cal_util_convert_tm_to_lli(NULL, &p->etm, &end_time.time.utime);
+ }
+
+ _calendar_set_start_time(record, &start_time);
+
+ _calendar_set_end_time(record, &end_time);
+}
+
+static void __cal_edit_ug_all_day_clicked_callback(Evas_Object *obj, void *data)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+ cal_edit_ug_data *p = data;
+
+ Evas_Object *all_obj = elm_object_part_content_get(p->allday, "elm.icon");
+ c_ret_if(!all_obj);
+
+ Eina_Bool is_allday = !elm_check_state_get(all_obj);
+
+ elm_check_state_set(all_obj, is_allday);
+
+ __cal_edit_ug_all_day_update(p->start_date, is_allday);
+ __cal_edit_ug_all_day_update(p->end_date, is_allday);
+
+ __cal_edit_ug_set_record_allday(p->event, is_allday, p);
+
+}
+
+static void __cal_edit_ug_all_day_changed_callback(void *data, Evas_Object* obj, void *ei)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+ c_retm_if(!obj, "obj is null");
+
+ cal_edit_ug_data *p = data;
+
+ Eina_Bool is_allday = elm_check_state_get(obj);
+
+ __cal_edit_ug_all_day_update(p->start_date, is_allday);
+ __cal_edit_ug_all_day_update(p->end_date, is_allday);
+
+ __cal_edit_ug_set_record_allday(p->event, is_allday, p);
+}
+
+static void __cal_edit_ug_update_allday_language(Evas_Object *item)
+{
+ c_ret_if(!item);
+
+ elm_object_part_text_set(item, "elm.text", C_("IDS_COM_BODY_ALL_DAY"));
+}
+
+static Evas_Object *__cal_edit_ug_add_all_day(cal_edit_ug_data* p, Eina_Bool allday)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_insert_item_after(p->dialogue, "1text.1icon", p->timezone, __cal_edit_ug_all_day_clicked_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ Evas_Object *check_obj;
+ check_obj = elm_check_add(item);
+ elm_check_state_set(check_obj, allday);
+ elm_object_style_set(check_obj, "on&off");
+ evas_object_smart_callback_add(check_obj, "changed", __cal_edit_ug_all_day_changed_callback, p);
+ elm_check_state_set(check_obj, allday);
+ evas_object_propagate_events_set(check_obj, EINA_FALSE);
+
+ elm_object_part_content_set(item, "elm.icon", check_obj);
+
+ __cal_edit_ug_update_allday_language(item);
+
+ return item;
+}
+
+static void __cal_edit_ug_worldclock_ug_destroy_callback(ui_gadget_h ug, void *priv)
+{
+ CAL_FN_START;
+
+ cal_edit_ug_data* p = (cal_edit_ug_data*) priv;
+
+ if (p->ug_worldclock) {
+ ug_destroy(p->ug_worldclock);
+ p->ug_worldclock= NULL;
+ }
+
+ Elm_Object_Item* navi_item = elm_naviframe_top_item_get(p->naviframe);
+ Evas_Object *back_btn = elm_object_item_part_content_get(navi_item, "prev_btn");
+ if (back_btn != NULL) {
+ elm_object_style_set(back_btn, "naviframe/back_btn/default"); /* take into effect */
+ }
+}
+
+static void __cal_edit_ug_worldclock_ug_result_callback(ui_gadget_h ug, service_h result, void *priv)
+{
+ CAL_FN_START;
+
+ c_retm_if(!priv, "priv is null");
+ c_retm_if(!result, "result is null");
+
+ cal_edit_ug_data *p = priv;
+
+ if (p->timezone_city) {
+ free(p->timezone_city);
+ p->timezone_city = NULL;
+ }
+
+ if (p->timezone_path) {
+ free(p->timezone_path);
+ p->timezone_path = NULL;
+ }
+
+ if (p->timezone_offset) {
+ free(p->timezone_offset);
+ p->timezone_offset = NULL;
+ }
+
+ char *tzpath = NULL;
+
+ int r = service_get_extra_data(result, "tzpath", &tzpath);
+ c_ret_if(r != SERVICE_ERROR_NONE);
+
+ p->timezone_path= tzpath;
+
+ cal_util_get_timezone(&p->timezone_path, &p->timezone_city, &p->timezone_offset);
+
+ p->is_selected_timezone = EINA_TRUE;
+
+ //update
+ char* timezone_text = NULL;
+ timezone_text = g_strdup_printf("%s, %s", S_(p->timezone_city), p->timezone_offset);
+ elm_object_part_text_set(p->timezone, "elm.text.1", timezone_text);
+ CAL_FREE(timezone_text);
+}
+
+static void __cal_edit_ug_worldclock_ug_layout_callback(ui_gadget_h ug, enum ug_mode mode, void *priv)
+{
+ CAL_FN_START;
+
+ c_retm_if(!ug, "ug is null");
+
+ Evas_Object *base = ug_get_layout(ug);
+ if (!base) {
+ ug_destroy(ug);
+ return;
+ }
+
+ switch (mode)
+ {
+ case UG_MODE_FULLVIEW:
+ evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
+ EVAS_HINT_EXPAND);
+ evas_object_show(base);
+ break;
+ default:
+ DBG("Unsupported ug layout");
+ break;
+ }
+
+}
+
+static void __cal_edit_ug_timezone_select_callback(Evas_Object *obj, void *data)
+{
+ c_retm_if(!data, "data is null");
+
+ cal_edit_ug_data *p = data;
+ struct ug_cbs uc;
+ ui_gadget_h ug;
+ memset(&uc, 0, sizeof(struct ug_cbs));
+ uc.destroy_cb = __cal_edit_ug_worldclock_ug_destroy_callback;
+ uc.layout_cb = __cal_edit_ug_worldclock_ug_layout_callback;
+ uc.result_cb = __cal_edit_ug_worldclock_ug_result_callback;
+ uc.priv = p;
+
+ ug = ug_create(NULL, "worldclock-efl", UG_MODE_FULLVIEW, NULL, &uc);
+ p->ug_worldclock = ug;
+}
+
+static void __cal_edit_ug_update_time_zone_language(Evas_Object *item, const char *timezone_city, const char *timezone_offset)
+{
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_CLD_BODY_TIME_ZONE"));
+
+ char buffer[128] = {0};
+
+ snprintf(buffer, sizeof(buffer), "%s, %s", S_(timezone_city), timezone_offset);
+
+ elm_object_part_text_set(item, "elm.text.1", buffer);
+}
+
+static Evas_Object *__cal_edit_ug_add_time_zone(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = __cal_edit_ug_insert_padding_after(p, NULL, p->end_date);
+ c_retvm_if(!item, NULL, "__cal_edit_ug_insert_padding_after() is failed");
+
+ item = cal_dialogue_insert_item_after(p->dialogue, "2text.2", item, __cal_edit_ug_timezone_select_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ __cal_edit_ug_get_record_time_zone(p, p->event);
+
+ __cal_edit_ug_update_time_zone_language(item, p->timezone_city, p->timezone_offset);
+
+ return item;
+}
+
+static void __cal_edit_ug_alarm_changed_callback(const Cal_Reminder* reminder, void* data)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+
+ Evas_Object *obj = data;
+
+ char* alarm_text = NULL;
+ char buf[128] = {0};
+ cal_reminder_get_string(reminder, buf, sizeof(buf));
+ alarm_text = strdup(buf);
+
+ elm_object_part_text_set(obj, "elm.text.1", alarm_text);
+ CAL_FREE(alarm_text);
+
+ Cal_Reminder* reminder_temp = evas_object_data_get(obj, "data");
+ reminder_temp->alarm_value = reminder->alarm_value;
+ reminder_temp->datetime = reminder->datetime;
+ reminder_temp->tick_unit = reminder->tick_unit;
+}
+
+static void __cal_edit_ug_alarm_select_callback(Evas_Object *obj, void *data)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+
+ cal_edit_ug_data* p = data;
+ Cal_Reminder* reminder = (Cal_Reminder*)evas_object_data_get(obj, "data");
+ cal_edit_alarm_type alarm_type = ALARM_TYPE_EVENT;
+
+ if(p->item_type == ITEM_TYPE_EVENT)
+ alarm_type = ALARM_TYPE_EVENT;
+ else if(p->item_type == ITEM_TYPE_TODO && p->is_no_due_date)
+ alarm_type = ALARM_TYPE_TODO_CUSTOM_ONLY;
+ else
+ alarm_type = ALARM_TYPE_TODO;
+
+ cal_edit_alarm_create_view(p->naviframe, reminder, alarm_type, __cal_edit_ug_alarm_changed_callback, obj);
+
+}
+
+static Evas_Object *__cal_edit_ug_add_alarm(cal_edit_ug_data* p, Cal_Reminder* reminder, Eina_Bool is_add_mode, Evas_Object *after);
+
+static void __cal_edit_ug_delete_reminder_callback(void *data, Evas *e, Evas_Object *obj, void *ei)
+{
+ CAL_FN_START;
+
+ c_ret_if(!data);
+
+ free(data);
+}
+
+
+static void __cal_edit_ug_alarm_plus_button_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+ c_retm_if(!obj, "obj is null");
+
+ cal_edit_ug_data* p = data;
+
+ if (eina_list_count(p->alarm_item_list)>=4) {
+ evas_object_del(p->alarm_plus_button);
+ p->alarm_plus_button = NULL;
+ }
+
+ Cal_Reminder* reminder = calloc(1, sizeof(Cal_Reminder));
+ c_retm_if(!reminder, "reminder is null");
+ reminder->tick_unit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
+ reminder->datetime = p->stm;
+
+ Eina_List *list = eina_list_last(p->alarm_item_list);
+ Evas_Object *last_item = eina_list_data_get(list);
+ __cal_edit_ug_add_alarm(p, reminder, EINA_FALSE, last_item);
+
+}
+
+static Evas_Object * __cal_edit_ug_alarm_plus_button_icon(cal_edit_ug_data* p, Evas_Object *obj)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!obj, NULL);
+
+ Evas_Object *button = NULL;
+
+ button = elm_button_add(obj);
+ c_retvm_if(!button, NULL, "elm_button_add() is failed");
+
+ elm_object_style_set(button, "icon_plus");
+ evas_object_propagate_events_set(button, EINA_FALSE);
+ evas_object_smart_callback_add(button, "clicked", __cal_edit_ug_alarm_plus_button_callback, p);
+ evas_object_show(button);
+ p->alarm_plus_button = button;
+
+ return button;
+}
+
+static void __cal_edit_ug_alarm_minus_button_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+ c_retm_if(!obj, "obj is null");
+
+ cal_edit_ug_data* p = data;
+
+ if (!p->alarm_plus_button) {
+ Evas_Object *first_item = eina_list_nth(p->alarm_item_list, 0);
+ p->alarm_plus_button = __cal_edit_ug_alarm_plus_button_icon(p, first_item);
+ elm_object_part_content_set(first_item, "elm.icon", p->alarm_plus_button);
+ }
+
+ evas_object_smart_callback_del(obj, "clicked", __cal_edit_ug_alarm_minus_button_callback);
+
+ Evas_Object *parent_item = evas_object_data_get(obj, "button");
+ p->alarm_item_list = eina_list_remove(p->alarm_item_list, parent_item);
+
+ cal_dialogue_delete_item(p->dialogue, parent_item);
+ evas_object_del(obj);
+
+
+}
+
+
+static Evas_Object * __cal_edit_ug_alarm_minus_button_icon(cal_edit_ug_data* p, Evas_Object *obj)
+{
+ c_retv_if(!p, NULL);
+ c_retv_if(!obj, NULL);
+
+ Evas_Object *button = NULL;
+
+ button = elm_button_add(obj);
+ c_retvm_if(!button, NULL, "elm_button_add() is failed");
+
+ elm_object_style_set(button, "icon_minus");
+ evas_object_data_set(button, "button", obj);
+ evas_object_propagate_events_set(button, EINA_FALSE);
+ evas_object_smart_callback_add(button, "clicked", __cal_edit_ug_alarm_minus_button_callback, p);
+ evas_object_show(button);
+
+ return button;
+}
+
+static void __cal_edit_ug_update_reminder_language(Eina_List *item_list)
+{
+ c_ret_if(!item_list);
+
+ Eina_List *cursor = NULL;
+ Evas_Object *item = NULL;
+
+ EINA_LIST_FOREACH(item_list, cursor, item) {
+ if (!item)
+ continue;
+
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_CLD_BODY_REMINDER"));
+
+ Cal_Reminder *reminder = NULL;
+
+ reminder = evas_object_data_get(item, "data");
+
+ char buffer[128] = {0};
+ cal_reminder_get_string(reminder, buffer, sizeof(buffer));
+
+ elm_object_part_text_set(item, "elm.text.1", buffer);
+ }
+}
+
+static Evas_Object *__cal_edit_ug_add_alarm(cal_edit_ug_data* p, Cal_Reminder* reminder, Eina_Bool is_add_mode, Evas_Object *after)
+{
+ c_retv_if(!p, NULL);
+ Evas_Object *item = NULL;
+ if(after) {
+ item = cal_dialogue_insert_item_after(p->dialogue, "2text.1icon.5", after, __cal_edit_ug_alarm_select_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_insert_item_after() is failed");
+ }
+ else {
+ item = cal_dialogue_append_item(p->dialogue, "2text.1icon.5", __cal_edit_ug_alarm_select_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+ }
+
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_CLD_BODY_REMINDER"));
+
+ const char* alarm_text = NULL;
+ char buf[128] = {0};
+ cal_reminder_get_string(reminder, buf, sizeof(buf));
+ alarm_text = strdup(buf);
+
+ elm_object_part_text_set(item, "elm.text.1", alarm_text);
+ p->alarm_item_list = eina_list_append(p->alarm_item_list, (void*)item);
+
+ if(p->item_type == ITEM_TYPE_EVENT) {
+ Evas_Object *button_obj = NULL;
+ if(is_add_mode)
+ button_obj = __cal_edit_ug_alarm_plus_button_icon(p, item);
+ else
+ button_obj = __cal_edit_ug_alarm_minus_button_icon(p, item);
+
+ elm_object_part_content_set(item, "elm.icon", button_obj);
+ }
+
+ evas_object_data_set(item, "data", reminder);
+ evas_object_event_callback_add(item, EVAS_CALLBACK_DEL, __cal_edit_ug_delete_reminder_callback, reminder);
+
+ return item;
+}
+
+static void __cal_edit_ug_add_multi_alarm(cal_edit_ug_data* p)
+{
+ c_retm_if(!p, "p is null");
+
+ Cal_Reminder* reminder = NULL;
+ reminder = calloc(1, sizeof(Cal_Reminder));
+ c_retm_if(!reminder, "reminder is null");
+
+ reminder->tick_unit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
+ reminder->datetime = p->stm;
+ Evas_Object *after = NULL;
+ Evas_Object *item = NULL;
+
+ if(p->is_edit_mode) {
+ if (p->item_type == ITEM_TYPE_EVENT)
+ __cal_edit_ug_get_record_alarm(p, p->event);
+ else
+ __cal_edit_ug_get_record_alarm(p, p->todo);
+
+ if(!p->alarm_list) {
+ reminder->tick_unit = CALENDAR_ALARM_NONE;\
+ }
+ }
+
+ GList *temp = p->alarm_list;
+ if (!temp) {
+ __cal_edit_ug_add_alarm(p, reminder, EINA_TRUE, NULL);
+ }
+ else {
+ free(reminder);
+
+ while (temp) {
+ if(!after) {
+ item = __cal_edit_ug_add_alarm( p, (Cal_Reminder*)temp->data, EINA_TRUE, after);
+ }
+ else {
+ item = __cal_edit_ug_add_alarm( p, (Cal_Reminder*)temp->data, EINA_FALSE, after);
+ }
+ c_retm_if(!item, "item is null");
+ after = item;
+ temp = g_list_next(temp);
+ }
+ }
+}
+
+static void __cal_edit_ug_reponse_event_callback(void *data, Evas_Object *obj, void *ei)
+{
+ c_retm_if(!data, "data is null");
+
+ Evas_Object *popup = data;
+ evas_object_del(popup);
+}
+
+static void __cal_edit_ug_repeat_callback(void *data)
+{
+ c_retm_if(!data, "data is null");
+
+ cal_edit_ug_data *p = data;
+
+ calendar_range_type_e range = CALENDAR_RANGE_NONE;
+ struct tm until = {0};
+ int count = 0;
+
+ int repeat = cal_edit_repeat_get_repeat(p->repeat_layout, &range, &until, &count);
+
+ if (CALENDAR_RECURRENCE_NONE != repeat) {
+
+ if (range == CALENDAR_RANGE_UNTIL) {
+
+ if (timegm(&until) <= timegm(&p->stm)) {
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_BODY_REPEAT_WARNING"),
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ return;
+ }
+ }
+ else if (range == CALENDAR_RANGE_COUNT) {
+
+ if (!count) {
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_BODY_REPEAT_WARNING"),
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ return;
+ }
+ }
+ }
+
+ p->repeat_freq = repeat;
+ p->repeat_range = range;
+ p->repeat_until = until;
+ p->repeat_count = count;
+
+ char buf[1024] = {0};
+ _cal_edit_repeat_get_freq_str(p->repeat_freq, buf, sizeof(buf));
+ elm_object_part_text_set(p->repeat, "elm.text.1", buf);
+
+ __cal_edit_ug_set_record_repeat(p);
+
+}
+
+static void __cal_edit_ug_repeat_select_callback(Evas_Object *obj, void *data)
+{
+ c_retm_if(!data, "data is null");
+
+ cal_edit_ug_data* p = data;
+
+ p->repeat_layout = cal_edit_repeat_create_view(p->naviframe, p->repeat_freq, p->repeat_range, &(p->stm), &(p->repeat_until),&(p->repeat_count),
+ (cal_edit_repeat_destroy_callback)__cal_edit_ug_repeat_callback, p);
+ c_retm_if(!p->repeat_layout, "p->repeat_layout is null");
+
+}
+
+static void __cal_edit_ug_update_recurrence_language(Evas_Object *item, int repeat_frequency)
+{
+ c_ret_if(!item);
+
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_CLD_BODY_REPEAT"));
+
+ char buffer[128] = {0};
+
+ _cal_edit_repeat_get_freq_str(repeat_frequency, buffer, sizeof(buffer));
+
+ elm_object_part_text_set(item, "elm.text.1", buffer);
+}
+
+static Evas_Object *__cal_edit_ug_add_repeat(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Eina_List *list = eina_list_last(p->alarm_item_list);
+ Evas_Object *last_item = eina_list_data_get(list);
+
+ Evas_Object *item = NULL;
+
+ if (p->instance) {
+
+ item = cal_dialogue_insert_item_after(p->dialogue, "2text.2", last_item, NULL, NULL);
+ elm_object_signal_emit(item, "elm,state,disabled", "elm");
+
+ } else
+ item = cal_dialogue_insert_item_after(p->dialogue, "2text.2", last_item, __cal_edit_ug_repeat_select_callback, p);
+
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ __cal_edit_ug_get_record_repeat(p, p->event);
+
+ __cal_edit_ug_update_recurrence_language(item, p->repeat_freq);
+
+ return item;
+}
+
+static void __cal_edit_ug_popup_hide_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ c_retm_if(!data, "data is null");
+ c_retm_if(!obj, "obj is null");
+
+ Evas_Object *popup = data;
+
+ cal_edit_ug_data *p = evas_object_data_get(popup, "data");
+
+ evas_object_del(popup);
+
+ c_retm_if(!p, "p is null");
+
+ p->popup = NULL;
+}
+
+static char *__cal_edit_ug_get_genlist_save_to_item_label(void *data, Evas_Object *obj, const char *part)
+{
+ c_retvm_if(!data, NULL, "data is null");
+ c_retvm_if(!part, NULL, "part is null");
+
+ calendar_record_h record = (calendar_record_h)data;
+ char *name;
+ int cid;
+ char* description;
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ calendar_record_h calendar_book = NULL;
+
+ _calendar_record_type record_type = _calendar_get_record_type(record);
+
+ if (record_type == _CALENDAR_RECORD_TYPE_CALENDARBOOK)
+ calendar_book = record;
+ else {
+ error = calendar_record_get_int(record, _calendar_event.calendar_book_id, &cid);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_record_get_int() is failed(%x)", error);
+
+ error = calendar_db_get_record(_calendar_book._uri, cid, &calendar_book);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_db_get_record() is failed(%x)", error);
+ }
+
+ error = calendar_record_get_int(record, _calendar_book.id, &cid);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_record_get_int() is failed(%x)", error);
+
+ if (!CAL_STRCMP(part,"elm.text.1")) {
+
+ if (cid == DEFAULT_EVENT_CALENDAR_BOOK_ID)
+ return strdup(C_("IDS_CLD_BODY_MY_CALENDAR"));
+ else if (cid == DEFAULT_TODO_CALENDAR_BOOK_ID)
+ return strdup(C_("IDS_TASK_BODY_MY_TASK"));
+
+ error = calendar_record_get_str(calendar_book, _calendar_book.name, &name);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_record_get_str() is failed(%x)", error);
+
+ if (record != calendar_book) {
+ error = calendar_record_destroy(calendar_book, true);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_record_destroy() is failed(%x)", error);
+ }
+
+ if (CAL_STRLEN(name))
+ return name;
+ else
+ CAL_FREE(name);
+
+ return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
+
+ } else if (!CAL_STRCMP(part,"elm.text.2")) {
+
+ if (cid == DEFAULT_EVENT_CALENDAR_BOOK_ID || cid == DEFAULT_TODO_CALENDAR_BOOK_ID)
+ return strdup(C_("IDS_CLD_POP_MY_PHONE"));
+
+ error = calendar_record_get_str(calendar_book, _calendar_book.description, &description);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_record_get_str() is failed(%x)", error);
+
+ if (record != calendar_book) {
+ error = calendar_record_destroy(calendar_book, true);
+ c_retvm_if(error != CALENDAR_ERROR_NONE, NULL, "calendar_record_destroy() is failed(%x)", error);
+ }
+
+ if (CAL_STRLEN(description))
+ return description;
+ else
+ CAL_FREE(description);
+
+ return strdup(S_("IDS_COM_POP_NO_ACCOUNTS"));
+ }
+
+ return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
+}
+
+static Evas_Object* __cal_edit_ug_add_save_to_icon(void *item_data, Evas_Object *obj, const char *part)
+{
+ if (!item_data)
+ {
+ ERR("item_data is null");
+ return NULL;
+ }
+
+ Evas_Object *icon = NULL;
+ char* icon_path = NULL;
+ calendar_record_h record = (calendar_record_h)item_data;
+ Eina_Bool r = EINA_FALSE;
+ int cid = _calendar_get_calendar_index(record);
+ int aid = _calendar_get_account_id(record);
+
+ if (!CAL_STRCMP(part, "elm.icon"))
+ {
+ icon = elm_icon_add(obj);
+
+ if (!icon)
+ {
+ ERR("elm_icon_add fail");
+ return NULL;
+ }
+
+ if ( cid == DEFAULT_EVENT_CALENDAR_BOOK_ID || cid == DEFAULT_TODO_CALENDAR_BOOK_ID) {
+ r = elm_icon_file_set(icon, CAL_IMAGES_EDJ, CAL_IMAGES_PHONE);
+ c_warn_if(!r, "elm_icon_file_set(%s) is failed", CAL_IMAGES_PHONE);
+ } else {
+ icon_path = cal_account_svc_get_account_icon_path(aid);
+ if (icon_path) {
+ r = elm_icon_file_set(icon, icon_path, NULL);
+ c_warn_if(!r, "elm_icon_file_set(%s) is failed", CAL_IMAGES_PHONE);
+ free(icon_path);
+ }
+ else {
+ r = elm_icon_file_set(icon, CAL_IMAGES_EDJ, CAL_IMAGES_PHONE);
+ c_warn_if(!r, "elm_icon_file_set(%s) is failed", CAL_IMAGES_PHONE);
+ }
+
+ }
+
+ if (!r) {
+ ERR("");
+ evas_object_del(icon);
+ icon = NULL;
+ }
+ else
+ evas_object_show(icon);
+ }
+
+ return icon;
+}
+
+static Eina_Bool __cal_edit_ug_popup_idler_callback(void *data)
+{
+ c_retv_if(!data, ECORE_CALLBACK_CANCEL);
+
+ cal_edit_ug_data *p = data;
+
+ if (p->popup) {
+ evas_object_del(p->popup);
+ p->popup = NULL;
+ }
+
+ p->idler = NULL;
+
+ return ECORE_CALLBACK_CANCEL;
+}
+
+static void __cal_edit_ug_save_to_popup_list_sel(void *data, Evas_Object *obj, void *event_info)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+ c_retm_if(!obj, "obj is null");
+
+ calendar_record_h calendar_book = data;
+ int calendar_book_id = 0;
+
+ cal_edit_ug_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
+ c_retm_if(!p, "p is null");
+
+ Elm_Object_Item *item = elm_genlist_selected_item_get(obj);
+ c_retm_if(!item, "elm_genlist_selected_item_get() returned null");
+
+ elm_genlist_item_selected_set(item, EINA_FALSE);
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_record_get_int(calendar_book, _calendar_book.id, &calendar_book_id);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+
+ if (p->item_type == ITEM_TYPE_TODO) {
+ __cal_edit_ug_set_record_save_to(p->todo, calendar_book_id);
+ __cal_edit_ug_update_save_to_item(p, p->todo);
+ }
+ else {
+ __cal_edit_ug_set_record_save_to(p->event, calendar_book_id);
+ __cal_edit_ug_update_save_to_item(p, p->event);
+ }
+
+ if (p->idler) {
+ ecore_idler_del(p->idler);
+ p->idler = NULL;
+ }
+
+ p->idler = ecore_idler_add(__cal_edit_ug_popup_idler_callback, p);
+ c_ret_if(!p->idler);
+
+}
+
+static Elm_Genlist_Item_Class itc_2text_1icon_2 = {
+ .item_style = "dialogue/2text.1icon.2",
+ .func.text_get = __cal_edit_ug_get_genlist_save_to_item_label,
+ .func.content_get = __cal_edit_ug_add_save_to_icon,
+};
+
+static Evas_Object* __cal_edit_ug_create_save_to_popup(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *popup = NULL;
+ Evas_Object *genlist = NULL;
+
+ Eina_List *l;
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ if (!p->calendar_book_list)
+ {
+ p->calendar_book_list = _calendar_get_calendar_book_list_with_account_id(_CALENDAR_ALL_ACCOUNT_ID);
+ }
+
+ popup = cal_util_add_popup(p->window, "liststyle", C_("IDS_ST_BODY_SAVE_TO"), NULL,
+ __cal_edit_ug_popup_hide_callback, p, S_("IDS_COM_BODY_CLOSE"), NULL);
+ c_retvm_if(!popup, NULL, "popup is null");
+
+ genlist = elm_genlist_add(popup);
+ if (!genlist) {
+ ERR("elm_genlist_add(popup) returned null");
+ evas_object_del(popup);
+ return NULL;
+ }
+
+ evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
+ evas_object_data_set(genlist, "priv", p);
+
+ calendar_record_h calendar_book = NULL;
+
+ EINA_LIST_FOREACH(p->calendar_book_list, l, calendar_book) {
+
+ int store_type = 0;
+
+ error = calendar_record_get_int(calendar_book, _calendar_book.store_type, &store_type);
+ if (error != CALENDAR_ERROR_NONE) {
+ ERR("calendar_record_get_int() is failed(%x)", calendar_book);
+ continue;
+ }
+
+ int sync_event = 0;
+ error = calendar_record_get_int(calendar_book, _calendar_book.sync_event, &sync_event);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_int() is failed(%x)", error);
+ if(!sync_event)
+ continue;
+
+ if (p->item_type == ITEM_TYPE_TODO) {
+ if (store_type == CALENDAR_BOOK_TYPE_TODO)
+ elm_genlist_item_append(genlist, &itc_2text_1icon_2, calendar_book, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_ug_save_to_popup_list_sel, calendar_book);
+ } else {
+ if (store_type == CALENDAR_BOOK_TYPE_EVENT)
+ elm_genlist_item_append(genlist, &itc_2text_1icon_2, calendar_book, NULL, ELM_GENLIST_ITEM_NONE, __cal_edit_ug_save_to_popup_list_sel, calendar_book);
+ }
+
+ }
+
+ elm_object_content_set(popup, genlist);
+ evas_object_show(genlist);
+
+ return popup;
+}
+
+static void __cal_edit_ug_saveto_select_callback(Evas_Object *obj, void *data)
+{
+ c_retm_if(!data, "data is null");
+
+ cal_edit_ug_data* p = data;
+ Evas_Object *popup = __cal_edit_ug_create_save_to_popup(p);
+ c_retm_if(!popup, "popup is NULL");
+
+ p->popup = popup;
+}
+
+static void __cal_edit_ug_get_save_to_str(int calid, char *buf, int sz)
+{
+ calendar_record_h calendar_book = NULL;
+ char *str;
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ error = calendar_db_get_record(_calendar_book._uri, calid, &calendar_book);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_db_get_record() is failed(%x)", error);
+
+ if (calid == DEFAULT_EVENT_CALENDAR_BOOK_ID)
+ str = C_("IDS_CLD_OPT_PHONE_CALENDAR");
+ else
+ {
+ error = calendar_record_get_str(calendar_book, _calendar_book.name, &str);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_get_str() is failed(%x)", error);
+
+ }
+
+ snprintf(buf, sz, "%s", str);
+
+ if (str)
+ free(str);
+
+ error = calendar_record_destroy(calendar_book, true);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_destroy() is failed(%x)", error);
+}
+
+static void __cal_edit_ug_update_saveto_language(Evas_Object *item, calendar_record_h record)
+{
+ c_ret_if(!item);
+
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_ST_BODY_SAVE_TO"));
+
+ int calendar_book_id = _calendar_get_calendar_index(record);
+
+ if (calendar_book_id == DEFAULT_EVENT_CALENDAR_BOOK_ID)
+ elm_object_part_text_set(item, "elm.text.1", C_("IDS_CLD_BODY_MY_CALENDAR"));
+ else if (calendar_book_id == DEFAULT_TODO_CALENDAR_BOOK_ID)
+ elm_object_part_text_set(item, "elm.text.1", C_("IDS_TASK_BODY_MY_TASK"));
+}
+
+static Evas_Object *__cal_edit_ug_add_saveto(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_append_item(p->dialogue, "2text.2", __cal_edit_ug_saveto_select_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_ST_BODY_SAVE_TO"));
+
+ char buf[1024];
+ char* saveto_text = NULL;
+ int calendar_book_id = 0;
+ if(p->item_type == ITEM_TYPE_TODO) {
+ calendar_book_id = _calendar_get_calendar_index(p->todo);
+ p->account_id = _calendar_get_account_id(p->todo);
+ }
+ else {
+ calendar_book_id = _calendar_get_calendar_index(p->event);
+ p->account_id = _calendar_get_account_id(p->event);
+ }
+ if (calendar_book_id == DEFAULT_EVENT_CALENDAR_BOOK_ID)
+ saveto_text = strdup(C_("IDS_CLD_BODY_MY_CALENDAR"));
+ else if (calendar_book_id == DEFAULT_TODO_CALENDAR_BOOK_ID)
+ saveto_text = strdup(C_("IDS_TASK_BODY_MY_TASK"));
+ else {
+ __cal_edit_ug_get_save_to_str(calendar_book_id, buf, sizeof(buf));
+ saveto_text = strdup(buf);
+ }
+
+ elm_object_part_text_set(item, "elm.text.1", saveto_text);
+ CAL_FREE(saveto_text);
+
+ if (p->instance)
+ elm_object_signal_emit(item, "elm,state,disabled", "elm");
+
+ return item;
+}
+
+static void __cal_edit_ug_no_due_date_clicked_callback(Evas_Object *obj, void *data)
+{
+ c_retm_if(!data, "data is NULL.");
+ c_retm_if(!obj, "obj is NULL.");
+
+ cal_edit_ug_data *p = data;
+
+ Evas_Object *check_obj = elm_object_part_content_get(p->no_due_date, "elm.icon");
+
+ if(p->is_no_due_date)
+ {
+ elm_check_state_set(check_obj, EINA_FALSE);
+ p->is_no_due_date = elm_check_state_get(check_obj);
+ elm_object_signal_emit(p->due_date, "elm,state,enabled", "elm");
+ }
+ else
+ {
+ elm_check_state_set(check_obj, EINA_TRUE);
+ p->is_no_due_date = elm_check_state_get(check_obj);
+ __cal_edit_ug_set_record_due_time(p, p->todo);
+ elm_object_signal_emit(p->due_date, "elm,state,disabled", "elm");
+ }
+
+ Evas_Object *edit_time_obj = elm_object_part_content_get(p->due_date, "elm.icon");
+ elm_object_disabled_set(edit_time_obj, p->is_no_due_date);
+}
+
+static void __cal_edit_ug_no_due_date_changed_callback(void *data, Evas_Object *obj, void *ei)
+{
+ c_retm_if(!data, "data is NULL.");
+ c_retm_if(!obj, "obj is NULL.");
+
+ cal_edit_ug_data *p = data;
+
+ p->is_no_due_date = elm_check_state_get(obj);
+
+ Evas_Object *edit_time_obj = elm_object_part_content_get(p->due_date, "elm.icon");
+ elm_object_disabled_set(edit_time_obj, p->is_no_due_date);
+ if(p->is_no_due_date)
+ {
+ __cal_edit_ug_set_record_due_time(p, p->todo);
+ elm_object_signal_emit(p->due_date, "elm,state,disabled", "elm");
+ }
+ else
+ {
+ elm_object_signal_emit(p->due_date, "elm,state,enabled", "elm");
+ }
+}
+
+static void __cal_edit_ug_update_no_due_date_language(Evas_Object *item)
+{
+ elm_object_part_text_set(item, "elm.text", C_("IDS_TASK_MBODY_NO_DUE_DATE"));
+}
+
+static Evas_Object *__cal_edit_ug_add_no_due_date(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_insert_item_after(p->dialogue, "1text.1icon.2", p->due_date, __cal_edit_ug_no_due_date_clicked_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ Evas_Object *check_obj;
+ check_obj = elm_check_add(item);
+ __cal_edit_ug_get_record_due_time(p, p->todo);
+ elm_check_state_set(check_obj, p->is_no_due_date);
+
+ evas_object_smart_callback_add(check_obj, "changed", __cal_edit_ug_no_due_date_changed_callback, p);
+ elm_check_state_set(check_obj, p->is_no_due_date);
+ evas_object_propagate_events_set(check_obj, EINA_FALSE);
+
+ __cal_edit_ug_update_no_due_date_language(item);
+
+ elm_object_part_content_set(item, "elm.icon", check_obj);
+
+ return item;
+}
+
+static void __cal_edit_ug_priority_popup_list_sel(void *data, Evas_Object *obj, void *event_info)
+{
+ c_ret_if(!data);
+ c_ret_if(!obj);
+
+ int priority = (int)data;
+
+ cal_edit_ug_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
+ c_ret_if(!p);
+
+ __cal_edit_ug_set_record_priority(p->todo, priority);
+ __cal_edit_ug_update_priority_item(p, p->todo);
+
+ evas_object_del(p->popup);
+ p->popup = NULL;
+}
+
+static Evas_Object* __cal_edit_ug_create_priority_popup(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *popup = cal_util_add_popup(p->window, NULL, C_("IDS_CLD_BODY_PRIORITY"), NULL,
+ __cal_edit_ug_popup_hide_callback, p, S_("IDS_COM_BODY_CLOSE"), NULL);
+ c_retv_if(!popup, NULL);
+
+ evas_object_data_set(popup, "priv", p);
+
+ Elm_Object_Item *popup_item = elm_popup_item_append(popup, S_("IDS_COM_OPT_HIGH_M_QUALITY"), NULL, __cal_edit_ug_priority_popup_list_sel, (const void *)CALENDAR_TODO_PRIORITY_HIGH);
+ c_retv_if(!popup_item, NULL);
+
+ popup_item = elm_popup_item_append(popup, S_("IDS_IDLE_BODY_NORMAL"), NULL, __cal_edit_ug_priority_popup_list_sel, (const void *)CALENDAR_TODO_PRIORITY_NORMAL);
+ c_retv_if(!popup_item, NULL);
+
+ popup_item = elm_popup_item_append(popup, S_("IDS_COM_BODY_LOW"), NULL, __cal_edit_ug_priority_popup_list_sel, (const void *)CALENDAR_TODO_PRIORITY_LOW);
+ c_retv_if(!popup_item, NULL);
+
+ return popup;
+}
+
+static void __cal_edit_ug_priority_select_callback(Evas_Object *obj, void *data)
+{
+ c_retm_if(!data, "data is null");
+ cal_edit_ug_data* p = data;
+
+ Evas_Object *popup = __cal_edit_ug_create_priority_popup(p);
+ c_retm_if(!popup, "popup is NULL");
+
+ p->popup = popup;
+
+}
+
+static void __cal_edit_ug_update_priority_language(Evas_Object *item, calendar_record_h record)
+{
+ elm_object_part_text_set(item, "elm.text.2", C_("IDS_CLD_BODY_PRIORITY"));
+
+ char* priority_text = NULL;
+ int priority = __cal_edit_ug_get_record_priority(record);
+ switch (priority) {
+ case CALENDAR_TODO_PRIORITY_LOW:
+ priority_text = strdup(S_("IDS_COM_BODY_LOW"));
+ break;
+ case CALENDAR_TODO_PRIORITY_NORMAL:
+ priority_text =strdup(C_("IDS_IDLE_BODY_NORMAL"));
+ break;
+ case CALENDAR_TODO_PRIORITY_HIGH:
+ priority_text =strdup(S_("IDS_COM_OPT_HIGH_M_QUALITY"));
+ break;
+ default:
+ break;
+ }
+
+ elm_object_part_text_set(item, "elm.text.1", priority_text);
+ CAL_FREE(priority_text);
+}
+
+static Evas_Object *__cal_edit_ug_add_priority(cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *item = cal_dialogue_insert_item_after(p->dialogue, "2text.2", p->no_due_date, __cal_edit_ug_priority_select_callback, p);
+ c_retvm_if(!item, NULL, "cal_dialogue_append_item() is failed");
+
+ __cal_edit_ug_update_priority_language(item, p->todo);
+
+ return item;
+}
+
+static void __cal_edit_ug_show_result_popup(cal_edit_ug_data *p, calendar_error_e error)
+{
+ char buf[100]={0,};
+
+ // TODO: i18n
+ switch(error) {
+ case CALENDAR_ERROR_DB_FAILED:
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_CALENDAR_SYNC_IN_PROGRESS"),
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ break;
+
+ case CALENDAR_ERROR_OUT_OF_MEMORY:
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_CALENDAR_SYNC_IN_PROGRESS"),
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ break;
+
+ case CALENDAR_ERROR_INVALID_PARAMETER:
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_INVALID_TIME"),
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ break;
+
+ default:
+ snprintf(buf,100,"not saved(internal error-%x)!",error);
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), buf,
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ break;
+ }
+}
+
+int __cal_edit_ug_save(cal_edit_ug_data *p, calendar_record_h record)
+{
+ CAL_FN_START;
+
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ int record_index = 0;
+
+ calendar_record_type_e record_type = CALENDAR_RECORD_TYPE_EVENT;
+
+ if (_calendar_is_task_record(record))
+ record_type = CALENDAR_RECORD_TYPE_TODO;
+
+ __cal_edit_ug_set_record_alarm(p, record);
+
+ if (p->is_edit_mode) {
+ if (p->instance) {
+
+ calendar_record_h exception_record = NULL;
+ error = calendar_record_clone(record, &exception_record);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_create() is failed(%x)", error);
+
+ int index = _calendar_get_record_index(record);
+ error = calendar_record_set_int(exception_record, _calendar_event.original_event_id, index);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_set_int() is failed(%x)", error);
+
+ __cal_edit_ug_set_record_time(p, exception_record);
+ _calendar_edit_recurrence_instance(exception_record, index);
+
+ error = calendar_db_insert_record(exception_record, &record_index);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_db_insert_record() is failed(%x)", error);
+
+ if (error != CALENDAR_ERROR_NONE) {
+ __cal_edit_ug_show_result_popup(p, error);
+
+ error = calendar_record_destroy(exception_record, true);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_destroy() is failed(%x)", error);
+
+ return -1;
+ }
+
+ error = calendar_record_destroy(exception_record, true);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_destroy() is failed(%x)", error);
+
+ } else {
+
+ if (p->account_id == _calendar_get_account_id(record))
+ {
+ error = calendar_db_update_record(record);
+ if (error != CALENDAR_ERROR_NONE) {
+
+ ERR("calendar_db_update_record() is failed(%x)", error);
+
+ __cal_edit_ug_show_result_popup(p, error);
+
+ return -1;
+ }
+ record_index = _calendar_get_record_index(record);
+ }
+ else
+ {
+ _calendar_delete_record(record);
+
+ error = calendar_db_insert_record(record, &record_index);
+ if (error != CALENDAR_ERROR_NONE) {
+
+ ERR("calendar_db_insert_record() is failed(%x)", error);
+ __cal_edit_ug_show_result_popup(p, error);
+
+ return -1;
+ }
+ }
+ }
+
+ } else {
+
+ error = calendar_db_insert_record(record, &record_index);
+ if (error != CALENDAR_ERROR_NONE) {
+
+ ERR("calendar_db_insert_record() is failed(%x)", error);
+
+ __cal_edit_ug_show_result_popup(p, error);
+
+ return -1;
+ }
+ }
+
+ return record_index;
+}
+
+static void __cal_edit_ug_send_result_to_detail_ug(cal_edit_ug_data *p, int record_index)
+{
+ c_retm_if(!p, "p is null");
+ c_retm_if(record_index < 0, "record_index < 0");
+
+ service_h service = NULL;
+
+ int ret = service_create(&service);
+ c_ret_if(ret != SERVICE_ERROR_NONE);
+
+ char value[64] = {0};
+ snprintf(value, sizeof(value), "%d", record_index);
+
+ ret = service_add_extra_data(service, "record_index", value);
+ c_warn_if(ret != SERVICE_ERROR_NONE, "service_add_extra_data() is failed(%x)", ret);
+
+ memset(value, 0x00, sizeof(value));
+
+ long long int lli_time = 0;
+ cal_util_convert_tm_to_lli(NULL, &p->stm, &lli_time);
+
+ snprintf(value, sizeof(value), "%lli", lli_time);
+
+ ret = service_add_extra_data(service, "base_time", value);
+ c_warn_if(ret != SERVICE_ERROR_NONE, "service_add_extra_data() is failed(%x)", ret);
+
+ ug_send_result(p->ug, service);
+
+ ret = service_destroy(service);
+ c_warn_if(ret != SERVICE_ERROR_NONE, "service_destroy() is failed(%x)", ret);
+}
+
+static void __cal_edit_ug_save_button_callback(void *data, Evas_Object *obj, void *event_info)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+ cal_edit_ug_data* p = data;
+ int record_index;
+
+ Eina_Bool result = __cal_edit_ug_check_date_validity(p);
+ if(!result) {
+ cal_util_add_popup(p->window, NULL, S_("IDS_COM_POP_WARNING"), C_("IDS_CLD_POP_END_TIME_SHOULD_BE_SET_AFTER_START_TIME"),
+ __cal_edit_ug_reponse_event_callback, NULL, NULL);
+ return;
+ }
+
+ if (p->item_type == ITEM_TYPE_TODO)
+ record_index = __cal_edit_ug_save(p, p->todo);
+ else
+ record_index = __cal_edit_ug_save(p, p->event);
+
+ c_retm_if(record_index < 0, "cal_edit_save() is failed");
+
+ __cal_edit_ug_send_result_to_detail_ug(p, record_index);
+
+ ug_destroy_me(p->ug);
+
+}
+
+
+static void __cal_edit_ug_back_button_callback(void *user_data, Evas_Object *obj, void *ei)
+{
+ CAL_FN_START;
+
+ c_ret_if(!user_data);
+
+ cal_edit_ug_data *data = user_data;
+
+ c_ret_if(!data->ug);
+
+ ug_destroy_me(data->ug);
+}
+
+static void __cal_edit_ug_show_multi_alarms (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ Evas_Object *first_item = eina_list_nth(p->alarm_item_list, 0);
+
+ if(eina_list_count(p->alarm_item_list)<5){
+ p->alarm_plus_button = __cal_edit_ug_alarm_plus_button_icon(p, first_item);
+ elm_object_part_content_set(first_item, "elm.icon", p->alarm_plus_button);
+ }
+ Eina_List *list = eina_list_next(p->alarm_item_list);
+ Eina_List *l;
+ Evas_Object *item = NULL;
+
+ EINA_LIST_FOREACH(list, l, item) {
+ if(item){
+ cal_dialogue_show_item_after(p->dialogue, item, first_item);
+ first_item = item;
+ }
+ }
+}
+
+static void __cal_edit_ug_show_event_items (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ if (!p->start_date_title)
+ p->start_date_title = __cal_edit_ug_insert_padding_after(p, C_("IDS_CLD_BODY_FROM"), p->title);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->start_date_title, p->title);
+
+ Eina_Bool is_allday = EINA_FALSE;
+
+ if (!p->start_date) {
+
+ is_allday = _calendar_is_allday_record(p->event);
+
+ p->start_date = __cal_edit_ug_insert_timepicker_after(p, &p->stm, is_allday, p->start_date_title, __cal_edit_ug_start_date_changed_callback);
+
+ } else
+ cal_dialogue_show_item_after(p->dialogue, p->start_date, p->start_date_title);
+
+ if (!p->end_date_title)
+ p->end_date_title = __cal_edit_ug_insert_padding_after(p, C_("IDS_CLD_BODY_TO"), p->start_date);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->end_date_title, p->start_date);
+
+ if (!p->end_date)
+ p->end_date = __cal_edit_ug_insert_timepicker_after(p, &p->etm, is_allday, p->end_date_title, __cal_edit_ug_end_date_changed_callback);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->end_date, p->end_date_title);
+
+ if (!p->timezone)
+ p->timezone = __cal_edit_ug_add_time_zone(p);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->timezone, p->end_date);
+
+ if (!p->allday)
+ p->allday = __cal_edit_ug_add_all_day(p, is_allday);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->allday, p->timezone);
+
+ __cal_edit_ug_show_multi_alarms(p);
+
+ Eina_List *list = eina_list_last(p->alarm_item_list);
+ Evas_Object *last_item = eina_list_data_get(list);
+
+ if (!p->repeat)
+ p->repeat = __cal_edit_ug_add_repeat(p);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->repeat, last_item);
+
+}
+
+static void __cal_edit_ug_show_todo_items (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ if (!p->due_date_title)
+ p->due_date_title = __cal_edit_ug_insert_padding_after(p, C_("IDS_CLD_BODY_DUE_DATE"), p->title);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->due_date_title, p->title);
+
+ if (!p->due_date)
+ p->due_date = __cal_edit_ug_insert_timepicker_after(p, &p->etm, EINA_FALSE, p->due_date_title, __cal_edit_ug_due_date_changed_callback);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->due_date, p->due_date_title);
+
+ if (!p->no_due_date)
+ p->no_due_date = __cal_edit_ug_add_no_due_date(p);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->no_due_date, p->due_date);
+
+ Evas_Object *first_item = eina_list_nth(p->alarm_item_list, 0);
+ if (!p->priority)
+ p->priority = __cal_edit_ug_add_priority(p);
+ else
+ cal_dialogue_show_item_after(p->dialogue, p->priority, first_item);
+}
+
+static void __cal_edit_ug_hide_multi_alarms (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ Evas_Object *first_item = eina_list_nth(p->alarm_item_list, 0);
+ Evas_Object *button_obj = elm_object_part_content_get(first_item, "elm.icon");
+ if(button_obj) {
+ evas_object_del(button_obj);
+ button_obj = NULL;
+ }
+
+ Eina_List *list = p->alarm_item_list;
+ list = eina_list_next(list);
+ Eina_List *l;
+ Evas_Object *item = NULL;
+
+ EINA_LIST_FOREACH(list, l, item) {
+ if(item){
+ cal_dialogue_hide_item(p->dialogue, item);
+ }
+ }
+}
+
+static void __cal_edit_ug_hide_event_items (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ cal_dialogue_hide_item(p->dialogue, p->start_date_title);
+ cal_dialogue_hide_item(p->dialogue, p->start_date);
+ cal_dialogue_hide_item(p->dialogue, p->end_date_title);
+ cal_dialogue_hide_item(p->dialogue, p->end_date);
+ cal_dialogue_hide_item(p->dialogue, p->allday);
+ cal_dialogue_hide_item(p->dialogue, p->timezone);
+ cal_dialogue_hide_item(p->dialogue, p->repeat);
+ __cal_edit_ug_hide_multi_alarms(p);
+
+}
+
+static void __cal_edit_ug_hide_todo_items (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ cal_dialogue_hide_item(p->dialogue, p->due_date_title);
+ cal_dialogue_hide_item(p->dialogue, p->due_date);
+ cal_dialogue_hide_item(p->dialogue, p->no_due_date);
+ cal_dialogue_hide_item(p->dialogue, p->priority);
+
+}
+
+static void __cal_edit_ug_update_event_info (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ __cal_edit_ug_update_title_item(p->title_entry, p->event);
+ __cal_edit_ug_update_note_item(p->note_entry, p->event);
+ __cal_edit_ug_update_location_item(p, p->event);
+
+ __cal_edit_ug_update_save_to_item(p, p->event);
+}
+
+static void __cal_edit_ug_update_todo_info (cal_edit_ug_data *p)
+{
+ c_retm_if(!p, "p is null");
+
+ __cal_edit_ug_update_title_item(p->title_entry, p->todo);
+ __cal_edit_ug_update_note_item(p->note_entry, p->todo);
+ __cal_edit_ug_update_location_item(p, p->todo);
+
+ __cal_edit_ug_update_save_to_item(p, p->todo);
+
+}
+
+static void __cal_edit_ug_new_event_clicked_callback (void *data, Evas_Object * obj, void *event_info)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data null");
+
+ cal_edit_ug_data *p = data;
+
+ if(p->item_type == ITEM_TYPE_EVENT)
+ return;
+
+ p->item_type = ITEM_TYPE_EVENT;
+
+ __cal_edit_ug_hide_todo_items(p);
+ __cal_edit_ug_show_event_items(p);
+ __cal_edit_ug_update_event_info(p);
+
+}
+
+static void __cal_edit_ug_new_todo_clicked_callback (void *data, Evas_Object * obj, void *event_info)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data null");
+
+ cal_edit_ug_data *p = data;
+
+ if(p->item_type == ITEM_TYPE_TODO)
+ return;
+
+ p->item_type = ITEM_TYPE_TODO;
+
+ __cal_edit_ug_hide_event_items(p);
+ __cal_edit_ug_show_todo_items(p);
+ __cal_edit_ug_update_todo_info(p);
+
+}
+
+static void __cal_edit_ug_add_dialogue_items(cal_edit_ug_data *p)
+{
+ CAL_FN_START;
+
+ c_retm_if(!p, "p is null");
+
+ p->title = __cal_edit_ug_add_title(p);
+
+ calendar_time_s time = {0};
+
+ if (p->item_type == ITEM_TYPE_TODO) {
+
+ p->due_date_title = __cal_edit_ug_insert_padding_after(p, C_("IDS_CLD_BODY_DUE_DATE"), p->title);
+
+ _calendar_get_end_time(p->todo, &time);
+ _calendar_convert_calendar_time_to_tm(&time, &p->etm);
+// __cal_edit_ug_get_record_due_time(p, p->todo);
+
+ p->due_date = __cal_edit_ug_insert_timepicker_after(p, &p->etm, EINA_FALSE, p->due_date_title, __cal_edit_ug_due_date_changed_callback);
+
+ p->no_due_date = __cal_edit_ug_add_no_due_date(p);
+
+ p->priority = __cal_edit_ug_add_priority(p);
+ } else {
+
+ p->start_date_title = __cal_edit_ug_insert_padding_after(p, C_("IDS_CLD_BODY_FROM"), p->title);
+
+ if (p->instance)
+ _calendar_get_start_time(p->instance, &time);
+ else
+ _calendar_get_start_time(p->event, &time);
+
+ _calendar_convert_calendar_time_to_tm(&time, &p->stm);
+ Eina_Bool allday = _calendar_is_allday_record(p->event);
+
+ p->start_date = __cal_edit_ug_insert_timepicker_after(p, &p->stm, allday, p->start_date_title, __cal_edit_ug_start_date_changed_callback);
+
+ p->end_date_title = __cal_edit_ug_insert_padding_after(p, C_("IDS_CLD_BODY_TO"), p->start_date);
+
+ if (p->instance)
+ _calendar_get_end_time(p->instance, &time);
+ else
+ _calendar_get_end_time(p->event, &time);
+
+ _calendar_convert_calendar_time_to_tm(&time, &p->etm);
+ p->end_date = __cal_edit_ug_insert_timepicker_after(p, &p->etm, allday, p->end_date_title, __cal_edit_ug_end_date_changed_callback);
+
+ p->timezone = __cal_edit_ug_add_time_zone(p);
+
+ p->allday = __cal_edit_ug_add_all_day(p, allday);
+
+ }
+
+ p->note = __cal_edit_ug_add_note(p);
+
+ p->location = __cal_edit_ug_add_location(p);
+
+ __cal_edit_ug_add_multi_alarm(p);
+
+ if (p->item_type == ITEM_TYPE_EVENT) {
+ p->repeat = __cal_edit_ug_add_repeat(p);
+ }
+
+ p->saveto = __cal_edit_ug_add_saveto(p);
+}
+
+static void __cal_edit_ug_update_naviframe_language(cal_edit_ug_data *data)
+{
+ c_ret_if(!data->naviframe);
+
+ Elm_Object_Item *item = elm_naviframe_top_item_get(data->naviframe);
+ c_ret_if(!item);
+
+ if (data->is_edit_mode) {
+
+ if (data->item_type == ITEM_TYPE_TODO)
+ elm_object_item_part_text_set(item, "default", C_("IDS_TASK_HEADER_EDIT_TASK"));
+ else
+ elm_object_item_part_text_set(item, "default", C_("IDS_CLD_HEADER_EDIT_EVENT"));
+
+ } else
+ elm_object_item_part_text_set(item, "default", S_("IDS_COM_BODY_CREATE"));
+}
+
+static void __cal_edit_ug_update_tabbar_language(cal_edit_ug_data *data)
+{
+ if (data->is_edit_mode)
+ return;
+
+ c_ret_if(!data->event_item);
+ c_ret_if(!data->todo_item);
+
+ elm_object_item_part_text_set(data->event_item, "default", C_("IDS_CLD_SK3_CREATE_EVENT"));
+ elm_object_item_part_text_set(data->todo_item, "default", C_("IDS_TASK_SK_CREATE_TASK"));
+}
+
+static void __cal_edit_ug_add_toolbar(cal_edit_ug_data *data, Evas_Object *scroller)
+{
+ CAL_FN_START;
+
+ c_retm_if(!data, "data is null");
+
+ Elm_Object_Item *navi_item = NULL;
+
+ if (data->is_edit_mode) {
+ navi_item = elm_naviframe_item_push(data->naviframe, NULL, NULL, NULL, scroller, NULL);
+ c_warn_if(!navi_item, "elm_naviframe_item_push() is failed");
+ } else {
+ navi_item = elm_naviframe_item_push(data->naviframe, NULL, NULL, NULL, scroller, "tabbar");
+ c_warn_if(!navi_item, "elm_naviframe_item_push() is failed");
+
+ data->tabbar = elm_toolbar_add(data->naviframe);
+ c_ret_if(!data->tabbar);
+
+ elm_object_item_part_content_set(navi_item, "tabbar", data->tabbar);
+ elm_toolbar_reorder_mode_set(data->tabbar, EINA_FALSE);
+ elm_toolbar_transverse_expanded_set(data->tabbar, EINA_TRUE);
+ elm_toolbar_shrink_mode_set(data->tabbar, ELM_TOOLBAR_SHRINK_EXPAND);
+ elm_object_style_set(data->tabbar, "tabbar");
+
+ if (data->item_type == ITEM_TYPE_TODO) {
+ data->todo_item = elm_toolbar_item_append(data->tabbar, NULL, NULL, __cal_edit_ug_new_todo_clicked_callback, data);
+
+ elm_toolbar_select_mode_set(data->tabbar, ELM_OBJECT_SELECT_MODE_ALWAYS);
+
+ data->event_item = elm_toolbar_item_insert_before(data->tabbar, data->todo_item, NULL, NULL, __cal_edit_ug_new_event_clicked_callback, data);
+ } else {
+ data->event_item = elm_toolbar_item_append(data->tabbar, NULL, NULL, __cal_edit_ug_new_event_clicked_callback, data);
+ data->todo_item = elm_toolbar_item_append(data->tabbar, NULL, NULL, __cal_edit_ug_new_todo_clicked_callback, data);
+
+ elm_toolbar_select_mode_set(data->tabbar, ELM_OBJECT_SELECT_MODE_ALWAYS);
+ }
+
+ if (data->item_type == ITEM_TYPE_TODO)
+ elm_toolbar_item_selected_set(data->todo_item, EINA_TRUE);
+ else
+ elm_toolbar_item_selected_set(data->event_item, EINA_TRUE);
+
+ __cal_edit_ug_update_tabbar_language(data);
+
+ }
+
+ __cal_edit_ug_update_naviframe_language(data);
+
+ data->save_cancel = cal_save_cancel_create(data->naviframe, NULL, __cal_edit_ug_save_button_callback, __cal_edit_ug_back_button_callback, data);
+
+}
+
+static void __cal_edit_ug_dialogue_item_clicked_callback(void *data, Evas *e, Evas_Object *obj, void *ei)
+{
+ c_ret_if(!data);
+ c_ret_if(!obj);
+
+ cal_edit_ug_data* p = data;
+}
+
+static Evas_Object *__cal_edit_ug_create_dialogue(Evas_Object *parent, cal_edit_ug_data* p)
+{
+ c_retv_if(!p, NULL);
+
+ Evas_Object *scroller = cal_dialogue_create(parent);
+ c_retvm_if(!scroller, NULL, "cal_dialogue_create() is failed");
+ __cal_edit_ug_add_toolbar(p, scroller);
+
+ Evas_Object *dialogue = cal_dialogue_get_box(scroller);
+
+ evas_object_event_callback_add(dialogue, EVAS_CALLBACK_MOUSE_UP, __cal_edit_ug_dialogue_item_clicked_callback, p);
+ evas_object_event_callback_add(dialogue, EVAS_CALLBACK_MOUSE_DOWN, __cal_edit_ug_dialogue_item_clicked_callback, p);
+ evas_object_event_callback_add(dialogue, EVAS_CALLBACK_MOUSE_MOVE, __cal_edit_ug_dialogue_item_clicked_callback, p);
+
+ return dialogue;
+
+}
+
+static Evas_Object *__cal_edit_ug_create_layout(Evas_Object *parent, cal_edit_ug_data *data)
+{
+ CAL_FN_START;
+
+ c_retv_if(!parent, NULL);
+ c_retv_if(!data, NULL);
+
+ data->parent = parent;
+
+ if (data->item_type == ITEM_TYPE_TODO)
+ data->todo = data->record;
+ else
+ data->event = data->record;
+
+ if(!data->is_edit_mode)
+ {
+ __cal_edit_ug_initialize_todo_record(data);
+ __cal_edit_ug_initialize_event_record(data);
+ }
+
+ Evas_Object *base_layout = cal_util_add_layout(parent, NULL);
+ c_retv_if(!base_layout, NULL);
+
+ Evas_Object *naviframe = elm_naviframe_add(base_layout);
+ if (!naviframe) {
+ ERR("elm_naviframe_add() is failed");
+
+ evas_object_del(base_layout);
+
+ return NULL;
+ }
+
+ evas_object_show(naviframe);
+
+ Evas_Object *bg = cal_util_add_bg(base_layout, EINA_FALSE);
+ if (!bg) {
+ ERR("cal_util_add_bg() is failed");
+
+ evas_object_del(base_layout);
+
+ return NULL;
+ }
+
+ data->base_layout = base_layout;
+ data->naviframe = naviframe;
+
+ cal_util_initialize_timezone();
+
+ data->dialogue = __cal_edit_ug_create_dialogue(naviframe, data);
+ c_warn_if(!data->dialogue, "__cal_edit_ug_create_dialogue() is failed");
+
+ __cal_edit_ug_add_dialogue_items(data);
+
+
+ elm_object_part_content_set(base_layout, "elm.swallow.content", naviframe);
+ elm_object_part_content_set(base_layout, "elm.swallow.bg", bg);
+
+ return base_layout;
+}
+
+static calendar_record_h inline __cal_edit_ug_get_origin_record(const calendar_record_h instance)
+{
+ CAL_FN_START;
+
+ c_retv_if(!instance, NULL);
+
+ int index = _calendar_get_record_index(instance);
+
+ return _calendar_get_record_with_index(index);
+}
+
+static void *__cal_edit_ug_create_callback(ui_gadget_h ug, enum ug_mode mode, service_h service, void *priv)
+{
+ CAL_FN_START;
+
+ c_retv_if(!ug, NULL);
+ c_retv_if(!service, NULL);
+ c_retv_if(!priv, NULL);
+ c_retv_if(mode != UG_MODE_FULLVIEW, NULL);
+
+ cal_edit_ug_data *data = priv;
+
+ data->ug = ug;
+
+ int cid = 0;
+ char *item_type = NULL;
+ char *index = NULL;
+ char *path = NULL;
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+
+ int r = service_get_extra_data(service, "index", &index);
+
+ if (r == SERVICE_ERROR_NONE)
+ cid = atoi(index);
+
+ r = service_get_extra_data(service, CAL_APPCONTROL_ITEM_TYPE, &item_type);
+ if (r == SERVICE_ERROR_NONE) {
+
+ if (!CAL_STRCMP(item_type, CAL_APPCONTROL_ITEM_TYPE_EVENT)) {
+ data->item_type = ITEM_TYPE_EVENT;
+ data->is_edit_mode = EINA_TRUE;
+
+ r = service_get_extra_data(service, CAL_APPCONTROL_EVENT_ID, &index);
+ if (r != SERVICE_ERROR_NONE) {
+ ERR("service_get_extra_data(%s) is failed(%x)", CAL_APPCONTROL_EVENT_ID, r);
+
+ CAL_FREE(index);
+
+ ug_destroy_me(ug);
+
+ return NULL;
+ }
+
+ cid = atoi(index);
+ calendar_record_h record = _calendar_get_record_with_index(cid);
+ c_retv_if(!record, NULL);
+
+ calendar_record_destroy(record, true);
+
+ } else if (!CAL_STRCMP(item_type, CAL_APPCONTROL_ITEM_TYPE_TODO)) {
+
+ data->item_type = ITEM_TYPE_TODO;
+ data->is_edit_mode = EINA_TRUE;
+
+ r = service_get_extra_data(service, CAL_APPCONTROL_TODO_ID, &index);
+ if (r != SERVICE_ERROR_NONE) {
+ ERR("service_get_extra_data(%s) is failed(%x)", CAL_APPCONTROL_TODO_ID, r);
+
+ CAL_FREE(index);
+
+ ug_destroy_me(ug);
+
+ return NULL;
+ }
+
+ cid = atoi(index);
+ calendar_record_h record = _calendar_get_record_with_index(cid);
+ c_retv_if(!record, NULL);
+
+ calendar_record_destroy(record, true);
+
+ }
+ else if (!CAL_STRCMP(item_type, CAL_APPCONTROL_ITEM_TYPE_VCS)) {
+
+ data->item_type = ITEM_TYPE_VCS;
+
+ r = service_get_extra_data(service, CAL_APPCONTROL_VCS_PATH, &path);
+ if (r != SERVICE_ERROR_NONE) {
+ ERR("service_get_extra_data(%s) is failed(%x)", CAL_APPCONTROL_VCS_PATH, r);
+
+ CAL_FREE(path);
+
+ ug_destroy_me(ug);
+
+ return NULL;
+ }
+
+ FILE * file = fopen(path, "r");
+ if (!file) {
+ ERR("fopen(%s) is failed.", path);
+
+ ug_destroy_me(ug);
+
+ return NULL;
+ }
+
+ struct stat st;
+ if (stat(path, &st) != 0) {
+ ERR("Getting file information Error!");
+ fclose(file);
+ CAL_FREE(path);
+ ug_destroy_me(ug);
+
+ return NULL;
+ }
+
+ int size = st.st_size;
+ char *raw_data = calloc(size + 1, sizeof(char));
+ if(!raw_data){
+ ERR("raw_data is NULL!");
+ fclose(file);
+ free(raw_data);
+ CAL_FREE(path);
+ ug_destroy_me(ug);
+
+ return NULL;
+ }
+
+ r = fread(raw_data, 1, size, file);
+ fclose( file );
+ c_retv_if(r < 0, NULL);
+
+ calendar_list_h list = NULL;
+
+ error = calendar_vcalendar_parse_to_calendar(raw_data, &list);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_vcalendar_parse_to_calendar() is failed(%x)", error);
+
+ if (list) {
+ calendar_record_h record = NULL;
+ error = calendar_list_get_current_record_p(list, &record);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_list_get_current_record_p() is failed(%x)", error);
+
+ error = calendar_record_clone(record, &data->record);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_clone() is failed(%x)", error);
+
+ error = calendar_list_destroy(list, true);
+ }
+
+ free(raw_data);
+ }
+ }
+
+ if (!data->record) {
+ if (0 < cid) {
+ data->is_edit_mode = EINA_TRUE;
+ data->record = _calendar_get_record_with_index(cid);
+ }
+ else {
+ data->is_edit_mode = EINA_FALSE;
+ char *record_address = NULL;
+
+ r = service_get_extra_data(service, "record", &record_address);
+ if(record_address){
+ data->record = (calendar_record_h)strtoul(record_address, NULL, 16);
+ c_warn_if(!data->record, "strtol(%s, NULL, 16) is failed", record_address);
+ }
+ else {
+ char *note_str = NULL;
+ r = service_get_extra_data(service, "note", ¬e_str);
+
+ if(note_str){
+ calendar_record_h record = NULL;
+ calendar_error_e error = CALENDAR_ERROR_NONE;
+ error = calendar_record_create(_calendar_event._uri, &record);
+ c_warn_if(error != CALENDAR_ERROR_NONE, "calendar_record_create() is failed(%x)", error);
+
+ data->record = record;
+ __cal_edit_ug_set_record_note(data->record, note_str);
+
+ time_t now = time(NULL);
+ localtime_r(&now, &data->base_time);
+
+ CAL_FREE(note_str);
+ }
+ }
+
+ int index = _calendar_get_record_index(data->record);
+ if(index>0) {
+ data->is_edit_mode = EINA_TRUE;
+ }
+ _calendar_record_type record_type = _calendar_get_record_type(data->record);
+ ERR("record_type=%d", record_type);
+
+ if (record_type != _CALENDAR_RECORD_TYPE_EVENT && record_type != _CALENDAR_RECORD_TYPE_TODO && record_type != _CALENDAR_RECORD_TYPE_SEARCH_TODO_CALENDAR) {
+ data->instance = data->record;
+ data->record = __cal_edit_ug_get_origin_record(data->instance);
+ }
+
+ if(record_address)
+ CAL_FREE(record_address);
+ }
+
+ if (_calendar_is_task_record(data->record))
+ data->item_type = ITEM_TYPE_TODO;
+ else
+ data->item_type = ITEM_TYPE_EVENT;
+ }
+
+
+ //base_time
+ char *base_time = NULL;
+ r = service_get_extra_data(service, "base_time", &base_time);
+ c_warn_if(SERVICE_ERROR_NONE != r,"service_get_extra_data is failed(%d).", r);
+
+ if(base_time){
+ long long int lli_time = strtoll(base_time, NULL, 10);
+ cal_util_convert_lli_to_tm(NULL, lli_time, &data->base_time);
+ CAL_FREE(base_time);
+ }
+
+ if (error != CALENDAR_ERROR_NONE || data->item_type == ITEM_TYPE_UNKNOWN) {
+ ERR("ERROR!! Invaild parameter!!");
+ ug_destroy_me(ug);
+ }
+
+ CAL_FREE(item_type);
+
+ CAL_FREE(index);
+
+ CAL_FREE(path);
+
+ Evas_Object *parent = ug_get_parent_layout(ug);
+ c_retv_if(!parent, NULL);
+
+ data->window = ug_get_window();
+ c_retv_if(!data->window, NULL);
+
+ elm_theme_extension_add(NULL, "/usr/apps/"CALENDAR_PACKAGE"/res/edje/theme.edj");
+ elm_theme_extension_add(NULL, "/usr/apps/"CALENDAR_PACKAGE"/res/edje/theme2.edj");
+
+ Evas_Object *base = __cal_edit_ug_create_layout(parent, data);
+ c_retv_if(!base, NULL);
+
+ return base;
+}
+
+static void __cal_edit_ug_destroy_callback(ui_gadget_h ug, service_h service, void *priv)
+{
+ CAL_FN_START;
+ c_ret_if(!priv);
+
+ cal_edit_ug_data *data = priv;
+
+ cal_util_delete_evas_object(&data->base_layout);
+
+ if (data->timezone_city)
+ free(data->timezone_city);
+ if (data->timezone_path)
+ free(data->timezone_path);
+ if (data->timezone_offset)
+ free(data->timezone_offset);
+
+ _calendar_free_record_list(&data->calendar_book_list);
+
+ if (data->alarm_list) {
+ g_list_free(data->alarm_list);
+ data->alarm_list = NULL;
+ }
+
+ if (data->alarm_item_list) {
+ eina_list_free(data->alarm_item_list);
+ data->alarm_item_list = NULL;
+ }
+
+ CAL_FREE(data->title_str);
+ CAL_FREE(data->address);
+ CAL_FREE(data->note_str);
+
+ if (data->save_cancel)
+ cal_save_cancel_destroy(data->save_cancel);
+
+ if (data->tabbar)
+ evas_object_del(data->tabbar);
+
+ if (data->event)
+ calendar_record_destroy(data->event, true);
+
+ if (data->todo)
+ calendar_record_destroy(data->todo, true);
+
+ if (data->instance)
+ calendar_record_destroy(data->instance, true);
+
+}
+
+static void __cal_edit_ug_key_callback(ui_gadget_h ug, enum ug_key_event evt, service_h data, void *priv)
+{
+ c_ret_if(!ug);
+
+ DBG("UG: key event %d", evt);
+
+ switch (evt) {
+ case UG_KEY_EVENT_END:
+ ug_destroy_me(ug);
+ break;
+ default:
+ break;
+ }
+}
+
+static void __cal_edit_ug_update_language(cal_edit_ug_data *data)
+{
+ c_ret_if(!data);
+
+ __cal_edit_ug_update_naviframe_language(data);
+
+ __cal_edit_ug_update_tabbar_language(data);
+
+ cal_save_cancel_set_button_text(data->save_cancel, S_("IDS_COM_OPT_SAVE"), NULL);
+
+ __cal_edit_ug_update_title_language(data->title);
+
+ if (data->item_type == ITEM_TYPE_EVENT) {
+
+ __cal_edit_ug_update_start_language(data->start_date_title);
+
+ __cal_edit_ug_update_end_language(data->end_date_title);
+ } else
+ __cal_edit_ug_update_due_language(data->due_date_title);
+
+ __cal_edit_ug_update_time_zone_language(data->timezone, data->timezone_city, data->timezone_offset);
+
+ if (data->item_type == ITEM_TYPE_TODO) {
+
+ __cal_edit_ug_update_no_due_date_language(data->no_due_date);
+
+ __cal_edit_ug_update_priority_language(data->priority, data->todo);
+ }
+
+ if (data->item_type == ITEM_TYPE_EVENT)
+ __cal_edit_ug_update_allday_language(data->allday);
+
+ __cal_edit_ug_update_description_language(data->note);
+
+ __cal_edit_ug_update_location_language(data->location);
+
+ __cal_edit_ug_update_reminder_language(data->alarm_item_list);
+
+ if (data->item_type == ITEM_TYPE_EVENT)
+ __cal_edit_ug_update_recurrence_language(data->repeat, data->repeat_freq);
+
+ if (data->item_type == ITEM_TYPE_EVENT)
+ __cal_edit_ug_update_saveto_language(data->saveto, data->event);
+ else
+ __cal_edit_ug_update_saveto_language(data->saveto, data->todo);
+}
+
+static void __cal_edit_ug_update_region(cal_edit_ug_data *data)
+{
+ c_ret_if(!data);
+
+ if (data->item_type == ITEM_TYPE_EVENT) {
+
+ Eina_Bool is_allday = _calendar_is_allday_record(data->event);
+
+ __cal_edit_ug_update_datetime_region(data->start_date, &data->stm, is_allday, __cal_edit_ug_start_date_changed_callback, data);
+
+ __cal_edit_ug_update_datetime_region(data->end_date, &data->etm, is_allday, __cal_edit_ug_end_date_changed_callback, data);
+
+ } else
+ __cal_edit_ug_update_datetime_region(data->due_date, &data->etm, _calendar_is_allday_record(data->todo), __cal_edit_ug_due_date_changed_callback, data);
+}
+
+static void __cal_edit_ug_event_callback(ui_gadget_h ug, enum ug_event event, service_h service, void *priv)
+{
+ c_ret_if(!ug);
+ c_ret_if(!priv);
+
+ switch (event) {
+ case UG_EVENT_LANG_CHANGE:
+ __cal_edit_ug_update_language((cal_edit_ug_data *)priv);
+ break;
+ case UG_EVENT_REGION_CHANGE:
+ __cal_edit_ug_update_region((cal_edit_ug_data *)priv);
+ break;
+ default:
+ break;
+ }
+}
+
+API int UG_MODULE_INIT(struct ug_module_ops *ops)
+{
+ CAL_FN_START;
+
+ c_retv_if(!ops, -1);
+
+ cal_edit_ug_data *data = calloc(1, sizeof(cal_edit_ug_data));
+
+ ops->create = __cal_edit_ug_create_callback;
+ ops->destroy = __cal_edit_ug_destroy_callback;
+ ops->key_event = __cal_edit_ug_key_callback;
+ ops->event = __cal_edit_ug_event_callback;
+ ops->priv = data;
+ ops->opt = UG_OPT_INDICATOR_PORTRAIT_ONLY;
+
+ const char *path = bindtextdomain(CALENDAR, LOCALEDIR);
+ c_warn_if(!path, "bindtextdomain(%s, %s) is failed.", CALENDAR, LOCALEDIR);
+
+ __cal_edit_ug_initialize(data);
+
+ return 0;
+}
+
+API void UG_MODULE_EXIT(struct ug_module_ops *ops)
+{
+ CAL_FN_START;
+
+ c_ret_if(!ops);
+
+ cal_edit_ug_data *data = ops->priv;
+
+ __cal_edit_ug_finish(data);
+
+ free(data);
+}