src/list.c

   1 /*
   2   *
   3   *  Copyright 2012  Samsung Electronics Co., Ltd
   4   *
   5   *  Licensed under the Flora License, Version 1.0 (the "License");
   6   *  you may not use this file except in compliance with the License.
   7   *  You may obtain a copy of the License at
   8   *
   9   *       http://www.tizenopensource.org/license
  10   *
  11   *  Unless required by applicable law or agreed to in writing, software
  12   *  distributed under the License is distributed on an "AS IS" BASIS,
  13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14   *  See the License for the specific language governing permissions and
  15   *  limitations under the License.
  16   */
  17
  18
  19 #include <vconf.h>
  20 #include <Elementary.h>
  21
  22 #include "detail.h"
  23 #include "noti-handler.h"
  24 #include "edit-repeat.h"
  25 #include "list.h"
  26 #include "external-ug.h"
  27 #include "view.h"
  28
  29 static Elm_Entry_Filter_Limit_Size _limit_20char = {
  30         .max_char_count = 20,
  31 };
  32
  33 typedef enum {
  34         CAL_LIST_MODE_NORMAL = 0,
  35         CAL_LIST_MODE_DAY,
  36         CAL_LIST_MODE_TASK,
  37 }cal_list_mode;
  38
  39 typedef struct {
  40         struct appdata *ad;
  41         Evas_Object *parent;
  42         Evas_Object *layout; // self
  43
  44         Evas_Object *box;
  45         Evas_Object *searchbar;
  46         Evas_Object *genlist;
  47         Evas_Object *no_contents;
  48
  49         cal_list_mode mode;
  50
  51         Eina_List *append_list;
  52         int appended_event_count;
  53
  54         Eina_List *prepend_list;
  55         int prepended_event_count;
  56
  57         const char *searchtext;
  58
  59         int cur_position;
  60         Ecore_Idler* idler; // To append list
  61
  62         struct tm last_itc_h; // To prevent duplicated cal_list_itc_h, in add events & add events idler
  63
  64         Eina_Bool is_today_added; //To check real today item is added.
  65
  66         Evas_Object *popup;
  67
  68         Ecore_Event_Handler *event_handler;
  69         Evas_Coord x;
  70         Evas_Coord y;
  71         Elm_Object_Item *sweep_it;
  72
  73         Elm_Object_Item* navi_item;
  74         Elm_Object_Item *bt_new;
  75         Elm_Object_Item *bt_delete;
  76
  77         int more_idx;
  78
  79         struct tm tm_start;
  80         struct tm tm_end;
  81
  82         Elm_Object_Item *load_more_top;
  83         Elm_Object_Item *load_more_bottom;
  84 }cal_list_data;
  85
  86 typedef struct {
  87         Elm_Object_Item *it;  // Genlist Item pointer
  88         Eina_Bool checked;     // Check status
  89         cal_struct *cs;
  90         struct tm *tm;
  91         char *color_str;
  92 }cal_list_genlist_item_data;
  93
  94 static int is_hour24;
  95 static Calendar_color calendar_color;
  96
  97 static void __cal_list_delete_genlist_header_item(void *data, Evas_Object *obj);
  98 static void __cal_list_delete_genlist_item(void *data, Evas_Object *obj);
  99 static char* __cal_list_get_genlist_header_item_label(void *data, Evas_Object *obj, const char *part);
 100 static char* __cal_list_get_genlist_item_label(void *data, Evas_Object *obj, const char *part);
 101 static Evas_Object *__cal_list_get_genlist_item_icon(void *data, Evas_Object *obj, const char *part);
 102 static char* __cal_list_share_genlist_item_label(void *data, Evas_Object *obj, const char *part);
 103 static void __cal_list_prepend_more(void *data, Evas_Object *obj, void *event_info);
 104 static void __cal_list_append_more(void *data, Evas_Object *obj, void *event_info);
 105 static char* __cal_list_get_genlist_task_item_label(void *data, Evas_Object *obj, const char *part);
 106 static Evas_Object *__cal_list_get_genlist_task_item_icon(void *data, Evas_Object *obj, const char *part);
 107
 108 static Elm_Genlist_Item_Class cal_list_itc_h = {
 109         .item_style = "grouptitle",
 110         .func.text_get = __cal_list_get_genlist_header_item_label,
 111         .func.del = __cal_list_delete_genlist_header_item,
 112 };
 113
 114 static Elm_Genlist_Item_Class cal_list_itc = {
 115         .item_style = "3text.5icon",
 116         .func.text_get = __cal_list_get_genlist_item_label,
 117         .func.del = __cal_list_delete_genlist_item,
 118         .func.content_get = __cal_list_get_genlist_item_icon,
 119         .decorate_item_style = "mode/slide3",
 120 };
 121
 122 static Elm_Genlist_Item_Class cal_list_normal_itc = {
 123         .item_style = "3text.4icon.calendar",
 124         .func.text_get = __cal_list_get_genlist_item_label,
 125         .func.del = __cal_list_delete_genlist_item,
 126         .func.content_get = __cal_list_get_genlist_item_icon,
 127         .decorate_item_style = "mode/slide3",
 128 };
 129
 130 static Elm_Genlist_Item_Class cal_task_itc = {
 131         .item_style = "2text.4icon.5",
 132         .func.text_get = __cal_list_get_genlist_task_item_label,
 133         .func.del = __cal_list_delete_genlist_item,
 134         .func.content_get = __cal_list_get_genlist_task_item_icon,
 135 };
 136
 137 static Elm_Genlist_Item_Class itc_1text = {
 138         .item_style = "1text",
 139         .func.content_get = NULL,
 140         .func.text_get = __cal_list_share_genlist_item_label,
 141 };
 142
 143 static inline void __cal_list_delete_popup(cal_list_data *p)
 144 {
 145         c_retm_if(!p || !p->popup, "param is null");
 146
 147         evas_object_del(p->popup);
 148         p->popup = NULL;
 149 }
 150
 151 static char* __cal_list_share_genlist_item_label(void *data, Evas_Object *obj, const char *part)
 152 {
 153         c_retvm_if(!data || !obj || !part, NULL, "data is null");
 154
 155         char *name = (char *)data;
 156         printf("Test");
 157
 158         if (!CAL_STRCMP(part, "elm.text")) {
 159                 return strdup(name);
 160         }
 161
 162         return NULL;
 163 }
 164
 165 static inline Elm_Object_Item* __cal_list_append_genlist_group_item(Evas_Object *genlist,
 166                 const Elm_Genlist_Item_Class *itc, struct tm *tm)
 167 {
 168         CAL_FN_START;
 169
 170         c_retv_if(!genlist, NULL);
 171
 172         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(genlist);
 173         c_retvm_if(!p, NULL, "p is null.");
 174
 175         if (p->mode == CAL_LIST_MODE_TASK || p->mode == CAL_LIST_MODE_DAY)
 176                 return NULL;
 177
 178         struct tm *t = calloc(1, sizeof(struct tm));
 179         c_retv_if(!t, NULL);
 180
 181         *t = *tm;
 182
 183         cal_list_genlist_item_data *item_data = calloc(1, sizeof(cal_list_genlist_item_data));
 184         c_retv_if(!item_data, NULL);
 185
 186         item_data->tm = t;
 187
 188         item_data->it = elm_genlist_item_append(genlist, itc, item_data, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 189         c_retv_if(!item_data->it, NULL);
 190
 191         elm_genlist_item_select_mode_set(item_data->it, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 192
 193         return item_data->it;
 194 }
 195
 196 static inline Elm_Object_Item* __cal_list_prepend_genlist_group_item(Evas_Object *genlist,
 197                 const Elm_Genlist_Item_Class *itc, struct tm *tm)
 198 {
 199         CAL_FN_START;
 200
 201         c_retv_if(!genlist, NULL);
 202
 203         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(genlist);
 204         c_retv_if(!p, NULL);
 205
 206         if (p->mode == CAL_LIST_MODE_TASK || p->mode == CAL_LIST_MODE_DAY)
 207                 return NULL;
 208
 209         struct tm *t = calloc(1, sizeof(struct tm));
 210         c_retv_if(!t, NULL);
 211
 212         *t = *tm;
 213
 214         cal_list_genlist_item_data *item_data = calloc(1, sizeof(cal_list_genlist_item_data));
 215         c_retv_if(!item_data, NULL);
 216
 217         item_data->tm = t;
 218
 219         item_data->it = elm_genlist_item_prepend(genlist, itc, item_data, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 220         c_retv_if(!item_data->it, NULL);
 221
 222         elm_genlist_item_select_mode_set(item_data->it, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 223
 224         return item_data->it;
 225 }
 226
 227
 228 static inline Elm_Object_Item* __cal_list_append_genlist_item(Evas_Object *genlist,
 229                 const Elm_Genlist_Item_Class *itc, cal_struct *cs, Elm_Object_Item *parent,
 230                 Evas_Smart_Cb func, const void *func_data)
 231 {
 232         CAL_FN_START;
 233
 234         cal_list_genlist_item_data *item_data = calloc(1, sizeof(cal_list_genlist_item_data));
 235         c_retv_if(!item_data, NULL);
 236
 237         item_data->cs = cs;
 238
 239         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(genlist);
 240         c_retv_if(!p, NULL);
 241
 242         item_data->it = elm_genlist_item_append(genlist, itc, item_data, parent, ELM_GENLIST_ITEM_NONE, func, func_data);
 243         c_retv_if(!item_data->it, NULL);
 244
 245         return item_data->it;
 246 }
 247
 248 static inline Elm_Object_Item* __cal_list_prepend_genlist_item(Evas_Object *genlist,
 249                 const Elm_Genlist_Item_Class *itc, cal_struct *cs, Elm_Object_Item *parent,
 250                 Evas_Smart_Cb func, const void *func_data)
 251 {
 252         CAL_FN_START;
 253
 254         cal_list_genlist_item_data *item_data = calloc(1, sizeof(cal_list_genlist_item_data));
 255         c_retv_if(!item_data, NULL);
 256
 257         item_data->cs = cs;
 258
 259         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(genlist);
 260         c_retv_if(!p, NULL);
 261
 262         item_data->it = elm_genlist_item_prepend(genlist, itc, item_data, NULL, ELM_GENLIST_ITEM_NONE, func, func_data);
 263         c_retv_if(!item_data->it, NULL);
 264
 265         return item_data->it;
 266 }
 267
 268 static void __cal_list_set_genlist_item_sweep_off(Elm_Object_Item *it)
 269 {
 270         c_retm_if(!it, "it is null");
 271         elm_genlist_item_decorate_mode_set(it, "slide", EINA_FALSE);
 272         elm_genlist_item_select_mode_set(it, ELM_OBJECT_SELECT_MODE_ALWAYS);
 273 }
 274
 275 static void __cal_list_init_sweep_data(cal_list_genlist_item_data* item_data, cal_list_data *p)
 276 {
 277         c_retm_if(!item_data, "item_data is null");
 278         c_retm_if(!p, "p is null");
 279
 280         cal_struct *cs = item_data->cs;
 281         c_retm_if(!cs, "cs is NULL.");
 282
 283         cal_main_set_cs(p->ad, cs);
 284 }
 285
 286 static void __cal_list_edit_popup_response_event_callback(void *data, Evas_Object *obj, void *event_info)
 287 {
 288         c_retm_if(!data, "data is null");
 289         c_retm_if(!obj, "obj is null");
 290
 291         Evas_Object *popup = data;
 292         Evas_Object *button = obj;
 293         cal_list_data* p = evas_object_data_get(popup, "data");
 294         c_retm_if(!p, "p is null");
 295
 296         struct appdata* ad = p->ad;
 297         c_retm_if(!ad, "ad is null");
 298
 299         if (!strcmp(elm_object_text_get(button), C_("IDS_CLD_BODY_ONLY_THIS_EVENT"))) {
 300                 ad->edit_special_one = EINA_TRUE;
 301
 302                 cal_edit_create_view(ad, p->layout);
 303                 __cal_list_set_genlist_item_sweep_off(p->sweep_it);
 304         }else if (!strcmp(elm_object_text_get(button), C_("IDS_CLD_POP_ALL_REPETITIVE_EVENTS"))) {
 305                 ad->edit_special_one = EINA_FALSE;
 306
 307                 cal_edit_create_view(ad, p->layout);
 308                 __cal_list_set_genlist_item_sweep_off(p->sweep_it);
 309         }
 310
 311         evas_object_del(popup);
 312         p->popup = NULL;
 313 }
 314
 315 static cal_struct* __cal_list_get_event(int idx)
 316 {
 317         c_retvm_if(idx < 0, NULL, "idx is invalied(%d)", idx);
 318         cal_struct *cs = NULL;
 319
 320         int r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, idx, NULL, &cs);
 321         c_retvm_if(r != CAL_SUCCESS, NULL, "CALENDAR_SVC_GET(%d) is failed(%d)", idx, r);
 322
 323         return cs;
 324 }
 325
 326 static void __cal_list_delete_event(cal_list_data* p, Eina_Bool is_delete_all)
 327 {
 328         c_retm_if(!p, "p is null");
 329
 330         int r = 0;
 331
 332         cal_struct *cs = __cal_list_get_event(p->ad->cid);
 333         c_ret_if(!cs);
 334
 335         if (!is_delete_all) {
 336                 long long int lli_time;
 337                 cal_util_convert_tm_to_lli(NULL, &p->ad->tm_start, &lli_time);
 338
 339                 r = calendar_svc_event_delete_normal_instance(p->ad->cid, lli_time);
 340                 if (r != CAL_SUCCESS)
 341                         ERR("calendar_svc_event_delete_normal_instance is failed %d", r);
 342         } else {
 343                 r = CALENDAR_SVC_DELETE(CAL_STRUCT_SCHEDULE, p->ad->cid);
 344                 if (r != CAL_SUCCESS)
 345                         ERR("CALENDAR_SVC_DELETE is failed %d", r);
 346         }
 347
 348         CALENDAR_SVC_STRUCT_FREE(&cs);
 349
 350         evas_object_del(p->popup);
 351
 352 }
 353
 354 static void __cal_list_delete_popup_response_event_callback(void *data, Evas_Object *obj, void *event_info)
 355 {
 356         c_retm_if(!data, "data is null");
 357         c_retm_if(!obj, "obj is null");
 358
 359         Evas_Object *popup = data;
 360         Evas_Object *button = obj;
 361
 362         cal_list_data* p = evas_object_data_get(popup, "data");
 363         c_retm_if(!p, "p is null");
 364
 365         if (!strcmp(elm_object_text_get(button), C_("IDS_CLD_BODY_ONLY_THIS_EVENT")))
 366                 __cal_list_delete_event(p, EINA_FALSE);
 367         else if (!strcmp(elm_object_text_get(button), C_("IDS_CLD_POP_ALL_REPETITIVE_EVENTS")))
 368                 __cal_list_delete_event(p, EINA_TRUE);
 369
 370         evas_object_del(popup);
 371         p->popup = NULL;
 372 }
 373
 374 static void __cal_list_show_popup(cal_list_data *p, const char *tit, Eina_Bool is_edit)
 375 {
 376         c_retm_if(!p, "p is NULL.");
 377
 378         void (*callback_func)(void *data, Evas_Object *obj, void *ei) = NULL;
 379
 380         if (is_edit)
 381                 callback_func = __cal_list_edit_popup_response_event_callback;
 382         else
 383                 callback_func = __cal_list_delete_popup_response_event_callback;
 384
 385         p->popup = cal_util_add_popup(p->ad->win, "verticalbuttonstyle", NULL, tit,
 386                 callback_func, p, C_("IDS_CLD_BODY_ONLY_THIS_EVENT"),
 387                 C_("IDS_CLD_POP_ALL_REPETITIVE_EVENTS"), S_("IDS_COM_SK_CANCEL"), NULL);
 388
 389         c_retm_if(!p->popup, "cal_util_add_popup(p->ad->win) returned null");
 390
 391         evas_object_data_set(p->popup, "priv", p);
 392 }
 393
 394 static void __cal_list_delete_popup_edit_response_event_callback(void *data, Evas_Object *obj, void *event_info)
 395 {
 396         c_retm_if(!data, "data is null");
 397         c_retm_if(!obj, "obj is null");
 398
 399         Evas_Object *popup = data;
 400         Evas_Object *button = obj;
 401
 402         cal_list_data *p = evas_object_data_get(popup, "data");
 403         c_retm_if(!p, "p is null");
 404
 405         if (!strcmp(elm_object_text_get(button), S_("IDS_COM_SK_OK"))) {
 406                 cal_edit_create_view(p->ad, p->layout);
 407                 __cal_list_set_genlist_item_sweep_off(p->sweep_it);
 408         }
 409
 410         evas_object_del(p->popup);
 411         p->popup = NULL;
 412 }
 413
 414 static void __cal_list_edit_button_callback(void *data, Evas_Object *obj, void *ei)
 415 {
 416         cal_list_genlist_item_data *item_data = data;
 417         c_retm_if(!item_data, "item_data is NULL.");
 418
 419         cal_list_data* p = CAL_UTIL_GET_PRIV_DATA(obj);
 420         c_retm_if(!p, "p is NULL.");
 421
 422         cal_struct *cs = item_data->cs;
 423         c_retm_if(!cs, "cs is NULL.");
 424
 425         __cal_list_init_sweep_data(item_data, p);
 426
 427         if (0 != CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_RRULE_ID)) {
 428                 __cal_list_show_popup(p,C_("IDS_CLD_HEADER_EDIT_EVENT"), EINA_TRUE);
 429         } else {
 430                 p->popup = cal_util_add_popup(p->ad->win, NULL, NULL, C_("IDS_CLD_HEADER_EDIT_EVENT"), __cal_list_delete_popup_edit_response_event_callback, p,
 431                         S_("IDS_COM_SK_OK"),S_("IDS_COM_SK_CANCEL"), NULL);
 432         }
 433
 434 }
 435
 436 static void __cal_list_delete_norepeat_popup_response_event_callback(void *data, Evas_Object *obj, void *event_info)
 437 {
 438         c_retm_if(!data, "data is null");
 439         c_retm_if(!obj, "obj is null");
 440
 441         Evas_Object *popup = data;
 442         Evas_Object *button = obj;
 443
 444         cal_list_data* p = evas_object_data_get(popup, "data");
 445
 446         c_retm_if(!p, "p is null");
 447         c_retm_if(!p->ad, "p->ad is null");
 448         c_retm_if(!p->popup, "p->popup is null");
 449
 450         if (!CAL_STRCMP(elm_object_text_get(button), S_("IDS_COM_SK_OK"))) {
 451                 int r = CALENDAR_SVC_DELETE(CAL_STRUCT_SCHEDULE, p->ad->cid);
 452                 c_warn_if(r != CAL_SUCCESS, "CALENDAR_SVC_DELETE(CAL_STRUCT_SCHEDULE, %d) is failed(%d)", p->ad->cid, r);
 453
 454                 cal_struct *cs = evas_object_data_get(p->layout, "cs");
 455                 if (cs)
 456                         CALENDAR_SVC_STRUCT_FREE(&cs);
 457                 else
 458                         ERR("cs is null");
 459         }
 460
 461         evas_object_del(p->popup);
 462         p->popup = NULL;
 463 }
 464
 465 static void __cal_list_delete_button_callback(void *data, Evas_Object *obj, void *ei)
 466 {
 467         cal_list_genlist_item_data *item_data = data;
 468         c_retm_if(!item_data, "item_data is NULL.");
 469
 470         cal_list_data* p = CAL_UTIL_GET_PRIV_DATA(obj);
 471         c_retm_if(!p, "p is NULL.");
 472
 473         __cal_list_init_sweep_data(item_data, p);
 474
 475         if (p->ad->cid) {
 476
 477                 cal_struct *cs = __cal_list_get_event(p->ad->cid);
 478                 c_retm_if(!cs, "cs is null");
 479
 480                 int r = CALENDAR_SVC_STRUCT_GET_INT(cs,CALS_VALUE_INT_RRULE_ID);
 481                 evas_object_data_set(p->layout, "cs", cs);
 482
 483                 if (0 != r)
 484                         __cal_list_show_popup(p, C_("IDS_CLD_OPT_DELETE_EVENT"), EINA_FALSE);
 485                 else {
 486                         p->popup = cal_util_add_popup(p->ad->win, NULL, NULL, C_("IDS_CLD_OPT_DELETE_EVENT"), __cal_list_delete_norepeat_popup_response_event_callback, p,
 487                                 S_("IDS_COM_SK_OK"),S_("IDS_COM_SK_CANCEL"), NULL);
 488                 }
 489         }
 490
 491 }
 492
 493 static void __cal_list_via_message_callback(void *data, Evas_Object *obj, void *ei)
 494 {
 495         c_retm_if(!data, "data is null");
 496         c_retm_if(!obj, "obj is null");
 497
 498         cal_list_data *p = data;
 499         c_retm_if(!p->ad, "p->ad is null");
 500
 501         cal_struct *cs = NULL;
 502         int r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, p->ad->cid, NULL, &cs);
 503         if (CAL_SUCCESS != r || NULL == cs) {
 504                 ERR("CALENDAR_SVC_GET failed: %d", r);
 505                 return;
 506         }
 507
 508         r = cal_util_create_vcs_file_from_cs(cs, MESSAGE_VCS);
 509         if (CAL_SUCCESS != r) {
 510                 CALENDAR_SVC_STRUCT_FREE(&cs);
 511                 ERR("cal_util_create_vcs_file_from_cs: %d", r);
 512                 return;
 513         }
 514
 515         CALENDAR_SVC_STRUCT_FREE(&cs);
 516
 517         cal_launch_ug_with_var(MESSAGE_COMPOSER_UG, NULL, "ATTACHFILE", MESSAGE_VCS, NULL);
 518         __cal_list_set_genlist_item_sweep_off(p->sweep_it);
 519
 520         __cal_list_delete_popup(p);
 521 }
 522
 523 static void __cal_list_via_email_callback(void *data, Evas_Object *obj, void *ei)
 524 {
 525         c_retm_if(!data, "data is null");
 526         c_retm_if(!obj, "obj is null");
 527
 528         cal_list_data *p = data;
 529         c_retm_if(!p->ad, "p->ad is null");
 530
 531         cal_struct *cs = NULL;
 532         int r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, p->ad->cid, NULL, &cs);
 533         if (CAL_SUCCESS != r || NULL == cs) {
 534                 ERR("CALENDAR_SVC_GET failed: %d", r);
 535                 return;
 536         }
 537
 538         r = cal_util_create_vcs_file_from_cs(cs, EMAIL_VCS);
 539         if (CAL_SUCCESS != r) {
 540                 CALENDAR_SVC_STRUCT_FREE(&cs);
 541                 ERR("cal_util_create_vcs_file_from_cs: %d", r);
 542                 return;
 543         }
 544
 545         CALENDAR_SVC_STRUCT_FREE(&cs);
 546
 547         cal_launch_ug_with_var(EMAIL_COMPOSER_UG, NULL, "RUN_TYPE", "5", "ATTACHFILE", EMAIL_VCS, NULL);
 548         __cal_list_set_genlist_item_sweep_off(p->sweep_it);
 549
 550         __cal_list_delete_popup(p);
 551 }
 552
 553 static void __cal_list_via_bluetooth_callback(void *data, Evas_Object *obj, void *ei)
 554 {
 555         c_retm_if(!data, "data is null");
 556         c_retm_if(!obj, "obj is null");
 557
 558         cal_list_data *p = data;
 559         c_retm_if(!p->ad, "p->ad is null");
 560
 561         cal_struct *cs = NULL;
 562         int r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, p->ad->cid, NULL, &cs);
 563         if (CAL_SUCCESS != r || NULL == cs) {
 564                 ERR("CALENDAR_SVC_GET failed: %d", r);
 565                 return;
 566         }
 567
 568         r = cal_util_create_vcs_file_from_cs(cs, BLUETOOTH_VCS);
 569         if (CAL_SUCCESS != r) {
 570                 CALENDAR_SVC_STRUCT_FREE(&cs);
 571                 ERR("cal_util_create_vcs_file_from_cs: %d", r);
 572                 return;
 573         }
 574
 575         CALENDAR_SVC_STRUCT_FREE(&cs);
 576
 577         cal_launch_ug_with_var(BLUETOOTH_UG, NULL, "launch-type", "send", "filecount", "1", "files", BLUETOOTH_VCS, NULL);
 578         __cal_list_set_genlist_item_sweep_off(p->sweep_it);
 579
 580         __cal_list_delete_popup(p);
 581 }
 582
 583 static void __cal_list_share_popup_response_callback(void *data, Evas_Object *obj, void *ei)
 584 {
 585         c_retm_if(!data, "data is null");
 586         c_retm_if(!obj, "obj is null");
 587
 588         Evas_Object *popup = data;
 589
 590         cal_list_data* p = evas_object_data_get(popup, "data");
 591         c_retm_if(!p, "p is null");
 592
 593         evas_object_del(popup);
 594         p->popup = NULL;
 595
 596 }
 597
 598 static void __cal_list_send_button_callback(void *data, Evas_Object *obj, void *ei)
 599 {
 600         cal_list_genlist_item_data *item_data = data;
 601         c_retm_if(!item_data, "item_data is NULL.");
 602
 603         cal_list_data* p = CAL_UTIL_GET_PRIV_DATA(obj);
 604         c_retm_if(!p, "p is NULL.");
 605
 606         __cal_list_init_sweep_data(item_data, p);
 607
 608         p->popup = cal_util_add_popup(p->ad->win, "menustyle", S_("IDS_COM_BUTTON_SHARE"), NULL,
 609                                 __cal_list_share_popup_response_callback, p,
 610                                 S_("IDS_COM_BODY_CLOSE"),  NULL);
 611
 612         c_retm_if(!p->popup, "cal_util_add_popup returned null");
 613         evas_object_data_set(p->popup, "data", p);
 614
 615         Evas_Object *genlist = elm_genlist_add(p->popup);
 616         c_retm_if(!genlist, "elm_genlist_add returned null");
 617
 618         elm_genlist_item_append(genlist, &itc_1text, S_("IDS_COM_BODY_EMAIL"), NULL, ELM_GENLIST_ITEM_NONE, __cal_list_via_email_callback, p);
 619         elm_genlist_item_append(genlist, &itc_1text, S_("IDS_COM_BODY_MESSAGE"), NULL, ELM_GENLIST_ITEM_NONE, __cal_list_via_message_callback, p);
 620         elm_genlist_item_append(genlist, &itc_1text, S_("IDS_COM_BODY_BLUETOOTH"), NULL, ELM_GENLIST_ITEM_NONE, __cal_list_via_bluetooth_callback, p);
 621
 622         elm_object_content_set(p->popup, genlist);
 623         evas_object_show(p->popup);
 624 }
 625
 626 static void __cal_list_genlist_item_check_changed_callback(void *data, Evas_Object *obj, void *event_info)
 627 {
 628         c_ret_if(!data);
 629         c_ret_if(!obj);
 630
 631         cal_list_genlist_item_data *item_data = data;
 632
 633         cal_list_data* p = CAL_UTIL_GET_PRIV_DATA(obj);
 634         c_ret_if(!p);
 635
 636         int r;
 637
 638         item_data->checked = elm_check_state_get(obj);
 639
 640         cal_struct *cs = item_data->cs;
 641         c_ret_if(!cs);
 642
 643         if (item_data->checked)
 644                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_TASK_STATUS, CALS_TODO_STATUS_COMPLETED);
 645         else
 646                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_TASK_STATUS, CALS_TODO_STATUS_IN_PROCESS);
 647
 648         r = CALENDAR_SVC_UPDATE(cs);
 649         c_retm_if(r != CAL_SUCCESS, "CALENDAR_SVC_UPDATE is failed(%d).", r);
 650
 651         elm_genlist_item_update(item_data->it);
 652
 653 }
 654
 655 static int __cal_list_get_cs_alarm_flag(cal_struct *cs)
 656 {
 657         c_retv_if(!cs, 0);
 658
 659         int r;
 660         cal_struct *cs_d = NULL;
 661         GList *al = NULL;
 662
 663         int cid = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_INDEX);
 664
 665         r = CALENDAR_SVC_GET(CAL_STRUCT_SCHEDULE, cid, NULL, &cs_d);
 666         c_retv_if(CAL_SUCCESS != r , 0);
 667         c_retv_if(!cs_d, 0);
 668
 669         r = CALENDAR_SVC_STRUCT_GET_LIST(cs_d, CAL_VALUE_LST_ALARM, &al);
 670         if (CAL_SUCCESS != r || !al) {
 671                 CALENDAR_SVC_STRUCT_FREE(&cs_d);
 672                 return 0;
 673         }
 674
 675         CALENDAR_SVC_STRUCT_FREE(&cs_d);
 676         return 1;
 677 }
 678
 679 static int __cal_list_get_cs_repeat_flag(cal_struct *cs)
 680 {
 681         c_retv_if(!cs, 0);
 682
 683         int r = 0;
 684
 685         r = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_RRULE_ID);
 686
 687         return r;
 688 }
 689
 690
 691 static Evas_Object *__cal_list_get_genlist_item_icon(void *data, Evas_Object *obj, const char *part)
 692 {
 693         c_retv_if(!data, NULL);
 694
 695         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
 696         c_retv_if(!p, NULL);
 697
 698         cal_list_genlist_item_data *item_data = data;
 699
 700         Evas_Object *button = NULL;
 701         cal_struct *calendar = NULL;
 702         Evas_Object *icon = NULL;
 703
 704         cal_struct *cs = item_data->cs;
 705
 706         if (!CAL_STRCMP(part, "elm.swallow.colorbar")) {
 707
 708                 int r = CALENDAR_SVC_GET(CAL_STRUCT_CALENDAR, CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_VALUE_INT_CALENDAR_ID), NULL, &calendar);
 709                 if (r != CAL_SUCCESS)
 710                 {
 711                         ERR("CALENDAR_SVC_GET fail. %d", r);
 712                         return NULL;
 713                 }
 714
 715                 icon = evas_object_rectangle_add(evas_object_evas_get(obj));
 716                 evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 717
 718                 CALENDAR_SVC_GET_CALENDAR_COLOR(calendar, &calendar_color);
 719
 720                 evas_object_color_set(icon, calendar_color.red, calendar_color.green, calendar_color.blue, calendar_color.alpha);
 721
 722                 CALENDAR_SVC_STRUCT_FREE(&calendar);
 723
 724                 return icon;
 725
 726         } else if (!CAL_STRCMP(part, "elm.slide.swallow.1")) {
 727
 728                 button = elm_button_add(obj);
 729                 c_retvm_if(!button, NULL, "button is NULL");
 730
 731                 elm_object_style_set(button, "text_only/sweep");
 732                 elm_object_text_set(button, S_("IDS_COM_SK_EDIT"));
 733                 evas_object_data_set(button, "priv", p);
 734                 evas_object_smart_callback_add(button, "clicked", __cal_list_edit_button_callback, item_data);
 735
 736                 return button;
 737
 738         } else if (!CAL_STRCMP(part, "elm.slide.swallow.2")) {
 739
 740                 button = elm_button_add(obj);
 741                 c_retvm_if(!button, NULL, "button is NULL");
 742
 743                 elm_object_style_set(button, "text_only/sweep");
 744                 elm_object_text_set(button, S_("IDS_COM_BODY_DELETE"));
 745                 evas_object_data_set(button, "priv", p);
 746                 evas_object_smart_callback_add(button, "clicked", __cal_list_delete_button_callback, item_data);
 747
 748                 return button;
 749
 750         } else if (!CAL_STRCMP(part, "elm.slide.swallow.3")) {
 751
 752                 button = elm_button_add(obj);
 753                 c_retvm_if(!button, NULL, "button is NULL");
 754
 755                 elm_object_style_set(button, "text_only/sweep");
 756                 elm_object_text_set(button, S_("IDS_COM_BUTTON_SHARE"));
 757                 evas_object_data_set(button, "priv", p);
 758                 evas_object_smart_callback_add(button, "clicked", __cal_list_send_button_callback, item_data);
 759
 760                 return button;
 761
 762         } else if (!CAL_STRCMP(part, "elm.edit.icon.1") ) {
 763                 icon = elm_check_add(obj);
 764                 c_retvm_if(!icon, NULL, "elm_check_add returned null");
 765
 766                 int todo_status = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_TASK_STATUS);
 767
 768                 if (CALS_TODO_STATUS_COMPLETED == todo_status)
 769                         item_data->checked = EINA_TRUE;
 770                 else if (CALS_TODO_STATUS_IN_PROCESS == todo_status)
 771                         item_data->checked = EINA_FALSE;
 772
 773                 elm_check_state_pointer_set(icon, &item_data->checked);
 774                 evas_object_smart_callback_add(icon, "changed", __cal_list_genlist_item_check_changed_callback, item_data);
 775                 evas_object_propagate_events_set(icon, EINA_FALSE);
 776                 evas_object_data_set(icon, "priv", p);
 777
 778                 return icon;
 779         } else if (!CAL_STRCMP(part, "elm.icon.1")) {
 780                 if ( CAL_LIST_MODE_NORMAL == p->mode) {
 781                         int r = __cal_list_get_cs_alarm_flag(cs);
 782                         c_retv_if(!r, NULL);
 783
 784                         icon = elm_icon_add(obj);
 785                         c_retv_if(!icon, NULL);
 786
 787                         r = elm_icon_file_set(icon, CAL_EVENT_LIST_ICON_ALARM, NULL);
 788                         c_retv_if(!r, NULL);
 789
 790                         return icon;
 791                 }
 792         } else if (!CAL_STRCMP(part, "elm.icon.2")) {
 793
 794                 if ( CAL_LIST_MODE_NORMAL == p->mode) {
 795                         int r = __cal_list_get_cs_repeat_flag(cs);
 796                         c_retv_if(r <= 0, NULL);
 797
 798                         icon = elm_icon_add(obj);
 799                         c_retv_if(!icon, NULL);
 800
 801                         r = elm_icon_file_set(icon, CAL_EVENT_LIST_ICON_REPEAT, NULL);
 802                         c_retv_if(!r, NULL);
 803
 804                         return icon;
 805                 }
 806         } else if (!CAL_STRCMP(part, "elm.icon.3")) {
 807                 if ( CAL_LIST_MODE_NORMAL == p->mode) {
 808                         int calendar_id = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_CALENDAR_ID);
 809                         if (p->ad->calendar_facebook_id == calendar_id) {
 810                                 icon = elm_icon_add(obj);
 811                                 c_retv_if(!icon, NULL);
 812
 813                                 int r = elm_icon_file_set(icon, CAL_EVENT_LIST_ICON_FACEBOOK, NULL);
 814                                 c_retv_if(!r, NULL);
 815
 816                                 return icon;
 817                         }
 818                 }
 819         }
 820
 821         return NULL;
 822 }
 823
 824 static void __cal_list_genlist_item_check_clicked_callback(void *data, Evas_Object *obj, void *event_info)
 825 {
 826         c_ret_if(!data);
 827         c_ret_if(!obj);
 828
 829         cal_list_genlist_item_data *item_data = data;
 830
 831         cal_list_data *p = evas_object_data_get(obj, "priv");
 832         c_ret_if(!p);
 833         c_ret_if(!p->ad);
 834
 835         int r;
 836
 837         item_data->checked = !item_data->checked;
 838
 839         cal_struct *cs = item_data->cs;
 840         c_ret_if(!cs);
 841
 842         if (item_data->checked)
 843                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_TASK_STATUS, CALS_TODO_STATUS_COMPLETED);
 844         else
 845                 CALENDAR_SVC_STRUCT_SET_INT(cs, CAL_VALUE_INT_TASK_STATUS, CALS_TODO_STATUS_IN_PROCESS);
 846
 847         CALENDAR_SVC_DEL_EVENT_CHANGED_CALLBACK(cal_main_update_view);
 848
 849         r = CALENDAR_SVC_UPDATE(cs);
 850         c_retm_if(r != CAL_SUCCESS, "CALENDAR_SVC_UPDATE is failed(%d).", r);
 851
 852         CALENDAR_SVC_ADD_EVENT_CHANGED_CALLBACK(cal_main_update_view, p->ad);
 853
 854         elm_genlist_item_update(item_data->it);
 855
 856 }
 857
 858 static Evas_Object *__cal_list_get_genlist_task_item_icon(void *data, Evas_Object *obj, const char *part)
 859 {
 860         c_retv_if(!data, NULL);
 861
 862         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
 863         c_retv_if(!p, NULL);
 864
 865         cal_list_genlist_item_data *item_data = data;
 866
 867         Evas_Object *button = NULL;
 868         cal_struct *calendar = NULL;
 869         Evas_Object *icon = NULL;
 870         const char *str = NULL;
 871         char *location = NULL;
 872
 873         cal_struct *cs = item_data->cs;
 874
 875         if (!CAL_STRCMP(part, "elm.swallow.colorbar")) {
 876
 877                 int r = CALENDAR_SVC_GET(CAL_STRUCT_CALENDAR, CALENDAR_SVC_STRUCT_GET_INT(cs,CAL_VALUE_INT_CALENDAR_ID), NULL, &calendar);
 878                 if (r != CAL_SUCCESS)
 879                 {
 880                         ERR("CALENDAR_SVC_GET fail. %d", r);
 881                         return NULL;
 882                 }
 883
 884                 icon = evas_object_rectangle_add(evas_object_evas_get(obj));
 885                 evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 886
 887                 CALENDAR_SVC_GET_CALENDAR_COLOR(calendar, &calendar_color);
 888
 889                 evas_object_color_set(icon, calendar_color.red, calendar_color.green, calendar_color.blue, calendar_color.alpha);
 890
 891                 CALENDAR_SVC_STRUCT_FREE(&calendar);
 892
 893                 return icon;
 894         } else if (!CAL_STRCMP(part, "elm.icon.1") ) {
 895                 cal_priority_type_t priority = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_PRIORITY);
 896                 c_retv_if(priority != EVENT_PRIORITY_HIGH, NULL);
 897
 898                 icon = elm_icon_add(obj);
 899                 c_retvm_if(!icon, NULL, "elm_icon_add returned null");
 900
 901                 elm_icon_file_set(icon, CAL_TASK_EVENT_HIGH_ICON, NULL);
 902                 return icon;
 903         } else if (!CAL_STRCMP(part, "elm.icon.2") ) {
 904                 Evas_Object *image = elm_image_add(obj);
 905                 c_retvm_if(!image, NULL, "elm_image_add returned null");
 906
 907                 evas_object_propagate_events_set(image, EINA_FALSE);
 908
 909                 int todo_status = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_TASK_STATUS);
 910                 if (CALS_TODO_STATUS_COMPLETED == todo_status) {
 911                         item_data->checked = EINA_TRUE;
 912                         elm_image_file_set(image, CAL_TASK_EVENT_COMPLETED_ICON, NULL);
 913                 } else {
 914                         item_data->checked = EINA_FALSE;
 915                         elm_image_file_set(image, CAL_TASK_EVENT_UNCOMPLETED_ICON, NULL);
 916                 }
 917
 918                 elm_image_resizable_set(image, EINA_TRUE, EINA_TRUE);
 919                 evas_object_data_set(image, "priv", p);
 920                 evas_object_smart_callback_add(image, "clicked", __cal_list_genlist_item_check_clicked_callback, item_data);
 921
 922                 evas_object_show(image);
 923                 return image;
 924         }
 925
 926         return NULL;
 927 }
 928
 929 // TODO: Create new type for header item data
 930 static void __cal_list_delete_genlist_header_item(void *data, Evas_Object *obj)
 931 {
 932         CAL_FN_START;
 933
 934         c_retm_if(!data, "data is null.");
 935
 936         cal_list_genlist_item_data *item_data = data;
 937
 938         free(item_data->tm);
 939         free(item_data);
 940 }
 941
 942 static void __cal_list_delete_genlist_item(void *data, Evas_Object *obj)
 943 {
 944         c_retm_if(!data, "data is null.");
 945         cal_list_genlist_item_data *item_data = data;
 946
 947         if (item_data->color_str) {
 948                 free(item_data->color_str);
 949                 item_data->color_str = NULL;
 950         }
 951
 952         free(item_data);
 953 }
 954
 955 static void __cal_list_append_list_with_iter(Eina_List **list, cal_iter *iter)
 956 {
 957         c_ret_if(!list);
 958         c_ret_if(!iter);
 959
 960         cal_struct *cs = NULL;
 961
 962         while (CALENDAR_SVC_ITER_NEXT(iter) == CAL_SUCCESS) {
 963
 964                 cs = NULL;
 965                 cal_error error = CALENDAR_SVC_ITER_GET_INFO(iter, &cs);
 966                 if (error != CAL_SUCCESS) {
 967                         ERR("CALENDAR_SVC_ITER_GET_INFO() is failed(%d)", error);
 968                         break;
 969                 }
 970
 971                 *list = eina_list_append(*list, cs);
 972         }
 973 }
 974
 975 static void __cal_list_get_data_with_search(cal_list_data *p, int (*calendar_svc_search)(int, const char *, cal_iter **))
 976 {
 977         CAL_FN_START;
 978
 979         c_ret_if(!p);
 980
 981         cal_iter *it = NULL;
 982
 983         int search_field = CALS_SEARCH_FIELD_NONE;
 984         search_field |= CALS_SEARCH_FIELD_SUMMARY;
 985         search_field |= CALS_SEARCH_FIELD_LOCATION;
 986         search_field |= CALS_SEARCH_FIELD_ATTENDEE;
 987         search_field |= CALS_SEARCH_FIELD_DESCRIPTION;
 988
 989         int r= calendar_svc_search(search_field, p->searchtext, &it);
 990         c_retm_if(r != CAL_SUCCESS, "calendar_svc_search() is failed(%d)");
 991
 992         __cal_list_append_list_with_iter(&p->append_list, it);
 993
 994         CALENDAR_SVC_ITER_REMOVE(&it);
 995
 996         CAL_FN_END;
 997 }
 998
 999 static void __cal_list_get_events_with_search(cal_list_data *p)
1000 {
1001         CAL_FN_START;
1002
1003         c_ret_if(!p);
1004
1005         __cal_list_get_data_with_search(p, calendar_svc_event_search);
1006
1007         CAL_FN_END;
1008 }
1009
1010 static void __cal_list_get_todo_with_search(cal_list_data *p)
1011 {
1012         CAL_FN_START;
1013
1014         c_ret_if(!p);
1015
1016         __cal_list_get_data_with_search(p, calendar_svc_todo_search);
1017
1018         CAL_FN_END;
1019 }
1020
1021 static void __cal_list_genlist_item_select_callback(void *data, Evas_Object *obj, void *event_info)
1022 {
1023         CAL_FN_START;
1024
1025         c_ret_if(!data);
1026         c_ret_if(!obj);
1027
1028         cal_struct *cs = data;
1029
1030         Elm_Object_Item *it = elm_genlist_selected_item_get(obj);
1031         c_ret_if(!it);
1032
1033         elm_genlist_item_selected_set(it, EINA_FALSE);
1034
1035         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
1036         c_retm_if(!p, "priv is null.");
1037
1038         cal_main_set_cs(p->ad, cs);
1039
1040         if (p->mode != CAL_LIST_MODE_TASK)
1041                 cal_detail_create_view(p->ad, p->parent);
1042         else
1043                 cal_detail_create_view_todo(p->ad, p->parent);
1044 }
1045
1046 static Eina_Bool __cal_list_check_idler_condition(cal_list_data *p)
1047 {
1048         c_retv_if(!p, ECORE_CALLBACK_CANCEL);
1049
1050         if (p->appended_event_count < eina_list_count(p->append_list) ||
1051                 p->prepended_event_count < eina_list_count(p->prepend_list)) {
1052
1053                 return ECORE_CALLBACK_RENEW;
1054         }
1055
1056         if (p->idler) {
1057                 ecore_idler_del(p->idler);
1058                 p->idler = NULL;
1059         }
1060
1061         return ECORE_CALLBACK_CANCEL;
1062 }
1063
1064 static void __cal_list_prepend_event_to_genlist(cal_list_data *p)
1065 {
1066         CAL_FN_START;
1067
1068         c_ret_if(!p);
1069         c_ret_if(!p->prepend_list);
1070
1071         struct appdata* ad = p->ad;
1072         c_retm_if(!ad, "ad is null.");
1073
1074         Elm_Object_Item *it = NULL;
1075         int time_previous = 0;
1076
1077         Eina_List *l, *list;
1078         cal_struct *cs;
1079         int prepended_event_count = 0;
1080         struct tm tm_previous = {0};
1081         struct tm tm_current = {0};
1082
1083         if (0 < p->prepended_event_count) {
1084                 list = eina_list_nth_list(p->prepend_list, p->prepended_event_count);
1085                 c_ret_if(!list);
1086         }
1087         else
1088                 list = p->prepend_list;
1089
1090         EINA_LIST_FOREACH(list, l, cs) {
1091
1092                 if (!cs)
1093                         continue;
1094
1095                 tm_current = p->ad->base_tm;
1096
1097                 if (CALENDAR_SVC_IS_ALLDAY_EVENT(cs)) {
1098
1099                         tm_current.tm_year = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_YEAR) - 1900;
1100                         tm_current.tm_mon = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MONTH) - 1;
1101                         tm_current.tm_mday = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MDAY);
1102
1103                 } else
1104                         cal_util_convert_lli_to_tm(NULL, CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME), &tm_current);
1105
1106                 int time_current = (tm_current.tm_year << 9) | (tm_current.tm_mon << 5) | tm_current.tm_mday;
1107
1108                 if (time_previous && time_previous != time_current)
1109                         it = __cal_list_prepend_genlist_group_item(p->genlist, &cal_list_itc_h, &tm_previous);
1110
1111                 switch (p->mode) {
1112                 case CAL_LIST_MODE_NORMAL:
1113                         __cal_list_prepend_genlist_item(p->genlist, &cal_list_normal_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1114                         break;
1115                 case CAL_LIST_MODE_DAY:
1116                         __cal_list_prepend_genlist_item(p->genlist, &cal_list_normal_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1117                         break;
1118                 case CAL_LIST_MODE_TASK:
1119                         __cal_list_prepend_genlist_item(p->genlist, &cal_task_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1120                         break;
1121                 default:
1122                         __cal_list_prepend_genlist_item(p->genlist, &cal_list_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1123                 }
1124
1125
1126                 time_previous = time_current;
1127                 tm_previous = tm_current;
1128
1129                 prepended_event_count++;
1130
1131                 if (10 < prepended_event_count)
1132                         break;
1133
1134         }
1135
1136         __cal_list_prepend_genlist_group_item(p->genlist, &cal_list_itc_h, &tm_current);
1137
1138         p->prepended_event_count += prepended_event_count;
1139
1140         CAL_FN_END;
1141 }
1142
1143 static void __cal_list_append_event_to_genlist(cal_list_data *p)
1144 {
1145         CAL_FN_START;
1146
1147         c_ret_if(!p);
1148
1149         struct appdata* ad = p->ad;
1150         c_ret_if(!ad);
1151
1152         Elm_Object_Item *it = NULL;
1153         int time_previous = 0;
1154         int time_today = (ad->today_tm.tm_year << 9) | (ad->today_tm.tm_mon << 5) | ad->today_tm.tm_mday;
1155
1156         Eina_List *l, *list;
1157         cal_struct *cs;
1158         int appended_event_count = 0;
1159         struct tm tm_current;
1160
1161         if (0 < p->appended_event_count) {
1162                 list = eina_list_nth_list(p->append_list, p->appended_event_count - 1);
1163                 c_ret_if(!list);
1164
1165                 cs = eina_list_data_get(list);
1166                 c_ret_if(!cs);
1167
1168                 if (CALENDAR_SVC_IS_ALLDAY_EVENT(cs)) {
1169
1170                         tm_current.tm_year = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_YEAR) - 1900;
1171                         tm_current.tm_mon = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MONTH) - 1;
1172                         tm_current.tm_mday = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MDAY);
1173                 } else {
1174                         cal_util_convert_lli_to_tm(NULL, CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME), &tm_current);
1175                 }
1176
1177                 time_previous = (tm_current.tm_year << 9) | (tm_current.tm_mon << 5) | tm_current.tm_mday;
1178
1179                 list = eina_list_next(list);
1180                 c_ret_if(!list);
1181         }
1182         else
1183                 list = p->append_list;
1184
1185         EINA_LIST_FOREACH(list, l, cs) {
1186
1187                 if (!cs)
1188                         continue;
1189
1190                 tm_current = p->ad->base_tm;
1191
1192                 if (CALENDAR_SVC_IS_ALLDAY_EVENT(cs)) {
1193
1194                         tm_current.tm_year = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_YEAR) - 1900;
1195                         tm_current.tm_mon = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MONTH) - 1;
1196                         tm_current.tm_mday = CALENDAR_SVC_STRUCT_GET_INT(cs, CALS_VALUE_INT_DTSTART_MDAY);
1197
1198                 } else
1199                         cal_util_convert_lli_to_tm(NULL, CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME), &tm_current);
1200
1201                 int time_current = (tm_current.tm_year << 9) | (tm_current.tm_mon << 5) | tm_current.tm_mday;
1202
1203                 if (time_previous != time_current) {
1204
1205                         it = __cal_list_append_genlist_group_item(p->genlist, &cal_list_itc_h, &tm_current);
1206                         time_previous = time_current;
1207
1208                         if (time_today == time_current) {
1209                                 ad->today_item = it;
1210                                 p->is_today_added = EINA_TRUE;
1211                         }
1212
1213                         if (!p->is_today_added) {
1214                                 if (time_today < time_current) {
1215                                         ad->today_item = it;
1216                                         p->is_today_added = EINA_TRUE;
1217                                 }
1218                                 else
1219                                         ad->today_item = it;
1220                         }
1221
1222                         p->last_itc_h = tm_current;
1223                 }
1224
1225                 switch (p->mode) {
1226                 case CAL_LIST_MODE_NORMAL:
1227                         __cal_list_append_genlist_item(p->genlist, &cal_list_normal_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1228                         break;
1229                 case CAL_LIST_MODE_DAY:
1230                         __cal_list_append_genlist_item(p->genlist, &cal_list_normal_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1231                         break;
1232                 case CAL_LIST_MODE_TASK:
1233                         __cal_list_append_genlist_item(p->genlist, &cal_task_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1234                         break;
1235                 default:
1236                         __cal_list_append_genlist_item(p->genlist, &cal_list_itc, cs, it, __cal_list_genlist_item_select_callback, cs);
1237                 }
1238
1239                 appended_event_count++;
1240
1241                 if (10 < appended_event_count)
1242                         break;
1243
1244         }
1245
1246         p->appended_event_count += appended_event_count;
1247
1248         CAL_FN_END;
1249 }
1250
1251 static void __cal_list_delete_load_more(Elm_Object_Item *item)
1252 {
1253         c_ret_if(!item);
1254
1255         char *text = elm_object_item_data_get(item);
1256         c_ret_if(!text);
1257
1258         free(text);
1259
1260         elm_object_item_del(item);
1261 }
1262
1263 static Elm_Object_Item * __cal_list_add_load_more_to_genlist(cal_list_data *p, const char *text, struct tm *tm)
1264 {
1265         c_retv_if(!p, NULL);
1266         c_retv_if(!p->genlist, NULL);
1267         c_retv_if(!text, NULL);
1268         c_retv_if(!tm, NULL);
1269
1270         char time[32] = {0};
1271
1272         cal_util_get_time_text(time, sizeof(time), CAL_UTIL_DATE_FORMAT_8, NULL, tm);
1273
1274         Elm_Object_Item *load_more = NULL;
1275
1276         if (p->tm_start.tm_year == tm->tm_year
1277                 && p->tm_start.tm_mon == tm->tm_mon
1278                 && p->tm_start.tm_mday == tm->tm_mday)
1279
1280                 load_more = elm_genlist_item_prepend(p->genlist, &itc_1text, g_strdup_printf("%s %s", text, time), NULL, ELM_GENLIST_ITEM_NONE, __cal_list_prepend_more, p);
1281         else
1282                 load_more = elm_genlist_item_append(p->genlist, &itc_1text, g_strdup_printf("%s %s", text, time), NULL, ELM_GENLIST_ITEM_NONE, __cal_list_append_more, p);
1283
1284         c_retv_if(!load_more, NULL);
1285
1286         return load_more;
1287 }
1288
1289 static void __cal_list_prepend_more(void *data, Evas_Object *obj, void *event_info)
1290 {
1291         c_ret_if(!data);
1292         c_ret_if(!obj);
1293
1294         cal_list_data *p = data;
1295
1296         __cal_list_delete_load_more(p->load_more_top);
1297
1298         struct tm tm_start= p->tm_start;
1299         struct tm tm_end = tm_start;
1300
1301         cal_util_update_tm_month(&tm_start, -3);
1302
1303         Eina_List *prepend_more_list = CALENDAR_SVC_GET_EVENT_LIST(&tm_start, &tm_end);
1304
1305         prepend_more_list = eina_list_reverse(prepend_more_list);
1306
1307         p->tm_start = tm_start;
1308
1309         p->prepend_list = eina_list_merge(p->prepend_list, prepend_more_list);
1310
1311         __cal_list_prepend_event_to_genlist(p);
1312
1313         // TODO:i18n
1314         p->load_more_top= __cal_list_add_load_more_to_genlist(p, "Load events before", &p->tm_start);
1315 }
1316
1317 static void __cal_list_append_more(void *data, Evas_Object *obj, void *event_info)
1318 {
1319         c_ret_if(!data);
1320         c_ret_if(!obj);
1321
1322         cal_list_data *p = data;
1323
1324         __cal_list_delete_load_more(p->load_more_bottom);
1325
1326         struct tm tm_start= p->tm_end;
1327         struct tm tm_end = tm_start;
1328
1329         cal_util_update_tm_month(&tm_end, 3);
1330
1331         Eina_List *append_more_list = CALENDAR_SVC_GET_EVENT_LIST(&tm_start, &tm_end);
1332
1333         p->tm_end = tm_end;
1334
1335         p->append_list = eina_list_merge(p->append_list, append_more_list);
1336
1337         __cal_list_append_event_to_genlist(p);
1338
1339         // TODO:i18n
1340         p->load_more_bottom = __cal_list_add_load_more_to_genlist(p, "Load events after", &p->tm_end);
1341 }
1342
1343 static void __cal_list_create_load_more(cal_list_data *p)
1344 {
1345         CAL_FN_START;
1346
1347         c_ret_if(!p);
1348         c_ret_if(!p->genlist);
1349
1350         if (CAL_STRLEN(p->searchtext) || p->mode == CAL_LIST_MODE_TASK)
1351                 return;
1352
1353         // TODO: i18n
1354         p->load_more_top = __cal_list_add_load_more_to_genlist(p, "Load events before", &p->tm_start);
1355
1356         p->load_more_bottom = __cal_list_add_load_more_to_genlist(p, "Load events after", &p->tm_end);
1357 }
1358
1359 Eina_Bool __cal_list_idler_callback(void* data)
1360 {
1361         CAL_FN_START;
1362
1363         c_retv_if(!data, ECORE_CALLBACK_CANCEL);
1364
1365         cal_list_data *p = data;
1366
1367         c_retv_if(!p->idler, ECORE_CALLBACK_CANCEL);
1368
1369         __cal_list_append_event_to_genlist(p);
1370
1371         __cal_list_prepend_event_to_genlist(p);
1372
1373         Eina_Bool ret = __cal_list_check_idler_condition(p);
1374
1375         if (!ret)
1376                 __cal_list_create_load_more(p);
1377
1378         CAL_FN_END;
1379
1380         return ret;
1381 }
1382
1383 static void __cal_list_add_idler(cal_list_data *p)
1384 {
1385         c_ret_if(!p);
1386
1387         if (p->appended_event_count < eina_list_count(p->append_list) ||
1388                 p->prepended_event_count < eina_list_count(p->prepend_list)) {
1389
1390                 if (p->idler)
1391                         ecore_idler_del(p->idler);
1392
1393                 p->idler = ecore_idler_add(__cal_list_idler_callback, p);
1394                 c_ret_if(!p->idler);
1395
1396         } else
1397                 __cal_list_create_load_more(p);
1398 }
1399
1400 static void __cal_list_get_events(cal_list_data *p)
1401 {
1402         CAL_FN_START;
1403
1404         c_ret_if(!p);
1405
1406         struct appdata *ad = p->ad;
1407         c_ret_if(!ad);
1408
1409         struct tm tm_base = ad->base_tm;
1410         tm_base.tm_hour = 0;
1411         tm_base.tm_min = 0;
1412         tm_base.tm_sec = 0;
1413
1414         p->append_list = CALENDAR_SVC_GET_EVENT_LIST(&tm_base, &p->tm_end);
1415         cal_util_update_tm_day(&tm_base, -1);
1416         tm_base.tm_hour = 23;
1417         tm_base.tm_min = 59;
1418         tm_base.tm_sec = 59;
1419
1420         p->prepend_list = CALENDAR_SVC_GET_EVENT_LIST(&p->tm_start, &tm_base);
1421         p->prepend_list = eina_list_reverse(p->prepend_list);
1422
1423         CAL_FN_END;
1424 }
1425
1426 static void __cal_list_get_task_list(cal_list_data *p)
1427 {
1428         CAL_FN_START;
1429
1430         c_ret_if(!p);
1431
1432         struct appdata *ad = p->ad;
1433         c_ret_if(!ad);
1434
1435         p->tm_start.tm_year = 70;
1436         p->tm_end.tm_year = 137;
1437
1438         cals_status_t status;
1439
1440         if (!ad->is_display_complete_todo) {
1441                 status = CALS_TODO_STATUS_IN_PROCESS
1442                                 || CALS_TODO_STATUS_NONE
1443                                 || CALS_TODO_STATUS_NEEDS_ACTION
1444                                 ||  CALS_TODO_STATUS_CANCELLED;
1445         } else {
1446                 status = CALS_TODO_STATUS_IN_PROCESS
1447                                 || CALS_TODO_STATUS_NONE
1448                                 || CALS_TODO_STATUS_NEEDS_ACTION
1449                                 ||  CALS_TODO_STATUS_CANCELLED
1450                                 || CALS_TODO_STATUS_COMPLETED;
1451         }
1452
1453         int priority = CALS_TODO_PRIORITY_NONE
1454                 |CALS_TODO_PRIORITY_HIGH
1455                 |CALS_TODO_PRIORITY_MID
1456                 |CALS_TODO_PRIORITY_LOW;
1457
1458         p->append_list = CALENDAR_SVC_GET_TASK_LIST(&p->tm_start, &p->tm_end, priority, status, ad->todo_sort_type);
1459
1460         CAL_FN_END;
1461 }
1462
1463 static void __cal_list_gl_mode_right(void *data, Evas_Object *obj, void *event_info)
1464 {
1465         c_retm_if(!event_info, "event_info is null");
1466         c_retm_if(!obj, "obj is null");
1467
1468         Elm_Object_Item *it = event_info;
1469
1470         elm_genlist_item_decorate_mode_set(it, "slide", EINA_TRUE);
1471
1472         cal_list_data* p = CAL_UTIL_GET_PRIV_DATA(obj);
1473         c_retm_if(!p, "p is null");
1474
1475         if (p->sweep_it && it != p->sweep_it)
1476                 elm_genlist_item_decorate_mode_set(p->sweep_it, "slide", EINA_FALSE);
1477
1478         p->sweep_it = it;
1479 }
1480
1481 static void __cal_list_gl_mode_left(void *data, Evas_Object *obj, void *event_info)
1482 {
1483         c_retm_if(!event_info, "event_info is null");
1484         Elm_Object_Item *it = event_info;
1485
1486         elm_genlist_item_decorate_mode_set(it, "slide", EINA_FALSE);
1487 }
1488
1489 static void __cal_list_gl_mode_cancel(void *data, Evas_Object *obj, void *event_info)
1490 {
1491         c_retm_if(!obj, "obj is null");
1492
1493         Elm_Object_Item *it = (Elm_Object_Item *)elm_genlist_decorated_item_get(obj);
1494         c_ret_if(!it);
1495
1496         elm_genlist_item_decorate_mode_set(it, "slide", EINA_FALSE);
1497 }
1498
1499 static void __cal_list_get_events_with_day(cal_list_data *p)
1500 {
1501         CAL_FN_START;
1502
1503         c_ret_if(!p);
1504
1505         struct tm tm_start = p->ad->base_tm;
1506         tm_start.tm_hour = 0;
1507         tm_start.tm_min = 0;
1508         tm_start.tm_sec = 0;
1509
1510         struct tm tm_end = tm_start;
1511         tm_end.tm_hour = 23;
1512         tm_end.tm_min = 59;
1513         tm_end.tm_sec = 59;
1514
1515         p->append_list = CALENDAR_SVC_GET_EVENT_LIST(&tm_start, &tm_end);
1516
1517         CAL_FN_END;
1518 }
1519
1520 static void __cal_list_delete_idler(cal_list_data *p)
1521 {
1522         CAL_FN_START;
1523
1524         c_ret_if(!p);
1525
1526         if (!p->idler)
1527                 return;
1528
1529         ecore_idler_del(p->idler);
1530
1531         p->idler = NULL;
1532 }
1533
1534 static void __cal_list_create_genlist(cal_list_data *p)
1535 {
1536         CAL_FN_START;
1537
1538         c_ret_if(!p);
1539
1540         if (p->genlist)
1541                 return;
1542
1543         Evas_Object *genlist = elm_genlist_add(p->layout);
1544         c_ret_if(!genlist);
1545
1546         evas_object_data_set(genlist, "priv", p);
1547
1548         if (p->mode != CAL_LIST_MODE_TASK) {
1549                 evas_object_smart_callback_add(genlist, "drag,start,right", __cal_list_gl_mode_right, NULL);
1550                 evas_object_smart_callback_add(genlist, "drag,start,left", __cal_list_gl_mode_left, NULL);
1551                 evas_object_smart_callback_add(genlist, "drag,start,up", __cal_list_gl_mode_cancel, NULL);
1552                 evas_object_smart_callback_add(genlist, "drag,start,down", __cal_list_gl_mode_cancel, NULL);
1553         }
1554
1555         elm_object_part_content_set(p->layout, "sw", genlist);
1556
1557         p->genlist = genlist;
1558 }
1559
1560 static void __cal_list_create_no_contents(cal_list_data *p)
1561 {
1562         CAL_FN_START;
1563
1564         c_ret_if(!p);
1565         c_ret_if(!p->layout);
1566
1567         if (p->no_contents)
1568                 return;
1569
1570         char* title = NULL;
1571
1572         if (p->mode == CAL_LIST_MODE_TASK)
1573                 title = C_("IDS_TASK_BODY_NO_TASKS");
1574         else
1575                 title = C_("IDS_CLD_BODY_NO_EVENTS");
1576
1577         Evas_Object *no_contents = cal_util_add_nocontents(p->layout, title);
1578         c_ret_if(!no_contents);
1579
1580         elm_object_part_content_set(p->layout, "sw", no_contents);
1581
1582         p->no_contents = no_contents;
1583 }
1584
1585 static inline void __cal_list_show_searchbar(cal_list_data *p)
1586 {
1587         if (p->mode != CAL_LIST_MODE_DAY)
1588                 edje_object_signal_emit(CAL_UTIL_GET_EDJ_DATA(p->layout), "searchbar,show", "prog");
1589 }
1590
1591 static inline void __cal_list_hide_searchbar(cal_list_data *p)
1592 {
1593         if (p->mode != CAL_LIST_MODE_DAY && !CAL_STRLEN(p->searchtext))
1594                 edje_object_signal_emit(CAL_UTIL_GET_EDJ_DATA(p->layout), "searchbar,hide", "prog");
1595 }
1596
1597 static void __cal_list_delete_no_contents(cal_list_data *p)
1598 {
1599         CAL_FN_START;
1600
1601         c_ret_if(!p);
1602
1603         if (!p->no_contents)
1604                 return;
1605
1606         elm_object_part_content_unset(p->layout, "sw");
1607
1608         evas_object_del(p->no_contents);
1609
1610         p->no_contents = NULL;
1611 }
1612
1613 static void __cal_list_delete_genlist(cal_list_data *p)
1614 {
1615         CAL_FN_START;
1616
1617         c_ret_if(!p);
1618
1619         if (!p->genlist)
1620                 return;
1621
1622         elm_object_part_content_unset(p->layout, "sw");
1623
1624         evas_object_del(p->genlist);
1625
1626         p->genlist = NULL;
1627 }
1628
1629 static void __cal_list_update_genlist(cal_list_data *p)
1630 {
1631         CAL_FN_START;
1632
1633         c_ret_if(!p);
1634
1635         __cal_list_delete_idler(p);
1636
1637         elm_genlist_clear(p->genlist);
1638
1639         struct appdata* ad = p->ad;
1640         c_ret_if(!ad);
1641
1642         ad->today_item = NULL;
1643
1644         p->appended_event_count = 0;
1645
1646         p->prepended_event_count = 0;
1647
1648         if (eina_list_count(p->append_list)) {
1649
1650                 __cal_list_show_searchbar(p);
1651
1652                 __cal_list_delete_no_contents(p);
1653
1654                 __cal_list_create_genlist(p);
1655
1656                 __cal_list_append_event_to_genlist(p);
1657
1658                 __cal_list_add_idler(p);
1659
1660         } else {
1661
1662                 __cal_list_hide_searchbar(p);
1663
1664                 __cal_list_delete_genlist(p);
1665
1666                 __cal_list_create_no_contents(p);
1667         }
1668
1669         CAL_FN_END;
1670 }
1671
1672 static void __cal_list_update_events(cal_list_data *p)
1673 {
1674         c_ret_if(!p);
1675
1676         CALENDAR_SVC_FREE_CS_LIST(&p->prepend_list);
1677         CALENDAR_SVC_FREE_CS_LIST(&p->append_list);
1678
1679         struct appdata *ad = p->ad;
1680         c_ret_if(!ad);
1681
1682         p->tm_start = ad->base_tm;
1683         p->tm_start.tm_hour = 0;
1684         p->tm_start.tm_min = 0;
1685         p->tm_start.tm_sec = 0;
1686
1687         p->tm_end = p->tm_start;
1688         p->tm_end.tm_hour = 23;
1689         p->tm_end.tm_min = 59;
1690         p->tm_end.tm_sec = 59;
1691
1692         cal_util_update_tm_month(&p->tm_start, -3);
1693         cal_util_update_tm_month(&p->tm_end, 3);
1694
1695         switch (p->mode) {
1696
1697         case CAL_LIST_MODE_NORMAL:
1698
1699                 if (CAL_STRLEN(p->searchtext))
1700                         __cal_list_get_events_with_search(p);
1701                 else
1702                         __cal_list_get_events(p);
1703
1704                 break;
1705
1706         case CAL_LIST_MODE_DAY:
1707
1708                 __cal_list_get_events_with_day(p);
1709
1710                 break;
1711
1712         case CAL_LIST_MODE_TASK:
1713
1714                 if (CAL_STRLEN(p->searchtext))
1715                         __cal_list_get_todo_with_search(p);
1716                 else
1717                         __cal_list_get_task_list(p);
1718
1719                 break;
1720         }
1721 }
1722
1723 static void __cal_list_update_list(cal_list_data *p)
1724 {
1725         CAL_FN_START;
1726
1727         c_ret_if(!p);
1728
1729         __cal_list_update_events(p);
1730
1731         __cal_list_update_genlist(p);
1732
1733         CAL_FN_END;
1734 }
1735
1736 static void __cal_list_searchbar_entry_changed_callback(void *data, Evas_Object *obj, void *event_info)
1737 {
1738         CAL_FN_START;
1739
1740         cal_list_data *p = data;
1741         c_ret_if(!p);
1742
1743         p->searchtext = elm_object_text_get(elm_object_part_content_get(p->searchbar, "elm.swallow.content"));
1744
1745         __cal_list_update_list(p);
1746
1747         CAL_FN_END;
1748 }
1749
1750 static void __cal_list_cancel_button_callback(void *data, Evas_Object *obj, void *event_info)
1751 {
1752         CAL_FN_START;
1753
1754         cal_list_data *p = data;
1755         c_ret_if(!p);
1756
1757         elm_object_item_disabled_set(p->ad->bt_new, EINA_FALSE);
1758
1759         Evas_Object *en = elm_object_part_content_get(p->searchbar, "elm.swallow.content");
1760
1761         Ecore_IMF_Context *imf_context = elm_entry_imf_context_get(en);
1762         c_ret_if(!imf_context);
1763
1764         ecore_imf_context_input_panel_hide(imf_context);
1765
1766         CAL_FN_END;
1767 }
1768
1769 static void __cal_list_day_event_changed_callback (void *user_data)
1770 {
1771         c_retm_if(!user_data, "user_data is null");
1772
1773         cal_list_data *p = user_data;
1774
1775         if (p->popup) {
1776                 evas_object_del(p->popup);
1777                 p->popup = NULL;
1778         }
1779
1780         cal_list_update_list(p->layout);
1781 }
1782
1783 static void __cal_list_delete_layout(void *data, Evas *e, Evas_Object *obj, void *ei)
1784 {
1785         CAL_FN_START;
1786
1787         cal_list_data *p = data;
1788         c_retm_if(!p, "priv is null.");
1789
1790         if (p->idler) {
1791                 ecore_idler_del(p->idler);
1792                 p->idler = NULL;
1793         }
1794
1795         CALENDAR_SVC_DEL_EVENT_CHANGED_CALLBACK(__cal_list_day_event_changed_callback);
1796
1797         CALENDAR_SVC_FREE_CS_LIST(&p->append_list);
1798
1799         if (p->event_handler)
1800                 ecore_event_handler_del(p->event_handler);
1801
1802         if (p->popup) {
1803                 evas_object_del(p->popup);
1804                 p->popup = NULL;
1805         }
1806
1807         free(p);
1808
1809         CAL_FN_END;
1810 }
1811
1812 static char* __cal_list_get_genlist_header_item_label(void *data, Evas_Object *obj, const char *part)
1813 {
1814         c_retvm_if(!data, NULL, "datais null.");
1815
1816         char buf[128];
1817         cal_list_genlist_item_data *item_data = data;
1818         const struct tm *tm = item_data->tm;
1819
1820         if (!CAL_STRCMP(part, "elm.text")) {
1821
1822                 if (!tm)
1823                         return strdup(C_("IDS_CLD_BODY_REPEATING_EVENT"));
1824                 else {
1825
1826                         cal_util_get_time_text(buf, sizeof(buf), CAL_UTIL_DATE_FORMAT_1, NULL, tm);
1827
1828                         return strdup(buf);
1829                 }
1830         }
1831
1832         return NULL;
1833 }
1834
1835 static char* __cal_list_get_genlist_item_cs_label(cal_list_data *p, cal_struct *cs)
1836 {
1837         c_retvm_if(!cs, NULL, "cs is null.");
1838         c_retvm_if(!p, NULL, "p is null.");
1839
1840         const char* time;
1841
1842         long long int lli_time;
1843
1844         if (p->mode == CAL_LIST_MODE_TASK) {
1845                 time = CAL_UTIL_DATE_FORMAT_12;
1846                 lli_time = CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTEND_UTIME);
1847         } else {
1848
1849                 if (is_hour24)
1850                         time = CAL_UTIL_TIME_FORMAT_6;
1851                 else
1852                         time = CAL_UTIL_TIME_FORMAT_1;
1853
1854                 lli_time = CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME);
1855         }
1856
1857         struct tm tm;
1858
1859         cal_util_convert_lli_to_tm(NULL, lli_time, &tm);
1860
1861         char stime[512];
1862
1863         cal_util_get_time_text(stime, sizeof(stime), NULL, time, &tm);
1864
1865         return strdup(stime);
1866 }
1867
1868 static char* __cal_list_get_genlist_item_tm_label(cal_list_data *p, cal_struct *cs)
1869 {
1870         c_retvm_if(!cs, NULL, "cs is null.");
1871         c_retvm_if(!p, NULL, "p is null.");
1872
1873         char buf[512];
1874         char stime[512];
1875         struct tm t;
1876
1877         long long int lli_start = CALENDAR_SVC_STRUCT_GET_LLI(cs, CALS_VALUE_LLI_DTSTART_UTIME);
1878         cal_util_convert_lli_to_tm(NULL, lli_start, &t);
1879
1880         if (p->mode == CAL_LIST_MODE_TASK)
1881                 cal_util_get_time_text(stime, sizeof(stime), NULL, CAL_UTIL_DATE_FORMAT_10, &t);
1882         else {
1883
1884                 if (is_hour24)
1885                         cal_util_get_time_text(stime, sizeof(stime), NULL, CAL_UTIL_TIME_FORMAT_6, &t);
1886                 else
1887                         cal_util_get_time_text(stime, sizeof(stime), NULL, CAL_UTIL_TIME_FORMAT_1, &t);
1888         }
1889
1890         snprintf(buf, sizeof(buf), "%s", stime);
1891
1892         return strdup(buf);
1893 }
1894
1895 static char* __cal_list_get_genlist_item_label(void *data, Evas_Object *obj, const char *part)
1896 {
1897         c_retv_if(!data, NULL);
1898         c_retv_if(!obj, NULL);
1899         c_retv_if(!part, NULL);
1900
1901         const char *str = NULL;
1902
1903         cal_list_genlist_item_data *item_data = data;
1904
1905         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
1906         c_retv_if(!p, NULL);
1907
1908         if (!item_data || !item_data->cs)
1909                 return NULL;
1910
1911         cal_struct *cs = item_data->cs;
1912         c_retv_if(!cs, NULL);
1913
1914         if (!CAL_STRCMP(part, "elm.text.1")) {
1915
1916                 if (item_data->color_str) {
1917                         free(item_data->color_str);
1918                         item_data->color_str = NULL;
1919                 }
1920
1921                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_SUMMARY);
1922
1923                 if (!CAL_STRLEN(str))
1924                         str =  C_("IDS_CLD_BODY_NO_TITLE");
1925
1926                 item_data->color_str =  cal_util_get_search_color_text(p->searchtext, str);
1927
1928                 if (item_data->color_str) {
1929                         return strdup(item_data->color_str);
1930                 } else {
1931                         return strdup(str);
1932                 }
1933
1934         } else if (!CAL_STRCMP(part, "elm.text.2")) {
1935
1936                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_LOCATION);
1937
1938                 if (CAL_STRLEN(str))
1939                         return strdup(str);
1940                 else
1941                         return strdup(C_("IDS_CLD_BODY_NO_LOCATION_SELECTED"));
1942
1943         } else if (!CAL_STRCMP(part, "elm.text.3")) {
1944
1945                 if (CALENDAR_SVC_IS_ALLDAY_EVENT(cs))
1946                         return strdup(C_("IDS_COM_BODY_ALL_DAY"));
1947                 else
1948                         return __cal_list_get_genlist_item_cs_label(p, cs);
1949
1950         } else if (!CAL_STRCMP(part, "elm.slide.text.1")) {
1951
1952                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_SUMMARY);
1953
1954                 if (CAL_STRLEN(str))
1955                         return strdup(str);
1956                 else
1957                         return strdup(C_("IDS_CLD_BODY_NO_TITLE"));
1958         }
1959
1960         return NULL;
1961 }
1962
1963 static char* __cal_list_get_genlist_task_item_label(void *data, Evas_Object *obj, const char *part)
1964 {
1965         c_retv_if(!data, NULL);
1966         c_retv_if(!obj, NULL);
1967         c_retv_if(!part, NULL);
1968
1969         const char *str = NULL;
1970         char *tmp = NULL;
1971
1972         cal_list_genlist_item_data *item_data = data;
1973
1974         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(obj);
1975         c_retv_if(!p, NULL);
1976
1977         if (!item_data || !item_data->cs)
1978                 return NULL;
1979
1980         cal_struct *cs = item_data->cs;
1981         c_retv_if(!cs, NULL);
1982
1983         Eina_Bool is_done = EINA_FALSE;
1984
1985         int todo_status = CALENDAR_SVC_STRUCT_GET_INT(cs, CAL_VALUE_INT_TASK_STATUS);
1986         if (CALS_TODO_STATUS_COMPLETED == todo_status) {
1987                 is_done = EINA_TRUE;
1988         } else {
1989                 is_done = EINA_FALSE;
1990         }
1991
1992         if (!CAL_STRCMP(part, "elm.textblock.1")) {
1993                 if (is_done) {
1994                         str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_SUMMARY);
1995
1996                         if (!p->searchtext) {
1997                                 if (CAL_STRLEN(str))
1998                                         tmp =  strdup(str);
1999                                 else
2000                                         tmp = strdup(C_("IDS_CLD_BODY_NO_TITLE"));
2001
2002                                 char *text = calloc(1, strlen(tmp)+500);
2003                                 c_retv_if(!text, NULL);
2004
2005                                 sprintf(text, "<strikethrough=on strikethrough_color=#D1D1D1>%s</strikethrough>", tmp);
2006
2007                                 free(tmp);
2008                                 tmp = NULL;
2009                                 return text;
2010                         } else {
2011                                 if (item_data->color_str) {
2012                                         free(item_data->color_str);
2013                                         item_data->color_str = NULL;
2014                                 }
2015
2016                                 if (!CAL_STRLEN(str)) {
2017                                         str =  C_("IDS_CLD_BODY_NO_TITLE");
2018                                 }
2019
2020                                 char *text = calloc(1, strlen(str) + 500);
2021                                 c_retv_if(!text, NULL);
2022
2023                                 item_data->color_str =  cal_util_get_search_color_text(p->searchtext, str);
2024                                 if (item_data->color_str) {
2025                                         sprintf(text, "<strikethrough=on strikethrough_color=#D1D1D1>%s</strikethrough>",item_data->color_str);
2026                                         return text;
2027                                 } else {
2028                                         sprintf(text, "<strikethrough=on strikethrough_color=#D1D1D1>%s</strikethrough>", str);
2029                                         return text;
2030                                 }
2031                         }
2032                 }
2033                 return NULL;
2034         } else if (!CAL_STRCMP(part, "elm.text.1")) {
2035                 if (!is_done) {
2036                         str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_SUMMARY);
2037
2038                         if (CAL_STRLEN(str)) {
2039                                 free(item_data->color_str);
2040                                 item_data->color_str = NULL;
2041                         } else {
2042                                 str =  C_("IDS_CLD_BODY_NO_TITLE");
2043                         }
2044
2045                         item_data->color_str =  cal_util_get_search_color_text(p->searchtext, str);
2046                         if (item_data->color_str) {
2047                                 return strdup(item_data->color_str);
2048                         } else {
2049                                 return strdup(str);
2050                         }
2051                 }
2052                 return NULL;
2053         } else if (!CAL_STRCMP(part, "elm.text.2")) {
2054                 if (is_done)
2055                         return NULL;
2056
2057                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_LOCATION);
2058                 if (CAL_STRLEN(str)) {
2059                         return strdup(str);
2060                 } else {
2061                         return strdup(C_("IDS_CLD_BODY_NO_LOCATION_SELECTED"));
2062                 }
2063
2064         } else if (!CAL_STRCMP(part, "elm.textblock.2")) {
2065                 if (!is_done)
2066                         return NULL;
2067
2068                 str = CALENDAR_SVC_STRUCT_GET_STR(cs, CAL_VALUE_TXT_LOCATION);
2069                 if (CAL_STRLEN(str)) {
2070                         return strdup(str);
2071                 } else {
2072                         return strdup(C_("IDS_CLD_BODY_NO_LOCATION_SELECTED"));
2073                 }
2074         } else if (!CAL_STRCMP(part, "elm.text.3")) {
2075                 if (is_done)
2076                         return NULL;
2077
2078                 if (CALENDAR_SVC_IS_ALLDAY_EVENT(cs))
2079                         return  strdup(C_("IDS_COM_BODY_ALL_DAY"));
2080                 else
2081                         return  __cal_list_get_genlist_item_cs_label(p, cs);
2082         } else if (!CAL_STRCMP(part, "elm.textblock.3")) {
2083                 if (!is_done)
2084                         return NULL;
2085
2086                 if (CALENDAR_SVC_IS_ALLDAY_EVENT(cs))
2087                         return  strdup(C_("IDS_COM_BODY_ALL_DAY"));
2088                 else
2089                         return  __cal_list_get_genlist_item_cs_label(p, cs);
2090         }
2091
2092         return NULL;
2093 }
2094
2095 static void __cal_list_searchbar_entry_unfocused_callback(void *data, Evas_Object *obj, void *event_info)
2096 {
2097         cal_list_data *p = data;
2098
2099         elm_object_item_disabled_set(p->ad->bt_new, EINA_FALSE);
2100 }
2101
2102 static void __cal_list_searchbar_clicked_callback(void *data, Evas_Object *obj, void *event_info)
2103 {
2104         cal_list_data *p = data;
2105
2106         elm_object_item_disabled_set(p->ad->bt_new, EINA_TRUE);
2107 }
2108
2109 static void __cal_list_create_searchbar(cal_list_data *p)
2110 {
2111         c_ret_if(!p);
2112         c_ret_if(!p->layout);
2113
2114         Evas_Object *searchbar = cal_util_add_searchbar(p->layout, NULL, NULL, EINA_TRUE);
2115         c_ret_if(!searchbar);
2116
2117         Evas_Object *entry = elm_object_part_content_get(searchbar, "elm.swallow.content");
2118         c_ret_if(!entry);
2119
2120         elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NORMAL);
2121         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size, &_limit_20char);
2122
2123         evas_object_size_hint_weight_set(searchbar, EVAS_HINT_EXPAND, 0);
2124         evas_object_size_hint_align_set(searchbar, EVAS_HINT_FILL, 0.0);
2125
2126         evas_object_smart_callback_add(entry, "changed", __cal_list_searchbar_entry_changed_callback, p);
2127         evas_object_smart_callback_add(entry, "unfocused", __cal_list_searchbar_entry_unfocused_callback, p);
2128         evas_object_smart_callback_add(searchbar, "clicked", __cal_list_searchbar_clicked_callback, p);
2129         evas_object_smart_callback_add(searchbar, "cancel,clicked", __cal_list_cancel_button_callback, p);
2130
2131         evas_object_show(searchbar);
2132         elm_object_part_content_set(p->layout, "searchbar", searchbar);
2133
2134         p->searchbar = searchbar;
2135 }
2136
2137 static Eina_Bool __cal_list_mouse_button_down_callback(void *data, int type, void *event)
2138 {
2139         c_retvm_if(!event, EINA_FALSE, "event is null");
2140         c_retvm_if(!data, EINA_FALSE, "data is null");
2141
2142         Ecore_Event_Mouse_Button *ev = event;
2143         cal_list_data *p = data;
2144
2145         p->x = ev->x;
2146         p->y = ev->y;
2147
2148         return ECORE_CALLBACK_RENEW;
2149 }
2150
2151 Evas_Object* cal_list_create_list(struct appdata *ad, Evas_Object *parent)
2152 {
2153         CAL_FN_START;
2154
2155         c_retv_if(!ad, NULL);
2156         c_retv_if(!parent, NULL);
2157
2158         cal_list_data *p = calloc(1, sizeof(cal_list_data));
2159         c_retv_if(!p, NULL);
2160
2161         p->ad = ad;
2162         p->parent = parent;
2163         is_hour24 = ad->is_hour24;
2164
2165         Evas_Object *layout = cal_util_add_layout(parent, "list/base");
2166         if (!layout) {
2167                 free(p);
2168
2169                 ERR("layout is null.");
2170
2171                 return NULL;
2172         }
2173
2174         evas_object_data_set(layout, "priv", p);
2175
2176         p->layout = layout;
2177         p->more_idx = -1;
2178
2179         elm_object_item_disabled_set(p->ad->bt_new, EINA_FALSE);
2180
2181         Evas_Object *bg = cal_util_add_bg(layout, EINA_FALSE);
2182         if (!bg) {
2183
2184                 free(p);
2185                 free(layout);
2186
2187                 ERR("bg is null.");
2188
2189                 return NULL;
2190         }
2191
2192         elm_object_part_content_set(layout, "base", bg);
2193
2194         evas_object_event_callback_add(layout, EVAS_CALLBACK_DEL, __cal_list_delete_layout, p);
2195
2196         p->event_handler = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, __cal_list_mouse_button_down_callback, p);
2197
2198         CAL_FN_END;
2199
2200         return layout;
2201 }
2202
2203 void cal_list_scroll_today(struct appdata* ad)
2204 {
2205         CAL_FN_START;
2206
2207         c_retm_if(!ad, "ad is null.");
2208
2209         Elm_Object_Item* it = ad->today_item;
2210         if (it) {
2211                 elm_genlist_item_bring_in(it, ELM_GENLIST_ITEM_SCROLLTO_TOP);
2212                 DBG("scroll to : %p", it);
2213         }
2214
2215         CAL_FN_END;
2216 }
2217
2218 static void __cal_list_update_delete_button(cal_list_data *p)
2219 {
2220         c_ret_if(!p);
2221
2222         Elm_Object_Item *delete_button = NULL;
2223
2224         if (p->mode == CAL_LIST_MODE_DAY)
2225                 delete_button = p->bt_delete;
2226         else
2227                 delete_button = p->ad->bt_delete;
2228
2229         if (eina_list_count(p->append_list))
2230                 elm_object_item_disabled_set(delete_button, EINA_FALSE);
2231         else
2232                 elm_object_item_disabled_set(delete_button, EINA_TRUE);
2233 }
2234
2235 void cal_list_update_list(Evas_Object *ly)
2236 {
2237         CAL_FN_START;
2238
2239         c_ret_if(!ly);
2240
2241         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(ly);
2242         c_ret_if(!p);
2243
2244         struct appdata *ad = p->ad;
2245         c_ret_if(!ad);
2246
2247         if (p->mode == CAL_LIST_MODE_DAY)
2248                 edje_object_signal_emit(CAL_UTIL_GET_EDJ_DATA(ly), "searchbar,hide", "prog");
2249         else
2250                 __cal_list_create_searchbar(p);
2251
2252         __cal_list_update_list(p);
2253
2254         __cal_list_update_delete_button(p);
2255
2256         CAL_FN_END;
2257 }
2258
2259 static void __cal_list_day_delete_button_callback(void *data, Evas_Object *obj, void *event_info)
2260 {
2261         c_retm_if(!data, "data is null");
2262         c_retm_if(!obj, "obj is null");
2263
2264         cal_list_data *p = data;
2265         Evas_Object *ly_delete = cal_list_delete_view_create_more_events(p->layout, p->ad, p->more_idx);
2266         c_retm_if(!ly_delete, "ly_delete is null");
2267
2268         cal_list_delete_update_view(ly_delete);
2269 }
2270
2271 static void __cal_list_day_new_button_callback(void *data, Evas_Object *obj, void *event_info)
2272 {
2273         c_retm_if(!data, "data is null");
2274         c_retm_if(!obj, "obj is null");
2275
2276         cal_list_data *p = data;
2277
2278         p->ad->base_hour = -1;
2279         p->ad->cid = 0;
2280
2281         cal_edit_create_view(p->ad, p->layout);
2282 }
2283
2284 Elm_Object_Item* cal_list_create_list_with_day(struct appdata *ad, Evas_Object *parent, int idx)
2285 {
2286         CAL_FN_START;
2287
2288         c_retvm_if(!ad, NULL, "ad is null.");
2289
2290         char title[1024] = {0};
2291         Evas_Object *controlbar;
2292
2293         Evas_Object *ly = cal_list_create_list(ad, parent);
2294         c_retvm_if(!ly, NULL, "ly is null.");
2295
2296         cal_list_data *p = (cal_list_data *)CAL_UTIL_GET_PRIV_DATA(ly);
2297         c_retvm_if(!p, NULL, "p is null.");
2298
2299         if (p->genlist) {
2300                 evas_object_smart_callback_del(p->genlist, "drag,start,right", __cal_list_gl_mode_right);
2301                 evas_object_smart_callback_del(p->genlist, "drag,start,left", __cal_list_gl_mode_left);
2302                 evas_object_smart_callback_del(p->genlist, "drag,start,up", __cal_list_gl_mode_cancel);
2303                 evas_object_smart_callback_del(p->genlist, "drag,start,down", __cal_list_gl_mode_cancel);
2304         }
2305
2306         p->mode = CAL_LIST_MODE_DAY;
2307         p->more_idx = idx;
2308
2309         CALENDAR_SVC_ADD_EVENT_CHANGED_CALLBACK(__cal_list_day_event_changed_callback, p);
2310
2311         cal_util_get_time_text(title, sizeof(title), CAL_UTIL_DATE_FORMAT_13, NULL, &p->ad->base_tm);
2312
2313         p->navi_item = elm_naviframe_item_push(ad->nv, title, NULL, NULL, ly, NULL);
2314         if (!p->navi_item)
2315         {
2316                 ERR("elm_naviframe_item_push is failed");
2317                 evas_object_del(ly);
2318                 return NULL;
2319         }
2320
2321         controlbar = cal_util_add_controlbar(ad->nv);
2322         if (!controlbar)
2323         {
2324                 ERR("cal_util_add_controlbar(ad->nv) is failed");
2325                 elm_naviframe_prev_btn_auto_pushed_set(ad->nv, EINA_TRUE);
2326                 elm_naviframe_item_pop(ad->nv);
2327                 return NULL;
2328         }
2329
2330         if (p->bt_delete != NULL) {
2331                 elm_object_item_del(p->bt_delete);
2332                 p->bt_delete = NULL;
2333         }
2334
2335         p->bt_new = elm_toolbar_item_append(controlbar, CAL_CBAR_ICON_CREAT, NULL,__cal_list_day_new_button_callback, p);
2336         if (p->bt_new != NULL) {
2337                 elm_object_item_del(p->bt_new);
2338                 p->bt_new = NULL;
2339         }
2340
2341         p->bt_delete = elm_toolbar_item_append(controlbar, CAL_CBAR_ICON_DELETE, NULL, __cal_list_day_delete_button_callback, p);
2342
2343         elm_object_item_part_content_set(p->navi_item, "controlbar", controlbar);
2344         cal_list_update_list(ly);
2345
2346         CAL_FN_END;
2347
2348         return p->navi_item;
2349 }
2350
2351 Evas_Object* cal_list_create_list_todo(struct appdata *ad, Evas_Object *parent)
2352 {
2353         CAL_FN_START;
2354
2355         c_retvm_if(!ad, NULL, "ad is null.");
2356
2357         Evas_Object *ly = cal_list_create_list(ad, parent);
2358         c_retvm_if(!ly, NULL, "ly is null.");
2359
2360         int r;
2361         cal_list_data *p = CAL_UTIL_GET_PRIV_DATA(ly);
2362         c_retvm_if(!p, NULL, "p is null.");
2363
2364         p->mode = CAL_LIST_MODE_TASK;
2365
2366         r = vconf_get_int(CAL_VCONFKEY_COMPLETE_TODO_ON_OFF, (int *)&ad->is_display_complete_todo);
2367         c_retvm_if(r != 0, NULL, "vconf_get_int(CAL_VCONFKEY_COMPLETE_TODO_ON_OFF, (int *)&p->is_display_complete_todo) is failed");
2368
2369         return ly;
2370 }