composer/src/bubble/msg-ui-composer-bubble-callback.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 "msg-ui-composer-data.h"
  19 #include "msg-ui-composer-main.h"
  20 #include "msg-ui-composer-recipient.h"
  21 #include "msg-ui-composer-external.h"
  22 #include "msg-ui-composer-common.h"
  23 #include <fcntl.h>
  24
  25 #define BUBBLE_TITLE_MENU_GENLIST_MAX_LINE 4
  26 #define BUBBLE_TITLE_MENU_GENLIST_1LINE_HEIGHT 112
  27 #define BUBBLE_TITLE_MENU_GENLIST_2LINE_HEIGHT 129
  28 #define BUBBLE_RETURN_DELETE_CANCEL 1000
  29
  30 Elm_Genlist_Item_Class itc_popup = {0,};        /** itc for list style popup */
  31
  32 Evas_Coord g_mouse_down_x = 0, g_mouse_down_y = 0;
  33
  34 static void _bubble_show_normal_mode(void *data)
  35 {
  36         D_ENTER;
  37
  38         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data);
  39
  40         MSG_COMPOSER_VIEW_DATA_S *cd = data;
  41         PMSG_BUBBLE_DATA pData = cd->bubble_data;
  42         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
  43
  44         elm_object_part_content_unset(pData->parent_layout, "swl.sel_all");
  45         evas_object_hide(pData->sel_all_ly);
  46
  47         Eina_List *l = NULL;
  48         PMSG_APP_CONV_DATA_S item_data = NULL;
  49
  50         if (pData->select_info) {
  51                 evas_object_del(pData->select_info);
  52                 pData->select_info = NULL;
  53         }
  54
  55         elm_check_state_set(pData->sel_all_box, EINA_FALSE);
  56
  57         l = NULL;
  58         item_data = NULL;
  59         EINA_LIST_FOREACH(pData->realized_list, l, item_data) {
  60                 if (item_data) {
  61                         evas_object_hide(item_data->chk);
  62                         if (item_data->isCheck)
  63                                 elm_check_state_set(item_data->chk, EINA_FALSE);
  64                         elm_object_signal_emit(item_data->ly, "elm,state,select,disable", "elm");
  65                         evas_object_event_callback_del(item_data->ly, EVAS_CALLBACK_MOUSE_DOWN, msg_ui_bubble_item_mouse_down_cb);
  66                 }
  67         }
  68
  69         l = NULL;
  70         item_data = NULL;
  71         EINA_LIST_FOREACH(pData->bubble_list, l, item_data) {
  72                 if (item_data) {
  73                         item_data->isCheck = false;
  74                 }
  75         }
  76
  77         pData->chk_list = eina_list_free(pData->chk_list);
  78
  79         msg_ui_bubble_change_normal_navi_control(pData);
  80
  81         pData->viewmode = BUBBLE_NORMAL_VIEW;
  82
  83         D_LEAVE;
  84 }
  85
  86 static void _bubble_add_edit_controlbar(PMSG_BUBBLE_DATA pData)
  87 {
  88         D_ENTER;
  89
  90         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)pData->callback_data;
  91
  92         elm_object_item_part_content_unset(cd->navi_it, "toolbar_button1");
  93         elm_object_item_part_content_unset(cd->navi_it, "toolbar_button2");
  94         elm_object_item_part_content_unset(cd->navi_it, "toolbar_more_btn");
  95
  96         Evas_Object *del_btn = elm_button_add(cd->navi_bar);
  97         elm_object_style_set(del_btn, "naviframe/toolbar/left");
  98         elm_object_text_set(del_btn, dgettext("sys_string", "IDS_COM_SK_DELETE"));
  99         evas_object_smart_callback_add(del_btn, "clicked", msg_ui_bubble_ctlbar_delete_cb, pData->callback_data);
 100         elm_object_item_part_content_set(cd->navi_it, "toolbar_button1", del_btn);
 101         elm_object_disabled_set(del_btn, EINA_TRUE);
 102
 103         Evas_Object *cancel_btn = elm_button_add(cd->navi_bar);
 104         elm_object_style_set(cancel_btn, "naviframe/toolbar/right");
 105         elm_object_text_set(cancel_btn, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
 106         evas_object_smart_callback_add(cancel_btn, "clicked", msg_ui_bubble_ctlbar_cancel_cb, pData->callback_data);
 107         elm_object_item_part_content_set(cd->navi_it, "toolbar_button2", cancel_btn);
 108
 109         D_LEAVE;
 110 }
 111
 112 static void _bubble_change_edit_mode_title(PMSG_BUBBLE_DATA pData)
 113 {
 114         D_ENTER;
 115
 116         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
 117
 118         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)pData->callback_data;
 119
 120         Evas_Object *content = elm_object_part_content_get(cd->navi_title_layout, "title_btn");
 121
 122         if (content)
 123                 evas_object_hide(content);
 124
 125         elm_object_part_content_unset(cd->navi_title_layout, "title_btn");
 126         elm_object_part_text_set(cd->navi_title_layout, "title_text", dgettext("sys_string", "IDS_COM_SK_DELETE"));
 127         D_LEAVE;
 128 }
 129
 130 static void _sel_all_ly_mouse_down_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 131 {
 132         MSG_UI_ENTER();
 133
 134         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA) data;
 135
 136         pData->sel_all_checked = !pData->sel_all_checked;
 137         elm_check_state_pointer_set(pData->sel_all_box, &pData->sel_all_checked);
 138
 139         msg_ui_bubble_sel_all_clicked_cb(data, NULL, NULL);
 140
 141         MSG_UI_LEAVE();
 142 }
 143
 144 static void _bubble_add_navi_select_all_ly(PMSG_BUBBLE_DATA pData)
 145 {
 146         if (!pData->sel_all_ly) {
 147                 pData->sel_all_ly = elm_layout_add(pData->bubble_layout);
 148                 elm_layout_theme_set(pData->sel_all_ly, "genlist", "item", "select_all/default");
 149                 evas_object_size_hint_weight_set(pData->sel_all_ly, EVAS_HINT_EXPAND, EVAS_HINT_FILL);
 150                 evas_object_size_hint_align_set(pData->sel_all_ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
 151                 evas_object_event_callback_add(pData->sel_all_ly, EVAS_CALLBACK_MOUSE_DOWN, _sel_all_ly_mouse_down_cb, pData);
 152
 153                 pData->sel_all_box = elm_check_add(pData->sel_all_ly);
 154                 elm_check_state_pointer_set(pData->sel_all_box, &pData->sel_all_checked);
 155                 evas_object_propagate_events_set(pData->sel_all_box, EINA_FALSE);
 156                 evas_object_smart_callback_add(pData->sel_all_box, "changed", msg_ui_bubble_sel_all_clicked_cb, pData);
 157                 evas_object_show(pData->sel_all_box);
 158
 159                 elm_object_part_content_set(pData->sel_all_ly, "elm.icon", pData->sel_all_box);
 160                 elm_object_part_text_set(pData->sel_all_ly, "elm.text", dgettext("sys_string", "IDS_COM_BODY_SELECT_ALL"));
 161         }
 162
 163         evas_object_show(pData->sel_all_ly);
 164         elm_object_part_content_set(pData->parent_layout, "swl.sel_all", pData->sel_all_ly);
 165 }
 166
 167 static void _progress_popup_delete(PMSG_BUBBLE_DATA pData)
 168 {
 169         if (pData->popup) {
 170                 evas_object_del(pData->popup);
 171                 pData->popup = NULL;
 172         }
 173
 174         if (pData->select_info) {
 175                 evas_object_del(pData->select_info);
 176                 pData->select_info = NULL;
 177         }
 178 }
 179
 180 static void _delete_finish(PMSG_BUBBLE_DATA pData)
 181 {
 182         if (pData->popup)
 183                 _progress_popup_delete(pData);
 184
 185         if (pData->del_index + 1 == pData->bubble_count) {
 186                 pData->bubble_count = 0;
 187         }
 188
 189         _bubble_show_normal_mode(pData->callback_data);
 190         msg_ui_bubble_list_load(pData);
 191
 192         pData->del_thread = NULL;
 193 }
 194
 195 static void _del_thread_feedback_fn(void *data, Ecore_Thread *thread, void *msg_data)
 196 {
 197         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !thread || !data || !msg_data);
 198
 199         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
 200         char buf[DEF_BUF_LEN_S] = {0,};
 201         int *ret = msg_data;
 202
 203         D_MSG("Delete message return value =[%d]", *ret);
 204         if (*ret == MSG_SUCCESS) {
 205                 if (pData->progressbar) {
 206                         snprintf(buf, sizeof(buf), "%d/%d %s", pData->del_index + 1, pData->check_cnt, dgettext("sys_string", "IDS_COM_POP_DELETED"));
 207                         elm_object_text_set(pData->progresslabel, buf);
 208                         elm_progressbar_value_set(pData->progressbar, (double) (pData->del_index + 1) / pData->check_cnt);
 209                 }
 210         } else if (*ret == BUBBLE_RETURN_DELETE_CANCEL) {
 211                 if (pData->del_cancel == true) {
 212                         _delete_finish(pData);
 213
 214                         if (ret)
 215                                 free(ret);
 216                         pData->del_cancel = false;
 217                         return;
 218                 }
 219         } else {
 220                 if (pData->popup)
 221                         _progress_popup_delete(pData);
 222
 223                 msg_ui_bubble_show_notify(pData, dgettext("sys_string", "IDS_COM_POP_UNABLE_TO_DELETE"));
 224
 225                 _bubble_show_normal_mode(pData->callback_data);
 226                 msg_ui_bubble_list_load(pData);
 227
 228                 pData->del_thread = NULL;
 229
 230                 if (ret)
 231                         free(ret);
 232                 return;
 233         }
 234
 235         if (pData->del_index + 1 == pData->check_cnt) {
 236                 msg_ui_bubble_show_deleted_info(pData);
 237                 _delete_finish(pData);
 238         } else {
 239                 pData->del_index++;
 240         }
 241
 242         if (ret)
 243                 free(ret);
 244 }
 245
 246 static void _del_thread_fn(void *data, Ecore_Thread *thread)
 247 {
 248         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data);
 249
 250         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
 251
 252         Eina_List *l;
 253         PMSG_APP_CONV_DATA_S item_data = NULL;
 254         EINA_LIST_FOREACH(pData->chk_list, l, item_data) {
 255                 int *ret = calloc(1, sizeof(int));
 256
 257                 if (pData->del_cancel == true) {
 258                         *ret = BUBBLE_RETURN_DELETE_CANCEL;
 259                         ecore_thread_feedback(thread, (void *)ret);
 260                         return;
 261                 }
 262
 263                 if (item_data) {
 264                         D_MSG("del_msg_id = [%d]", item_data->msgId);
 265                         *ret = msg_delete_message(pData->msgHandle, item_data->msgId);
 266
 267                         ecore_thread_feedback(thread, (void *)ret);
 268
 269                         if (*ret != MSG_SUCCESS)
 270                                 return;
 271                 } else {
 272                         *ret = MSG_ERR_NULL_POINTER;
 273                         ecore_thread_feedback(thread, (void *)ret);
 274                         return;
 275                 }
 276         }
 277
 278 }
 279
 280 static void _del_all_item(PMSG_BUBBLE_DATA pData)
 281 {
 282         D_ENTER;
 283
 284         msg_error_t err = MSG_SUCCESS;
 285
 286         err = msg_delete_thread_message_list(pData->msgHandle, pData->threadId, false);
 287
 288         if (err == MSG_SUCCESS) {
 289                 pData->bubble_count = 0;
 290                 msg_ui_bubble_show_deleted_info(pData);
 291         } else {
 292                 msg_ui_bubble_show_notify(pData, dgettext("sys_string", "IDS_COM_POP_UNABLE_TO_DELETE"));
 293
 294                 _bubble_show_normal_mode(pData->callback_data);
 295                 msg_ui_bubble_list_load(pData);
 296         }
 297
 298         D_LEAVE;
 299 }
 300
 301 void msg_ui_bubble_change_normal_navi_control(PMSG_BUBBLE_DATA pData)
 302 {
 303         if (!pData)
 304                         return;
 305
 306         MSG_COMPOSER_VIEW_DATA_S *cd = pData->callback_data;
 307
 308         Evas_Object *btn1 = elm_object_item_part_content_unset(cd->navi_it, "toolbar_button1");
 309         Evas_Object *btn2 = elm_object_item_part_content_unset(cd->navi_it, "toolbar_button2");
 310
 311         if (btn1)
 312                 evas_object_del(btn1);
 313
 314         if (btn2)
 315                 evas_object_del(btn2);
 316
 317         if (cd->back_btn) {
 318                 evas_object_show(cd->back_btn);
 319                 elm_object_part_content_set(cd->navi_title_layout, "prev_btn", cd->back_btn);
 320         }
 321
 322         if (cd->more_btn) {
 323                 evas_object_show(cd->more_btn);
 324                 elm_object_part_content_set(cd->navi_title_layout, "more_btn", cd->more_btn);
 325         }
 326
 327         if (cd->compose_btn && pData->isRotate == true) {
 328                 evas_object_show(cd->compose_btn);
 329                 elm_object_part_content_set(cd->navi_title_layout, "compose_btn", cd->compose_btn);
 330         }
 331
 332         /* change title */
 333         msg_ui_composer_navi_title_set(cd);
 334
 335         if (pData->msg_type == MSG_TYPE_SMS_WAPPUSH || pData->msg_type == MSG_TYPE_SMS_CB || pData->msg_type == MSG_TYPE_SMS_SYNCML)
 336                 msg_ui_composer_editable_set(cd, EINA_FALSE);
 337         else
 338                 msg_ui_composer_editable_set(cd, EINA_TRUE);
 339 }
 340
 341 void msg_ui_popup_close_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 342 {
 343         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 344
 345         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
 346
 347         if (pData->popup) {
 348                 evas_object_del(pData->popup);
 349                 pData->popup = NULL;
 350         }
 351 }
 352
 353 static void __msg_ui_bubble_unblock(PMSG_BUBBLE_DATA pData, char *addr)
 354 {
 355         D_ENTER;
 356         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData || !addr);
 357
 358         msg_error_t err = msg_common_delete_block_number(pData->msgHandle, addr);
 359
 360         if (err == MSG_SUCCESS) {
 361                 char msg[DEF_BUF_LEN] = {0,};
 362                 const char *str = dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_PS_UNBLOCKED");
 363                 snprintf(msg, sizeof(msg), str, addr);
 364                 msg_ui_bubble_show_notify(pData, msg);
 365         } else {
 366                 D_EMSG("Unblock failed %d", err);
 367         }
 368 }
 369
 370 static void __msg_ui_bubble_block(PMSG_BUBBLE_DATA pData, char *addr)
 371 {
 372         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData || !addr);
 373
 374         msg_error_t err = msg_common_add_block_number(pData->msgHandle, addr);
 375
 376         if (err == MSG_SUCCESS) {
 377                 char msg[DEF_BUF_LEN] = {0,};
 378                 const char *str = dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_PS_BLOCKED");
 379                 snprintf(msg, sizeof(msg), str, addr);
 380                 msg_ui_bubble_show_notify(pData, msg);
 381         } else if (err == MSG_ERR_FILTER_DUPLICATED){
 382                 msg_ui_bubble_show_notify(pData, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_BLOCKNUMBERDUPLICATED"));
 383         } else {
 384                 D_EMSG("block failed %d", err);
 385         }
 386 }
 387
 388
 389 void __msg_block_ok_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 390 {
 391         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
 392
 393         if (pData->popup) {
 394                 evas_object_del(pData->popup);
 395                 pData->popup = NULL;
 396         }
 397
 398         char* addr = (char *)evas_object_data_get(obj, "address");
 399         __msg_ui_bubble_block(pData, addr);
 400 }
 401
 402 static void __msg_ui_bubble_create_block_popup(PMSG_BUBBLE_DATA pData, char *addr)
 403 {
 404         D_ENTER;
 405         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData || !addr);
 406
 407         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)pData->callback_data;
 408         char title[DEF_BUF_LEN] = {0,};
 409
 410         if (pData->popup) {
 411                 evas_object_del(pData->popup);
 412                 pData->popup = NULL;
 413         }
 414
 415         Evas_Object *popup = elm_popup_add(cd->main_window);
 416         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 417         const char *str =  dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_BLOCK_PS_Q");
 418         snprintf(title, sizeof(title), str, addr);
 419         elm_object_text_set(popup, title);
 420
 421         Evas_Object *btn_ok = elm_button_add(popup);
 422         elm_object_style_set(btn_ok, "popup_button/default");
 423         evas_object_data_set(btn_ok, "address", addr);
 424         elm_object_text_set(btn_ok, dgettext("sys_string", "IDS_COM_SK_OK"));
 425         elm_object_part_content_set(popup, "button1", btn_ok);
 426         evas_object_smart_callback_add(btn_ok, "clicked", __msg_block_ok_clicked_cb, pData);
 427
 428         Evas_Object *btn_cancel = elm_button_add(popup);
 429         elm_object_style_set(btn_cancel, "popup_button/default");
 430         elm_object_text_set(btn_cancel, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
 431         elm_object_part_content_set(popup, "button2", btn_cancel);
 432         evas_object_smart_callback_add(btn_cancel, "clicked", msg_ui_popup_close_clicked_cb, pData);
 433
 434         evas_object_show(popup);
 435         pData->popup = popup;
 436 }
 437
 438 static void __msg_ui_bubble_list_popup_selected_cb(void *data, Evas_Object *obj, void *event_info)
 439 {
 440         D_ENTER;
 441
 442         BUBBLE_ADDRESS_INFO *addr_info = (BUBBLE_ADDRESS_INFO *)data;
 443         PMSG_BUBBLE_DATA bubble_data = evas_object_data_get(obj, "bubble_data");
 444
 445         if (!bubble_data) {
 446                 D_EMSG("[ERROR] bubble_data is NULL");
 447                 return;
 448         }
 449
 450         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S  *)bubble_data->callback_data;
 451
 452         if (!cd) {
 453                 D_EMSG("[ERROR] composer data is NULL");
 454                 return;
 455         }
 456
 457         if (bubble_data->popup) {
 458                 evas_object_del(bubble_data->popup);
 459                 bubble_data->popup = NULL;
 460         }
 461
 462         const char *label = elm_object_item_text_get((Elm_Object_Item *) event_info);
 463
 464         if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_CALL")) == 0) {
 465                 msg_ui_bubble_launch_voice_call(addr_info->address);
 466         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_VIDEO_CALL")) == 0) {
 467                 msg_ui_bubble_launch_video_call(addr_info->address);
 468         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_OPT_ADD_TO_CONTACTS")) == 0) { /* Add to contact with phone number string... */
 469                 msg_ui_composer_launch_contact_list_ug(cd, MSG_CT_UG_REQUEST_UPDATE_WITH_NUM, addr_info->address);
 470         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_OPT_VIEW_CONTACT")) == 0) {
 471                 msg_ui_composer_launch_contact_detail_ug(cd, addr_info->contact_id);
 472         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SEND_EMAIL")) == 0) {
 473                 service_h svc_handle;
 474                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 475                         D_EMSG("service_create() is failed !!");
 476                 } else {
 477                         service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_RUN_TYPE, MSG_BUNDLE_VALUE_EMAIL_COMPOSE);
 478                         service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_TO, addr_info->address);
 479
 480                         msg_ui_composer_launch_email_create(cd, svc_handle);
 481                         if (!cd->loaded_ug)
 482                                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_UNABLE_TO_OPEN"));
 483
 484                         service_destroy(svc_handle);
 485                 }
 486         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_SK3_BLOCK")) == 0) {
 487                 __msg_ui_bubble_create_block_popup(bubble_data, addr_info->address);
 488         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_UNBLOCK")) == 0) {
 489                 __msg_ui_bubble_unblock(bubble_data, addr_info->address);
 490         }
 491
 492         D_LEAVE;
 493 }
 494
 495 static char *__msg_ui_bubble_gl_text_get(void *data, Evas_Object *obj, const char *part)
 496 {
 497         PMSG_BUBBLE_DATA bubble_data = evas_object_data_get(obj, "bubble_data");
 498         BUBBLE_ADDRESS_INFO *addr_info = (BUBBLE_ADDRESS_INFO *)data;
 499         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !bubble_data || !addr_info, NULL);
 500
 501         if (g_strcmp0(part, "elm.text") == 0) {
 502                 return strdup((char *)data);
 503         } else if (g_strcmp0(part, "elm.text.1") == 0) {
 504                 if (addr_info->contact_id > 0 && addr_info->name[0] != '\0')
 505                         return strdup(addr_info->name);
 506                 else if (addr_info->address[0] != '\0')
 507                         return strdup (addr_info->address);
 508                 else
 509                         return strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
 510         } else if (g_strcmp0(part, "elm.text.2") == 0) {
 511                 if (addr_info->address[0] != '\0')
 512                         return strdup(addr_info->address);
 513                 else
 514                         return strdup(dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
 515         }
 516
 517         return NULL;
 518 }
 519
 520 static Evas_Object * __msg_ui_bubble_gl_content_get(void *data, Evas_Object *obj, const char *part)
 521 {
 522         // Currently, this function do nothing, caller_id concept is not determined
 523         // TODO: add callerId
 524         return NULL;
 525 }
 526
 527 static void __msg_ui_bubble_gl_sel(void *data, Evas_Object *obj, void *event_info)
 528 {
 529         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 530         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 531         Elm_Object_Item *item = NULL;
 532         BUBBLE_ADDRESS_INFO *addr_info = NULL;
 533
 534         Evas_Object *popup = NULL;
 535         Evas_Object *list = NULL;
 536         Evas_Object *btn_close = NULL;
 537         unsigned char num_type;
 538
 539         item = (Elm_Object_Item *) event_info;
 540         MSG_UI_RETM_IF(MSG_UI_LEVEL_ERR, !item, "Item is  NULL or Item is not Message item\n");
 541
 542         addr_info = (BUBBLE_ADDRESS_INFO *) elm_object_item_data_get(item);
 543         MSG_UI_RETM_IF(MSG_UI_LEVEL_ERR, addr_info == NULL, "item_data is NULL");
 544
 545         elm_genlist_item_selected_set(item, 0);
 546
 547
 548         if (bubble_data->popup) {
 549                 evas_object_del(bubble_data->popup);
 550                 bubble_data->popup = NULL;
 551         }
 552
 553         num_type = msg_ui_bubble_check_word_type(addr_info->address);
 554
 555         /** create popup */
 556         popup = elm_popup_add(cd->main_window);
 557         elm_object_style_set(popup, "min_menustyle");
 558         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 559
 560         btn_close = elm_button_add(popup);
 561         elm_object_style_set(btn_close, "popup_button/default");
 562         elm_object_text_set(btn_close, dgettext("sys_string", "IDS_COM_BODY_CLOSE"));
 563         elm_object_part_content_set(popup, "button1", btn_close);
 564         evas_object_smart_callback_add(btn_close, "clicked", msg_ui_popup_close_clicked_cb, bubble_data);
 565
 566         list = elm_list_add(popup);
 567         elm_list_mode_set(list, ELM_LIST_EXPAND);
 568
 569         evas_object_data_set(list, "bubble_data", bubble_data);
 570
 571         if (num_type == WORD_TYPE_NUM) {
 572                 elm_list_item_append(list, dgettext("sys_string", "IDS_COM_BODY_CALL"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 573                 elm_list_item_append(list, dgettext("sys_string", "IDS_COM_BODY_VIDEO_CALL"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 574         } else if (num_type == WORD_TYPE_EMAIL) {
 575                 elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SEND_EMAIL"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 576         } else {
 577                 D_MSG("invalid_numtype");
 578         }
 579
 580         if (addr_info->contact_id > 0) {
 581                 elm_object_part_text_set(popup, "title,text", addr_info->name);
 582                 elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_OPT_VIEW_CONTACT"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 583         } else {
 584                 elm_object_part_text_set(popup, "title,text", addr_info->address);
 585                 elm_list_item_append(list, dgettext("sys_string", "IDS_COM_OPT_ADD_TO_CONTACTS"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 586         }
 587
 588         if (num_type == WORD_TYPE_NUM) {
 589                 msg_error_t err;
 590                 bool isBlock;
 591                 err = msg_common_check_block_number(bubble_data->msgHandle, addr_info->address, &isBlock);
 592
 593                 if (err == MSG_SUCCESS) {
 594                         if (isBlock == false)
 595                                 elm_list_item_append(list, dgettext("sys_string", "IDS_COM_SK3_BLOCK"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 596                         else
 597                                 elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_UNBLOCK"), NULL, NULL, __msg_ui_bubble_list_popup_selected_cb, (void *)addr_info);
 598                 }
 599         }
 600
 601         elm_list_go(list);
 602         elm_object_content_set(popup, list);
 603         evas_object_show(popup);
 604
 605         bubble_data->popup = popup;
 606
 607         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 608 }
 609
 610 static void _dim_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 611 {
 612         msg_ui_bubble_close_title_menu_genlist(data);
 613 }
 614
 615 void msg_ui_bubble_open_title_menu_genlist(PMSG_BUBBLE_DATA bubble_data)
 616 {
 617         D_ENTER;
 618         MSG_UI_RETM_IF(MSG_UI_LEVEL_ASSERT, !bubble_data, "[ERROR] bubble_data is NULL !!");
 619
 620         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 621         MSG_UI_RETM_IF(MSG_UI_LEVEL_ASSERT, !cd, "[ERROR] cd is NULL !!");
 622         int i = 0;
 623
 624         /** 2. create box -- for setting min. size of genlist.*/
 625         Evas_Object *box = elm_box_add(cd->content_layout);
 626         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 627         evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
 628         evas_object_show(box);
 629
 630         elm_object_part_content_set(cd->content_layout, "swl.bubble.titlemenu", box);
 631
 632         /** 3. create genlist */
 633         Evas_Object *genlist = elm_genlist_add(box);
 634         elm_object_theme_set(genlist, cd->th);
 635         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 636         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 637         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
 638         evas_object_data_set(genlist, "bubble_data", bubble_data);
 639         evas_object_show(genlist);
 640
 641         elm_box_pack_end(box, genlist);
 642
 643         bubble_data->title_genlist = genlist;
 644         cd->title_menu_layout = box;
 645
 646         elm_object_signal_callback_add(cd->content_layout, "action,clicked", "", _dim_clicked_cb, bubble_data);
 647
 648         if (bubble_data->addr_list.addr_cnt == 1) {
 649                 unsigned char num_type;
 650                 /** 3.1 set genlist styles */
 651                 bubble_data->itc_title_single.item_style = "1text.custom";
 652                 bubble_data->itc_title_single.func.text_get = __msg_ui_bubble_gl_text_get;
 653                 bubble_data->itc_title_single.func.content_get = NULL;
 654                 bubble_data->itc_title_single.func.state_get = NULL;
 655                 bubble_data->itc_title_single.func.del = NULL;
 656
 657                 /** 3.2 genlist list load */
 658
 659                 num_type = msg_ui_bubble_check_word_type(bubble_data->addr_list.addr_info[0].address);
 660
 661                 if (num_type == WORD_TYPE_NUM) {
 662                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext("sys_string", "IDS_COM_BODY_CALL"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_call_cb, cd);
 663                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext("sys_string", "IDS_COM_BODY_VIDEO_CALL"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_vcall_cb, cd);
 664                 } else if (num_type == WORD_TYPE_EMAIL) {
 665                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SEND_EMAIL"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_email_cb, cd);
 666                 } else {
 667                         D_MSG("invalid_numtype");
 668                 }
 669
 670                 if (bubble_data->addr_list.addr_info[0].contact_id > 0)
 671                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext(MESSAGE_PKGNAME, "IDS_MSGC_OPT_VIEW_CONTACT"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_view_ct_detail_cb, cd);
 672                 else
 673                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext("sys_string", "IDS_COM_OPT_ADD_TO_CONTACTS"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_add_to_contact_cb, cd);
 674
 675                 if (num_type == WORD_TYPE_NUM) {
 676                         msg_error_t err;
 677                         bool isBlock;
 678                         err = msg_common_check_block_number(bubble_data->msgHandle, bubble_data->addr_list.addr_info[0].address, &isBlock);
 679
 680                         if (err == MSG_SUCCESS) {
 681                                 if (isBlock == false)
 682                                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext("sys_string", "IDS_COM_SK3_BLOCK"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_block_cb, bubble_data);
 683                                 else
 684                                         elm_genlist_item_append(genlist, &(bubble_data->itc_title_single), dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_UNBLOCK"), NULL, ELM_GENLIST_ITEM_NONE, msg_ui_bubble_ctlbar_unblock_cb, bubble_data);
 685                         }
 686                 }
 687
 688                 evas_object_size_hint_min_set(box, 0, BUBBLE_TITLE_MENU_GENLIST_1LINE_HEIGHT * elm_genlist_items_count(genlist));
 689         } else if (bubble_data->addr_list.addr_cnt > 1) {
 690                 /** 3.1 set genlist styles */
 691                 bubble_data->itc_title.item_style = "2text.1icon.2.custom";
 692                 bubble_data->itc_title.func.text_get = __msg_ui_bubble_gl_text_get;
 693                 bubble_data->itc_title.func.content_get = __msg_ui_bubble_gl_content_get;
 694                 bubble_data->itc_title.func.state_get = NULL;
 695                 bubble_data->itc_title.func.del = NULL;
 696
 697                 /** 3.2 genlist list load */
 698                 for (i = 0; i < bubble_data->addr_list.addr_cnt; i++)
 699                         elm_genlist_item_append(genlist, &(bubble_data->itc_title), &bubble_data->addr_list.addr_info[i], NULL, ELM_GENLIST_ITEM_NONE, __msg_ui_bubble_gl_sel, bubble_data);
 700
 701                         /** Determine genlist size to show - it shows maxmum 3 rows */
 702                         if (bubble_data->addr_list.addr_cnt >= BUBBLE_TITLE_MENU_GENLIST_MAX_LINE)
 703                                 evas_object_size_hint_min_set(box, 0, BUBBLE_TITLE_MENU_GENLIST_2LINE_HEIGHT * BUBBLE_TITLE_MENU_GENLIST_MAX_LINE);
 704                         else
 705                                 evas_object_size_hint_min_set(box, 0, BUBBLE_TITLE_MENU_GENLIST_2LINE_HEIGHT * bubble_data->addr_list.addr_cnt);
 706
 707         }
 708
 709         /** emit signal for changing state of swl.bubble.titlemenu to open */
 710         elm_object_signal_emit(cd->content_layout, "elm,state,title_menu,open", "");
 711
 712         bubble_data->title_menu_opened = true;
 713
 714         D_LEAVE;
 715 }
 716
 717 void msg_ui_bubble_close_title_menu_genlist(PMSG_BUBBLE_DATA bubble_data)
 718 {
 719         D_ENTER;
 720         MSG_UI_RETM_IF(MSG_UI_LEVEL_ASSERT, !bubble_data, "[ERROR] bubble_data is NULL !!");
 721
 722         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 723         MSG_UI_RETM_IF(MSG_UI_LEVEL_ASSERT, !cd, "[ERROR] cd is NULL !!");
 724
 725         bubble_data->title_menu_opened = false;
 726
 727         elm_object_signal_emit(cd->content_layout, "elm,state,title_menu,close", "");
 728
 729         Evas_Object *layout = elm_object_part_content_unset(cd->content_layout, "swl.bubble.titlemenu");
 730         if (layout)
 731                 evas_object_del(layout);
 732
 733         D_LEAVE;
 734 }
 735
 736 void msg_ui_bubble_title_button_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 737 {
 738         D_ENTER;
 739
 740         if (!data) {
 741                 D_EMSG("data is NULL");
 742                 return;
 743         }
 744
 745         MSG_COMPOSER_VIEW_DATA_S *cd = data;
 746         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
 747
 748         if (cd->ctx_popup) {
 749                 evas_object_del(cd->ctx_popup);
 750                 cd->ctx_popup = NULL;
 751         }
 752
 753         if (bubble_data->title_menu_opened) {
 754                 msg_ui_bubble_close_title_menu_genlist(bubble_data);
 755         } else {
 756                 msg_ui_bubble_open_title_menu_genlist(bubble_data);
 757         }
 758
 759         D_LEAVE;
 760 }
 761
 762 void msg_ui_bubble_msg_storage_change_cb(msg_handle_t handle, msg_storage_change_type_t type, msg_id_list_s *pMsgIdList, void *user_param)
 763 {
 764         D_ENTER;
 765
 766         if (!user_param || !pMsgIdList)
 767                 return;
 768
 769         MSG_COMPOSER_VIEW_DATA_S *cd = user_param;
 770         PMSG_BUBBLE_DATA BubbleData = cd->bubble_data;
 771
 772         if (BubbleData == NULL)
 773                 return;
 774
 775         if (BubbleData->ug_state == BUBBLE_UG_DESTROY)
 776                 return;
 777
 778         if (type == MSG_STORAGE_CHANGE_CONTACT) {
 779                 msg_ui_bubble_contact_info_update(BubbleData);
 780                 return;
 781         } else if (type == MSG_STORAGE_CHANGE_DELETE) {
 782                 return;
 783         }
 784
 785         int i;
 786         for (i = 0; i < pMsgIdList->nCount; i++) {
 787                 msg_struct_t conv = msg_create_struct(MSG_STRUCT_CONV_INFO);
 788                 msg_error_t err = MSG_SUCCESS;
 789
 790                 err = msg_get_conversation(BubbleData->msgHandle, pMsgIdList->msgIdList[i], conv);
 791                 if (err != MSG_SUCCESS) {
 792                         msg_release_struct(&conv);
 793                         return;
 794                 }
 795
 796                 int folder_id = 0;
 797                 int thread_id = 0;
 798                 int msg_id = 0;
 799                 msg_get_int_value(conv, MSG_CONV_MSG_FOLDER_ID_INT, &folder_id);
 800                 msg_get_int_value(conv, MSG_CONV_MSG_THREAD_ID_INT, &thread_id);
 801                 msg_get_int_value(conv, MSG_CONV_MSG_ID_INT, &msg_id);
 802
 803                 if (BubbleData->threadId == thread_id && folder_id != MSG_SPAMBOX_ID) {
 804                         switch (type) {
 805                                 case MSG_STORAGE_CHANGE_INSERT :
 806                                         if (msg_id != BubbleData->copy_id)
 807                                                 msg_ui_bubble_list_append(BubbleData, conv);
 808                                         else
 809                                                 BubbleData->copy_id = 0;
 810                                         break;
 811
 812                                 case MSG_STORAGE_CHANGE_UPDATE :
 813                                         if (msg_id == BubbleData->draft_msg_id) {
 814                                                 BubbleData->draft_msg_id = 0;
 815                                                 msg_ui_bubble_list_append(BubbleData, conv);
 816                                         } else {
 817                                                 msg_ui_bubble_item_data_update(BubbleData, conv);
 818                                         }
 819
 820                                         break;
 821
 822                                 default :
 823                                         break;
 824                         }
 825                 }
 826
 827                 msg_release_struct(&conv);
 828         }
 829
 830         D_LEAVE;
 831 }
 832
 833 static void __backup_thread_fn(void *data, Ecore_Thread *thread)
 834 {
 835         D_ENTER;
 836         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 837
 838         int fd;
 839         char *folderpath = NULL;
 840         char *foldername = NULL;
 841         char *filename = NULL;
 842         msg_struct_list_s msg_list;
 843         msg_error_t err = MSG_SUCCESS;
 844         int bubble_count = 0;
 845         int i = 0;
 846
 847         // initialize backup file path
 848         memset(bubble_data->backupPath, 0x00, sizeof(bubble_data->backupPath));
 849
 850         err = msg_get_conversation_view_list(bubble_data->msgHandle, bubble_data->threadId, &msg_list);
 851         if (err != MSG_SUCCESS)
 852                 return;
 853
 854         bubble_count = msg_list.nCount;
 855         if (bubble_count <= 0) {
 856                 msg_release_list_struct(&msg_list);
 857                 return;
 858         }
 859
 860         foldername = msg_ui_bubble_create_export_folder_name();
 861         if (!foldername) {
 862                 D_EMSG("create folder error!!!");
 863                 goto FREE_MEM;
 864         }
 865
 866         folderpath = msg_ui_bubble_create_export_folder(bubble_data, foldername);
 867         if (!folderpath) {
 868                 D_EMSG("file path is NULL!!!");
 869                 goto FREE_MEM;
 870         }
 871
 872         filename = msg_ui_bubble_create_export_file_name();
 873         if (!filename) {
 874                 D_EMSG("filename create error!!!");
 875                 goto FREE_MEM;
 876         }
 877
 878         snprintf(bubble_data->backupPath, sizeof(bubble_data->backupPath), "%s/%s", folderpath, filename);
 879
 880         // open file
 881         fd = open(bubble_data->backupPath, O_RDWR | O_CREAT | O_DSYNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 882         if (fd < 0) {
 883                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "open error");
 884                 goto FREE_MEM;
 885         }
 886
 887         // write file
 888         for (i = 0; i < bubble_count; i++) {
 889
 890                 if (bubble_data->backup_cancel)
 891                         break;
 892
 893                 char *msg_str = msg_ui_bubble_create_export_string(bubble_data, msg_list.msg_struct_info[i]);
 894                 if (msg_str) {
 895                         if (write(fd, msg_str, strlen(msg_str)) > 0)
 896                         fdatasync(fd);
 897                 } else {
 898                         continue;
 899                 }
 900         }
 901         close(fd);
 902 FREE_MEM:
 903         msg_release_list_struct(&msg_list);
 904
 905         if (foldername)
 906                 free(foldername);
 907
 908         if (folderpath)
 909                 free(folderpath);
 910
 911         if (filename)
 912                 free(filename);
 913 }
 914
 915 static void __backup_thread_end_fn(void *data, Ecore_Thread *thread)
 916 {
 917         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 918
 919         if (bubble_data->popup) {
 920                 evas_object_del(bubble_data->popup);
 921                 bubble_data->popup = NULL;
 922         }
 923
 924         if (bubble_data->backupPath[0] == '\0') {
 925                 /** if backup file path is NULL, it can be considered as a fail to backup */
 926                 msg_ui_bubble_status_message_post(bubble_data, dgettext("sys_string", "IDS_COM_POP_FAILED"));
 927                 goto INIT_VARS;
 928         }
 929
 930         if (bubble_data->backup_type == BUBBLE_BACKUP_TYPE_SD) {
 931                 if (bubble_data->backup_cancel) {
 932                         msg_ui_bubble_status_message_post(bubble_data, dgettext("sys_string", "IDS_COM_POP_CANCELLED"));
 933                 } else {
 934                         msg_ui_bubble_status_message_post(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_SAVED_IN_MY_FILES"));
 935                 }
 936         } else if (bubble_data->backup_type == BUBBLE_BACKUP_TYPE_EMAIL) {
 937                 MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 938                 // send via email
 939                 service_h svc_handle;
 940                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 941                         D_EMSG("service_create() is failed !!");
 942                 } else {
 943                         service_set_operation(svc_handle, SERVICE_OPERATION_SEND);
 944                         service_set_app_id(svc_handle, "email-composer-efl");
 945                         service_set_uri(svc_handle, bubble_data->backupPath);
 946                         service_add_extra_data(svc_handle, "RUN_TYPE","5");
 947
 948                         Ecore_X_Window win_id = elm_win_xwindow_get(cd->main_window);
 949                         service_set_window(svc_handle, win_id);
 950
 951                         service_send_launch_request(svc_handle, NULL, NULL);
 952
 953                         service_destroy(svc_handle);
 954                 }
 955         }
 956
 957 INIT_VARS:
 958         memset(bubble_data->backupPath, 0x00, sizeof(bubble_data->backupPath));
 959         bubble_data->backup_type = BUBBLE_BACKUP_TYPE_NONE;
 960         bubble_data->backup_cancel = false;
 961 }
 962
 963
 964 static void __backup_thread_cancel_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 965 {
 966         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 967         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 968         bubble_data->backup_cancel = true;
 969
 970         if (bubble_data->popup) {
 971                 evas_object_del(bubble_data->popup);
 972                 bubble_data->popup = NULL;
 973         }
 974 }
 975
 976 static void __msg_ui_bubble_backup_menu_selected_cb(void *data, Evas_Object *obj, void *event_info)
 977 {
 978         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 979         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 980
 981         const char *label = elm_object_item_text_get((Elm_Object_Item *) event_info);
 982
 983         // create popup
 984         if (bubble_data->popup) {
 985                 evas_object_del(bubble_data->popup);
 986                 bubble_data->popup = NULL;
 987         }
 988
 989         Evas_Object *popup = elm_popup_add(cd->main_window);
 990
 991         elm_object_text_set(popup, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_IN_PROGRESS_ING"));
 992
 993         Evas_Object *cancel_btn = elm_button_add(popup);
 994         elm_object_style_set(cancel_btn, "popup_button/default");
 995         elm_object_text_set(cancel_btn, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
 996         elm_object_part_content_set(popup, "button1", cancel_btn);
 997         evas_object_smart_callback_add(cancel_btn, "clicked", __backup_thread_cancel_clicked_cb, bubble_data);
 998
 999         bubble_data->popup = popup;
1000         evas_object_show(popup);
1001
1002         if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSG_OPT_EXPORT_TO_SD_CARD")) == 0) {
1003                 bubble_data->backup_type = BUBBLE_BACKUP_TYPE_SD;
1004         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_OPT_SEND_VIA_EMAIL")) == 0) {
1005                 bubble_data->backup_type = BUBBLE_BACKUP_TYPE_EMAIL;
1006         } else {
1007                 D_EMSG("invalid label text");
1008                 return;
1009         }
1010
1011         bubble_data->backup_thread = ecore_thread_run(__backup_thread_fn, __backup_thread_end_fn, NULL, (void *)bubble_data);
1012 }
1013
1014
1015 void msg_ui_bubble_backup_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1016 {
1017         D_ENTER;
1018         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1019
1020         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1021         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1022         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
1023
1024         if (cd->ctx_popup) {
1025                 evas_object_del(cd->ctx_popup);
1026                 cd->ctx_popup = NULL;
1027         }
1028
1029         Evas_Object *popup = elm_popup_add(cd->main_window);
1030         elm_object_style_set(popup, "min_menustyle");
1031         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1032
1033         Evas_Object *btn_close = elm_button_add(popup);
1034         elm_object_style_set(btn_close, "popup_button/default");
1035         elm_object_text_set(btn_close, dgettext("sys_string", "IDS_COM_BODY_CLOSE"));
1036         elm_object_part_content_set(popup, "button1", btn_close);
1037         evas_object_smart_callback_add(btn_close, "clicked", msg_ui_popup_close_clicked_cb, bubble_data);
1038
1039         Evas_Object *list = elm_list_add(popup);
1040         elm_list_mode_set(list, ELM_LIST_EXPAND);
1041
1042         evas_object_data_set(list, "bubble_data", bubble_data);
1043
1044         elm_list_item_append(list, dgettext(MESSAGE_PKGNAME, "IDS_MSG_OPT_EXPORT_TO_SD_CARD"), NULL, NULL, __msg_ui_bubble_backup_menu_selected_cb, (void *)bubble_data);
1045         elm_list_item_append(list, dgettext("sys_string", "IDS_COM_OPT_SEND_VIA_EMAIL"), NULL, NULL, __msg_ui_bubble_backup_menu_selected_cb, (void *)bubble_data);
1046
1047         elm_list_go(list);
1048         elm_object_content_set(popup, list);
1049         evas_object_show(popup);
1050
1051         bubble_data->popup = popup;
1052
1053 }
1054
1055 void msg_ui_bubble_more_delete_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1056 {
1057         D_ENTER;
1058         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1059
1060         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1061         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1062
1063         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
1064
1065         bubble_data->viewmode = BUBBLE_EDIT_VIEW;
1066         bubble_data->check_cnt = 0;
1067         bubble_data->del_index = 0;
1068
1069         msg_ui_composer_editable_set(cd, EINA_FALSE);
1070
1071         elm_object_part_content_unset(cd->navi_title_layout, "prev_btn");
1072         elm_object_part_content_unset(cd->navi_title_layout, "more_btn");
1073         elm_object_part_content_unset(cd->navi_title_layout, "compose_btn");
1074
1075         if (cd->back_btn)
1076                 evas_object_hide(cd->back_btn);
1077
1078         if (cd->more_btn)
1079                 evas_object_hide(cd->more_btn);
1080
1081         if (cd->compose_btn)
1082                 evas_object_hide(cd->compose_btn);
1083
1084         if (cd->ctx_popup) {
1085                 evas_object_del(cd->ctx_popup);
1086                 cd->ctx_popup = NULL;
1087         }
1088
1089         Eina_List *l;
1090         PMSG_APP_CONV_DATA_S item_data = NULL;
1091         EINA_LIST_FOREACH(bubble_data->realized_list, l, item_data) {
1092                 if (item_data) {
1093                         Evas_Object *check = NULL;
1094                         if (!item_data->chk) {
1095                                 check = elm_check_add(item_data->ly);
1096                                 elm_check_state_pointer_set(check, &item_data->isCheck);
1097                                 evas_object_data_set(check, "item_data", (const void *)item_data);
1098                                 evas_object_smart_callback_add(check, "changed", msg_ui_bubble_list_checked_cb, (const void *)bubble_data);
1099                                 evas_object_propagate_events_set(check, EINA_FALSE);
1100                                 item_data->chk = check;
1101                         }
1102                         evas_object_data_set(item_data->ly, "bubble_data", bubble_data);
1103                         evas_object_event_callback_add(item_data->ly, EVAS_CALLBACK_MOUSE_DOWN, msg_ui_bubble_item_mouse_down_cb, (const void*)item_data);
1104                         elm_object_style_set(check, "default/genlist_edit");
1105                         elm_object_part_content_set(item_data->ly, "elm.swallow.select_icon", item_data->chk);
1106                         elm_object_signal_emit(item_data->ly, "elm,state,select,enable", "elm");
1107                 }
1108         }
1109
1110         _bubble_change_edit_mode_title(bubble_data);
1111         _bubble_add_edit_controlbar(bubble_data);
1112         _bubble_add_navi_select_all_ly(bubble_data);
1113 }
1114
1115 void msg_ui_bubble_ctlbar_email_cb(void *data, Evas_Object *obj, void *event_info)
1116 {
1117         D_ENTER;
1118
1119         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1120         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1121         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1122         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1123
1124         msg_ui_bubble_close_title_menu_genlist(pData);
1125
1126         if (pData->addr_list.addr_cnt == 1) {
1127                 service_h svc_handle;
1128                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1129                         D_EMSG("service_create() is failed !!");
1130                 } else {
1131                         service_set_operation(svc_handle, SERVICE_OPERATION_SEND);
1132                         service_set_app_id(svc_handle, "email-composer-efl");
1133                         service_add_extra_data(svc_handle, "RUN_TYPE","5");
1134
1135                         Ecore_X_Window win_id = elm_win_xwindow_get(cd->main_window);
1136
1137                         service_set_window(svc_handle, win_id);
1138                         service_add_extra_data(svc_handle, SERVICE_DATA_TO, pData->addr_list.addr_info[0].address);
1139
1140                         service_send_launch_request(svc_handle, NULL, NULL);
1141
1142                         service_destroy(svc_handle);
1143                 }
1144         }
1145 }
1146
1147 void msg_ui_bubble_ctlbar_call_cb(void *data, Evas_Object *obj, void *event_info)
1148 {
1149         D_ENTER;
1150         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1151         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1152         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)cd->bubble_data;
1153         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1154
1155         if (pData->addr_list.addr_cnt == 1)
1156                 msg_ui_bubble_launch_voice_call(pData->addr_list.addr_info[0].address);
1157
1158         msg_ui_bubble_close_title_menu_genlist(pData);
1159 }
1160
1161 void msg_ui_bubble_ctlbar_vcall_cb(void *data, Evas_Object *obj, void *event_info)
1162 {
1163         D_ENTER;
1164         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1165         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1166         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1167         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1168
1169         if (pData->addr_list.addr_cnt == 1)
1170                 msg_ui_bubble_launch_video_call(pData->addr_list.addr_info[0].address);
1171
1172         msg_ui_bubble_close_title_menu_genlist(pData);
1173 }
1174
1175 void msg_ui_bubble_ctlbar_add_to_contact_cb(void *data, Evas_Object *obj, void *event_info)
1176 {
1177         D_ENTER;
1178         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1179         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1180
1181         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1182         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1183
1184         if (pData->addr_list.addr_cnt == 1)
1185                 msg_ui_composer_launch_contact_list_ug(cd, MSG_CT_UG_REQUEST_UPDATE_WITH_NUM, pData->addr_list.addr_info[0].address);
1186
1187         msg_ui_bubble_close_title_menu_genlist(pData);
1188 }
1189
1190 void msg_ui_bubble_ctlbar_view_ct_detail_cb(void *data, Evas_Object *obj, void *event_info)
1191 {
1192         D_ENTER;
1193         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1194
1195         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1196
1197         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1198         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1199
1200         if (pData->addr_list.addr_cnt == 1)
1201                 msg_ui_composer_launch_contact_detail_ug(cd, pData->addr_list.addr_info[0].contact_id);
1202
1203         msg_ui_bubble_close_title_menu_genlist(pData);
1204 }
1205
1206 void msg_ui_bubble_ctlbar_block_cb(void *data, Evas_Object *obj, void *event_info)
1207 {
1208         D_ENTER;
1209         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1210
1211         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
1212
1213         __msg_ui_bubble_create_block_popup(pData, pData->addr_list.addr_info[0].address);
1214
1215         msg_ui_bubble_close_title_menu_genlist(pData);
1216 }
1217
1218 void msg_ui_bubble_ctlbar_unblock_cb(void *data, Evas_Object *obj, void *event_info)
1219 {
1220         D_ENTER;
1221         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1222
1223         PMSG_BUBBLE_DATA pData = data;
1224
1225         __msg_ui_bubble_unblock(pData, pData->addr_list.addr_info[0].address);
1226
1227         msg_ui_bubble_close_title_menu_genlist(pData);
1228 }
1229
1230 void msg_ui_bubble_ctlbar_delete_cb(void *data, Evas_Object *obj, void *event_info)
1231 {
1232         D_ENTER;
1233         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1234         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1235         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1236         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1237         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, pData->del_thread);
1238
1239         if (pData->popup) {
1240                 evas_object_del(pData->popup);
1241                 pData->popup = NULL;
1242         }
1243
1244         bool isDraft = msg_ui_composer_common_is_send_possible(cd);
1245
1246         if (pData->sel_all_checked && isDraft == false) {
1247                 pData->bubble_count = 0;
1248                 _del_all_item(pData);
1249         } else {
1250                 pData->popup = msg_ui_bubble_show_notify_with_progressbar(pData, pData->check_cnt);
1251                 pData->del_thread = ecore_thread_feedback_run(_del_thread_fn, _del_thread_feedback_fn, NULL, NULL, (void *)pData, EINA_TRUE);
1252         }
1253
1254 }
1255
1256 void msg_ui_bubble_ctlbar_cancel_cb(void *data, Evas_Object *obj, void *event_info)
1257 {
1258         D_ENTER;
1259         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1260         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1261         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1262         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1263
1264         _bubble_show_normal_mode(data);
1265
1266         if (pData->added_list)
1267                 pData->add_animator = ecore_animator_add(msg_ui_bubble_item_add_cb, (const void *) pData);
1268
1269         msg_ui_composer_last_focus_load(cd);
1270 }
1271
1272 void msg_ui_bubble_sel_all_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1273 {
1274         MSG_UI_ENTER();
1275
1276         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA) data;
1277         PMSG_APP_CONV_DATA_S item_data = NULL;
1278
1279         D_MSG("pData->sel_all_checked = %d", pData->sel_all_checked);
1280
1281         if (pData->sel_all_checked) {
1282                 pData->check_cnt = pData->bubble_count;
1283                 pData->chk_list = eina_list_clone(pData->bubble_list);
1284         } else {
1285                 pData->check_cnt = 0;
1286                 pData->chk_list = eina_list_free(pData->chk_list);
1287         }
1288
1289         Eina_List *l;
1290         EINA_LIST_FOREACH(pData->bubble_list, l, item_data) {
1291                 if (item_data) {
1292                         item_data->isCheck = pData->sel_all_checked;
1293                 }
1294         }
1295
1296         EINA_LIST_FOREACH(pData->realized_list, l, item_data) {
1297                 if (item_data) {
1298                         elm_check_state_set(item_data->chk, item_data->isCheck);
1299                 }
1300         }
1301
1302         msg_ui_bubble_show_select_info(pData);
1303
1304         MSG_UI_LEAVE();
1305 }
1306
1307 void msg_ui_bubble_item_mouse_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1308 {
1309         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !event_info);
1310
1311         Evas_Coord x, y;
1312         Evas_Event_Mouse_Down *ev = event_info;
1313
1314         PMSG_APP_CONV_DATA_S item_data = (PMSG_APP_CONV_DATA_S)data;
1315         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)evas_object_data_get(item_data->ly, "bubble_data");
1316
1317         x = ev->canvas.x;
1318         y = ev->canvas.y;
1319
1320         if (abs(x - g_mouse_down_x) > 20 || abs(y - g_mouse_down_y) > 20) {
1321                 goto RESET_EVAS_COORD;
1322         }
1323
1324         if (elm_check_state_get(item_data->chk) == EINA_TRUE)
1325                 elm_check_state_set(item_data->chk, EINA_FALSE);
1326         else
1327                 elm_check_state_set(item_data->chk, EINA_TRUE);
1328
1329         msg_ui_bubble_list_checked_cb((void *)bubble_data, item_data->chk, NULL);
1330
1331 RESET_EVAS_COORD:
1332         evas_object_event_callback_del(item_data->ly, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_item_mouse_up_cb);
1333         g_mouse_down_x = 0;
1334         g_mouse_down_y = 0;
1335 }
1336
1337 void msg_ui_bubble_item_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1338 {
1339         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !event_info);
1340
1341         PMSG_APP_CONV_DATA_S item_data = (PMSG_APP_CONV_DATA_S)data;
1342
1343         Evas_Event_Mouse_Down *ev = event_info;
1344
1345         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1346                 return;
1347
1348         g_mouse_down_x = ev->canvas.x;
1349         g_mouse_down_y = ev->canvas.y;
1350
1351         evas_object_event_callback_add(item_data->ly, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_item_mouse_up_cb, (const void*)item_data);
1352 }
1353
1354 #ifdef _BUBBLE_FLICK_EVENT
1355 void msg_ui_bubble_layout_mouse_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1356 {
1357         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1358         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !event_info);
1359
1360         Evas_Coord x, y, w, h;
1361         Evas_Event_Mouse_Down *ev = event_info;
1362         int width = 0;
1363         int rotate = 0;
1364         Evas_Coord start_x;
1365         Evas_Coord start_y;
1366         Evas_Coord end_x;
1367         Evas_Coord end_y;
1368         int move_x = 0;
1369         int move_y = 0;
1370
1371         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1372         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1373
1374         evas_object_geometry_get(bubble_data->bubble_layout, &x, &y, &w, &h);
1375
1376         rotate = elm_win_rotation_get(cd->main_window);
1377         if (rotate == 0) {
1378                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "PORTRAIT mode");
1379                 start_x = bubble_data->m_x;
1380                 end_x = ev->canvas.x;
1381                 start_y = bubble_data->m_y;
1382                 end_y = ev->canvas.y;
1383                 width = w-x;
1384         } else if (rotate == 180) {
1385                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "PORTRAIT reverse mode");
1386                 start_x = ev->canvas.x;
1387                 end_x = bubble_data->m_x;
1388                 start_y = bubble_data->m_y;
1389                 end_y = ev->canvas.y;
1390                 width = w-x;
1391         } else if (rotate == 90) {
1392                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "LANDSCAPE mode");
1393                 start_x = ev->canvas.y;
1394                 end_x = bubble_data->m_y;
1395                 start_y = bubble_data->m_x;
1396                 end_y = ev->canvas.x;
1397                 width = h-y;
1398         } else if (rotate== 270) {
1399                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "LANDSCAPE reverse mode");
1400                 start_x = bubble_data->m_y;
1401                 end_x = ev->canvas.y;
1402                 start_y = bubble_data->m_x;
1403                 end_y = ev->canvas.x;
1404                 width = h-y;
1405         } else {
1406                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Invalid rotation value");
1407                 evas_object_event_callback_del(bubble_data->bubble_layout, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_layout_mouse_up_cb);
1408                 return;
1409         }
1410
1411         move_x = abs(start_x - end_x);
1412         move_y = abs(start_y - end_y);
1413
1414         if (move_x > move_y) {
1415                 if (move_x > (width / 3)) { // It should be moved over 1/3 of the screen width to show next/previous converstaions.
1416                         int row = 0;
1417                         int selected = 0;
1418                         msg_struct_list_s peerList = {0,};
1419                         msg_struct_t sortRule = NULL;
1420                         msg_struct_list_s addrList = {0,};
1421
1422                         sortRule = msg_create_struct(MSG_STRUCT_SORT_RULE);
1423                         msg_set_int_value(sortRule, MSG_SORT_RULE_SORT_TYPE_INT, MSG_SORT_BY_THREAD_DATE);
1424                         msg_set_bool_value(sortRule, MSG_SORT_RULE_ACSCEND_BOOL, false);
1425
1426                         msg_get_thread_view_list(cd->msg_handle, sortRule, &peerList);
1427                         msg_release_struct(&sortRule);
1428
1429                         for (row=0; row < peerList.nCount; row++) {
1430                                 int thread_id = 0;
1431                                 msg_get_int_value(peerList.msg_struct_info[row], MSG_THREAD_ID_INT, &thread_id);
1432
1433                                 if (bubble_data->threadId == thread_id) {
1434                                         msg_ui_bubble_init_bubble_list(bubble_data);
1435                                         if (start_x > end_x) // show next
1436                                                 selected = row+1 < peerList.nCount ? row+1 : 0;
1437                                         else // show previous
1438                                                 selected = row-1 < 0 ? peerList.nCount-1 : row-1;
1439
1440                                         int selecte_thread_id = 0;
1441                                         msg_get_int_value(peerList.msg_struct_info[selected], MSG_THREAD_ID_INT, &selecte_thread_id);
1442                                         bubble_data->threadId = selecte_thread_id;
1443
1444                                         msg_get_address_list(bubble_data->msgHandle, bubble_data->threadId, &addrList);
1445
1446                                         bubble_data->addr_list.addr_cnt = addrList.nCount;
1447                                         int i = 0;
1448
1449                                         /* clear recipient_list of bubble composer */
1450                                         msg_ui_composer_recipient_clear_recipient_list(cd);
1451
1452                                         for (i=0; i < addrList.nCount; i++) {
1453                                                 int contact_id = 0;
1454
1455                                                 msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, bubble_data->addr_list.addr_info[i].address, DEF_THREAD_ADDR_LEN);
1456                                                 msg_get_int_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_CONTACT_ID_INT, &contact_id);
1457
1458                                                 if (contact_id > 0) {
1459                                                         bubble_data->addr_list.addr_info[i].contact_id = contact_id;
1460                                                         msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_DISPLAYNAME_STR, bubble_data->addr_list.addr_info[i].name, DEF_THREAD_NAME_LEN);
1461                                                 } else {
1462                                                         bubble_data->addr_list.addr_info[i].contact_id = 0;
1463                                                 }
1464
1465                                                 /* set recipient_list for bubble composer */
1466                                                 msg_ui_composer_recipient_add_recipient_list(cd, addrList.addrInfo[i].addressVal);
1467                                         }
1468
1469                                         // bubble list update
1470                                         msg_ui_bubble_list_load(bubble_data);
1471                                         msg_ui_composer_navi_title_set((void *)cd);
1472                                         service_h svc_handle;
1473                                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1474                                                 D_EMSG("service_create() is failed !!");
1475                                         } else {
1476                                                 char buf[DEF_BUF_LEN_S] = {0,};
1477                                                 snprintf(buf, DEF_BUF_LEN_L, "%d", bubble_data->threadId);
1478                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, buf);
1479
1480                                                 ug_send_result(cd->ug, svc_handle);
1481
1482                                                 service_destroy(svc_handle);
1483                                         }
1484
1485                                         msg_release_list_struct(&addrList);
1486
1487                                         break;
1488                                 }
1489                         }
1490                         msg_release_list_struct(&peerList);
1491                 }
1492         }
1493         evas_object_event_callback_del(bubble_data->bubble_layout, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_layout_mouse_up_cb);
1494 }
1495
1496 void msg_ui_bubble_layout_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1497 {
1498         D_ENTER;
1499
1500         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, data == NULL);
1501         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1502
1503         Evas_Event_Mouse_Down *ev = (Evas_Event_Mouse_Down *)event_info;
1504
1505         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1506                 return;
1507
1508         bubble_data->m_x = ev->canvas.x;
1509         bubble_data->m_y = ev->canvas.y;
1510
1511         evas_object_event_callback_add(bubble_data->bubble_layout, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_layout_mouse_up_cb, (const void*)bubble_data);
1512 }
1513 #endif
1514
1515 void msg_ui_bubble_list_checked_cb(void *data, Evas_Object *obj, void *event_info)
1516 {
1517         MSG_UI_ENTER();
1518
1519         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA) data;
1520         PMSG_APP_CONV_DATA_S item_data = NULL;
1521
1522         item_data = evas_object_data_get(obj, "item_data");
1523
1524         if (item_data->isCheck) {
1525                 pData->check_cnt++;
1526                 if (!eina_list_data_find(pData->chk_list, item_data))
1527                         pData->chk_list = eina_list_append(pData->chk_list, item_data);
1528         } else {
1529                 pData->check_cnt--;
1530                 pData->chk_list = eina_list_remove(pData->chk_list, item_data);
1531         }
1532
1533         if (pData->bubble_count == pData->check_cnt)
1534                 elm_check_state_set(pData->sel_all_box, EINA_TRUE);
1535         else
1536                 elm_check_state_set(pData->sel_all_box, EINA_FALSE);
1537
1538         msg_ui_bubble_show_select_info(pData);
1539
1540         MSG_UI_LEAVE();
1541 }
1542
1543 void msg_ui_bubble_timezone_change_cb(keynode_t *key, void *data)
1544 {
1545         D_ENTER;
1546
1547         PMSG_BUBBLE_DATA BubbleData = (PMSG_BUBBLE_DATA)data;
1548
1549         char *timezone_id = NULL;
1550         UChar utimezone_id[DEF_BUF_LEN] = {0,};
1551         UErrorCode status = U_ZERO_ERROR;
1552
1553         timezone_id = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
1554
1555         if (!timezone_id)
1556                 return;
1557
1558         u_uastrcpy(utimezone_id, timezone_id);
1559
1560         ucal_setDefaultTimeZone(utimezone_id, &status);
1561
1562         if (U_FAILURE(status))
1563                 return;
1564
1565         msg_ui_bubble_get_locale(BubbleData);
1566         msg_ui_bubble_get_time_format(BubbleData);
1567
1568         if (BubbleData->date_ptn_default) {
1569                 free(BubbleData->date_ptn_default);
1570                 BubbleData->date_ptn_default = NULL;
1571         }
1572
1573         if (BubbleData->date_ptn_year) {
1574                 free(BubbleData->date_ptn_year);
1575                 BubbleData->date_ptn_year = NULL;
1576         }
1577
1578         if (BubbleData->time_12h_ptn) {
1579                 free(BubbleData->time_12h_ptn);
1580                 BubbleData->time_12h_ptn = NULL;
1581         }
1582
1583         if (BubbleData->time_24h_ptn) {
1584                 free(BubbleData->time_24h_ptn);
1585                 BubbleData->time_24h_ptn = NULL;
1586         }
1587
1588         BubbleData->time_12h_ptn = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_TIME_PATTERN_12H);
1589         BubbleData->time_24h_ptn = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_TIME_PATTERN_24H);
1590         BubbleData->date_ptn_default = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_DATE_PATTERN_DEFAULT);
1591         BubbleData->date_ptn_year = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_DATE_PATTERN_YEAR);
1592
1593         msg_ui_bubble_list_data_update(BubbleData);
1594
1595         D_LEAVE;
1596 }
1597
1598 void msg_ui_bubble_scroll_edge_top_cb(void *data, Evas_Object *obj, void *event_info)
1599 {
1600         D_ENTER;
1601
1602         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
1603
1604         evas_object_smart_callback_del(obj, "scroll,drag,start", msg_ui_bubble_scroll_drag_start_cb);
1605
1606         if (!pData->load_animator)
1607                 pData->load_animator = ecore_animator_add(msg_ui_bubble_item_load_cb, data);
1608
1609         D_LEAVE;
1610 }
1611
1612 void msg_ui_bubble_scroll_drag_start_cb(void *data, Evas_Object *obj, void *event_info)
1613 {
1614         D_ENTER;
1615
1616         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
1617
1618         evas_object_smart_callback_add(obj, "edge,top", msg_ui_bubble_scroll_edge_top_cb, (void *)pData);
1619
1620         D_LEAVE;
1621 }
1622
1623 void msg_ui_bubble_anchor_menu_click_cb(void *data, Evas_Object *obj, void *event_info)
1624 {
1625         D_ENTER;
1626         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1627         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1628         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1629         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
1630
1631         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1632         elm_list_item_selected_set(item, 0);
1633
1634         const char *label = elm_object_item_text_get(item);
1635         const char *title =  elm_object_part_text_get(bubble_data->popup, "title,text");
1636
1637         if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_CALL")) == 0) {
1638                 msg_ui_bubble_launch_voice_call(title);
1639         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_SEND_MESSAGE")) == 0) {
1640                 service_h svc_handle;
1641                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1642                         D_EMSG("service_create() is failed !!");
1643                 } else {
1644                         service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_TO, title);
1645                         msg_ui_composer_launch_composer_create(cd, svc_handle);
1646                         if (!cd->loaded_ug)
1647                                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_UNABLE_TO_OPEN"));
1648
1649                         service_destroy(svc_handle);
1650                 }
1651
1652         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_VIDEO_CALL")) == 0) {
1653                 msg_ui_bubble_launch_video_call(title);
1654         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_OPT_ADD_TO_CONTACTS")) == 0) { /* Add to contact with phone number string... */
1655                 msg_ui_composer_launch_contact_list_ug(cd, MSG_CT_UG_REQUEST_UPDATE_WITH_NUM, title);
1656         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_OPT_VIEW_CONTACT")) == 0) {
1657                 msg_ui_composer_launch_contact_detail_ug(cd, bubble_data->addr_list.addr_info[0].contact_id);
1658         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SEND_EMAIL")) == 0) {
1659                 service_h svc_handle;
1660                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1661                         D_EMSG("service_create() is failed !!");
1662                 } else {
1663                         service_set_operation(svc_handle, SERVICE_OPERATION_SEND);
1664                         service_set_app_id(svc_handle, "email-composer-efl");
1665                         service_add_extra_data(svc_handle, "RUN_TYPE","5");
1666
1667                         Ecore_X_Window win_id = elm_win_xwindow_get(cd->main_window);
1668
1669                         service_set_window(svc_handle, win_id);
1670                         service_add_extra_data(svc_handle, SERVICE_DATA_TO, title);
1671
1672                         service_send_launch_request(svc_handle, NULL, NULL);
1673
1674                         service_destroy(svc_handle);
1675                 }
1676         }
1677
1678         if (bubble_data->popup) {
1679                 evas_object_del(bubble_data->popup);
1680                 bubble_data->popup = NULL;
1681         }
1682
1683         D_LEAVE;
1684 }
1685
1686 void msg_ui_bubble_main_layout_clicked_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1687 {
1688         D_ENTER;
1689         D_MSG_RETM_IF(data == NULL, "data is NULL");
1690         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1691
1692         if (!cd->is_keypad_show)
1693                 msg_ui_composer_make_default_body_size(cd);
1694
1695         cd->make_default_body_size = true;
1696
1697         D_LEAVE;
1698 }
1699