composer/src/bubble/msg-ui-composer-bubble-list.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://floralicense.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "msg-ui-composer-bubble.h"
  18 #include "appsvc.h"
  19 #include "msg-ui-composer-external.h"
  20 #include "msg-ui-composer-main.h"
  21 #include "msg-ui-composer-message.h"
  22 #include "msg-ui-composer-common.h"
  23 #include "syspopup_caller.h"
  24
  25 bool g_isFirstLoading = true;
  26
  27 #define MSG_BUBBLE_IMAGE_DRM_ICON IMGDIR"/M01_icon_DRM_64x64.png"
  28
  29 #define MSG_BUBBLE_BLOCK_COUNT  (20)
  30
  31 static void __anchor_click_cb(void *data, Evas_Object *obj, void *event_info);
  32 static void __longpressed_cb(void *data, Evas_Object *obj, void *event_info);
  33
  34 static char *__msg_ui_get_display_time(time_t *msg_t, PMSG_BUBBLE_DATA bubble_data)
  35 {
  36         if (!msg_t || !bubble_data)
  37                 return NULL;
  38
  39         char buf[DEF_BUF_LEN] = { 0 };
  40         char *str_time = NULL;
  41
  42         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !bubble_data, NULL);
  43
  44         if (bubble_data->time_fmt == MSG_TIME_FORMAT_24H)
  45                 str_time = msg_common_get_formatted_date(bubble_data->locale, bubble_data->time_24h_ptn, msg_t);
  46         else
  47                 str_time = msg_common_get_formatted_date(bubble_data->locale, bubble_data->time_12h_ptn, msg_t); /* MSG_TIME_FORMAT_12H */
  48
  49         snprintf(buf, sizeof(buf), "%s", str_time);
  50
  51         if (str_time)
  52                 free(str_time);
  53
  54         return strdup(buf);
  55
  56 }
  57
  58 static void __msg_bubble_add_content(PMSG_BUBBLE_DATA bubble_data, PMSG_APP_CONV_DATA_S conv_data)
  59 {
  60         bool isMsgText = false;
  61         Eina_Strbuf *msg_data = eina_strbuf_new();
  62
  63         if (conv_data->msgText[0] != '\0')
  64                 isMsgText = true;
  65
  66         /* Subject & image */
  67         if ((conv_data->msgType == MSG_TYPE_MMS || conv_data->msgType == MSG_TYPE_MMS_NOTI)) {
  68                 if (conv_data->subject[0] != '\0') {
  69                         char *subject = NULL;
  70                         eina_strbuf_append(msg_data, "<color=#050288FF>");
  71
  72                         subject = elm_entry_utf8_to_markup(conv_data->subject);
  73                         eina_strbuf_append(msg_data, subject);
  74
  75                         if (subject)
  76                                 free(subject);
  77                         eina_strbuf_append(msg_data, "</color><br>");
  78                 }
  79
  80                 if (conv_data->thumbNailPath[0] != '\0') {
  81                         Evas_Object *tmp_obj = NULL;
  82
  83                         int w = 0;
  84                         int h = 0;
  85                         double rate = 0.0;
  86
  87                         tmp_obj = evas_object_image_filled_add(evas_object_evas_get(conv_data->entry));
  88                         evas_object_image_file_set(tmp_obj, conv_data->thumbNailPath, NULL);
  89                         evas_object_image_size_get(tmp_obj, &w, &h);
  90                         if (tmp_obj)
  91                                 evas_object_del(tmp_obj);
  92
  93                         if (w >= h) {
  94                                 rate = MSG_BUBBLE_IMG_MAX_W / (double) w;
  95                                 w = MSG_BUBBLE_IMG_MAX_W;
  96                                 h = h * rate;
  97                         } else {
  98                                 rate = MSG_BUBBLE_IMG_MAX_H / (double)h;
  99                                 w = w * rate;
 100                                 h = MSG_BUBBLE_IMG_MAX_H;
 101                         }
 102
 103                         /* Don't remove <br> between <item> and </item>. if it is removed, anchor wouldn't work */
 104                         /* In case of body text is not exist, <br> should not be shown. for this, change font size to 1*/
 105                         if (!isMsgText && conv_data->attachment_cnt == 0 && conv_data->audio_filename[0] == '\0')
 106                                 eina_strbuf_append(msg_data, "<font_size=1>");
 107                         eina_strbuf_append_printf(msg_data, "<a href=image.%d>",  conv_data->msgId);
 108                         eina_strbuf_append_printf(msg_data, "<item size=%dx%d vsize=full href=file://%s><br></item></a>", w, h, conv_data->thumbNailPath);
 109                 }
 110         }
 111
 112         if (conv_data->bProtected)
 113                 eina_strbuf_append_printf(msg_data, "<item size=44x44 vsize=full href=file://%s></item>", MSG_BUBBLE_PROTECTED_ICON);
 114
 115         /* Message Text */
 116         char *tmp_str = elm_entry_utf8_to_markup(conv_data->msgText);
 117         eina_strbuf_append(msg_data, tmp_str);
 118         if (tmp_str)
 119                 free(tmp_str);
 120
 121         if (conv_data->msgType == MSG_TYPE_MMS) {
 122                 /** audio file */
 123                 if (conv_data->audio_filename[0] != '\0') {
 124
 125                         if (isMsgText)
 126                                 eina_strbuf_append(msg_data, "<br>");
 127
 128                         eina_strbuf_append_printf(msg_data, "<a href=audio.%d>",  conv_data->msgId);
 129                         eina_strbuf_append_printf(msg_data, "<item size=42x42 vsize=full href=file://%s> %s</item></a>", MSG_BUBBLE_AUDIOFILE_ICON, conv_data->audio_filename);
 130                 }
 131                 /** attachment files*/
 132                 if (conv_data->attachment_cnt > 0) {
 133                         char attach_str[DEF_BUF_LEN] = {0,};
 134                         if (conv_data->attachment_cnt == 1 && conv_data->attachment_filename[0] != '\0') {
 135                                 snprintf(attach_str, sizeof(attach_str), "%s", conv_data->attachment_filename);
 136                          } else {
 137                                 const char *text = dgettext(MESSAGE_PKGNAME, "IDS_MSGC_BODY_PD_ATTACHMENTS");
 138                                 snprintf(attach_str, sizeof(attach_str), text, conv_data->attachment_cnt);
 139                         }
 140
 141                         if (isMsgText || conv_data->audio_filename[0] != '\0')
 142                                 eina_strbuf_append(msg_data, "<br>");
 143
 144                         eina_strbuf_append_printf(msg_data, "<item size=42x42 vsize=full href=file://%s> %s</item>", MSG_BUBBLE_ATTACH_ICON, attach_str);
 145                 }
 146         } else if (conv_data->msgType == MSG_TYPE_SMS && conv_data->storageId == MSG_STORAGE_SIM) {
 147                 if (isMsgText) {
 148                         eina_strbuf_append(msg_data, "<font_size=24>");
 149                         eina_strbuf_append(msg_data, "<br>");
 150                 }
 151
 152                 eina_strbuf_append_printf(msg_data, "<item size=34x34 vsize=full href=file://%s></item>", MSG_BUBBLE_SIM_MSG_ICON);
 153         }
 154
 155         elm_entry_entry_set(conv_data->entry, eina_strbuf_string_get(msg_data));
 156         eina_strbuf_free(msg_data);
 157 }
 158
 159 static void __add_bubble_item(PMSG_BUBBLE_DATA bubble_data, PMSG_APP_CONV_DATA_S conv_data, MsgBoxPackType type, Evas_Object *obj)
 160 {
 161         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data || !conv_data);
 162         if (type == MSG_BOX_PACK_BEFORE || type == MSG_BOX_PACK_AFTER) {
 163                 MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !obj);
 164         }
 165         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 166
 167         Evas_Object *layout = elm_layout_add(bubble_data->box);
 168         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 169         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 170
 171         Evas_Object *entry = elm_entry_add(bubble_data->box);
 172
 173         if (conv_data->direction == MSG_DIRECTION_TYPE_MO) {
 174                 elm_layout_theme_set(layout, "layout", "bubble", "sentmessage/default");
 175                 elm_object_theme_set(entry, cd->th);
 176                 elm_object_style_set(entry, MSG_BUBBLE_STYLE_SENT);
 177         } else {
 178                 elm_layout_theme_set(layout, "layout", "bubble", "readmessage/default");
 179                 elm_object_theme_set(entry, cd->th);
 180                 elm_object_style_set(entry, MSG_BUBBLE_STYLE_RECV);
 181         }
 182
 183         elm_entry_input_panel_enabled_set(entry, EINA_FALSE);
 184         elm_entry_editable_set(entry, EINA_FALSE);
 185         elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_NO_IMAGE);
 186         elm_entry_context_menu_disabled_set(entry, EINA_TRUE);
 187         elm_entry_magnifier_disabled_set(entry, EINA_TRUE);
 188
 189         conv_data->entry = entry;
 190         conv_data->ly = layout;
 191
 192         msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
 193
 194         evas_object_data_set(entry, "conv_data", conv_data);
 195
 196         evas_object_smart_callback_add(entry, "anchor,clicked", __anchor_click_cb, (const void*)bubble_data);
 197         evas_object_smart_callback_add(entry, "longpressed", __longpressed_cb, (const void*)bubble_data);
 198
 199         elm_object_part_content_set(layout, "elm.icon", entry);
 200         evas_object_show(layout);
 201
 202         switch (type) {
 203                 case MSG_BOX_PACK_START :
 204                         elm_box_pack_start(bubble_data->box, layout);
 205                         break;
 206                 case MSG_BOX_PACK_END :
 207                         elm_box_pack_end(bubble_data->box, layout);
 208                         break;
 209                 case MSG_BOX_PACK_BEFORE :
 210                         elm_box_pack_before(bubble_data->box, layout, obj);
 211                         break;
 212                 case MSG_BOX_PACK_AFTER :
 213                         elm_box_pack_after(bubble_data->box, layout, obj);
 214                         break;
 215                 default :
 216                         break;
 217         }
 218
 219         if (bubble_data->viewmode == BUBBLE_EDIT_VIEW) {
 220                 Evas_Object *check = NULL;
 221                 if (!conv_data->chk) {
 222                         check = elm_check_add(conv_data->ly);
 223                         elm_check_state_pointer_set(check, &conv_data->isCheck);
 224                         evas_object_data_set(check, "item_data", (const void *)conv_data);
 225                         evas_object_smart_callback_add(check, "changed", msg_ui_bubble_list_checked_cb, (const void *)bubble_data);
 226                         evas_object_propagate_events_set(check, EINA_FALSE);
 227                         conv_data->chk = check;
 228                 }
 229                 evas_object_data_set(conv_data->ly, "bubble_data", bubble_data);
 230                 evas_object_event_callback_add(conv_data->ly, EVAS_CALLBACK_MOUSE_DOWN, msg_ui_bubble_item_mouse_down_cb, (const void*)conv_data);
 231                 elm_object_style_set(check, "default/genlist_edit");
 232                 elm_object_part_content_set(conv_data->ly, "elm.swallow.select_icon", conv_data->chk);
 233                 elm_object_signal_emit(conv_data->ly, "elm,state,select,enable", "elm");
 234
 235                 if (conv_data->isCheck) {
 236                         elm_check_state_set(conv_data->chk, conv_data->isCheck);
 237                 }
 238         }
 239 }
 240
 241 static void __msg_media_clicked_cb(PMSG_BUBBLE_DATA bubble_data, char *msgID, int file_type)
 242 {
 243         D_ENTER;
 244         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !msgID);
 245
 246         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
 247         MSG_UI_RETM_IF(MSG_UI_LEVEL_ERR, bubble_data->viewmode != BUBBLE_NORMAL_VIEW, "Not Normal Mode!");
 248
 249         msg_error_t err = MSG_SUCCESS;
 250         msg_struct_t msg_t = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 251         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 252         msg_struct_t mms_data = NULL;
 253         msg_list_handle_t page_list = NULL;
 254         msg_struct_t mms_page = NULL;
 255         msg_struct_t mms_media = NULL;
 256         char filepath[DEF_BUF_LEN_L+1] = {0,};
 257
 258         int msg_id = atoi(msgID);
 259         int i = 0;
 260         int j = 0;
 261         int pageCnt = 0;
 262
 263         err = msg_get_message(bubble_data->msgHandle, msg_id, msg_t, sendOpt);
 264         if (err != MSG_SUCCESS) {
 265                 D_MSG("err = [%d]", err);
 266                 msg_release_struct(&msg_t);
 267                 msg_release_struct(&sendOpt);
 268                 return;
 269         }
 270
 271         mms_data = msg_create_struct(MSG_STRUCT_MMS);
 272         err = msg_get_mms_struct(msg_t, mms_data);
 273         if (err != MSG_SUCCESS) {
 274                 D_MSG("err = [%d]", err);
 275                 goto OUTSIDE_OF_LOOP;
 276         }
 277
 278         msg_get_list_handle(mms_data, MSG_MMS_PAGE_LIST_HND, (void **)&page_list);
 279         pageCnt = msg_list_length(page_list);
 280         for (i = 0 ; i < pageCnt; i++) {
 281                 mms_page = (msg_struct_t)msg_list_nth_data(page_list, i);
 282                 msg_list_handle_t medialist = NULL;
 283                 int mediaCnt = 0;
 284
 285                 msg_get_list_handle(mms_page, MSG_MMS_PAGE_MEDIA_LIST_HND, (void **)&medialist);
 286                 mediaCnt = msg_list_length(medialist);
 287
 288                 for (j = 0; j < mediaCnt; j++) {
 289                         int media_type;
 290                         mms_media = (msg_struct_t)msg_list_nth_data(medialist, j);
 291
 292                         msg_get_int_value(mms_media, MSG_MMS_MEDIA_TYPE_INT, &media_type);
 293
 294                         if (media_type == file_type) {
 295                                 goto OUTSIDE_OF_LOOP;
 296                         }
 297                 }
 298         }
 299
 300 OUTSIDE_OF_LOOP:
 301         if (mms_media)
 302                 msg_get_str_value(mms_media, MSG_MMS_MEDIA_FILEPATH_STR, filepath, sizeof(filepath)-1);
 303
 304         if (mms_media && filepath[0] != '\0') {
 305                 service_h svc_handle;
 306                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 307                         D_EMSG("service_create() is failed !!");
 308                 } else {
 309                         service_set_operation(svc_handle, SERVICE_OPERATION_VIEW);
 310                         service_set_uri(svc_handle, filepath);
 311
 312                         if (service_send_launch_request(svc_handle, NULL, NULL) < 0)
 313                                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "service_send_launch_request is failed");
 314
 315                         service_destroy(svc_handle);
 316                 }
 317         }
 318
 319         msg_release_struct(&mms_data);
 320         msg_release_struct(&msg_t);
 321         msg_release_struct(&sendOpt);
 322
 323         D_LEAVE;
 324 }
 325
 326 static void __msg_install_clicked_cb(PMSG_BUBBLE_DATA bubble_data, int msg_id)
 327 {
 328         D_ENTER;
 329         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, bubble_data == NULL);
 330
 331         D_MSG("syncml message operation, msg id = [%d]", msg_id);
 332
 333         msg_error_t err = MSG_SUCCESS;
 334
 335         err = msg_syncml_message_operation(bubble_data->msgHandle, (msg_message_id_t) msg_id);
 336         if (err != MSG_SUCCESS)
 337                 D_MSG("msg_syncml_message_operation failed.");
 338
 339         D_LEAVE;
 340 }
 341
 342 Eina_Bool __resend_idler_cb(void *data)
 343 {
 344         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 345         PMSG_APP_CONV_DATA_S conv_data = NULL;
 346
 347         msg_struct_t failed_msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 348         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 349         msg_error_t err = MSG_SUCCESS;
 350         int msg_type = MSG_TYPE_INVALID;
 351
 352         D_MSG("Re-send message, msg id = [%d]", bubble_data->resend_id);
 353
 354         err = msg_get_message(bubble_data->msgHandle, bubble_data->resend_id, failed_msg, sendOpt);
 355
 356         if (err != MSG_SUCCESS) {
 357                 D_MSG("msg_get_message is failed.");
 358                 msg_release_struct(&sendOpt);
 359                 msg_release_struct(&failed_msg);
 360                 bubble_data->resend_id = 0;
 361                 return EINA_FALSE;
 362         }
 363
 364         msg_struct_t req = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
 365         msg_set_struct_handle(req, MSG_REQUEST_MESSAGE_HND, failed_msg);
 366         msg_set_struct_handle(req, MSG_REQUEST_SENDOPT_HND, sendOpt);
 367
 368         msg_get_int_value(failed_msg, MSG_MESSAGE_TYPE_INT, &msg_type);
 369
 370         if (msg_is_sms(msg_type))
 371                 err = msg_sms_send_message(bubble_data->msgHandle, req);
 372         else
 373                 err = msg_mms_send_message(bubble_data->msgHandle, req);
 374
 375         if (err != MSG_SUCCESS) {
 376                 D_MSG("Send_message is failed.");
 377
 378                 Eina_List *l;
 379                 EINA_LIST_FOREACH(bubble_data->bubble_list, l, conv_data) {
 380                         if (conv_data) {
 381                                 if (bubble_data->resend_id == conv_data->msgId) {
 382                                         conv_data->networkStatus = MSG_NETWORK_SEND_FAIL;
 383                                         msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
 384                                         break;
 385                                 }
 386                         }
 387                 }
 388
 389                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_DETAILSSENDINGFAILED"));
 390         }
 391
 392         msg_release_struct(&failed_msg);
 393         msg_release_struct(&sendOpt);
 394         msg_release_struct(&req);
 395
 396         bubble_data->resend_idler = NULL;
 397         bubble_data->resend_id = 0;
 398
 399         return EINA_FALSE;
 400 }
 401
 402 void msg_ui_bubble_resend_msg(PMSG_BUBBLE_DATA bubble_data, int msg_id)
 403 {
 404         D_ENTER;
 405         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, bubble_data == NULL);
 406         PMSG_APP_CONV_DATA_S conv_data = NULL;
 407
 408         Eina_List *l;
 409         EINA_LIST_FOREACH(bubble_data->bubble_list, l, conv_data) {
 410                 if (conv_data) {
 411                         if (msg_id == conv_data->msgId) {
 412                                 conv_data->networkStatus = MSG_NETWORK_SENDING;
 413                                 msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
 414                                 elm_object_signal_emit(conv_data->ly, "elm,state,contents,disabled", "elm");
 415                                 break;
 416                         }
 417                 }
 418         }
 419
 420         if (!bubble_data->resend_idler) {
 421                 bubble_data->resend_id = msg_id;
 422                 bubble_data->resend_idler = ecore_idler_add(__resend_idler_cb, (void *)bubble_data);
 423         }
 424
 425         D_LEAVE;
 426 }
 427
 428 static Eina_Bool __retrieve_idler_cb(void *data)
 429 {
 430         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 431
 432         msg_error_t err = MSG_SUCCESS;
 433         PMSG_APP_CONV_DATA_S conv_data = NULL;
 434         msg_struct_t retrieve_msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 435         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 436
 437         D_MSG("Retrieve mms message, msg id = [%d]", bubble_data->retrieve_id);
 438
 439         err = msg_get_message(bubble_data->msgHandle, bubble_data->retrieve_id, retrieve_msg, sendOpt);
 440         if (err != MSG_SUCCESS) {
 441                 D_MSG("msg_get_message is failed.");
 442                 bubble_data->retrieve_id = 0;
 443                 msg_release_struct(&retrieve_msg);
 444                 msg_release_struct(&sendOpt);
 445                 return EINA_FALSE;
 446         }
 447
 448         msg_struct_t req = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
 449         msg_set_struct_handle(req, MSG_REQUEST_MESSAGE_HND, retrieve_msg);
 450         msg_set_struct_handle(req, MSG_REQUEST_SENDOPT_HND, sendOpt);
 451
 452         err = msg_mms_retrieve_message(bubble_data->msgHandle, req);
 453
 454         if (err != MSG_SUCCESS) {
 455                 D_MSG("msg_mms_retrieve_message is failed.");
 456                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_RETRIEVING_FAILED"));
 457
 458                 Eina_List *l;
 459                 EINA_LIST_FOREACH(bubble_data->bubble_list, l, conv_data) {
 460                         if (conv_data && bubble_data->retrieve_id == conv_data->msgId) {
 461                                 Evas_Object *retrieve_btn = elm_object_part_content_get(conv_data->entry, "elm.swallow.end");
 462
 463                                 if (retrieve_btn)
 464                                         elm_object_disabled_set(retrieve_btn, EINA_FALSE);
 465
 466                                 conv_data->networkStatus = MSG_NETWORK_RETRIEVE_FAIL;
 467                                 msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
 468                                 break;
 469                         }
 470                 }
 471         }
 472
 473         msg_release_struct(&retrieve_msg);
 474         msg_release_struct(&sendOpt);
 475         msg_release_struct(&req);
 476
 477         bubble_data->retrieve_idler = NULL;
 478         bubble_data->retrieve_id = 0;
 479
 480         return EINA_FALSE;
 481 }
 482
 483 static void __msg_retrieve_clicked_cb(PMSG_BUBBLE_DATA bubble_data, int msg_id)
 484 {
 485         D_ENTER;
 486         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, bubble_data == NULL);
 487         PMSG_APP_CONV_DATA_S conv_data = NULL;
 488
 489         Eina_List *l;
 490         EINA_LIST_FOREACH(bubble_data->bubble_list, l, conv_data) {
 491                 if (conv_data && msg_id == conv_data->msgId) {
 492                         Evas_Object *retrieve_btn = elm_object_part_content_get(conv_data->entry, "elm.swallow.end");
 493
 494                         if (retrieve_btn)
 495                                 elm_object_disabled_set(retrieve_btn, EINA_TRUE);
 496
 497                         conv_data->networkStatus = MSG_NETWORK_RETRIEVING;
 498                         msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
 499                         break;
 500                 }
 501         }
 502
 503         if (!bubble_data->retrieve_idler) {
 504                 bubble_data->retrieve_id = msg_id;
 505                 bubble_data->retrieve_idler = ecore_idler_add(__retrieve_idler_cb, (void *)bubble_data);
 506         }
 507
 508         D_LEAVE;
 509 }
 510
 511 static void __popup_close_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 512 {
 513         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 514
 515         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 516
 517         if (bubble_data->popup) {
 518                 evas_object_del(bubble_data->popup);
 519                 bubble_data->popup = NULL;
 520         }
 521 }
 522
 523 static void __anchor_click_cb(void *data, Evas_Object *obj, void *event_info)
 524 {
 525         D_ENTER;
 526         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj || !event_info);
 527
 528         PMSG_BUBBLE_DATA bubble_data = data;
 529         Elm_Entry_Anchor_Info *ac_info = NULL;
 530
 531         if(bubble_data->viewmode != BUBBLE_NORMAL_VIEW)
 532                 return;
 533
 534         /* Avoiding conflict long_press_menu popup */
 535         if (bubble_data->popup)
 536                 return;
 537
 538         char *token = NULL, *tok_r = NULL;
 539         char type[DEF_BUF_LEN] = { 0, };
 540
 541         ac_info = (Elm_Entry_Anchor_Info *) event_info;
 542         strncpy(type, ac_info->name, DEF_BUF_LEN - 1);
 543
 544         token = strtok_r(type, ".", &tok_r);
 545
 546         elm_entry_anchor_hover_end(obj);
 547
 548         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, tok_r == NULL);
 549
 550         if (g_strcmp0(token, "image") == 0)
 551                 __msg_media_clicked_cb(bubble_data, tok_r, MMS_SMIL_MEDIA_IMG);
 552         else if (g_strcmp0(token, "audio") == 0)
 553                 __msg_media_clicked_cb(bubble_data, tok_r, MMS_SMIL_MEDIA_AUDIO);
 554
 555         D_LEAVE;
 556 }
 557
 558 static void __msg_copy_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 559 {
 560         D_ENTER;
 561         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data);
 562
 563         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 564         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
 565
 566         if (bubble_data->popup) {
 567                 evas_object_del(bubble_data->popup);
 568                 bubble_data->popup = NULL;
 569         }
 570
 571         if (!conv_data) {
 572                 D_EMSG("conv_data is NULL");
 573                 return;
 574         }
 575
 576         char copy_str[DEF_BUF_LEN_L + DEF_BUF_LEN_S + 1] = {0,};
 577         if (conv_data->subject[0] != '\0') {
 578                 strncat(copy_str, conv_data->subject, strlen(conv_data->subject));
 579                 strncat(copy_str, "\n", strlen("\n"));
 580         }
 581
 582         if (conv_data->msgText[0] != '\0')
 583                 strncat(copy_str, conv_data->msgText, sizeof(copy_str) - strlen(conv_data->subject) - 1);
 584
 585         if (copy_str[0] != '\0')
 586                 elm_cnp_selection_set(conv_data->entry, ELM_SEL_TYPE_CLIPBOARD, ELM_SEL_FORMAT_TEXT, copy_str, strlen(copy_str));
 587
 588         D_LEAVE;
 589 }
 590
 591 static void __msg_protect_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 592 {
 593         D_ENTER;
 594         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data);
 595
 596         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 597         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
 598
 599         if (bubble_data->popup) {
 600                 evas_object_del(bubble_data->popup);
 601                 bubble_data->popup = NULL;
 602         }
 603
 604         if (msg_update_protected_status(bubble_data->msgHandle, conv_data->msgId, !conv_data->bProtected) == MSG_SUCCESS) {
 605                 conv_data->bProtected = !conv_data->bProtected;
 606                 msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
 607         }
 608 }
 609
 610 static void __msg_delete_ok_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 611 {
 612         D_ENTER;
 613         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data);
 614
 615         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 616         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(bubble_data->popup, "conv_data");
 617         msg_message_id_t msg_id;
 618         int err;
 619
 620         if (bubble_data->popup) {
 621                 evas_object_del(bubble_data->popup);
 622                 bubble_data->popup = NULL;
 623         }
 624
 625         if (!conv_data) {
 626                 msg_ui_bubble_show_notify(bubble_data, dgettext("sys_string", "IDS_COM_POP_UNABLE_TO_DELETE"));
 627                 return;
 628         }
 629
 630         bool isDraft = msg_ui_composer_common_is_send_possible((MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data);
 631
 632         if (bubble_data->bubble_count == 1 && isDraft == false) {
 633                 bubble_data->bubble_count = 0;
 634                 err = msg_delete_thread_message_list(bubble_data->msgHandle, bubble_data->threadId, false);
 635         } else {
 636                 msg_id = conv_data->msgId;
 637                 err = msg_delete_message(bubble_data->msgHandle, msg_id);
 638                 msg_ui_bubble_list_load(bubble_data);
 639         }
 640
 641         if (err != MSG_SUCCESS) {
 642                 msg_ui_bubble_show_notify(bubble_data, dgettext("sys_string", "IDS_COM_POP_UNABLE_TO_DELETE"));
 643         } else {
 644                 msg_ui_bubble_show_deleted_info(bubble_data);
 645         }
 646
 647         return;
 648 }
 649
 650 static void __msg_delete_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 651 {
 652         D_ENTER;
 653
 654         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 655
 656         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 657         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
 658         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 659
 660         if (bubble_data->popup) {
 661                 evas_object_del(bubble_data->popup);
 662                 bubble_data->popup = NULL;
 663         }
 664
 665         if (!conv_data) {
 666                 D_EMSG("conv_data is NULL");
 667                 return;
 668         }
 669
 670         Evas_Object *popup = elm_popup_add(cd->main_window);
 671         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 672         elm_object_text_set(popup, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_DELETE_Q"));
 673
 674         Evas_Object *btn_ok = elm_button_add(popup);
 675         elm_object_style_set(btn_ok, "popup_button/default");
 676         elm_object_text_set(btn_ok, dgettext("sys_string", "IDS_COM_SK_OK"));
 677         elm_object_part_content_set(popup, "button1", btn_ok);
 678         evas_object_smart_callback_add(btn_ok, "clicked", __msg_delete_ok_clicked_cb, bubble_data);
 679
 680         Evas_Object *btn_cancel = elm_button_add(popup);
 681         elm_object_style_set(btn_cancel, "popup_button/default");
 682         elm_object_text_set(btn_cancel, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
 683         elm_object_part_content_set(popup, "button2", btn_cancel);
 684         evas_object_smart_callback_add(btn_cancel, "clicked", __popup_close_clicked_cb, bubble_data);
 685
 686         evas_object_data_set(popup, "conv_data", conv_data);
 687         evas_object_show(popup);
 688
 689         bubble_data->popup = popup;
 690
 691         D_LEAVE;
 692 }
 693
 694 static int __msg_bubble_get_media_list(PMSG_BUBBLE_DATA bubble_data, PMSG_APP_CONV_DATA_S item_data)
 695 {
 696         D_ENTER;
 697
 698         PBUBBLE_MEDIA_INFO media_item = NULL;
 699         msg_struct_t msgInfo = NULL;
 700         msg_struct_t sendOpt = NULL;
 701         msg_struct_t mmsInfo = NULL;
 702         msg_list_handle_t pagelist = NULL;
 703         msg_list_handle_t medialist = NULL;
 704         msg_list_handle_t attachlist = NULL;
 705
 706         int attach_count = 0;
 707         int page_count = 0;
 708         int i = 0;
 709         int j = 0;
 710         int media_count = 0;
 711
 712         /**** getting msgInfo ***/
 713         msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 714         sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 715         if (msg_get_message(bubble_data->msgHandle, item_data->msgId, msgInfo, sendOpt) != MSG_SUCCESS) {
 716                 D_EMSG("msg_get_message FAILED !!!");
 717                 msg_release_struct(&msgInfo);
 718                 msg_release_struct(&sendOpt);
 719                 return 0;
 720         }
 721
 722         /*** getting MMS info ****/
 723         mmsInfo = msg_create_struct(MSG_STRUCT_MMS);
 724         if (msg_get_mms_struct(msgInfo, mmsInfo) != MSG_SUCCESS) {
 725                 D_EMSG("msg_get_mms_struct FAILED !!!");
 726                 msg_release_struct(&msgInfo);
 727                 msg_release_struct(&sendOpt);
 728                 msg_release_struct(&mmsInfo);
 729                 return 0;
 730         }
 731
 732         msg_get_list_handle(mmsInfo, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist);
 733         page_count = msg_list_length(pagelist);
 734
 735         for (i=0; i<page_count; i++) {
 736                 msg_struct_t page_info = (msg_struct_t)msg_list_nth_data(pagelist, i);
 737                 int page_media_count = 0;
 738
 739                 msg_get_list_handle(page_info, MSG_MMS_PAGE_MEDIA_LIST_HND, (void **)&medialist);
 740                 page_media_count = msg_list_length(medialist);
 741
 742                 for (j = 0; j < page_media_count; j++) {
 743                         int mediaType;
 744                         msg_struct_t media_info = NULL;
 745                         media_info = (msg_struct_t)msg_list_nth_data(medialist, j);
 746
 747                         msg_get_int_value(media_info, MSG_MMS_MEDIA_TYPE_INT, &mediaType);
 748
 749                         if (mediaType == MMS_SMIL_MEDIA_TEXT)
 750                                 continue;
 751
 752                         media_item = (PBUBBLE_MEDIA_INFO)calloc(1, sizeof(BUBBLE_MEDIA_INFO));
 753
 754                         media_item->media_type = mediaType;
 755                         msg_get_str_value(media_info, MSG_MMS_MEDIA_FILEPATH_STR, media_item->filepath, sizeof(media_item->filepath));
 756                         msg_get_str_value(media_info, MSG_MMS_MEDIA_FILENAME_STR, media_item->filename, sizeof(media_item->filename));
 757                         media_item->file_size = (int)ecore_file_size(media_item->filepath) / 1024; // KB
 758
 759                         bubble_data->media_list = eina_list_append(bubble_data->media_list, media_item);
 760                         media_count++;
 761                         media_item = NULL;
 762                 }
 763         }
 764
 765
 766         /*** getting attachment info ***/
 767         msg_get_list_handle(mmsInfo, MSG_MMS_ATTACH_LIST_HND, (void **)&attachlist);
 768         attach_count = msg_list_length(attachlist);
 769
 770         for (i=0; i<attach_count; i++) {
 771                 msg_struct_t attach_info = (msg_struct_t)msg_list_nth_data(attachlist, i);
 772
 773                 media_item = (PBUBBLE_MEDIA_INFO)calloc(1, sizeof(BUBBLE_MEDIA_INFO));
 774
 775                 msg_get_int_value(attach_info, MSG_MMS_ATTACH_DRM_TYPE_INT, &media_item->drm_type);
 776                 msg_get_str_value(attach_info, MSG_MMS_ATTACH_FILEPATH_STR, media_item->filepath, sizeof(media_item->filepath));
 777                 msg_get_str_value(attach_info, MSG_MMS_ATTACH_FILENAME_STR, media_item->filename, sizeof(media_item->filename));
 778                 media_item->file_size = (int)ecore_file_size(media_item->filepath) / 1024; // KB
 779
 780                 bubble_data->media_list = eina_list_append(bubble_data->media_list, media_item);
 781                 media_count++;
 782                 media_item = NULL;
 783         }
 784
 785         msg_release_struct(&msgInfo);
 786         msg_release_struct(&sendOpt);
 787         msg_release_struct(&mmsInfo);
 788
 789         D_LEAVE;
 790         return media_count;
 791 }
 792
 793 void __msg_ui_bubble_save_attachments_checked_cb(void *data, Evas_Object *obj, void *event_info)
 794 {
 795         D_ENTER;
 796
 797         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 798         PBUBBLE_MEDIA_INFO mediaData = (PBUBBLE_MEDIA_INFO)evas_object_data_get(obj, "item_data");
 799         Elm_Object_Item *it = NULL;
 800
 801         int genlist_count = elm_genlist_items_count(bubble_data->popup_genlist);
 802         int media_count = 0;
 803
 804         if (genlist_count == 1)
 805                 media_count = 1;
 806         else
 807                 media_count = genlist_count - 1;
 808
 809         if (media_count == 1) {
 810                 if (mediaData->isChecked)
 811                         bubble_data->media_chk_cnt = 1;
 812                 else
 813                         bubble_data->media_chk_cnt = 0;
 814         } else if (media_count > 1) {
 815                 it = elm_genlist_first_item_get(bubble_data->popup_genlist);
 816
 817                 if (!strcmp(mediaData->filename, dgettext("sys_string", "IDS_COM_BODY_SELECT_ALL"))) {
 818                         while (it) {
 819                                 PBUBBLE_MEDIA_INFO item_data = (PBUBBLE_MEDIA_INFO)elm_object_item_data_get(it);
 820                                 if (item_data) {
 821                                                 item_data->isChecked = mediaData->isChecked;
 822                                                 elm_check_state_set(item_data->check, item_data->isChecked);
 823                                         }
 824
 825                                 it = elm_genlist_item_next_get(it);
 826                         }
 827
 828                         if (mediaData->isChecked)
 829                                 bubble_data->media_chk_cnt = media_count;
 830                         else
 831                                 bubble_data->media_chk_cnt = 0;
 832                 } else {
 833                         if (mediaData->isChecked) {
 834                                 bubble_data->media_chk_cnt++;
 835                                 // handle select  all
 836                                 if (bubble_data->media_chk_cnt == media_count) {
 837                                         it = elm_genlist_first_item_get(bubble_data->popup_genlist);
 838                                         PBUBBLE_MEDIA_INFO item_data = (PBUBBLE_MEDIA_INFO)elm_object_item_data_get(it);
 839                                         if (item_data) {
 840                                                 item_data->isChecked = true;
 841                                                 elm_check_state_set(item_data->check, item_data->isChecked);
 842                                         }
 843                                 }
 844                         } else {
 845                                 // handle select all
 846                                 if (bubble_data->media_chk_cnt == media_count) {
 847                                         it = elm_genlist_first_item_get(bubble_data->popup_genlist);
 848                                         PBUBBLE_MEDIA_INFO item_data = (PBUBBLE_MEDIA_INFO)elm_object_item_data_get(it);
 849                                         if (item_data) {
 850                                                 item_data->isChecked = false;
 851                                                 elm_check_state_set(item_data->check, item_data->isChecked);
 852                                         }
 853                                 }
 854                                 bubble_data->media_chk_cnt--;
 855                         }
 856                 }
 857         }
 858
 859         if (bubble_data->save_button) {
 860                 if (bubble_data->media_chk_cnt > 0)
 861                         elm_object_disabled_set(bubble_data->save_button, EINA_FALSE);
 862                 else
 863                         elm_object_disabled_set(bubble_data->save_button, EINA_TRUE);
 864         }
 865
 866         D_LEAVE;
 867 }
 868
 869
 870 static char *__msg_ui_bubble_save_attachments_gl_text_get(void *data, Evas_Object *obj, const char *part)
 871 {
 872         D_ENTER;
 873         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, data == NULL || obj == NULL, NULL);
 874
 875         PBUBBLE_MEDIA_INFO media_info = (PBUBBLE_MEDIA_INFO)data;
 876
 877         if (!strcmp(part, "elm.text")) {
 878                 return strdup(media_info->filename);
 879         }
 880         D_LEAVE;
 881         return NULL;
 882 }
 883
 884 static Evas_Object *__msg_ui_bubble_save_attachments_gl_content_get(void *data, Evas_Object *obj, const char *part)
 885 {
 886         D_ENTER;
 887         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, data == NULL || obj == NULL, NULL);
 888
 889         PBUBBLE_MEDIA_INFO media_info = (PBUBBLE_MEDIA_INFO)data;
 890         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)evas_object_data_get(obj, "bubble_data");
 891
 892         if (!strcmp(part, "elm.icon.1") || !strcmp(part, "elm.icon")) {
 893                 Evas_Object *check = elm_check_add(obj);
 894                 //set the State pointer to keep the current UI state of Checkbox.
 895                 elm_check_state_pointer_set(check, &media_info->isChecked);
 896                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 897                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 898
 899                 media_info->check = check;
 900                 evas_object_data_set(check, "item_data", media_info);
 901
 902                 evas_object_smart_callback_add(check, "changed", __msg_ui_bubble_save_attachments_checked_cb, bubble_data);
 903
 904                 return check;
 905         } else  if (strcmp(part, "elm.icon.2") == 0) {
 906                 Evas_Object *image = elm_icon_add(obj);
 907
 908                 if (media_info->drm_type != MSG_DRM_TYPE_NONE) {
 909                         elm_image_file_set(image, MSG_BUBBLE_IMAGE_DRM_ICON, NULL);
 910                 } else {
 911                         if (media_info->media_type == MMS_SMIL_MEDIA_IMG) {
 912                                 if (media_info->filepath[0] != '\0')
 913                                         elm_image_file_set(image, media_info->filepath, NULL);
 914                                 else
 915                                         elm_image_file_set(image, MSG_BUBBLE_ATTACH_ICON, NULL);
 916                         } else {
 917                                 const char *icon_path = msg_common_get_file_icon(media_info->filepath);
 918                                 if (icon_path) {
 919                                         elm_image_file_set(image, MSG_IMAGES_EDJ, icon_path);
 920                                 } else {
 921                                         D_EMSG("icon_path is NULL");
 922                                         elm_image_file_set(image, MSG_IMAGES_EDJ, MSG_BUBBLE_ATTACH_ICON);
 923                                 }
 924                         }
 925
 926                 }
 927
 928                 if (image)
 929                         evas_object_size_hint_aspect_set(image, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 930
 931                 return image;
 932         } else {
 933                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Invalid part : %s", part);
 934         }
 935
 936         D_LEAVE;
 937         return NULL;
 938 }
 939
 940 static void __msg_ui_bubble_save_attachments_gl_sel(void *data, Evas_Object *obj, void *event_info)
 941 {
 942         D_ENTER;
 943         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 944
 945         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 946
 947         PBUBBLE_MEDIA_INFO item_data = (PBUBBLE_MEDIA_INFO)elm_object_item_data_get(item);
 948
 949         elm_genlist_item_selected_set(item, false);
 950
 951         item_data->isChecked = !item_data->isChecked;
 952
 953         const char *filename = elm_object_item_part_text_get(item, "elm.text");
 954         if (!strcmp(filename, dgettext("sys_string", "IDS_COM_BODY_SELECT_ALL")))
 955                 elm_genlist_item_fields_update(item, "elm.icon", ELM_GENLIST_ITEM_FIELD_CONTENT);
 956         else
 957                 elm_genlist_item_fields_update(item, "elm.icon.1", ELM_GENLIST_ITEM_FIELD_CONTENT);
 958
 959         evas_object_smart_callback_call(item_data->check, "changed", event_info);
 960
 961         D_LEAVE;
 962 }
 963
 964
 965 static void __popup_save_attachment_save_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 966 {
 967         D_ENTER;
 968
 969         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 970
 971         if (bubble_data->popup) {
 972                 evas_object_del(bubble_data->popup);
 973                 bubble_data->popup = NULL;
 974         }
 975
 976         Eina_List *l = NULL;
 977         Eina_Bool ret = EINA_FALSE;
 978         PBUBBLE_MEDIA_INFO item_data = NULL;
 979
 980         l = NULL;
 981         item_data = NULL;
 982         EINA_LIST_FOREACH(bubble_data->media_list,l,item_data) {
 983                 if (item_data) {
 984                         if (item_data->isChecked) {
 985                                 char dst[MSG_FILEPATH_LEN_MAX+1] = {0,};
 986                                 snprintf(dst, MSG_FILEPATH_LEN_MAX, "%s/%s", MSG_BUBBLE_DOWNLOAD_DIR, item_data->filename);
 987
 988                                 if (ecore_file_exists(dst) == EINA_FALSE) {
 989                                         ret = ecore_file_cp(item_data->filepath, dst);
 990                                 } else {
 991                                         // make new file path
 992                                         char *file_ext = NULL;
 993                                         char file_name_no_ext[MSG_FILENAME_LEN_MAX+1] = {0,};
 994                                         char new_file_path[MSG_FILENAME_LEN_MAX+1] = {0,};
 995
 996                                         file_ext = strrchr(item_data->filename, '.') + 1;
 997                                         strncpy(file_name_no_ext, item_data->filename, strlen(item_data->filename) - strlen(file_ext) - 1);
 998                                         int count = 1;
 999
1000                                         while(count < 100) {
1001                                                 snprintf(new_file_path, MSG_FILENAME_LEN_MAX, "%s/%s_%02d.%s", MSG_BUBBLE_DOWNLOAD_DIR, file_name_no_ext, count, file_ext);
1002                                                 if (ecore_file_exists(new_file_path) == EINA_TRUE) {
1003                                                         count++;
1004                                                 } else {
1005                                                         ret = ecore_file_cp(item_data->filepath, new_file_path);
1006                                                         break;
1007                                                 }
1008                                         }
1009
1010                                 }
1011                         }
1012                 }
1013         }
1014         if (ret == EINA_TRUE) {
1015                 msg_ui_bubble_status_message_post(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_SAVED_IN_MY_FILES"));
1016         } else {
1017                 msg_ui_bubble_show_notify(bubble_data, dgettext("sys_string", "IDS_COM_POP_SAVING_FAILED"));
1018         }
1019
1020         if (bubble_data->media_list) {
1021                 EINA_LIST_FREE(bubble_data->media_list, item_data) {
1022                         if (item_data)
1023                                 free(item_data);
1024                 }
1025
1026                 bubble_data->media_list = eina_list_free(bubble_data->media_list);
1027         }
1028
1029         bubble_data->popup_genlist = NULL;
1030         bubble_data->media_chk_cnt = 0;
1031         bubble_data->save_button = NULL;
1032
1033
1034         D_LEAVE;
1035 }
1036
1037 static void __popup_save_attachment_close_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1038 {
1039         D_ENTER;
1040
1041         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1042         void *item_data = NULL;
1043
1044         if (bubble_data->popup) {
1045                 evas_object_del(bubble_data->popup);
1046                 bubble_data->popup = NULL;
1047         }
1048
1049         if (bubble_data->media_list) {
1050                 EINA_LIST_FREE(bubble_data->media_list, item_data) {
1051                         if (item_data)
1052                                 free(item_data);
1053                 }
1054
1055                 bubble_data->media_list = eina_list_free(bubble_data->media_list);
1056         }
1057
1058         bubble_data->popup_genlist = NULL;
1059         bubble_data->media_chk_cnt = 0;
1060         bubble_data->save_button = NULL;
1061
1062         D_LEAVE;
1063 }
1064
1065
1066 static void __msg_save_attachment_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1067 {
1068         D_ENTER;
1069
1070         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1071
1072         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1073         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1074         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1075
1076         if (bubble_data->popup) {
1077                 evas_object_del(bubble_data->popup);
1078                 bubble_data->popup = NULL;
1079         }
1080
1081         if (!conv_data) {
1082                 D_EMSG("conv_data is NULL");
1083                 return;
1084         }
1085
1086         int total_count = __msg_bubble_get_media_list(bubble_data, conv_data);
1087
1088         if (total_count > 0) {
1089                 /** create popup **/
1090                 Evas_Object *popup = NULL;
1091                 Evas_Object *genlist = NULL;
1092                 Evas_Object *btn_save = NULL;
1093                 Evas_Object *btn_close = NULL;
1094                 PBUBBLE_MEDIA_INFO media_info = NULL;
1095                 int i = 0;
1096
1097                 popup = elm_popup_add(cd->main_window);
1098
1099                 elm_object_style_set(popup, "min_menustyle");
1100                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1101
1102                 elm_object_part_text_set(popup, "title,text", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SAVE_ATTACHMENT"));
1103
1104                 /** create genlist **/
1105                 genlist = elm_genlist_add(popup);
1106                 evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1107                 evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
1108                 evas_object_data_set(genlist, "bubble_data", bubble_data);
1109                 bubble_data->popup_genlist = genlist;
1110
1111                 bubble_data->itc_popup_selall.item_style = "1text.1icon.2";
1112                 bubble_data->itc_popup_selall.func.text_get = __msg_ui_bubble_save_attachments_gl_text_get;
1113                 bubble_data->itc_popup_selall.func.content_get = __msg_ui_bubble_save_attachments_gl_content_get;
1114                 bubble_data->itc_popup_selall.func.state_get = NULL;
1115                 bubble_data->itc_popup_selall.func.del = NULL;
1116
1117                 // Genlist style set
1118                 bubble_data->itc_popup.item_style = "1text.2icon.2";
1119                 bubble_data->itc_popup.func.text_get =  __msg_ui_bubble_save_attachments_gl_text_get;
1120                 bubble_data->itc_popup.func.content_get = __msg_ui_bubble_save_attachments_gl_content_get;
1121                 bubble_data->itc_popup.func.state_get = NULL;
1122                 bubble_data->itc_popup.func.del = NULL;
1123
1124                 // Add first Item, (select  all)
1125                 if (total_count > 1) {
1126                         PBUBBLE_MEDIA_INFO select_all_info = NULL;
1127                         const char *str_sel_all = dgettext("sys_string", "IDS_COM_BODY_SELECT_ALL");
1128                         select_all_info = (PBUBBLE_MEDIA_INFO)calloc(1, sizeof(BUBBLE_MEDIA_INFO));
1129                         strncpy(select_all_info->filename, str_sel_all, strlen(str_sel_all));
1130                         elm_genlist_item_append(genlist, &bubble_data->itc_popup_selall, select_all_info, NULL, ELM_GENLIST_ITEM_NONE, __msg_ui_bubble_save_attachments_gl_sel, bubble_data);
1131                 }
1132
1133                 for (i=0; i<total_count; i++) {
1134                         media_info = eina_list_nth(bubble_data->media_list, i);
1135                         if (media_info)
1136                                 elm_genlist_item_append(genlist, &bubble_data->itc_popup, media_info, NULL, ELM_GENLIST_ITEM_NONE, __msg_ui_bubble_save_attachments_gl_sel, bubble_data);
1137                 }
1138
1139                 Evas_Object *box = elm_box_add(popup);
1140                 if (total_count == 1)
1141                         evas_object_size_hint_min_set(box, 0, MSG_BUBBLE_POPUP_LIST_1LINE_HEIGHT * elm_config_scale_get() * total_count);
1142                 else if (total_count < MSG_BUBBLE_POPUP_LIST_MAX_MENU)
1143                         evas_object_size_hint_min_set(box, 0, MSG_BUBBLE_POPUP_LIST_1LINE_HEIGHT * elm_config_scale_get() * (total_count+1)); // +1 for select all  menu
1144                 else
1145                         evas_object_size_hint_min_set(box, 0, MSG_BUBBLE_POPUP_LIST_1LINE_HEIGHT * elm_config_scale_get() * MSG_BUBBLE_POPUP_LIST_MAX_MENU);
1146
1147                 elm_box_pack_start(box, genlist);
1148                 elm_object_content_set(popup, box);
1149
1150                 /*** creating Buttons ***/
1151                 // Save button
1152                 btn_save = elm_button_add(popup);
1153                 elm_object_style_set(btn_save, "popup_button/default");
1154                 elm_object_text_set(btn_save, dgettext("sys_string", "IDS_COM_SK_SAVE"));
1155                 elm_object_part_content_set(popup, "button1", btn_save);
1156                 evas_object_smart_callback_add(btn_save, "clicked", __popup_save_attachment_save_clicked_cb, bubble_data);
1157                 elm_object_disabled_set(btn_save, EINA_TRUE);
1158                 bubble_data->save_button = btn_save;
1159
1160                 // Cancel button
1161                 btn_close = elm_button_add(popup);
1162                 elm_object_style_set(btn_close, "popup_button/default");
1163                 elm_object_text_set(btn_close, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
1164                 elm_object_part_content_set(popup, "button2", btn_close);
1165                 evas_object_smart_callback_add(btn_close, "clicked", __popup_save_attachment_close_clicked_cb, bubble_data);
1166
1167                 evas_object_show(genlist);
1168                 evas_object_show(popup);
1169                 bubble_data->popup = popup;
1170         } else {
1171                 /** No attachment */
1172                 D_MSG("No attachments");
1173                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_NO_ATTACHMENTS"));
1174         }
1175
1176         D_LEAVE;
1177 }
1178
1179 static void __msg_forward_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1180 {
1181         D_ENTER;
1182         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1183
1184         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1185         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1186         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1187
1188         if (bubble_data->popup) {
1189                 evas_object_del(bubble_data->popup);
1190                 bubble_data->popup = NULL;
1191         }
1192
1193         if (!conv_data) {
1194                 D_EMSG("conv_data is NULL");
1195                 return;
1196         }
1197
1198         char buf[DEF_BUF_LEN_S] = { 0, };
1199         service_h svc_handle;
1200         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1201                 D_EMSG("service_create() is failed !!");
1202         } else {
1203                 snprintf(buf, sizeof(buf), "%d", conv_data->msgId);
1204                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_MSG_ID, buf);
1205                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_MODE, MSG_BUNDLE_VALUE_FORWARD);
1206                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_FROM, MSG_BUNDLE_VALUE_INTERNAL);
1207                 msg_ui_composer_launch_composer_create(cd, svc_handle);
1208                 service_destroy(svc_handle);
1209         }
1210         D_LEAVE;
1211 }
1212
1213 static void __msg_bubble_copy_to_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1214 {
1215         D_ENTER;
1216         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1217
1218         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1219         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1220
1221         if (bubble_data->popup) {
1222                 evas_object_del(bubble_data->popup);
1223                 bubble_data->popup = NULL;
1224         }
1225
1226         if (!conv_data) {
1227                 D_EMSG("conv_data is NULL");
1228                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_UNABLE_TO_COPY"));
1229                 return;
1230         }
1231
1232         msg_error_t err = MSG_SUCCESS;
1233         int msg_id = 0;
1234         msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1235         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
1236
1237         if (msg_get_message(bubble_data->msgHandle, conv_data->msgId, msg, sendOpt) != MSG_SUCCESS)
1238                 goto COPY_FAIL;
1239
1240         if (conv_data->msgType == MSG_TYPE_SMS) {
1241                 if (conv_data->storageId == MSG_STORAGE_PHONE) {
1242                         if ((msg_id = msg_add_message(bubble_data->msgHandle, msg, sendOpt)) < 0)
1243                                 goto COPY_FAIL;
1244                         bubble_data->copy_id = msg_id;
1245                         err = msg_move_msg_to_storage(bubble_data->msgHandle, msg_id, MSG_STORAGE_SIM);
1246                 } else if (conv_data->storageId == MSG_STORAGE_SIM) {
1247                         msg_set_int_value(msg, MSG_MESSAGE_STORAGE_ID_INT, MSG_STORAGE_PHONE);
1248                         if ((msg_id = msg_add_message(bubble_data->msgHandle, msg, sendOpt)) < 0)
1249                                 goto COPY_FAIL;
1250                 } else {
1251                         D_EMSG("invalid storage id [%d]", conv_data->storageId);
1252                         goto COPY_FAIL;
1253                 }
1254                  /** remove if it failed to move */
1255                 if (err != MSG_SUCCESS)
1256                         msg_delete_message(bubble_data->msgHandle, msg_id);
1257         }
1258
1259         if (err == MSG_SUCCESS) {
1260                 msg_ui_bubble_status_message_post(bubble_data, dgettext("sys_string", "IDS_COM_POP_COPIED_P"));
1261                 if (conv_data->storageId != MSG_STORAGE_PHONE)
1262                         msg_ui_bubble_list_load(bubble_data);
1263         } else {
1264                 goto COPY_FAIL;
1265         }
1266
1267         if (msg)
1268                 msg_release_struct(&msg);
1269
1270         if (sendOpt)
1271                 msg_release_struct(&sendOpt);
1272
1273         D_LEAVE;
1274         return;
1275
1276
1277 COPY_FAIL:
1278         if (msg)
1279                 msg_release_struct(&msg);
1280
1281         if (sendOpt)
1282                 msg_release_struct(&sendOpt);
1283
1284         msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_UNABLE_TO_COPY"));
1285
1286 }
1287
1288 static void __msg_bubble_view_detail_msg_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1289 {
1290         D_ENTER;
1291
1292         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1293
1294         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1295         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1296         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1297
1298         if (bubble_data->popup) {
1299                 evas_object_del(bubble_data->popup);
1300                 bubble_data->popup = NULL;
1301         }
1302
1303         // create popup
1304         Evas_Object *popup = elm_popup_add(cd->main_window);
1305         elm_object_style_set(popup, "min_menustyle");
1306
1307         if (!popup) {
1308                 D_EMSG("create popup error !!! ");
1309                 return;
1310         }
1311
1312         // popup title
1313         elm_object_part_text_set(popup, "title,text", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_VIEW_MESSAGE_DETAILS_ABB"));
1314
1315         // box
1316         Evas_Object *box = elm_box_add(popup);
1317         evas_object_size_hint_min_set(box, -1, 450);
1318         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1319         evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
1320
1321         // popup entry
1322         Evas_Object *entry = elm_entry_add(popup);
1323         evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1324         evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
1325
1326         elm_entry_input_panel_enabled_set(entry, EINA_FALSE);
1327         elm_entry_editable_set(entry, EINA_FALSE);
1328         elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_NO_IMAGE);
1329         elm_entry_context_menu_disabled_set(entry, EINA_TRUE);
1330         elm_entry_magnifier_disabled_set(entry, EINA_TRUE);
1331         elm_entry_scrollable_set(entry, EINA_TRUE);
1332
1333         char *str = msg_common_make_message_detail_text(bubble_data->msgHandle, conv_data->msgId);
1334
1335         if (str) {
1336                 elm_entry_entry_set(entry, str);
1337                 free(str);
1338         }
1339
1340         evas_object_show(entry);
1341         evas_object_show(box);
1342
1343         elm_box_pack_start(box, entry);
1344         elm_object_content_set(popup, box);
1345
1346         // popup close button
1347         Evas_Object * btn1 = elm_button_add(popup);
1348         elm_object_style_set(btn1, "popup_button/default");
1349         elm_object_text_set(btn1, dgettext("sys_string", "IDS_COM_BODY_CLOSE"));
1350         elm_object_part_content_set(popup, "button1", btn1);
1351
1352         evas_object_smart_callback_add(btn1, "clicked", __popup_close_clicked_cb, bubble_data);
1353
1354         evas_object_show(popup);
1355         bubble_data->popup = popup;
1356 }
1357
1358 static void __longpressed_cb(void *data, Evas_Object *obj, void *event_info)
1359 {
1360         D_ENTER;
1361         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1362
1363         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1364         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1365         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !cd);
1366
1367         Evas_Object *popup = NULL;
1368         Evas_Object *list = NULL;
1369         char title[DEF_THREAD_ADDR_LEN+1] = {0,};
1370
1371         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1372         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !conv_data);
1373
1374         if(bubble_data->viewmode != BUBBLE_NORMAL_VIEW)
1375                 return;
1376
1377         /** create popup */
1378         popup = elm_popup_add(cd->main_window);
1379         if (!popup) {
1380                 D_EMSG("elm_popup_add returns NULL");
1381                 return;
1382         }
1383
1384         elm_object_style_set(popup, "min_menustyle");
1385         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1386
1387         /** set popup title */
1388         /** Sender: contents ... ex> "01012341234: Hello......" */
1389         if (bubble_data->threadName[0] != '\0')
1390                 snprintf(title, DEF_THREAD_ADDR_LEN, "%s: %s", bubble_data->threadName, conv_data->msgText);
1391         else
1392                 snprintf(title, DEF_THREAD_ADDR_LEN, "%s: %s", dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"), conv_data->msgText);
1393
1394         /** create menu list */
1395         list = elm_list_add(cd->main_window);
1396         elm_list_mode_set(list, ELM_LIST_EXPAND);
1397         evas_object_size_hint_max_set(list, -1, MSG_BUBBLE_POPUP_LIST_1LINE_HEIGHT * MSG_BUBBLE_POPUP_LIST_MAX_MENU * elm_config_scale_get());
1398
1399         if (!list)
1400                 return;
1401
1402         evas_object_data_set(list, "conv_data", conv_data);
1403
1404         elm_list_item_append(list, dgettext("sys_string", "IDS_COM_SK_DELETE"), NULL, NULL, __msg_delete_clicked_cb, bubble_data);
1405         elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_COPY_MESSAGE_TEXT_ABB"), NULL, NULL, __msg_copy_clicked_cb, bubble_data);
1406         if (conv_data->bProtected == true)
1407                 elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_PROTECTION_OFF"), NULL, NULL, __msg_protect_clicked_cb, bubble_data);
1408         else
1409                 elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_PROTECTION_ON"), NULL, NULL, __msg_protect_clicked_cb, bubble_data);
1410         elm_list_item_append(list, dgettext("sys_string", "IDS_COM_BODY_FORWARD"), NULL, NULL, __msg_forward_clicked_cb, bubble_data);
1411
1412         if (conv_data->msgType == MSG_TYPE_SMS) {
1413                 if (conv_data->storageId == MSG_STORAGE_PHONE)
1414                         elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_COPY_TO_SIM"), NULL, NULL, __msg_bubble_copy_to_clicked_cb, bubble_data);
1415                 else if (conv_data->storageId == MSG_STORAGE_SIM)
1416                         elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_COPY_TO_PHONE"), NULL, NULL, __msg_bubble_copy_to_clicked_cb, bubble_data);
1417         } else if (conv_data->msgType == MSG_TYPE_MMS) {
1418                 elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SAVE_ATTACHMENT"), NULL, NULL, __msg_save_attachment_clicked_cb, bubble_data);
1419         }
1420
1421         elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_VIEW_MESSAGE_DETAILS_ABB"), NULL, NULL, __msg_bubble_view_detail_msg_clicked_cb, bubble_data);
1422         elm_list_go(list);
1423
1424         elm_object_part_text_set(popup,"title,text",title);
1425         elm_object_content_set(popup, list);
1426
1427         Evas_Object * btn1 = elm_button_add(popup);
1428         elm_object_style_set(btn1, "popup_button/default");
1429         elm_object_text_set(btn1, dgettext("sys_string", "IDS_COM_BODY_CLOSE"));
1430         elm_object_part_content_set(popup, "button1", btn1);
1431         bubble_data->popup = popup;
1432
1433         evas_object_show(popup);
1434
1435         evas_object_smart_callback_add(btn1, "clicked", __popup_close_clicked_cb, bubble_data);
1436
1437         D_LEAVE;
1438 }
1439
1440
1441 static void __set_msg_data_by_conv_data(PMSG_BUBBLE_DATA bubble_data, PMSG_APP_CONV_DATA_S conv_data, msg_struct_t msgInfo)
1442 {
1443         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, !conv_data || !msgInfo || !bubble_data);
1444
1445         char *msg_date = NULL;
1446
1447         msg_get_int_value(msgInfo, MSG_CONV_MSG_ID_INT, (int *)(&conv_data->msgId));
1448         msg_get_int_value(msgInfo, MSG_CONV_MSG_TYPE_INT, &conv_data->msgType);
1449         msg_get_int_value(msgInfo, MSG_CONV_MSG_STORAGE_ID_INT, (int *)(&conv_data->storageId));
1450
1451         if (conv_data->msgTime == NULL)
1452                 conv_data->msgTime = (time_t *) calloc(1, sizeof(time_t));
1453
1454         if (conv_data->msgTime) {
1455                 bzero(conv_data->msgTime,sizeof(time_t));
1456                 msg_get_int_value(msgInfo, MSG_CONV_MSG_DISPLAY_TIME_INT, (int *)conv_data->msgTime);
1457                 msg_date = msg_common_get_display_date(bubble_data->locale, bubble_data->date_ptn_default, bubble_data->date_ptn_year, conv_data->msgTime);
1458                 snprintf(conv_data->displayDate, sizeof(conv_data->displayDate), "%s", msg_date);
1459                 if (msg_date)
1460                         free(msg_date);
1461         }
1462
1463         msg_get_int_value(msgInfo, MSG_CONV_MSG_NETWORK_STATUS_INT, (int *)(&conv_data->networkStatus));
1464         msg_get_bool_value(msgInfo, MSG_CONV_MSG_READ_BOOL, &conv_data->bRead);
1465         msg_get_bool_value(msgInfo, MSG_CONV_MSG_PROTECTED_BOOL, &conv_data->bProtected);
1466         msg_get_int_value(msgInfo, MSG_CONV_MSG_DIRECTION_INT, &conv_data->direction);
1467
1468         bzero(conv_data->thumbNailPath, sizeof(conv_data->thumbNailPath));
1469         msg_get_str_value(msgInfo, MSG_CONV_MSG_IMAGE_THUMB_PATH_STR, conv_data->thumbNailPath, DEF_IMG_PATH_LEN);
1470
1471         if (conv_data->thumbNailPath[0] == '\0') {
1472                 msg_get_str_value(msgInfo, MSG_CONV_MSG_VIDEO_THUMB_PATH_STR, conv_data->thumbNailPath, DEF_IMG_PATH_LEN);
1473
1474                 if (conv_data->thumbNailPath[0] == '\0')
1475                         conv_data->thumbType = BUBBLE_THUMBNAIL_VIDEO;
1476                 else
1477                         conv_data->thumbType = BUBBLE_THUMBNAIL_NONE;
1478
1479         } else {
1480                 conv_data->thumbType = BUBBLE_THUMBNAIL_IMAGE;
1481         }
1482
1483         bzero(conv_data->audio_filename, sizeof(conv_data->audio_filename));
1484         msg_get_str_value(msgInfo, MSG_CONV_MSG_AUDIO_NAME_STR, conv_data->audio_filename, DEF_IMG_PATH_LEN);
1485
1486         bzero(conv_data->subject, sizeof(conv_data->subject));
1487         msg_get_str_value(msgInfo, MSG_CONV_MSG_SUBJECT_STR, conv_data->subject, DEF_BUF_LEN_S);
1488
1489         if (conv_data->msgType == MSG_TYPE_MMS) {
1490                 msg_get_str_value(msgInfo, MSG_CONV_MSG_TEXT_STR, conv_data->msgText, DEF_MAX_MSG_TEXT_LEN);            /** get body text */
1491                 msg_get_int_value(msgInfo, MSG_CONV_MSG_ATTACH_COUNT_INT, &conv_data->attachment_cnt);                  /** get attachment count */
1492                 if (conv_data->attachment_cnt == 1)
1493                         msg_get_str_value(msgInfo, MSG_CONV_MSG_ATTACH_NAME_STR, conv_data->attachment_filename, DEF_IMG_PATH_LEN);
1494         } else if (conv_data->msgType == MSG_TYPE_MMS_NOTI) {
1495                 bzero(conv_data->msgText, sizeof(conv_data->msgText));
1496         } else {
1497                 msg_get_str_value(msgInfo, MSG_CONV_MSG_TEXT_STR, conv_data->msgText, DEF_MAX_MSG_TEXT_LEN);
1498         }
1499 }
1500
1501 static int __calc_scroller_geometry(PMSG_BUBBLE_DATA bubble_data)
1502 {
1503         Evas_Coord sw, sh;
1504
1505         elm_scroller_child_size_get(bubble_data->scrl, &sw, &sh);
1506
1507         return sh;
1508 }
1509
1510 void __msg_resend_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1511 {
1512         D_ENTER;
1513
1514         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1515         PMSG_APP_CONV_DATA_S item_data = NULL;
1516
1517         if (bubble_data->popup) {
1518                 evas_object_del(bubble_data->popup);
1519                 bubble_data->popup = NULL;
1520         }
1521
1522         item_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1523
1524         msg_ui_bubble_resend_msg(bubble_data, item_data->msgId);
1525
1526         D_LEAVE;
1527 }
1528
1529 void __msg_install_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1530 {
1531         D_ENTER;
1532
1533         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1534         PMSG_APP_CONV_DATA_S item_data = NULL;
1535
1536         item_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1537
1538         __msg_install_clicked_cb(bubble_data, item_data->msgId);
1539
1540         D_LEAVE;
1541 }
1542
1543 void __msg_retrieve_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1544 {
1545         D_ENTER;
1546
1547         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1548         PMSG_APP_CONV_DATA_S item_data = NULL;
1549
1550         item_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1551
1552         __msg_retrieve_clicked_cb(bubble_data, item_data->msgId);
1553
1554         D_LEAVE;
1555 }
1556
1557 void __msg_more_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1558 {
1559         D_ENTER;
1560
1561         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data);
1562
1563         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1564         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, bubble_data->viewmode != BUBBLE_NORMAL_VIEW);
1565
1566
1567         PMSG_APP_CONV_DATA_S item_data = NULL;
1568         item_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1569
1570         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !item_data);
1571
1572         int BatteryStatus;
1573
1574         vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &BatteryStatus);
1575         D_MSG("Battery status = [%d]", BatteryStatus);
1576
1577         if (BatteryStatus == VCONFKEY_SYSMAN_BAT_POWER_OFF) {
1578                 int charger_status = -1;
1579                 vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &charger_status);
1580
1581                 if (!charger_status) {
1582                         msg_ui_bubble_show_notify(bubble_data, dgettext("sys_string", "IDS_COM_BODY_LOW_BATTERY"));
1583                         return;
1584                 }
1585         }
1586
1587         service_h svc_handle;
1588         char msgId[DEF_BUF_LEN_S] = {0,};
1589
1590         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1591                 D_EMSG("service_create() is failed !!");
1592         } else {
1593                 snprintf(msgId, DEF_BUF_LEN_S, "%d", item_data->msgId);
1594                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_MSG_ID, msgId);
1595                 msg_ui_composer_launch_viewer_create(bubble_data->callback_data, svc_handle);
1596                 service_destroy(svc_handle);
1597         }
1598 }
1599
1600 static void __msg_send_failed_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1601 {
1602         D_ENTER;
1603         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1604
1605         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1606         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, bubble_data->viewmode != BUBBLE_NORMAL_VIEW);
1607
1608         PMSG_APP_CONV_DATA_S conv_data = (PMSG_APP_CONV_DATA_S)evas_object_data_get(obj, "conv_data");
1609         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1610
1611         if (bubble_data->popup) {
1612                 evas_object_del(bubble_data->popup);
1613                 bubble_data->popup = NULL;
1614         }
1615
1616         Evas_Object *popup = elm_popup_add(cd->main_window);
1617         elm_object_style_set(popup, "min_menustyle");
1618         elm_object_part_text_set(popup, "title,text", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_SENDING_FAILED_MESSAGE"));
1619
1620         Evas_Object *btn_close = elm_button_add(popup);
1621         elm_object_style_set(btn_close, "popup_button/default");
1622         elm_object_text_set(btn_close, dgettext("sys_string", "IDS_COM_BODY_CLOSE"));
1623         elm_object_part_content_set(popup, "button1", btn_close);
1624         evas_object_smart_callback_add(btn_close, "clicked", msg_ui_popup_close_clicked_cb, bubble_data);
1625
1626         Evas_Object *list = elm_list_add(popup);
1627         elm_list_mode_set(list, ELM_LIST_EXPAND);
1628         evas_object_data_set(list, "conv_data", conv_data);
1629
1630         elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_SK_RESEND"), NULL, NULL, __msg_resend_btn_clicked_cb, (void *)bubble_data);
1631         elm_list_item_append(list, dgettext("sys_string", "IDS_COM_SK_DELETE"), NULL, NULL, __msg_delete_clicked_cb, (void *)bubble_data);
1632
1633         elm_list_go(list);
1634         elm_object_content_set(popup, list);
1635         evas_object_show(popup);
1636
1637         bubble_data->popup = popup;
1638 }
1639
1640 void msg_ui_bubble_fill_bubble_contents(PMSG_BUBBLE_DATA bubble_data, PMSG_APP_CONV_DATA_S item_data)
1641 {
1642         D_ENTER;
1643         MSG_UI_RET_IF(MSG_UI_LEVEL_ASSERT, !bubble_data || !item_data);
1644         char time_status_str[DEF_BUF_LEN + DEF_BUF_LEN_S + 1] = {0, };
1645         char *time_str = NULL;
1646
1647         __msg_bubble_add_content(bubble_data, item_data);
1648
1649         if (item_data->msgType == MSG_TYPE_MMS) {
1650                 Evas_Object *prev_obj = NULL;
1651                 Evas_Object *media_layout = elm_layout_add(item_data->entry);
1652
1653                 elm_layout_file_set(media_layout, MSGC_UI_DEFAULT_EDJ, MSGC_EDJ_GRP_BUBBLE_MEDIA_LAYOUT);
1654
1655                 prev_obj = elm_object_part_content_get(item_data->entry, "elm.swallow.end");
1656                 if (prev_obj) {
1657                         elm_object_part_content_unset(item_data->entry, "elm.swallow.end");
1658                         evas_object_del(prev_obj);
1659                 }
1660
1661                 if (item_data->networkStatus == MSG_NETWORK_SEND_SUCCESS || item_data->networkStatus == MSG_NETWORK_SEND_FAIL || item_data->networkStatus == MSG_NETWORK_RETRIEVE_SUCCESS) {
1662                         /** add more button */
1663                         Evas_Object *more_btn = elm_button_add(media_layout);
1664                         elm_object_style_set(more_btn, "reveal");
1665                         evas_object_data_set(more_btn, "conv_data", item_data);
1666                         evas_object_smart_callback_add(more_btn, "clicked", __msg_more_btn_clicked_cb, bubble_data);
1667
1668                         elm_object_part_content_set(media_layout, "bubble.swallow.more", more_btn);
1669                         evas_object_smart_calculate(media_layout);
1670
1671                         elm_object_part_text_set(media_layout, "msgtype_text", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_MMS"));
1672                         evas_object_show(more_btn);
1673                 }
1674
1675                 evas_object_show(media_layout);
1676                 elm_object_part_content_set(item_data->entry, "elm.swallow.end", media_layout);
1677                 elm_entry_calc_force(item_data->entry);
1678         } else if (item_data->msgType == MSG_TYPE_MMS_NOTI && item_data->networkStatus != MSG_NETWORK_RETRIEVE_SUCCESS && item_data->networkStatus != MSG_NETWORK_RETRIEVING) {
1679                 Evas_Object *prev_obj = NULL;
1680                 Evas_Object *retrieve_btn = NULL;
1681                 prev_obj = elm_object_part_content_get(item_data->entry, "elm.swallow.end");
1682                 if (prev_obj) {
1683                         elm_object_part_content_unset(item_data->entry, "elm.swallow.end");
1684                         evas_object_del(prev_obj);
1685                 }
1686
1687                 retrieve_btn = elm_button_add(item_data->entry);
1688                 elm_object_text_set(retrieve_btn, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_RETRIEVE"));
1689                 evas_object_data_set(retrieve_btn, "conv_data", item_data);
1690
1691                 evas_object_smart_callback_add(retrieve_btn, "clicked", __msg_retrieve_btn_clicked_cb, bubble_data);
1692
1693                 elm_object_part_content_set(item_data->entry, "elm.swallow.end", retrieve_btn);
1694         } else if (item_data->msgType == MSG_TYPE_SMS_SYNCML) {
1695                 Evas_Object *prev_obj = NULL;
1696                 Evas_Object *install_btn = NULL;
1697                 prev_obj = elm_object_part_content_get(item_data->entry, "elm.swallow.end");
1698                 if (prev_obj) {
1699                         elm_object_part_content_unset(item_data->entry, "elm.swallow.end");
1700                         evas_object_del(prev_obj);
1701                 }
1702
1703                 install_btn = elm_button_add(item_data->entry);
1704                 elm_object_text_set(install_btn, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_INSTALL"));
1705                 evas_object_data_set(install_btn, "conv_data", item_data);
1706
1707                 evas_object_smart_callback_add(install_btn, "clicked", __msg_install_btn_clicked_cb, bubble_data);
1708
1709                 elm_object_part_content_set(item_data->entry, "elm.swallow.end", install_btn);
1710         }
1711
1712         /** Network status (Sending, Retrieving); */
1713         switch (item_data->networkStatus) {
1714         case MSG_NETWORK_SEND_FAIL:
1715                 if (item_data->direction == MSG_DIRECTION_TYPE_MO) {
1716                         if (item_data->progressbar) {
1717                                 evas_object_del(item_data->progressbar);
1718                                 item_data->progressbar = NULL;
1719                         }
1720
1721                         item_data->failed_button = elm_button_add(item_data->entry);
1722                         elm_object_style_set(item_data->failed_button, "warning");
1723                         evas_object_show(item_data->failed_button);
1724                         elm_object_part_content_set(item_data->entry, "elm.swallow.icon1", item_data->failed_button);
1725
1726                         evas_object_data_set(item_data->failed_button, "conv_data", item_data);
1727                         evas_object_smart_callback_add(item_data->failed_button, "clicked", __msg_send_failed_btn_clicked_cb, bubble_data);
1728
1729                         elm_object_signal_emit(item_data->entry, "elm,state,text,status,disabled", "elm");
1730                         elm_object_signal_emit(item_data->entry, "elm,state,content,status,enabled", "elm");
1731                 } else {
1732                         strncpy(time_status_str, dgettext("sys_string", "IDS_COM_POP_FAILED"), sizeof(time_status_str)-1);
1733                 }
1734                 break;
1735         case MSG_NETWORK_RETRIEVE_FAIL:
1736                 /** elm.text.status */
1737                 strncpy(time_status_str, dgettext("sys_string", "IDS_COM_POP_FAILED"), sizeof(time_status_str)-1);
1738                 break;
1739         case MSG_NETWORK_SENDING:
1740         case MSG_NETWORK_RETRIEVING:
1741                 /** Add progress icon */
1742                 if (item_data->progressbar) {
1743                         evas_object_del(item_data->progressbar);
1744                         item_data->progressbar = NULL;
1745                 }
1746
1747                 item_data->progressbar = elm_progressbar_add(item_data->entry);
1748                 elm_object_style_set(item_data->progressbar, "list_process_small");
1749                 evas_object_show(item_data->progressbar);
1750                 elm_progressbar_pulse(item_data->progressbar, EINA_TRUE);
1751                 elm_object_part_content_set(item_data->entry, "elm.swallow.icon1", item_data->progressbar);
1752
1753                 elm_object_signal_emit(item_data->entry, "elm,state,text,status,disabled", "elm");
1754                 elm_object_signal_emit(item_data->entry, "elm,state,content,status,enabled", "elm");
1755                 break;
1756         default:
1757                 /** display time */
1758                 time_str = __msg_ui_get_display_time(item_data->msgTime, bubble_data);
1759                 if (time_str) {
1760                         strncpy(time_status_str, time_str, sizeof(time_status_str)-1);
1761                         free(time_str);
1762                 } else {
1763                         /** This "else" case is for avoiding NULL of the time_status_str */
1764                         /** if time_status_str is NULL, it could be shown progress icon although it's not sending or retrieving */
1765                         strncpy(time_status_str, item_data->displayDate, sizeof(time_status_str)-1);
1766                 }
1767                 break;
1768         }
1769
1770         if (time_status_str[0] != '\0') {
1771                 if (item_data->progressbar) {
1772                         evas_object_del(item_data->progressbar);
1773                         item_data->progressbar = NULL;
1774                 }
1775
1776                 elm_object_part_text_set(item_data->entry, "elm.text.time", time_status_str);
1777                 elm_object_signal_emit(item_data->entry, "elm,state,text,status,enabled", "elm");
1778                 elm_object_signal_emit(item_data->entry, "elm,state,content,status,disabled", "elm");
1779         }
1780
1781 }
1782
1783 Eina_Bool msg_ui_bubble_item_load_cb(void *data)
1784 {
1785         D_ENTER;
1786
1787         MSG_UI_RETV_IF(MSG_UI_LEVEL_DEBUG, !data, EINA_FALSE);
1788
1789         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA) data;
1790         PMSG_APP_CONV_DATA_S item_data = NULL;
1791         double scr_g;
1792
1793         bool cb_cancel = false;
1794
1795         evas_object_smart_callback_del(bubble_data->scrl, "edge,top", msg_ui_bubble_scroll_edge_top_cb);
1796
1797         if (bubble_data->added_count%(MSG_BUBBLE_BLOCK_COUNT+1) == MSG_BUBBLE_BLOCK_COUNT || bubble_data->bubble_index < 0) {
1798                 cb_cancel = true;
1799         } else {
1800                 if (bubble_data->bubble_list) {
1801                         item_data = (PMSG_APP_CONV_DATA_S) eina_list_nth(bubble_data->bubble_list, bubble_data->bubble_index);
1802                         if (item_data == NULL)
1803                                 cb_cancel = true;
1804
1805                 } else {
1806                         cb_cancel = true;
1807                 }
1808         }
1809
1810         if (cb_cancel == false) {
1811                 elm_scroller_gravity_get(bubble_data->scrl, NULL, &scr_g);
1812                 if(!scr_g)
1813                         elm_scroller_gravity_set(bubble_data->scrl, 0.0, 1.0);
1814
1815                 __add_bubble_item(bubble_data, item_data, MSG_BOX_PACK_START, NULL);
1816
1817                 /* add date seperator */
1818                 PMSG_APP_CONV_DATA_S prev_data = NULL;
1819                 Evas_Object * layout = NULL;
1820                 prev_data = (PMSG_APP_CONV_DATA_S) eina_list_nth(bubble_data->bubble_list, bubble_data->bubble_index - 1);
1821
1822                 if((!prev_data || g_strcmp0(prev_data->displayDate, item_data->displayDate) != 0)) {
1823                         layout = elm_layout_add(bubble_data->box);
1824                         elm_layout_file_set(layout, MSGC_UI_DEFAULT_EDJ, "composer/content/bubble/date_line");
1825                         elm_object_part_text_set(layout, "elm.text.date", item_data->displayDate);
1826                         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1827                         evas_object_size_hint_align_set(layout,EVAS_HINT_FILL,EVAS_HINT_FILL);
1828                         evas_object_show(layout);
1829
1830                         elm_box_pack_start(bubble_data->box, layout);
1831                 }
1832
1833                 bubble_data->realized_list = eina_list_append(bubble_data->realized_list, item_data);
1834
1835                 bubble_data->bubble_index--;
1836                 bubble_data->added_count++;
1837         } else {
1838                 elm_scroller_gravity_set(bubble_data->scrl, 0.0, 0.0);
1839                 evas_object_show(bubble_data->scrl);
1840                 if (g_isFirstLoading) {
1841                         Evas_Coord height = __calc_scroller_geometry(bubble_data);
1842                         if (height <= MSG_BUBBLE_CONTENT_H)
1843                                 elm_scroller_region_show(bubble_data->scrl, 0, 0, 0, 0);
1844                         else
1845                                 elm_scroller_region_show(bubble_data->scrl, 0, height, 0, 0);
1846
1847                         g_isFirstLoading = false;
1848                 }
1849
1850                 bubble_data->load_animator = NULL;
1851                 bubble_data->added_count = 0;
1852
1853                 return ECORE_CALLBACK_CANCEL;
1854         }
1855
1856         D_LEAVE;
1857
1858         return ECORE_CALLBACK_RENEW;
1859
1860 }
1861
1862 void msg_ui_bubble_list_load(PMSG_BUBBLE_DATA bubble_data)
1863 {
1864         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1865         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, !bubble_data);
1866
1867         msg_error_t err = MSG_SUCCESS;
1868         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1869         msg_struct_list_s conv_list;
1870         PMSG_APP_CONV_DATA_S item_data = NULL;
1871         int i;
1872
1873         err = msg_get_conversation_view_list(bubble_data->msgHandle, bubble_data->threadId, &conv_list);
1874         if (err != MSG_SUCCESS)
1875                 return;
1876
1877         msg_ui_bubble_start_bubble_list(bubble_data);
1878         g_isFirstLoading = true;
1879
1880         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Bubble count = %d", conv_list.nCount);
1881
1882         bubble_data->bubble_count = conv_list.nCount;
1883
1884         if (bubble_data->bubble_count <= 0) {
1885                 msg_release_list_struct(&conv_list);
1886                 return;
1887         }
1888
1889         int folder_id = MSG_MAX_FOLDER_ID;
1890         int msg_id = 0;
1891
1892         for (i = 0; i < conv_list.nCount; i++) {
1893                 msg_get_int_value(conv_list.msg_struct_info[i], MSG_CONV_MSG_FOLDER_ID_INT, &folder_id);
1894
1895                 if (folder_id == MSG_DRAFT_ID) {
1896                         msg_get_int_value(conv_list.msg_struct_info[i], MSG_CONV_MSG_ID_INT, &msg_id);
1897                         D_MSG("msg_id = %d is a draft message", msg_id);
1898
1899                         bubble_data->bubble_count--;
1900                         bubble_data->isDraft = true;
1901
1902                         continue;
1903                 }
1904
1905                 item_data = (PMSG_APP_CONV_DATA_S) calloc(1, sizeof(MSG_APP_CONV_DATA_S));
1906                 __set_msg_data_by_conv_data(bubble_data, item_data, conv_list.msg_struct_info[i]);
1907
1908                 bubble_data->bubble_list = eina_list_append(bubble_data->bubble_list, (const void *)item_data);
1909         }
1910
1911         /* load last draft message */
1912         if (bubble_data->isDraft) {
1913                 D_MSG("last draft msgid is %d", msg_id);
1914
1915                 cd->loading_draft = true;
1916
1917                 msg_ui_composer_message_init();
1918                 msg_ui_composer_message_load_message(cd->msg_handle, msg_id);
1919                 if (msg_ui_composer_message_set_loaded_data(cd, false) != COMPOSER_RETURN_CREATION_WARINING_MODE_FAIL)
1920                         msg_ui_composer_message_destroy();
1921
1922                 cd->loading_draft = false;
1923         }
1924
1925         if (item_data) {
1926                 bubble_data->msg_type = item_data->msgType;
1927                 if (bubble_data->msg_type == MSG_TYPE_SMS_WAPPUSH || bubble_data->msg_type == MSG_TYPE_SMS_CB || bubble_data->msg_type == MSG_TYPE_SMS_SYNCML)
1928                         msg_ui_composer_editable_set(cd, EINA_FALSE);
1929                 else
1930                         msg_ui_composer_editable_set(cd, EINA_TRUE);
1931         }
1932
1933         msg_release_list_struct(&conv_list);
1934
1935         bubble_data->bubble_index = bubble_data->bubble_count - 1; // bubble_index : Message index to append on box.
1936         bubble_data->load_animator = ecore_animator_add(msg_ui_bubble_item_load_cb, (const void *)bubble_data);
1937
1938         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1939
1940 }
1941
1942 void msg_ui_bubble_list_data_update(PMSG_BUBBLE_DATA bubble_data)
1943 {
1944         MSG_UI_ENTER();
1945
1946         PMSG_APP_CONV_DATA_S item_data = NULL;
1947
1948         Eina_List *l = NULL;
1949         EINA_LIST_FOREACH (bubble_data->bubble_list, l, item_data) {
1950                 if (item_data) {
1951                         msg_ui_bubble_fill_bubble_contents(bubble_data, item_data);
1952                 }
1953         }
1954
1955         MSG_UI_LEAVE();
1956 }
1957
1958 void msg_ui_bubble_item_data_update(PMSG_BUBBLE_DATA bubble_data, msg_struct_t msg)
1959 {
1960         MSG_UI_ENTER();
1961
1962         PMSG_APP_CONV_DATA_S item_data = NULL;
1963
1964         int msg_id = 0 ;
1965         time_t msgTime = 0;
1966         msg_get_int_value(msg, MSG_CONV_MSG_ID_INT, &msg_id);
1967         msg_get_int_value(msg, MSG_CONV_MSG_DISPLAY_TIME_INT, (int *)(&msgTime));
1968
1969         Eina_List *l = NULL;
1970         EINA_LIST_FOREACH (bubble_data->bubble_list, l, item_data) {
1971                 if (item_data) {
1972                         if (item_data->msgId == msg_id) {
1973                                 if (bubble_data->ug_state != BUBBLE_UG_PAUSE)
1974                                         msg_update_read_status(bubble_data->msgHandle, msg_id, true);
1975
1976                                 if ( *item_data->msgTime != msgTime ){
1977                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "item_data->msgTime = %d and msgTime = %d", *item_data->msgTime, msgTime);
1978                                         msg_ui_bubble_list_item_move(bubble_data, msg);
1979                                 } else {
1980                                         __set_msg_data_by_conv_data(bubble_data, item_data, msg);
1981                                         msg_ui_bubble_fill_bubble_contents(bubble_data, item_data);
1982                                 }
1983                                 break;
1984                         }
1985                 }
1986         }
1987
1988         MSG_UI_LEAVE();
1989 }
1990
1991 Eina_Bool msg_ui_bubble_item_add_cb(void *data)
1992 {
1993         D_ENTER;
1994         MSG_UI_RETV_IF(MSG_UI_LEVEL_DEBUG, !data, EINA_FALSE);
1995
1996         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1997         BUBBLE_PACK_INFO *pack_info = NULL;
1998
1999         bool cb_cancel = false;
2000
2001         if (bubble_data->added_list) {
2002                 pack_info = (BUBBLE_PACK_INFO *) eina_list_nth(bubble_data->added_list, 0);
2003                 if (pack_info == NULL) {
2004                         cb_cancel = true;
2005                 } else {
2006                         if (bubble_data->ug_state != BUBBLE_UG_PAUSE && bubble_data->ug_state != BUBBLE_UG_DESTROY)
2007                                 msg_update_read_status(bubble_data->msgHandle, pack_info->add_item->msgId, true);
2008                 }
2009
2010         } else {
2011                 cb_cancel = true;
2012         }
2013
2014         if (cb_cancel == true) {
2015                 elm_scroller_gravity_set(bubble_data->scrl, 0.0, 0.0);
2016                 elm_scroller_region_show(bubble_data->scrl, 0, __calc_scroller_geometry(bubble_data), 0, 0);
2017
2018                 bubble_data->add_animator = NULL;
2019
2020                 return ECORE_CALLBACK_CANCEL;
2021         }
2022
2023         elm_scroller_gravity_set(bubble_data->scrl, 0.0, 1.0);
2024
2025         if (pack_info) {
2026                 __add_bubble_item(bubble_data, pack_info->add_item, pack_info->pack_type, pack_info->rel_obj);
2027
2028                 bubble_data->realized_list = eina_list_append(bubble_data->realized_list, pack_info->add_item);
2029
2030                 bubble_data->added_list = eina_list_remove(bubble_data->added_list, pack_info);
2031
2032                 bubble_data->bubble_count++;
2033
2034                 free(pack_info);
2035         }
2036
2037         return ECORE_CALLBACK_RENEW;
2038
2039 }
2040
2041 void msg_ui_bubble_list_update_read_status(PMSG_BUBBLE_DATA bubble_data)
2042 {
2043         MSG_UI_ENTER();
2044         PMSG_APP_CONV_DATA_S item_data = NULL;
2045
2046         Eina_List *l = NULL;
2047         EINA_LIST_FOREACH (bubble_data->bubble_list, l, item_data) {
2048                 if (item_data) {
2049                         if (!item_data->bRead)
2050                                 msg_update_read_status(bubble_data->msgHandle, item_data->msgId, true);
2051                 }
2052         }
2053
2054         MSG_UI_LEAVE();
2055 }
2056
2057 void msg_ui_bubble_list_append(PMSG_BUBBLE_DATA bubble_data, msg_struct_t msg)
2058 {
2059         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, !bubble_data);
2060
2061         int msg_id = 0;
2062         int folder_id = 0;
2063         Eina_List *l = NULL;
2064         PMSG_APP_CONV_DATA_S item_data = NULL;
2065
2066         msg_get_int_value(msg, MSG_CONV_MSG_ID_INT, &msg_id);
2067         msg_get_int_value(msg, MSG_CONV_MSG_FOLDER_ID_INT, &folder_id);
2068
2069         if (folder_id == MSG_DRAFT_ID)
2070                 return;
2071
2072         EINA_LIST_FOREACH(bubble_data->bubble_list, l, item_data) {
2073                 if (item_data && item_data->msgId == msg_id)
2074                         return;
2075         }
2076
2077         PMSG_APP_CONV_DATA_S conv_data = NULL;
2078         conv_data = (PMSG_APP_CONV_DATA_S) calloc(1, sizeof(MSG_APP_CONV_DATA_S));
2079         __set_msg_data_by_conv_data(bubble_data, conv_data, msg);
2080
2081         BUBBLE_PACK_INFO *pack_info = (BUBBLE_PACK_INFO *)calloc(1, sizeof(BUBBLE_PACK_INFO));
2082         pack_info->add_item = conv_data;
2083         pack_info->rel_obj = NULL;
2084         pack_info->pack_type = MSG_BOX_PACK_END;
2085
2086         bubble_data->added_list = eina_list_append(bubble_data->added_list, (const void *)pack_info);
2087         bubble_data->bubble_list = eina_list_append(bubble_data->bubble_list, (const void *)conv_data);
2088
2089         if (bubble_data->viewmode == BUBBLE_EDIT_VIEW)
2090                 return;
2091
2092         if (bubble_data->add_animator)
2093                 return;
2094
2095         bubble_data->add_animator = ecore_animator_add(msg_ui_bubble_item_add_cb, (const void *) bubble_data);
2096
2097         D_LEAVE;
2098 }
2099
2100 void msg_ui_bubble_list_item_move(PMSG_BUBBLE_DATA bubble_data, msg_struct_t msg)
2101 {
2102         MSG_UI_ENTER();
2103
2104         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, !bubble_data);
2105
2106         int msg_id = 0;
2107         PMSG_APP_CONV_DATA_S prev_data = NULL;
2108         PMSG_APP_CONV_DATA_S insert_data = NULL;
2109         BUBBLE_PACK_INFO *add_pack_info = NULL;
2110
2111         msg_get_int_value(msg, MSG_CONV_MSG_ID_INT, &msg_id);
2112
2113         Eina_List *l;
2114         EINA_LIST_FOREACH(bubble_data->added_list, l, add_pack_info) {
2115                 if (add_pack_info) {
2116                         if (add_pack_info->add_item->msgId == msg_id) {
2117                                 bubble_data->added_list = eina_list_remove(bubble_data->added_list, (const void *)add_pack_info);
2118                                 free(add_pack_info);
2119                                 break;
2120                         }
2121                 }
2122         }
2123
2124         EINA_LIST_FOREACH(bubble_data->bubble_list, l, prev_data) {
2125                 if (prev_data) {
2126                         if (prev_data->msgId == msg_id) {
2127                                 if (eina_list_data_find(bubble_data->realized_list, (const void *)prev_data)) {
2128                                         elm_box_unpack(bubble_data->box, prev_data->ly);
2129                                         evas_object_hide(prev_data->ly);
2130                                         evas_object_del(prev_data->ly);
2131
2132                                         bubble_data->realized_list = eina_list_remove(bubble_data->realized_list, (const void *)prev_data);
2133                                 }
2134
2135                                 bubble_data->bubble_list = eina_list_remove(bubble_data->bubble_list, (const void *)prev_data);
2136
2137                                 bubble_data->bubble_count--;
2138
2139                                 if (prev_data) {
2140                                         if (prev_data->msgTime)
2141                                                 free(prev_data->msgTime);
2142
2143                                         free(prev_data);
2144                                 }
2145                                 break;
2146                         }
2147                 }
2148         }
2149
2150         insert_data = (PMSG_APP_CONV_DATA_S) calloc(1, sizeof(MSG_APP_CONV_DATA_S));
2151         __set_msg_data_by_conv_data(bubble_data, insert_data, msg);
2152
2153         BUBBLE_PACK_INFO *pack_info = (BUBBLE_PACK_INFO *)calloc(1, sizeof(BUBBLE_PACK_INFO));
2154         pack_info->add_item = insert_data;
2155         pack_info->rel_obj = NULL;
2156         pack_info->pack_type = MSG_BOX_PACK_END;
2157
2158         bubble_data->bubble_list = eina_list_append(bubble_data->bubble_list, (const void *)insert_data);
2159         bubble_data->added_list = eina_list_append(bubble_data->added_list, (const void *)pack_info);
2160
2161
2162         if (bubble_data->viewmode == BUBBLE_EDIT_VIEW || bubble_data->ug_state == BUBBLE_UG_PAUSE)
2163                 return;
2164
2165         if (bubble_data->add_animator)
2166                 return;
2167
2168         bubble_data->add_animator = ecore_animator_add(msg_ui_bubble_item_add_cb, (const void *) bubble_data);
2169
2170         MSG_UI_LEAVE();
2171 }
2172
2173 void msg_ui_bubble_delete_msg(PMSG_BUBBLE_DATA bubble_data, int msg_id)
2174 {
2175         D_ENTER;
2176         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
2177         int err;
2178
2179         if (bubble_data->popup) {
2180                 evas_object_del(bubble_data->popup);
2181                 bubble_data->popup = NULL;
2182         }
2183
2184         bool isDraft = msg_ui_composer_common_is_send_possible((MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data);
2185
2186         if (bubble_data->bubble_count == 1 && isDraft == false) {
2187                 bubble_data->bubble_count = 0;
2188                 err = msg_delete_thread_message_list(bubble_data->msgHandle, bubble_data->threadId, false);
2189         } else {
2190                 err = msg_delete_message(bubble_data->msgHandle, msg_id);
2191                 msg_ui_bubble_list_load(bubble_data);
2192         }
2193
2194         if (err != MSG_SUCCESS) {
2195                 msg_ui_bubble_show_notify(bubble_data, dgettext("sys_string", "IDS_COM_POP_UNABLE_TO_DELETE"));
2196         } else {
2197                 msg_ui_bubble_show_deleted_info(bubble_data);
2198         }
2199
2200         return;
2201 }
2202
2203 void msg_ui_bubble_refresh_msg_lock_status(PMSG_BUBBLE_DATA bubble_data, int msg_id)
2204 {
2205         D_ENTER;
2206         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
2207         PMSG_APP_CONV_DATA_S conv_data = NULL;
2208         Eina_List *l;
2209         bool is_found = false;
2210
2211         EINA_LIST_FOREACH(bubble_data->bubble_list, l, conv_data) {
2212                 if (conv_data) {
2213                         if (msg_id == conv_data->msgId) {
2214                                 conv_data->bProtected = !conv_data->bProtected;
2215                                 msg_ui_bubble_fill_bubble_contents(bubble_data, conv_data);
2216                                 is_found = !is_found;
2217                                 break;
2218                         }
2219                 }
2220         }
2221
2222         if (!is_found)
2223                 D_MSG("given msg_id(%d) is not found within current bubble data", msg_id);
2224
2225         return;
2226 }
2227