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                                         msg_ui_bubble_item_data_update(BubbleData, conv);
 814
 815                                         break;
 816
 817                                 default :
 818                                         break;
 819                         }
 820                 }
 821
 822                 msg_release_struct(&conv);
 823         }
 824
 825         D_LEAVE;
 826 }
 827
 828 static void __backup_thread_fn(void *data, Ecore_Thread *thread)
 829 {
 830         D_ENTER;
 831         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 832
 833         int fd;
 834         char *folderpath = NULL;
 835         char *foldername = NULL;
 836         char *filename = NULL;
 837         msg_struct_list_s msg_list;
 838         msg_error_t err = MSG_SUCCESS;
 839         int bubble_count = 0;
 840         int i = 0;
 841
 842         // initialize backup file path
 843         memset(bubble_data->backupPath, 0x00, sizeof(bubble_data->backupPath));
 844
 845         err = msg_get_conversation_view_list(bubble_data->msgHandle, bubble_data->threadId, &msg_list);
 846         if (err != MSG_SUCCESS)
 847                 return;
 848
 849         bubble_count = msg_list.nCount;
 850         if (bubble_count <= 0) {
 851                 msg_release_list_struct(&msg_list);
 852                 return;
 853         }
 854
 855         foldername = msg_ui_bubble_create_export_folder_name();
 856         if (!foldername) {
 857                 D_EMSG("create folder error!!!");
 858                 goto FREE_MEM;
 859         }
 860
 861         folderpath = msg_ui_bubble_create_export_folder(bubble_data, foldername);
 862         if (!folderpath) {
 863                 D_EMSG("file path is NULL!!!");
 864                 goto FREE_MEM;
 865         }
 866
 867         filename = msg_ui_bubble_create_export_file_name();
 868         if (!filename) {
 869                 D_EMSG("filename create error!!!");
 870                 goto FREE_MEM;
 871         }
 872
 873         snprintf(bubble_data->backupPath, sizeof(bubble_data->backupPath), "%s/%s", folderpath, filename);
 874
 875         // open file
 876         fd = open(bubble_data->backupPath, O_RDWR | O_CREAT | O_DSYNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 877         if (fd < 0) {
 878                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "open error");
 879                 goto FREE_MEM;
 880         }
 881
 882         // write file
 883         for (i = 0; i < bubble_count; i++) {
 884
 885                 if (bubble_data->backup_cancel)
 886                         break;
 887
 888                 char *msg_str = msg_ui_bubble_create_export_string(bubble_data, msg_list.msg_struct_info[i]);
 889                 if (msg_str) {
 890                         if (write(fd, msg_str, strlen(msg_str)) > 0)
 891                         fdatasync(fd);
 892                 } else {
 893                         continue;
 894                 }
 895         }
 896         close(fd);
 897 FREE_MEM:
 898         msg_release_list_struct(&msg_list);
 899
 900         if (foldername)
 901                 free(foldername);
 902
 903         if (folderpath)
 904                 free(folderpath);
 905
 906         if (filename)
 907                 free(filename);
 908 }
 909
 910 static void __backup_thread_end_fn(void *data, Ecore_Thread *thread)
 911 {
 912         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 913
 914         if (bubble_data->popup) {
 915                 evas_object_del(bubble_data->popup);
 916                 bubble_data->popup = NULL;
 917         }
 918
 919         if (bubble_data->backupPath[0] == '\0') {
 920                 /** if backup file path is NULL, it can be considered as a fail to backup */
 921                 msg_ui_bubble_status_message_post(bubble_data, dgettext("sys_string", "IDS_COM_POP_FAILED"));
 922                 goto INIT_VARS;
 923         }
 924
 925         if (bubble_data->backup_type == BUBBLE_BACKUP_TYPE_SD) {
 926                 if (bubble_data->backup_cancel) {
 927                         msg_ui_bubble_status_message_post(bubble_data, dgettext("sys_string", "IDS_COM_POP_CANCELLED"));
 928                 } else {
 929                         msg_ui_bubble_status_message_post(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_SAVED_IN_MY_FILES"));
 930                 }
 931         } else if (bubble_data->backup_type == BUBBLE_BACKUP_TYPE_EMAIL) {
 932                 MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 933                 // send via email
 934                 service_h svc_handle;
 935                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 936                         D_EMSG("service_create() is failed !!");
 937                 } else {
 938                         service_set_operation(svc_handle, SERVICE_OPERATION_SEND);
 939                         service_set_app_id(svc_handle, "email-composer-efl");
 940                         service_set_uri(svc_handle, bubble_data->backupPath);
 941                         service_add_extra_data(svc_handle, "RUN_TYPE","5");
 942
 943                         Ecore_X_Window win_id = elm_win_xwindow_get(cd->main_window);
 944                         service_set_window(svc_handle, win_id);
 945
 946                         service_send_launch_request(svc_handle, NULL, NULL);
 947
 948                         service_destroy(svc_handle);
 949                 }
 950         }
 951
 952 INIT_VARS:
 953         memset(bubble_data->backupPath, 0x00, sizeof(bubble_data->backupPath));
 954         bubble_data->backup_type = BUBBLE_BACKUP_TYPE_NONE;
 955         bubble_data->backup_cancel = false;
 956 }
 957
 958
 959 static void __backup_thread_cancel_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 960 {
 961         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
 962         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 963         bubble_data->backup_cancel = true;
 964
 965         if (bubble_data->popup) {
 966                 evas_object_del(bubble_data->popup);
 967                 bubble_data->popup = NULL;
 968         }
 969 }
 970
 971 static void __msg_ui_bubble_backup_menu_selected_cb(void *data, Evas_Object *obj, void *event_info)
 972 {
 973         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
 974         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
 975
 976         const char *label = elm_object_item_text_get((Elm_Object_Item *) event_info);
 977
 978         // create popup
 979         if (bubble_data->popup) {
 980                 evas_object_del(bubble_data->popup);
 981                 bubble_data->popup = NULL;
 982         }
 983
 984         Evas_Object *popup = elm_popup_add(cd->main_window);
 985
 986         elm_object_text_set(popup, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_IN_PROGRESS_ING"));
 987
 988         Evas_Object *cancel_btn = elm_button_add(popup);
 989         elm_object_style_set(cancel_btn, "popup_button/default");
 990         elm_object_text_set(cancel_btn, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
 991         elm_object_part_content_set(popup, "button1", cancel_btn);
 992         evas_object_smart_callback_add(cancel_btn, "clicked", __backup_thread_cancel_clicked_cb, bubble_data);
 993
 994         bubble_data->popup = popup;
 995         evas_object_show(popup);
 996
 997         if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSG_OPT_EXPORT_TO_SD_CARD")) == 0) {
 998                 bubble_data->backup_type = BUBBLE_BACKUP_TYPE_SD;
 999         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_OPT_SEND_VIA_EMAIL")) == 0) {
1000                 bubble_data->backup_type = BUBBLE_BACKUP_TYPE_EMAIL;
1001         } else {
1002                 D_EMSG("invalid label text");
1003                 return;
1004         }
1005
1006         bubble_data->backup_thread = ecore_thread_run(__backup_thread_fn, __backup_thread_end_fn, NULL, (void *)bubble_data);
1007 }
1008
1009
1010 void msg_ui_bubble_backup_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1011 {
1012         D_ENTER;
1013         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1014
1015         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1016         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1017         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
1018
1019         if (cd->ctx_popup) {
1020                 evas_object_del(cd->ctx_popup);
1021                 cd->ctx_popup = NULL;
1022         }
1023
1024         Evas_Object *popup = elm_popup_add(cd->main_window);
1025         elm_object_style_set(popup, "min_menustyle");
1026         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1027
1028         Evas_Object *btn_close = elm_button_add(popup);
1029         elm_object_style_set(btn_close, "popup_button/default");
1030         elm_object_text_set(btn_close, dgettext("sys_string", "IDS_COM_BODY_CLOSE"));
1031         elm_object_part_content_set(popup, "button1", btn_close);
1032         evas_object_smart_callback_add(btn_close, "clicked", msg_ui_popup_close_clicked_cb, bubble_data);
1033
1034         Evas_Object *list = elm_list_add(popup);
1035         elm_list_mode_set(list, ELM_LIST_EXPAND);
1036
1037         evas_object_data_set(list, "bubble_data", bubble_data);
1038
1039         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);
1040         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);
1041
1042         elm_list_go(list);
1043         elm_object_content_set(popup, list);
1044         evas_object_show(popup);
1045
1046         bubble_data->popup = popup;
1047
1048 }
1049
1050 void msg_ui_bubble_more_delete_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1051 {
1052         D_ENTER;
1053         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1054
1055         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1056         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1057
1058         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
1059
1060         bubble_data->viewmode = BUBBLE_EDIT_VIEW;
1061         bubble_data->check_cnt = 0;
1062         bubble_data->del_index = 0;
1063
1064         msg_ui_composer_editable_set(cd, EINA_FALSE);
1065
1066         elm_object_part_content_unset(cd->navi_title_layout, "prev_btn");
1067         elm_object_part_content_unset(cd->navi_title_layout, "more_btn");
1068         elm_object_part_content_unset(cd->navi_title_layout, "compose_btn");
1069
1070         if (cd->back_btn)
1071                 evas_object_hide(cd->back_btn);
1072
1073         if (cd->more_btn)
1074                 evas_object_hide(cd->more_btn);
1075
1076         if (cd->compose_btn)
1077                 evas_object_hide(cd->compose_btn);
1078
1079         if (cd->ctx_popup) {
1080                 evas_object_del(cd->ctx_popup);
1081                 cd->ctx_popup = NULL;
1082         }
1083
1084         Eina_List *l;
1085         PMSG_APP_CONV_DATA_S item_data = NULL;
1086         EINA_LIST_FOREACH(bubble_data->realized_list, l, item_data) {
1087                 if (item_data) {
1088                         Evas_Object *check = NULL;
1089                         if (!item_data->chk) {
1090                                 check = elm_check_add(item_data->ly);
1091                                 elm_check_state_pointer_set(check, &item_data->isCheck);
1092                                 evas_object_data_set(check, "item_data", (const void *)item_data);
1093                                 evas_object_smart_callback_add(check, "changed", msg_ui_bubble_list_checked_cb, (const void *)bubble_data);
1094                                 evas_object_propagate_events_set(check, EINA_FALSE);
1095                                 item_data->chk = check;
1096                         }
1097                         evas_object_data_set(item_data->ly, "bubble_data", bubble_data);
1098                         evas_object_event_callback_add(item_data->ly, EVAS_CALLBACK_MOUSE_DOWN, msg_ui_bubble_item_mouse_down_cb, (const void*)item_data);
1099                         elm_object_style_set(check, "default/genlist_edit");
1100                         elm_object_part_content_set(item_data->ly, "elm.swallow.select_icon", item_data->chk);
1101                         elm_object_signal_emit(item_data->ly, "elm,state,select,enable", "elm");
1102                 }
1103         }
1104
1105         _bubble_change_edit_mode_title(bubble_data);
1106         _bubble_add_edit_controlbar(bubble_data);
1107         _bubble_add_navi_select_all_ly(bubble_data);
1108 }
1109
1110 void msg_ui_bubble_ctlbar_email_cb(void *data, Evas_Object *obj, void *event_info)
1111 {
1112         D_ENTER;
1113
1114         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1115         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1116         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1117         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1118
1119         msg_ui_bubble_close_title_menu_genlist(pData);
1120
1121         if (pData->addr_list.addr_cnt == 1) {
1122                 service_h svc_handle;
1123                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1124                         D_EMSG("service_create() is failed !!");
1125                 } else {
1126                         service_set_operation(svc_handle, SERVICE_OPERATION_SEND);
1127                         service_set_app_id(svc_handle, "email-composer-efl");
1128                         service_add_extra_data(svc_handle, "RUN_TYPE","5");
1129
1130                         Ecore_X_Window win_id = elm_win_xwindow_get(cd->main_window);
1131
1132                         service_set_window(svc_handle, win_id);
1133                         service_add_extra_data(svc_handle, SERVICE_DATA_TO, pData->addr_list.addr_info[0].address);
1134
1135                         service_send_launch_request(svc_handle, NULL, NULL);
1136
1137                         service_destroy(svc_handle);
1138                 }
1139         }
1140 }
1141
1142 void msg_ui_bubble_ctlbar_call_cb(void *data, Evas_Object *obj, void *event_info)
1143 {
1144         D_ENTER;
1145         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1146         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1147         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)cd->bubble_data;
1148         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1149
1150         if (pData->addr_list.addr_cnt == 1)
1151                 msg_ui_bubble_launch_voice_call(pData->addr_list.addr_info[0].address);
1152
1153         msg_ui_bubble_close_title_menu_genlist(pData);
1154 }
1155
1156 void msg_ui_bubble_ctlbar_vcall_cb(void *data, Evas_Object *obj, void *event_info)
1157 {
1158         D_ENTER;
1159         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1160         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1161         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1162         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1163
1164         if (pData->addr_list.addr_cnt == 1)
1165                 msg_ui_bubble_launch_video_call(pData->addr_list.addr_info[0].address);
1166
1167         msg_ui_bubble_close_title_menu_genlist(pData);
1168 }
1169
1170 void msg_ui_bubble_ctlbar_add_to_contact_cb(void *data, Evas_Object *obj, void *event_info)
1171 {
1172         D_ENTER;
1173         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1174         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1175
1176         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1177         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1178
1179         if (pData->addr_list.addr_cnt == 1)
1180                 msg_ui_composer_launch_contact_list_ug(cd, MSG_CT_UG_REQUEST_UPDATE_WITH_NUM, pData->addr_list.addr_info[0].address);
1181
1182         msg_ui_bubble_close_title_menu_genlist(pData);
1183 }
1184
1185 void msg_ui_bubble_ctlbar_view_ct_detail_cb(void *data, Evas_Object *obj, void *event_info)
1186 {
1187         D_ENTER;
1188         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1189
1190         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1191
1192         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1193         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1194
1195         if (pData->addr_list.addr_cnt == 1)
1196                 msg_ui_composer_launch_contact_detail_ug(cd, pData->addr_list.addr_info[0].contact_id);
1197
1198         msg_ui_bubble_close_title_menu_genlist(pData);
1199 }
1200
1201 void msg_ui_bubble_ctlbar_block_cb(void *data, Evas_Object *obj, void *event_info)
1202 {
1203         D_ENTER;
1204         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1205
1206         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
1207
1208         __msg_ui_bubble_create_block_popup(pData, pData->addr_list.addr_info[0].address);
1209
1210         msg_ui_bubble_close_title_menu_genlist(pData);
1211 }
1212
1213 void msg_ui_bubble_ctlbar_unblock_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 pData = data;
1219
1220         __msg_ui_bubble_unblock(pData, pData->addr_list.addr_info[0].address);
1221
1222         msg_ui_bubble_close_title_menu_genlist(pData);
1223 }
1224
1225 void msg_ui_bubble_ctlbar_delete_cb(void *data, Evas_Object *obj, void *event_info)
1226 {
1227         D_ENTER;
1228         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1229         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1230         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1231         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1232         MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, pData->del_thread);
1233
1234         if (pData->popup) {
1235                 evas_object_del(pData->popup);
1236                 pData->popup = NULL;
1237         }
1238
1239         bool isDraft = msg_ui_composer_common_is_send_possible(cd);
1240
1241         if (pData->sel_all_checked && isDraft == false) {
1242                 pData->bubble_count = 0;
1243                 _del_all_item(pData);
1244         } else {
1245                 pData->popup = msg_ui_bubble_show_notify_with_progressbar(pData, pData->check_cnt);
1246                 pData->del_thread = ecore_thread_feedback_run(_del_thread_fn, _del_thread_feedback_fn, NULL, NULL, (void *)pData, EINA_TRUE);
1247         }
1248
1249 }
1250
1251 void msg_ui_bubble_ctlbar_cancel_cb(void *data, Evas_Object *obj, void *event_info)
1252 {
1253         D_ENTER;
1254         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1255         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1256         PMSG_BUBBLE_DATA pData = cd->bubble_data;
1257         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1258
1259         _bubble_show_normal_mode(data);
1260
1261         if (pData->added_list)
1262                 pData->add_animator = ecore_animator_add(msg_ui_bubble_item_add_cb, (const void *) pData);
1263
1264         msg_ui_composer_last_focus_load(cd);
1265 }
1266
1267 void msg_ui_bubble_sel_all_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1268 {
1269         MSG_UI_ENTER();
1270
1271         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA) data;
1272         PMSG_APP_CONV_DATA_S item_data = NULL;
1273
1274         D_MSG("pData->sel_all_checked = %d", pData->sel_all_checked);
1275
1276         if (pData->sel_all_checked) {
1277                 pData->check_cnt = pData->bubble_count;
1278                 pData->chk_list = eina_list_clone(pData->bubble_list);
1279         } else {
1280                 pData->check_cnt = 0;
1281                 pData->chk_list = eina_list_free(pData->chk_list);
1282         }
1283
1284         Eina_List *l;
1285         EINA_LIST_FOREACH(pData->bubble_list, l, item_data) {
1286                 if (item_data) {
1287                         item_data->isCheck = pData->sel_all_checked;
1288                 }
1289         }
1290
1291         EINA_LIST_FOREACH(pData->realized_list, l, item_data) {
1292                 if (item_data) {
1293                         elm_check_state_set(item_data->chk, item_data->isCheck);
1294                 }
1295         }
1296
1297         msg_ui_bubble_show_select_info(pData);
1298
1299         MSG_UI_LEAVE();
1300 }
1301
1302 void msg_ui_bubble_item_mouse_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1303 {
1304         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !event_info);
1305
1306         Evas_Coord x, y;
1307         Evas_Event_Mouse_Down *ev = event_info;
1308
1309         PMSG_APP_CONV_DATA_S item_data = (PMSG_APP_CONV_DATA_S)data;
1310         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)evas_object_data_get(item_data->ly, "bubble_data");
1311
1312         x = ev->canvas.x;
1313         y = ev->canvas.y;
1314
1315         if (abs(x - g_mouse_down_x) > 20 || abs(y - g_mouse_down_y) > 20) {
1316                 goto RESET_EVAS_COORD;
1317         }
1318
1319         if (elm_check_state_get(item_data->chk) == EINA_TRUE)
1320                 elm_check_state_set(item_data->chk, EINA_FALSE);
1321         else
1322                 elm_check_state_set(item_data->chk, EINA_TRUE);
1323
1324         msg_ui_bubble_list_checked_cb((void *)bubble_data, item_data->chk, NULL);
1325
1326 RESET_EVAS_COORD:
1327         evas_object_event_callback_del(item_data->ly, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_item_mouse_up_cb);
1328         g_mouse_down_x = 0;
1329         g_mouse_down_y = 0;
1330 }
1331
1332 void msg_ui_bubble_item_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1333 {
1334         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !event_info);
1335
1336         PMSG_APP_CONV_DATA_S item_data = (PMSG_APP_CONV_DATA_S)data;
1337
1338         Evas_Event_Mouse_Down *ev = event_info;
1339
1340         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1341                 return;
1342
1343         g_mouse_down_x = ev->canvas.x;
1344         g_mouse_down_y = ev->canvas.y;
1345
1346         evas_object_event_callback_add(item_data->ly, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_item_mouse_up_cb, (const void*)item_data);
1347 }
1348
1349 #ifdef _BUBBLE_FLICK_EVENT
1350 void msg_ui_bubble_layout_mouse_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1351 {
1352         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1353         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !event_info);
1354
1355         Evas_Coord x, y, w, h;
1356         Evas_Event_Mouse_Down *ev = event_info;
1357         int width = 0;
1358         int rotate = 0;
1359         Evas_Coord start_x;
1360         Evas_Coord start_y;
1361         Evas_Coord end_x;
1362         Evas_Coord end_y;
1363         int move_x = 0;
1364         int move_y = 0;
1365
1366         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1367         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)bubble_data->callback_data;
1368
1369         evas_object_geometry_get(bubble_data->bubble_layout, &x, &y, &w, &h);
1370
1371         rotate = elm_win_rotation_get(cd->main_window);
1372         if (rotate == 0) {
1373                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "PORTRAIT mode");
1374                 start_x = bubble_data->m_x;
1375                 end_x = ev->canvas.x;
1376                 start_y = bubble_data->m_y;
1377                 end_y = ev->canvas.y;
1378                 width = w-x;
1379         } else if (rotate == 180) {
1380                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "PORTRAIT reverse mode");
1381                 start_x = ev->canvas.x;
1382                 end_x = bubble_data->m_x;
1383                 start_y = bubble_data->m_y;
1384                 end_y = ev->canvas.y;
1385                 width = w-x;
1386         } else if (rotate == 90) {
1387                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "LANDSCAPE mode");
1388                 start_x = ev->canvas.y;
1389                 end_x = bubble_data->m_y;
1390                 start_y = bubble_data->m_x;
1391                 end_y = ev->canvas.x;
1392                 width = h-y;
1393         } else if (rotate== 270) {
1394                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "LANDSCAPE reverse mode");
1395                 start_x = bubble_data->m_y;
1396                 end_x = ev->canvas.y;
1397                 start_y = bubble_data->m_x;
1398                 end_y = ev->canvas.x;
1399                 width = h-y;
1400         } else {
1401                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Invalid rotation value");
1402                 evas_object_event_callback_del(bubble_data->bubble_layout, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_layout_mouse_up_cb);
1403                 return;
1404         }
1405
1406         move_x = abs(start_x - end_x);
1407         move_y = abs(start_y - end_y);
1408
1409         if (move_x > move_y) {
1410                 if (move_x > (width / 3)) { // It should be moved over 1/3 of the screen width to show next/previous converstaions.
1411                         int row = 0;
1412                         int selected = 0;
1413                         msg_struct_list_s peerList = {0,};
1414                         msg_struct_t sortRule = NULL;
1415                         msg_struct_list_s addrList = {0,};
1416
1417                         sortRule = msg_create_struct(MSG_STRUCT_SORT_RULE);
1418                         msg_set_int_value(sortRule, MSG_SORT_RULE_SORT_TYPE_INT, MSG_SORT_BY_THREAD_DATE);
1419                         msg_set_bool_value(sortRule, MSG_SORT_RULE_ACSCEND_BOOL, false);
1420
1421                         msg_get_thread_view_list(cd->msg_handle, sortRule, &peerList);
1422                         msg_release_struct(&sortRule);
1423
1424                         for (row=0; row < peerList.nCount; row++) {
1425                                 int thread_id = 0;
1426                                 msg_get_int_value(peerList.msg_struct_info[row], MSG_THREAD_ID_INT, &thread_id);
1427
1428                                 if (bubble_data->threadId == thread_id) {
1429                                         msg_ui_bubble_init_bubble_list(bubble_data);
1430                                         if (start_x > end_x) // show next
1431                                                 selected = row+1 < peerList.nCount ? row+1 : 0;
1432                                         else // show previous
1433                                                 selected = row-1 < 0 ? peerList.nCount-1 : row-1;
1434
1435                                         int selecte_thread_id = 0;
1436                                         msg_get_int_value(peerList.msg_struct_info[selected], MSG_THREAD_ID_INT, &selecte_thread_id);
1437                                         bubble_data->threadId = selecte_thread_id;
1438
1439                                         msg_get_address_list(bubble_data->msgHandle, bubble_data->threadId, &addrList);
1440
1441                                         bubble_data->addr_list.addr_cnt = addrList.nCount;
1442                                         int i = 0;
1443
1444                                         /* clear recipient_list of bubble composer */
1445                                         msg_ui_composer_recipient_clear_recipient_list(cd);
1446
1447                                         for (i=0; i < addrList.nCount; i++) {
1448                                                 int contact_id = 0;
1449
1450                                                 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);
1451                                                 msg_get_int_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_CONTACT_ID_INT, &contact_id);
1452
1453                                                 if (contact_id > 0) {
1454                                                         bubble_data->addr_list.addr_info[i].contact_id = contact_id;
1455                                                         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);
1456                                                 } else {
1457                                                         bubble_data->addr_list.addr_info[i].contact_id = 0;
1458                                                 }
1459
1460                                                 /* set recipient_list for bubble composer */
1461                                                 msg_ui_composer_recipient_add_recipient_list(cd, addrList.addrInfo[i].addressVal);
1462                                         }
1463
1464                                         // bubble list update
1465                                         msg_ui_bubble_list_load(bubble_data);
1466                                         msg_ui_composer_navi_title_set((void *)cd);
1467                                         service_h svc_handle;
1468                                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1469                                                 D_EMSG("service_create() is failed !!");
1470                                         } else {
1471                                                 char buf[DEF_BUF_LEN_S] = {0,};
1472                                                 snprintf(buf, DEF_BUF_LEN_L, "%d", bubble_data->threadId);
1473                                                 service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_THREAD_ID, buf);
1474
1475                                                 ug_send_result(cd->ug, svc_handle);
1476
1477                                                 service_destroy(svc_handle);
1478                                         }
1479
1480                                         msg_release_list_struct(&addrList);
1481
1482                                         break;
1483                                 }
1484                         }
1485                         msg_release_list_struct(&peerList);
1486                 }
1487         }
1488         evas_object_event_callback_del(bubble_data->bubble_layout, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_layout_mouse_up_cb);
1489 }
1490
1491 void msg_ui_bubble_layout_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1492 {
1493         D_ENTER;
1494
1495         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, data == NULL);
1496         PMSG_BUBBLE_DATA bubble_data = (PMSG_BUBBLE_DATA)data;
1497
1498         Evas_Event_Mouse_Down *ev = (Evas_Event_Mouse_Down *)event_info;
1499
1500         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1501                 return;
1502
1503         bubble_data->m_x = ev->canvas.x;
1504         bubble_data->m_y = ev->canvas.y;
1505
1506         evas_object_event_callback_add(bubble_data->bubble_layout, EVAS_CALLBACK_MOUSE_UP, msg_ui_bubble_layout_mouse_up_cb, (const void*)bubble_data);
1507 }
1508 #endif
1509
1510 void msg_ui_bubble_list_checked_cb(void *data, Evas_Object *obj, void *event_info)
1511 {
1512         MSG_UI_ENTER();
1513
1514         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA) data;
1515         PMSG_APP_CONV_DATA_S item_data = NULL;
1516
1517         item_data = evas_object_data_get(obj, "item_data");
1518
1519         if (item_data->isCheck) {
1520                 pData->check_cnt++;
1521                 if (!eina_list_data_find(pData->chk_list, item_data))
1522                         pData->chk_list = eina_list_append(pData->chk_list, item_data);
1523         } else {
1524                 pData->check_cnt--;
1525                 pData->chk_list = eina_list_remove(pData->chk_list, item_data);
1526         }
1527
1528         if (pData->bubble_count == pData->check_cnt)
1529                 elm_check_state_set(pData->sel_all_box, EINA_TRUE);
1530         else
1531                 elm_check_state_set(pData->sel_all_box, EINA_FALSE);
1532
1533         msg_ui_bubble_show_select_info(pData);
1534
1535         MSG_UI_LEAVE();
1536 }
1537
1538 void msg_ui_bubble_timezone_change_cb(keynode_t *key, void *data)
1539 {
1540         D_ENTER;
1541
1542         PMSG_BUBBLE_DATA BubbleData = (PMSG_BUBBLE_DATA)data;
1543
1544         char *timezone_id = NULL;
1545         UChar utimezone_id[DEF_BUF_LEN] = {0,};
1546         UErrorCode status = U_ZERO_ERROR;
1547
1548         timezone_id = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
1549
1550         if (!timezone_id)
1551                 return;
1552
1553         u_uastrcpy(utimezone_id, timezone_id);
1554
1555         ucal_setDefaultTimeZone(utimezone_id, &status);
1556
1557         if (U_FAILURE(status))
1558                 return;
1559
1560         msg_ui_bubble_get_locale(BubbleData);
1561         msg_ui_bubble_get_time_format(BubbleData);
1562
1563         if (BubbleData->date_ptn_default) {
1564                 free(BubbleData->date_ptn_default);
1565                 BubbleData->date_ptn_default = NULL;
1566         }
1567
1568         if (BubbleData->date_ptn_year) {
1569                 free(BubbleData->date_ptn_year);
1570                 BubbleData->date_ptn_year = NULL;
1571         }
1572
1573         if (BubbleData->time_12h_ptn) {
1574                 free(BubbleData->time_12h_ptn);
1575                 BubbleData->time_12h_ptn = NULL;
1576         }
1577
1578         if (BubbleData->time_24h_ptn) {
1579                 free(BubbleData->time_24h_ptn);
1580                 BubbleData->time_24h_ptn = NULL;
1581         }
1582
1583         BubbleData->time_12h_ptn = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_TIME_PATTERN_12H);
1584         BubbleData->time_24h_ptn = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_TIME_PATTERN_24H);
1585         BubbleData->date_ptn_default = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_DATE_PATTERN_DEFAULT);
1586         BubbleData->date_ptn_year = msg_common_get_date_best_pattern(BubbleData->locale, MSG_UI_DATE_PATTERN_YEAR);
1587
1588         msg_ui_bubble_list_data_update(BubbleData);
1589
1590         D_LEAVE;
1591 }
1592
1593 void msg_ui_bubble_scroll_edge_top_cb(void *data, Evas_Object *obj, void *event_info)
1594 {
1595         D_ENTER;
1596
1597         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
1598
1599         evas_object_smart_callback_del(obj, "scroll,drag,start", msg_ui_bubble_scroll_drag_start_cb);
1600
1601         if (!pData->load_animator)
1602                 pData->load_animator = ecore_animator_add(msg_ui_bubble_item_load_cb, data);
1603
1604         D_LEAVE;
1605 }
1606
1607 void msg_ui_bubble_scroll_drag_start_cb(void *data, Evas_Object *obj, void *event_info)
1608 {
1609         D_ENTER;
1610
1611         PMSG_BUBBLE_DATA pData = (PMSG_BUBBLE_DATA)data;
1612
1613         evas_object_smart_callback_add(obj, "edge,top", msg_ui_bubble_scroll_edge_top_cb, (void *)pData);
1614
1615         D_LEAVE;
1616 }
1617
1618 void msg_ui_bubble_anchor_menu_click_cb(void *data, Evas_Object *obj, void *event_info)
1619 {
1620         D_ENTER;
1621         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !data || !obj);
1622         MSG_COMPOSER_VIEW_DATA_S *cd = data;
1623         PMSG_BUBBLE_DATA bubble_data = cd->bubble_data;
1624         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !bubble_data);
1625
1626         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1627         elm_list_item_selected_set(item, 0);
1628
1629         const char *label = elm_object_item_text_get(item);
1630         const char *title =  elm_object_part_text_get(bubble_data->popup, "title,text");
1631
1632         if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_CALL")) == 0) {
1633                 msg_ui_bubble_launch_voice_call(title);
1634         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_SEND_MESSAGE")) == 0) {
1635                 service_h svc_handle;
1636                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1637                         D_EMSG("service_create() is failed !!");
1638                 } else {
1639                         service_add_extra_data(svc_handle, MSG_BUNDLE_KEY_TO, title);
1640                         msg_ui_composer_launch_composer_create(cd, svc_handle);
1641                         if (!cd->loaded_ug)
1642                                 msg_ui_bubble_show_notify(bubble_data, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_POP_UNABLE_TO_OPEN"));
1643
1644                         service_destroy(svc_handle);
1645                 }
1646
1647         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_BODY_VIDEO_CALL")) == 0) {
1648                 msg_ui_bubble_launch_video_call(title);
1649         } else if (g_strcmp0(label, dgettext("sys_string", "IDS_COM_OPT_ADD_TO_CONTACTS")) == 0) { /* Add to contact with phone number string... */
1650                 msg_ui_composer_launch_contact_list_ug(cd, MSG_CT_UG_REQUEST_UPDATE_WITH_NUM, title);
1651         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGC_OPT_VIEW_CONTACT")) == 0) {
1652                 msg_ui_composer_launch_contact_detail_ug(cd, bubble_data->addr_list.addr_info[0].contact_id);
1653         } else if (g_strcmp0(label, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_SEND_EMAIL")) == 0) {
1654                 service_h svc_handle;
1655                 if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
1656                         D_EMSG("service_create() is failed !!");
1657                 } else {
1658                         service_set_operation(svc_handle, SERVICE_OPERATION_SEND);
1659                         service_set_app_id(svc_handle, "email-composer-efl");
1660                         service_add_extra_data(svc_handle, "RUN_TYPE","5");
1661
1662                         Ecore_X_Window win_id = elm_win_xwindow_get(cd->main_window);
1663
1664                         service_set_window(svc_handle, win_id);
1665                         service_add_extra_data(svc_handle, SERVICE_DATA_TO, title);
1666
1667                         service_send_launch_request(svc_handle, NULL, NULL);
1668
1669                         service_destroy(svc_handle);
1670                 }
1671         }
1672
1673         if (bubble_data->popup) {
1674                 evas_object_del(bubble_data->popup);
1675                 bubble_data->popup = NULL;
1676         }
1677
1678         D_LEAVE;
1679 }
1680
1681 void msg_ui_bubble_main_layout_clicked_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1682 {
1683         D_ENTER;
1684         D_MSG_RETM_IF(data == NULL, "data is NULL");
1685         MSG_COMPOSER_VIEW_DATA_S *cd = (MSG_COMPOSER_VIEW_DATA_S *)data;
1686
1687         if (!cd->is_keypad_show)
1688                 msg_ui_composer_make_default_body_size(cd);
1689
1690         cd->make_default_body_size = true;
1691
1692         D_LEAVE;
1693 }
1694