thread/src/msg-ui-thread-list.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://www.tizenopensource.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-thread-main.h"
  18
  19 static int __msg_ui_thread_init_genlist(PMSG_THREAD_LIST_DATA pListData);
  20 static char *__msg_ui_thread_gl_text_get(void *data, Evas_Object *obj, const char *part);
  21 static Evas_Object *__msg_ui_thread_gl_content_get(void *data, Evas_Object *obj, const char *part);
  22 static void __msg_ui_thread_gl_del(void *data, Evas_Object *obj);
  23 static void __msg_ui_thread_gl_sel(void *data, Evas_Object *obj, void *event_info);
  24 Eina_Bool __msg_ui_thread_list_load_remain_item(void *data);
  25 void __msg_ui_thread_create_bubble_by_msgid(PMSG_THREAD_LIST_DATA pListData, PMSG_APP_THREAD_MSG_DATA_S item_data);
  26
  27
  28 static int __msg_ui_thread_init_genlist(PMSG_THREAD_LIST_DATA pListData)
  29 {
  30         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
  31
  32         if (pListData->genlist)
  33                 elm_genlist_clear(pListData->genlist);
  34
  35         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
  36
  37         return MSG_UI_RET_SUCCESS;
  38 }
  39
  40 void msg_ui_thread_set_thread_data(PMSG_THREAD_LIST_DATA pListData, PMSG_APP_THREAD_DATA_S thread_data, msg_struct_t msgThreadInfo)
  41 {
  42         if (thread_data == NULL || msgThreadInfo == NULL)
  43                 return;
  44
  45         int thread_id = 0, unreadCnt = 0, msgType = 0, direction = 0, smsCnt = 0, mmsCnt = 0;
  46         char name[DEF_THREAD_NAME_LEN+1] = {0,};
  47         char threadData[DEF_BUF_LEN_S+1] = {0,};
  48
  49         msg_get_int_value(msgThreadInfo, MSG_THREAD_ID_INT, &thread_id);
  50         thread_data->thread_id = thread_id;
  51
  52         msg_get_str_value(msgThreadInfo, MSG_THREAD_NAME_STR, name, DEF_THREAD_NAME_LEN);
  53         bzero(thread_data->thread_name, sizeof(thread_data->thread_name));
  54         strncpy(thread_data->thread_name, name, DEF_THREAD_NAME_LEN);
  55
  56         msg_get_str_value(msgThreadInfo, MSG_THREAD_MSG_DATA_STR, threadData, DEF_BUF_LEN_S);
  57         bzero(thread_data->thread_data, sizeof(thread_data->thread_data));
  58         strncpy(thread_data->thread_data, threadData, DEF_BUF_LEN_S);
  59
  60         if (thread_data->thread_time == NULL)
  61                 thread_data->thread_time = (time_t *) calloc(1, sizeof(time_t));
  62
  63         if (thread_data->thread_time) {
  64                 int msgTime = 0;
  65                 msg_get_int_value(msgThreadInfo, MSG_THREAD_MSG_TIME_INT, &msgTime);
  66                 bzero(thread_data->thread_time, sizeof(time_t));
  67                 memcpy(thread_data->thread_time, &msgTime, sizeof(time_t));
  68         }
  69
  70         msg_get_int_value(msgThreadInfo, MSG_THREAD_MSG_TYPE_INT, &msgType);
  71         thread_data->msg_type =  msgType;
  72         msg_get_int_value(msgThreadInfo, MSG_THREAD_MMS_COUNT_INT, &mmsCnt);
  73         thread_data->mms_cnt = mmsCnt;
  74         msg_get_int_value(msgThreadInfo, MSG_THREAD_SMS_COUNT_INT, &smsCnt);
  75         thread_data->sms_cnt = smsCnt;
  76         msg_get_int_value(msgThreadInfo, MSG_THREAD_DIRECTION_INT, &direction);
  77         thread_data->direction = direction;
  78
  79         if (pListData && pListData->sel_thread_id == thread_data->thread_id) {
  80                 thread_data->unread_cnt = 0;
  81         } else {
  82                 msg_get_int_value(msgThreadInfo, MSG_THREAD_UNREAD_COUNT_INT, &unreadCnt);
  83                 thread_data->unread_cnt = unreadCnt;
  84         }
  85 }
  86
  87 void msg_ui_thread_set_msg_data(PMSG_APP_THREAD_MSG_DATA_S msg_data, msg_struct_t msgInfo)
  88 {
  89         if (msg_data == NULL || msgInfo == NULL)
  90                 return;
  91
  92         int msgId = 0;
  93         int msgType = 0;
  94         int direction = 0;
  95         bool read_status = 0;
  96         msg_struct_list_s *addr_list = NULL;
  97         char strNumber[DEF_THREAD_ADDR_LEN+1] = {0,};
  98         char strName[DEF_THREAD_NAME_LEN+1] = {0,};
  99         int contact_id = 0;
 100         int i = 0;
 101
 102         /* msg_id */
 103         msg_get_int_value(msgInfo, MSG_MESSAGE_ID_INT, &msgId);
 104         msg_data->msg_id = msgId;
 105         /* msg_type */
 106         msg_get_int_value(msgInfo, MSG_MESSAGE_TYPE_INT, &msgType);
 107         msg_data->msg_type = msgType;
 108         /* read status */
 109         msg_get_bool_value(msgInfo, MSG_MESSAGE_READ_BOOL, &read_status);
 110         msg_data->is_read = read_status;
 111
 112         msg_get_int_value(msgInfo, MSG_MESSAGE_DIRECTION_INT, &direction);
 113         msg_data->direction = direction;
 114
 115         /* contact ID, display name  */
 116         msg_get_list_handle(msgInfo, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addr_list);
 117
 118         msg_data->addr_info = (PMSG_APP_THREAD_ADDR_INFO_S *)calloc(1, sizeof(PMSG_APP_THREAD_ADDR_INFO_S) * addr_list->nCount);
 119         msg_data->addr_cnt = addr_list->nCount;
 120
 121         for (i = 0; i < addr_list->nCount; i++) {
 122                 msg_data->addr_info[i] = (PMSG_APP_THREAD_ADDR_INFO_S)calloc(1, sizeof(MSG_APP_THREAD_ADDR_INFO_S));
 123
 124                 msg_get_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, strNumber, DEF_THREAD_ADDR_LEN);
 125                 msg_get_str_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_DISPLAYNAME_STR, strName, DEF_THREAD_NAME_LEN);
 126                 msg_get_int_value(addr_list->msg_struct_info[i], MSG_ADDRESS_INFO_CONTACT_ID_INT, &contact_id);
 127
 128                 msg_data->addr_info[i]->contact_id = contact_id;
 129
 130                 if (strlen(strName) > 0)
 131                         strncpy(msg_data->addr_info[i]->display_name, strName, sizeof(msg_data->addr_info[i]->display_name) -1);
 132                 else
 133                         strncpy(msg_data->addr_info[i]->display_name, "", sizeof(msg_data->addr_info[i]->display_name)-1);
 134
 135                 if (strlen(strNumber) > 0)
 136                         strncpy(msg_data->addr_info[i]->address, strNumber, sizeof(msg_data->addr_info[i]->address)-1);
 137                 else
 138                         strncpy(msg_data->addr_info[i]->address, "", sizeof(msg_data->addr_info[i]->address)-1);
 139         }
 140
 141         /*body*/
 142         const char *pContent = NULL;
 143         int msgSize = 0;
 144         msg_get_int_value(msgInfo, MSG_MESSAGE_DATA_SIZE_INT, &msgSize);
 145         char msgText[msgSize + 1];
 146         char subject[DEF_BUF_LEN_S+1] = {0,};
 147         memset(msgText, 0, msgSize + 1);
 148
 149         msg_get_str_value(msgInfo, MSG_MESSAGE_SMS_DATA_STR, msgText, msgSize);
 150         msg_get_str_value(msgInfo, MSG_MESSAGE_SUBJECT_STR, subject, DEF_BUF_LEN_S);
 151
 152         if (msg_data->msg_type >= MSG_TYPE_MMS && msg_data->msg_type <= MSG_TYPE_MMS_NOTI) {
 153                 if (strlen(subject) > 0)
 154                         pContent = subject;
 155                 else
 156                         pContent = msgText;
 157         } else {
 158                 pContent = msgText;
 159         }
 160
 161         if (strlen(pContent) > 0)
 162                 strncpy(msg_data->msg_body, pContent, sizeof(msg_data->msg_body)-1);
 163         else
 164                 strncpy(msg_data->msg_body, "", sizeof(msg_data->msg_body)-1);
 165
 166         msg_data->msg_time = (time_t *)calloc(1, sizeof(time_t));
 167         if (msg_data->msg_time != NULL) {
 168                 int msgTime = 0;
 169                 msg_get_int_value(msgInfo, MSG_MESSAGE_DISPLAY_TIME_INT, &msgTime);
 170                 memcpy(msg_data->msg_time, &msgTime, sizeof(time_t));
 171         }
 172 }
 173
 174 static char *__msg_ui_thread_gl_text_get(void *data, Evas_Object *obj, const char *part)
 175 {
 176         PMSG_APP_THREAD_DATA_S item_data = (PMSG_APP_THREAD_DATA_S) data;
 177         char buf[DEF_BUF_LEN] = { 0, };
 178
 179         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !item_data, NULL);
 180
 181         if (g_strcmp0(part, "elm.text.1") == 0) {
 182                 if (item_data->thread_name[0] != '\0')
 183                         snprintf(buf, sizeof(buf), "%s", item_data->thread_name);
 184                 else
 185                         snprintf(buf, sizeof(buf), dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
 186         } else if (g_strcmp0(part, "elm.text.2") == 0) {
 187                 msg_ui_thread_make_time_string(item_data->thread_time, buf, sizeof(buf));
 188         } else if (g_strcmp0(part, "elm.text.3") == 0) {
 189                 int idx = 0;
 190                 char msg[DEF_BUF_LEN] = { 0, };
 191
 192                 if (item_data->thread_data[0] != '\0') {
 193                         strncpy(msg, item_data->thread_data, sizeof(msg) - 1);
 194                         while (msg[idx]) {
 195                                 if (g_ascii_iscntrl(msg[idx]))
 196                                         msg[idx] = ' ';
 197                                 idx++;
 198                         }
 199                         snprintf(buf, sizeof(buf), "%s", msg);
 200                 } else {
 201                         if (item_data->msg_type >= MSG_TYPE_MMS && item_data->msg_type <= MSG_TYPE_MMS_NOTI)
 202                                 snprintf(buf, sizeof(buf), "(%s)", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_NO_SUBJECT"));
 203                 }
 204         } else if (g_strcmp0(part, "elm.text.4") == 0) {
 205                 if (item_data->unread_cnt > 0) {
 206                         if (item_data->unread_cnt > 999)
 207                                 snprintf(buf, sizeof(buf), "...");
 208                         else
 209                                 snprintf(buf, sizeof(buf), "%d", item_data->unread_cnt);
 210                 } else {
 211                         msg_struct_list_s draft_list;
 212                         msg_get_message_list(msg_ui_thread_get_data_handle(), MSG_DRAFT_ID, item_data->thread_id, 0, MSG_STORAGE_PHONE, &draft_list);
 213
 214                         if (draft_list.nCount > 0)
 215                                 snprintf(buf, sizeof(buf), "%s", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_HEADER_DRAFT_ABB"));
 216
 217                         msg_release_list_struct(&draft_list);
 218                 }
 219         }
 220
 221         return strdup(buf);
 222 }
 223
 224 static Evas_Object *__msg_ui_thread_gl_content_get(void *data, Evas_Object *obj, const char *part)
 225 {
 226         PMSG_APP_THREAD_DATA_S item_data = (PMSG_APP_THREAD_DATA_S) data;
 227         PMSG_THREAD_LIST_DATA pListData = NULL;
 228         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !item_data, NULL);
 229
 230         Evas_Object *ic = NULL;
 231         bool bNumExist = false;
 232         bool isBlock = true;
 233
 234         pListData = msg_ui_thread_get_current_list();
 235         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !pListData, NULL);
 236
 237         if (g_strcmp0(part, "elm.slide.swallow.1") == 0 || g_strcmp0(part, "elm.slide.swallow.2") == 0 || g_strcmp0(part, "elm.slide.swallow.3") == 0) {
 238                 int i = 0;
 239                 msg_struct_list_s addrList;
 240
 241                 memset(&addrList, 0x00, sizeof(msg_struct_list_s));
 242                 msg_get_address_list(msg_ui_thread_get_data_handle(), item_data->thread_id, &addrList);
 243
 244                 for (i=0; i<addrList.nCount; i++) {
 245                         int addressType = 0;
 246
 247                         msg_get_int_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_TYPE_INT, &addressType);
 248                         if (addressType == MSG_ADDRESS_TYPE_PLMN) {
 249                                 bNumExist = true;
 250                                 break;
 251                         }
 252                 }
 253
 254                 for (i=0; i<addrList.nCount; i++) {
 255                         char address[DEF_THREAD_ADDR_LEN+1] = {0,};
 256
 257                         msg_get_str_value(addrList.msg_struct_info[i], MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, address, DEF_THREAD_ADDR_LEN);
 258                         msg_common_check_block_number(msg_ui_thread_get_data_handle(), address, &isBlock);
 259                         if (isBlock == false)
 260                                 break;
 261                 }
 262                 msg_release_list_struct(&addrList);
 263         }
 264
 265         if (g_strcmp0(part, "elm.icon.1") == 0) {
 266                 if (item_data->msg_type == MSG_TYPE_SMS_CB) {
 267                         ic = elm_icon_add(obj);
 268                         elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_CB_ICON);
 269                 } else if (item_data->msg_type == MSG_TYPE_SMS_WAPPUSH) {
 270                         ic = elm_icon_add(obj);
 271                         elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_PUSH_ICON);
 272                 } else if (item_data->msg_type == MSG_TYPE_SMS_SYNCML) {
 273                         ic = elm_icon_add(obj);
 274                         elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_OTA_ICON);
 275                 }
 276
 277                 if (ic) {
 278                         evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 279                         evas_object_show(ic);
 280                 }
 281         } else if (g_strcmp0(part, "elm.slide.swallow.1") == 0) {
 282                 ic = elm_button_add(obj);
 283                 elm_object_style_set(ic, "sweep/multiline");
 284                 elm_object_text_set(ic, dgettext("sys_string", "IDS_COM_BODY_CALL"));
 285                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 286                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 287
 288                 if (bNumExist == false)
 289                         elm_object_disabled_set(ic, EINA_TRUE);
 290         } else if (g_strcmp0(part, "elm.slide.swallow.2") == 0) {
 291                 ic = elm_button_add(obj);
 292                 elm_object_style_set(ic, "sweep/multiline");
 293                 elm_object_text_set(ic, dgettext("sys_string", "IDS_COM_SK_VIDEO_CALL"));
 294                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 295                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 296
 297                 if (bNumExist == false)
 298                         elm_object_disabled_set(ic, EINA_TRUE);
 299         } else if (g_strcmp0(part, "elm.slide.swallow.3") == 0) {
 300                 ic = elm_button_add(obj);
 301                 elm_object_style_set(ic, "sweep/multiline");
 302
 303                 if (isBlock == false)
 304                         elm_object_text_set(ic, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_BLOCK"));
 305                 else
 306                         elm_object_text_set(ic, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_OPT_UNBLOCK"));
 307
 308                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 309                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 310
 311                 if (bNumExist == false)
 312                         elm_object_disabled_set(ic, EINA_TRUE);
 313         } else if (g_strcmp0(part, "elm.slide.swallow.4") == 0) {
 314                 ic = elm_button_add(obj);
 315                 elm_object_style_set(ic, "sweep/delete");
 316                 elm_object_text_set(ic, dgettext("sys_string", "IDS_COM_SK_DELETE"));
 317                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 318                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 319         }
 320
 321         if (elm_genlist_decorate_mode_get(obj)) {
 322                 if (!strcmp(part, "elm.edit.icon.1")) {
 323                         ic = elm_check_add(obj);
 324                         elm_check_state_pointer_set(ic, &item_data->is_check);
 325                         evas_object_data_set(ic, "item_data", item_data);
 326                         evas_object_smart_callback_add(ic, "changed", msg_ui_thread_list_checked_cb, pListData);
 327                         item_data->chk = ic;
 328                 }
 329         }
 330
 331         return ic;
 332 }
 333
 334 static void __msg_ui_thread_gl_del(void *data, Evas_Object *obj)
 335 {
 336         PMSG_APP_THREAD_DATA_S del_data = (PMSG_APP_THREAD_DATA_S) data;
 337
 338         if (del_data) {
 339                 if (del_data->thread_time) {
 340                         free(del_data->thread_time);
 341                         del_data->thread_time = NULL;
 342                 }
 343                 free(del_data);
 344                 del_data = NULL;
 345         }
 346 }
 347
 348 static void __msg_ui_thread_gl_sel(void *data, Evas_Object *obj, void *event_info)
 349 {
 350         PMSG_THREAD_LIST_DATA pListData = (PMSG_THREAD_LIST_DATA) data;
 351         Elm_Object_Item *item = NULL;
 352         Elm_Object_Item* it_sweep = NULL;
 353         PMSG_APP_THREAD_DATA_S item_data = NULL;
 354         service_h svc_handle = NULL;
 355
 356         item = (Elm_Object_Item *) event_info;
 357         MSG_UI_RETM_IF(MSG_UI_LEVEL_DEBUG, !item, "Item is  NULL or Item is not Message item\n");
 358
 359         item_data = (PMSG_APP_THREAD_DATA_S) elm_object_item_data_get(item);
 360         MSG_UI_RETM_IF(MSG_UI_LEVEL_ERR, item_data == NULL, "item_data is NULL");
 361
 362         MSG_UI_RETM_IF(MSG_UI_LEVEL_DEBUG, pListData->sel_thread_id == item_data->thread_id, "Already selected item.");
 363
 364         it_sweep = (Elm_Object_Item *)elm_genlist_decorated_item_get(pListData->genlist);
 365         if (it_sweep) {
 366                 elm_genlist_item_decorate_mode_set(it_sweep, "slide", EINA_FALSE);
 367                 elm_genlist_item_select_mode_set(it_sweep, ELM_OBJECT_SELECT_MODE_DEFAULT);
 368         }
 369
 370         if (pListData->search_mode == THREAD_SEARCH_ON)
 371                 msg_ui_thread_show_toolbar(pListData);
 372
 373         switch (pListData->view_mode) {
 374                 case THREAD_NORMAL_VIEW:
 375                 case THREAD_UNLOAD_VIEW:
 376                         pListData->sel_gen_item = item;
 377                         pListData->sel_thread_id = item_data->thread_id;
 378
 379                         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 380                                 D_EMSG("service_create() is failed !!");
 381                         } else {
 382                                 msg_struct_list_s draft_list;
 383                                 int draft_id = 0;
 384                                 MessageComposerUgType ug_type = MSG_COMPOSER_UG_TYPE_NONE;
 385                                 msg_get_message_list(msg_ui_thread_get_data_handle(), MSG_DRAFT_ID, item_data->thread_id, 0, MSG_STORAGE_PHONE, &draft_list);
 386
 387                                 if (draft_list.nCount > 0 && (item_data->sms_cnt + item_data->mms_cnt) == 1) {
 388                                         msg_get_int_value(draft_list.msg_struct_info[0], MSG_MESSAGE_ID_INT, &draft_id);
 389                                         msg_ui_thread_get_composer_data(draft_id, svc_handle);
 390                                         ug_type = MSG_COMPOSER_UG_TYPE_COMPOSER;
 391                                 } else {
 392                                         msg_ui_thread_get_bubble_data(item_data, svc_handle);
 393                                         ug_type = MSG_COMPOSER_UG_TYPE_VIEWER;
 394                                 }
 395
 396                                 msg_release_list_struct(&draft_list);
 397
 398                                 if (msg_ui_load_composer_ug(svc_handle, ug_type) == MSG_UI_RET_ERR) {
 399                                         D_MSG("Failed to load composer ug");
 400
 401                                         pListData->sel_gen_item = NULL;
 402                                         pListData->sel_thread_id = 0;
 403                                 }
 404
 405                                 service_destroy(svc_handle);
 406                         }
 407
 408                         item_data->unread_cnt = 0;
 409                         elm_genlist_item_item_class_update(item, &pListData->itc_default);
 410                         elm_genlist_item_update(item);
 411                         break;
 412                 case THREAD_EDIT_VIEW:
 413                         elm_genlist_item_selected_set(item, false);
 414                         item_data->is_check = !item_data->is_check;
 415                         elm_genlist_item_fields_update(item, "elm.edit.icon.1", ELM_GENLIST_ITEM_FIELD_CONTENT);
 416                         evas_object_smart_callback_call(item_data->chk, "changed", NULL);
 417                         break;
 418                 default:
 419                         break;
 420         }
 421
 422         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 423 }
 424
 425 char *msg_ui_thread_msg_gl_text_get(void *data, Evas_Object *obj, const char *part)
 426 {
 427         PMSG_APP_THREAD_MSG_DATA_S item_data = (PMSG_APP_THREAD_MSG_DATA_S)data;
 428         char buf[DEF_BUF_LEN+1] = { 0, };
 429
 430         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !item_data, NULL);
 431
 432         if (!strcmp(part, "elm.text.1")) {
 433                 int i = 0;
 434                 char str_name[DEF_BUF_LEN+1] = { 0, };
 435                 char temp[DEF_BUF_LEN+1] = { 0, };
 436
 437                 for (i = 0; i < item_data->addr_cnt; i++) {
 438                         if (item_data->addr_info[i]->contact_id > 0 && item_data->addr_info[i]->display_name[0] != '\0') {
 439                                 snprintf(str_name, sizeof(str_name), "%s", item_data->addr_info[i]->display_name);
 440                         } else {
 441                                 if (item_data->addr_info[i]->address[0] != '\0')
 442                                         snprintf(str_name, sizeof(str_name), "%s", item_data->addr_info[i]->address);
 443                                 else
 444                                         snprintf(str_name, sizeof(str_name), dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
 445                         }
 446
 447                         snprintf(temp, sizeof(temp), "%s", buf);
 448
 449                         if (*temp)
 450                                 snprintf(buf, sizeof(buf), "%s, %s", temp, str_name);
 451                         else
 452                                 snprintf(buf, sizeof(buf), "%s", str_name);
 453                 }
 454         } else if (g_strcmp0(part, "elm.text.2") == 0) {
 455                 char msg[DEF_BUF_LEN] = { 0, };
 456                 int idx = 0;
 457
 458                 if (item_data->msg_body[0] != '\0') {
 459                         strncpy(msg, item_data->msg_body, sizeof(msg) - 1);
 460                         while (msg[idx]) {
 461                                 if (g_ascii_iscntrl(msg[idx]))
 462                                         msg[idx] = ' ';
 463                                 idx++;
 464                         }
 465                 } else if ((item_data->msg_type >= MSG_TYPE_MMS && item_data->msg_type <= MSG_TYPE_MMS_NOTI)) {
 466                         snprintf(msg, sizeof(msg), "(%s)", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_NO_SUBJECT"));
 467                 }
 468                 snprintf(buf, sizeof(buf), "%s", msg);
 469         } else if (g_strcmp0(part, "elm.text.3") == 0) {
 470                 msg_ui_thread_make_time_string(item_data->msg_time, buf, sizeof(buf));
 471         } else {
 472                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Invalid part = %s", part);
 473                 return NULL;
 474         }
 475
 476         return strdup(buf);
 477 }
 478
 479 char *msg_ui_thread_search_msg_gl_text_get(void *data, Evas_Object *obj, const char *part)
 480 {
 481         PMSG_THREAD_LIST_DATA pListData = NULL;
 482         PMSG_APP_THREAD_MSG_DATA_S item_data = (PMSG_APP_THREAD_MSG_DATA_S)data;
 483         char buf[DEF_BUF_LEN+1] = { 0, };
 484         bool result = false;
 485
 486         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !item_data, NULL);
 487
 488         pListData = msg_ui_thread_get_current_list();
 489         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !pListData, NULL);
 490
 491         if (!strcmp(part, "elm.text.1")) {
 492                 bool search = true;
 493                 if (item_data->addr_info[0]->contact_id > 0 && item_data->addr_info[0]->display_name[0] != '\0') {
 494                         snprintf(buf, sizeof(buf), "%s", item_data->addr_info[0]->display_name);
 495                 } else {
 496                         if (item_data->addr_info[0]->address[0] != '\0') {
 497                                 snprintf(buf, sizeof(buf), "%s", item_data->addr_info[0]->address);
 498                         } else {
 499                                 snprintf(buf, sizeof(buf), dgettext("sys_string", "IDS_COM_BODY_UNKNOWN"));
 500                                 search =false;
 501                         }
 502                 }
 503
 504                 if (search == true) {
 505                         Evas_Object *entry = elm_object_part_content_get( pListData->searchbar, "elm.swallow.content");
 506                         char *search_str = elm_entry_markup_to_utf8(elm_entry_entry_get(entry));
 507                         if (search_str) {
 508                                 if (strlen(search_str) > 0) {
 509                                         const char *str = msg_ui_thread_make_search_result_string(buf, search_str, &result);
 510                                         free(search_str);
 511                                         return strdup(str);
 512                                 }
 513                                 free(search_str);
 514                         }
 515                 }
 516         } else if (g_strcmp0(part, "elm.text.2") == 0) {
 517                 char msg[DEF_BUF_LEN] = { 0, };
 518                 int idx = 0;
 519
 520                 if (item_data->msg_body[0] != '\0') {
 521                         strncpy(msg, item_data->msg_body, sizeof(msg) - 1);
 522                         while (msg[idx]) {
 523                                 if (g_ascii_iscntrl(msg[idx]))
 524                                         msg[idx] = ' ';
 525                                 idx++;
 526                         }
 527                 } else if ((item_data->msg_type >= MSG_TYPE_MMS && item_data->msg_type <= MSG_TYPE_MMS_NOTI)) {
 528                         snprintf(msg, sizeof(msg), "(%s)", dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_NO_SUBJECT"));
 529                 }
 530                 snprintf(buf, sizeof(buf), "%s", msg);
 531
 532                 Evas_Object *entry = elm_object_part_content_get( pListData->searchbar, "elm.swallow.content");
 533                 char *search_str = elm_entry_markup_to_utf8(elm_entry_entry_get(entry));
 534                 if (search_str) {
 535                         if (strlen(search_str) > 0) {
 536                                 const char *str = msg_ui_thread_make_search_result_string(buf, search_str, &result);
 537                                 free(search_str);
 538                                 return strdup(str);
 539                         }
 540                         free(search_str);
 541                 }
 542         } else if (g_strcmp0(part, "elm.text.3") == 0) {
 543                 msg_ui_thread_make_time_string(item_data->msg_time, buf, sizeof(buf));
 544         } else {
 545                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Invalid part = %s", part);
 546                 return NULL;
 547         }
 548
 549         return strdup(buf);
 550 }
 551
 552 Evas_Object *msg_ui_thread_msg_gl_content_get(void *data, Evas_Object *obj, const char *part)
 553 {
 554         PMSG_THREAD_LIST_DATA pListData = msg_ui_thread_get_current_list();
 555         PMSG_APP_THREAD_MSG_DATA_S item_data = (PMSG_APP_THREAD_MSG_DATA_S)data;
 556         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !item_data, NULL);
 557
 558         Evas_Object *ic = NULL;
 559
 560         if (g_strcmp0(part, "elm.icon") == 0) {
 561                 if (item_data->msg_type >= MSG_TYPE_MMS && item_data->msg_type <= MSG_TYPE_MMS_NOTI) {
 562                         ic = elm_icon_add(obj);
 563
 564                         if (item_data->direction == MSG_DIRECTION_TYPE_MO)
 565                                 elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_STATUS_MMS_SENT);
 566                         else if (item_data->is_read == 0)
 567                                 elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_STATUS_MMS_UNREAD);
 568                         else
 569                                 elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_STATUS_MMS_READ);
 570                 } else {
 571                         ic = elm_icon_add(obj);
 572
 573                         if (item_data->direction == MSG_DIRECTION_TYPE_MO)
 574                                 elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_STATUS_SMS_SENT);
 575                         else if (item_data->is_read == 0)
 576                                 elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_STATUS_SMS_UNREAD);
 577                         else
 578                                 elm_image_file_set(ic, MSG_IMAGES_EDJ, MSG_UI_THREAD_LIST_STATUS_SMS_READ);
 579                 }
 580
 581                 if (ic) {
 582                         evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 583                         evas_object_show(ic);
 584                 }
 585         }
 586
 587         if (pListData->search_mode == THREAD_SEARCH_OFF) {
 588                 if (pListData->list_type == THREAD_CBMSG_LIST_TYPE) {
 589                         if (g_strcmp0(part, "elm.slide.swallow.1") == 0) {
 590                                 ic = elm_button_add(obj);
 591                                 elm_object_style_set(ic, "sweep/delete");
 592                                 elm_object_text_set(ic, dgettext("sys_string", "IDS_COM_SK_DELETE"));
 593                                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 594                                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 595                         }
 596                 } else {
 597                         if (g_strcmp0(part, "elm.slide.swallow.1") == 0) {
 598                                 ic = elm_button_add(obj);
 599                                 elm_object_style_set(ic, "sweep/multiline");
 600                                 if (pListData->list_type == THREAD_SIM_LIST_TYPE)
 601                                         elm_object_text_set(ic, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_BODY_COPY_TO_PHONE"));
 602                                 else if (pListData->list_type == THREAD_SPAM_LIST_TYPE)
 603                                         elm_object_text_set(ic, dgettext(MESSAGE_PKGNAME, "IDS_MSGF_SK_RESTORE"));
 604
 605                                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 606                                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 607                         } else if (g_strcmp0(part, "elm.slide.swallow.2") == 0) {
 608                                 ic = elm_button_add(obj);
 609                                 elm_object_style_set(ic, "sweep/delete");
 610                                 elm_object_text_set(ic, dgettext("sys_string", "IDS_COM_SK_DELETE"));
 611                                 evas_object_data_set(ic, "sel_peer_data", (void *) item_data);
 612                                 evas_object_smart_callback_add(ic, "clicked", msg_ui_thread_sweep_btn_cb, (void *) pListData);
 613                         }
 614                 }
 615         }
 616
 617         if (elm_genlist_decorate_mode_get(obj)) {
 618                 if (!strcmp(part, "elm.edit.icon.1")) {
 619                         ic = elm_check_add(obj);
 620                         elm_check_state_pointer_set(ic, &item_data->is_check);
 621                         evas_object_data_set(ic, "item_data", item_data);
 622                         evas_object_smart_callback_add(ic, "changed", msg_ui_thread_list_checked_cb, (void *) pListData);
 623                         item_data->chk = ic;
 624                 }
 625         }
 626
 627         return ic;
 628 }
 629
 630 void msg_ui_thread_msg_gl_del(void *data, Evas_Object *obj)
 631 {
 632         PMSG_APP_THREAD_MSG_DATA_S del_data = (PMSG_APP_THREAD_MSG_DATA_S) data;
 633         if (del_data) {
 634                 if (del_data->msg_time) {
 635                         free(del_data->msg_time);
 636                         del_data->msg_time = NULL;
 637                 }
 638
 639                 if (del_data->addr_info) {
 640                         int i = 0;
 641                         for (i = 0; i < del_data->addr_cnt; i++) {
 642                                 if (del_data->addr_info[i])
 643                                         free(del_data->addr_info[i]);
 644                         }
 645                         free(del_data->addr_info);
 646                         del_data->addr_info = NULL;
 647                 }
 648
 649                 free(del_data);
 650                 del_data = NULL;
 651         }
 652 }
 653
 654 void msg_ui_thread_msg_gl_sel(void *data, Evas_Object *obj, void *event_info)
 655 {
 656         PMSG_THREAD_LIST_DATA pListData = (PMSG_THREAD_LIST_DATA) data;
 657         Elm_Object_Item *item = NULL;
 658         Elm_Object_Item* it_sweep = NULL;
 659         PMSG_APP_THREAD_MSG_DATA_S item_data = NULL;
 660         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
 661
 662         item = (Elm_Object_Item *) event_info;
 663         MSG_UI_RETM_IF(MSG_UI_LEVEL_DEBUG, !item, "Item is  NULL or Item is not Message item\n");
 664
 665         item_data = (PMSG_APP_THREAD_MSG_DATA_S) elm_object_item_data_get(item);
 666         MSG_UI_RETM_IF(MSG_UI_LEVEL_ERR, item_data == NULL, "item_data is NULL");
 667         MSG_UI_RETM_IF(MSG_UI_LEVEL_DEBUG, pListData->sel_msg_id == item_data->msg_id, "Already selected item");
 668
 669         it_sweep = (Elm_Object_Item *)elm_genlist_decorated_item_get(pListData->genlist);
 670         if (it_sweep) {
 671                 elm_genlist_item_decorate_mode_set(it_sweep, "slide", EINA_FALSE);
 672                 elm_genlist_item_select_mode_set(it_sweep, ELM_OBJECT_SELECT_MODE_DEFAULT);
 673         }
 674
 675         if (pListData->search_mode == THREAD_SEARCH_ON)
 676                 msg_ui_thread_show_toolbar(pListData);
 677
 678         switch (pListData->view_mode) {
 679                 case THREAD_NORMAL_VIEW:
 680                 case THREAD_UNLOAD_VIEW:
 681                         if (pListData->list_type >= THREAD_SPAM_LIST_TYPE) {
 682                                 pListData->sel_gen_item = item;
 683                                 pListData->sel_msg_id = item_data->msg_id;
 684
 685                                 if (item_data->msg_type == MSG_TYPE_MMS) {
 686                                         /** in case of MMS launch MMS viewer UG */
 687                                         msg_ui_thread_launch_viewer_ug(pListData, pListData->sel_msg_id);
 688                                         if (pData->detail_layout)
 689                                                 pData->detail_layout = NULL;
 690                                 } else {
 691                                         /** in case of sms, its own SMS viewer view */
 692                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "type SMS");
 693                                         if (pData->isRotate == true && pData->split_data == NULL) {
 694                                                 msg_ui_thread_create_split_data();
 695                                                 msg_ui_thread_splitview_launch(pData, pData->split_data);
 696                                         }
 697                                         if (pListData->loaded_ug) {
 698                                                 ug_destroy(pListData->loaded_ug);
 699                                                 pListData->loaded_ug = NULL;
 700                                         }
 701                                         msg_ui_thread_launch_msg_detail_view(pListData, item_data);
 702                                 }
 703
 704                                 /** update read status */
 705                                 msg_update_read_status(msg_ui_thread_get_data_handle(), item_data->msg_id, true);
 706                         } else {
 707                                 pListData->sel_gen_item = item;
 708                                 pListData->sel_msg_id = item_data->msg_id;
 709
 710                                 __msg_ui_thread_create_bubble_by_msgid(pListData, item_data);
 711                         }
 712
 713                         item_data->is_read = true;
 714                         elm_genlist_item_item_class_update(item, &pListData->itc_default);
 715                         elm_genlist_item_update(item);
 716                         break;
 717                 case THREAD_EDIT_VIEW:
 718                         elm_genlist_item_selected_set(item, false);
 719                         item_data->is_check = !item_data->is_check;
 720                         elm_genlist_item_fields_update(item, "elm.edit.icon.1", ELM_GENLIST_ITEM_FIELD_CONTENT);
 721                         evas_object_smart_callback_call(item_data->chk, "changed", NULL);
 722                         break;
 723                 default:
 724                         break;
 725         }
 726
 727         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 728 }
 729
 730 void __msg_ui_thread_create_bubble_by_msgid(PMSG_THREAD_LIST_DATA pListData, PMSG_APP_THREAD_MSG_DATA_S item_data)
 731 {
 732         msg_struct_t msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 733         msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
 734         msg_struct_t threadInfo = NULL;
 735         PMSG_APP_THREAD_DATA_S thread_data = NULL;
 736         msg_error_t err =  MSG_SUCCESS;
 737         int thread_id = 0;
 738         service_h svc_handle = NULL;
 739
 740         err = msg_get_message(msg_ui_thread_get_data_handle(), (msg_message_id_t)item_data->msg_id, msgInfo, sendOpt);
 741         if (err != MSG_SUCCESS) {
 742                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "msg_get_message() is failed : err = %d", err);
 743                 msg_release_struct(&msgInfo);
 744                 msg_release_struct(&sendOpt);
 745                 return;
 746         }
 747         msg_get_int_value(msgInfo, MSG_MESSAGE_THREAD_ID_INT, &thread_id);
 748
 749         threadInfo = msg_create_struct(MSG_STRUCT_THREAD_INFO);
 750         err = msg_get_thread(msg_ui_thread_get_data_handle(), thread_id, threadInfo);
 751         if (err != MSG_SUCCESS) {
 752                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "msg_get_message() is failed : err = %d", err);
 753                 msg_release_struct(&msgInfo);
 754                 msg_release_struct(&sendOpt);
 755                 msg_release_struct(&threadInfo);
 756                 return;
 757         }
 758
 759         thread_data = (PMSG_APP_THREAD_DATA_S) calloc(1, sizeof(MSG_APP_THREAD_DATA_S));
 760         msg_ui_thread_set_thread_data(pListData, thread_data, threadInfo);
 761
 762         if (service_create(&svc_handle) < 0 || svc_handle == NULL) {
 763                 D_EMSG("service_create() is failed !!");
 764         } else {
 765                 MessageComposerUgType ug_type = MSG_COMPOSER_UG_TYPE_NONE;
 766
 767                 msg_ui_thread_get_bubble_data(thread_data, svc_handle);
 768                 ug_type = MSG_COMPOSER_UG_TYPE_VIEWER;
 769
 770                 if (msg_ui_load_composer_ug(svc_handle, ug_type) == MSG_UI_RET_ERR) {
 771                         D_MSG("Failed to load composer ug");
 772
 773                         pListData->sel_gen_item = NULL;
 774                         pListData->sel_msg_id = 0;
 775                 }
 776
 777                 service_destroy(svc_handle);
 778         }
 779
 780         if (thread_data)
 781                 free(thread_data);
 782
 783         msg_release_struct(&threadInfo);
 784         msg_release_struct(&sendOpt);
 785         msg_release_struct(&msgInfo);
 786 }
 787
 788 char *msg_ui_thread_gl_empty_get(void *data, Evas_Object *obj, const char *part)
 789 {
 790         char buf[DEF_BUF_LEN] = { '0', };
 791
 792         PMSG_THREAD_LIST_DATA pListData = msg_ui_thread_get_current_list();
 793
 794         if (pListData && pListData->search_mode == THREAD_SEARCH_ON)
 795                 snprintf(buf, sizeof(buf), "%s", dgettext("sys_string", "IDS_COM_BODY_NO_SEARCH_RESULTS"));
 796         else
 797                 snprintf(buf, sizeof(buf), "%s", dgettext("sys_string", "IDS_COM_POP_EMPTY"));
 798
 799         return strdup(buf);
 800 }
 801
 802 void msg_ui_thread_gl_empty_sel(void *data, Evas_Object *obj, void *event_info)
 803 {
 804         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 805
 806         Elm_Object_Item *item = NULL;
 807
 808         item = (Elm_Object_Item *) event_info;
 809         MSG_UI_RETM_IF(MSG_UI_LEVEL_DEBUG, !item, "Item is  NULL or Item is not Message item\n");
 810
 811         elm_genlist_item_selected_set(item, false);
 812
 813         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 814 }
 815
 816 char *msg_ui_thread_date_gl_text_get(void *data, Evas_Object *obj, const char *part)
 817 {
 818         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
 819         PMSG_APP_THREAD_DATELINE_DATA_S item_data = (PMSG_APP_THREAD_DATELINE_DATA_S) data;
 820         char *date_str = NULL;
 821         char buf[DEF_BUF_LEN] = { 0, };
 822
 823         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !pData || !item_data, NULL);
 824
 825         if (0 == strcmp(part, "elm.text")) {
 826                 date_str = msg_common_get_display_date(pData->locale, pData->date_ptn_default, pData->date_ptn_year, item_data->thread_time);
 827
 828                 if (date_str) {
 829                         snprintf(buf, sizeof(buf), "%s", date_str);
 830                         free(date_str);
 831                 }
 832                 return strdup(buf);
 833         } else {
 834                 return NULL;
 835         }
 836 }
 837
 838 void msg_ui_thread_date_gl_del(void *data, Evas_Object *obj)
 839 {
 840         PMSG_APP_THREAD_DATELINE_DATA_S del_data = (PMSG_APP_THREAD_DATELINE_DATA_S) data;
 841
 842         if (del_data) {
 843                 if (del_data->thread_time) {
 844                         free(del_data->thread_time);
 845                         del_data->thread_time = NULL;
 846                 }
 847                 free(del_data);
 848                 del_data = NULL;
 849         }
 850 }
 851
 852 PMSG_APP_THREAD_DATELINE_DATA_S msg_ui_thread_list_insert_dateline(PMSG_THREAD_LIST_DATA pListData, time_t* cur_time, time_t* prev_time)
 853 {
 854         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
 855         PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
 856
 857         char *date_str = NULL;
 858         char cur_date_buf[DEF_BUF_LEN+1] = { 0, };
 859         char prev_date_buf[DEF_BUF_LEN+1] = { 0, };
 860
 861         date_str = msg_common_get_display_date(pData->locale, pData->date_ptn_default, pData->date_ptn_year, cur_time);
 862         if (date_str) {
 863                 snprintf(cur_date_buf, sizeof(cur_date_buf), " %s ", date_str);
 864                 free(date_str);
 865                 date_str = NULL;
 866         }
 867
 868         if (prev_time != NULL) {
 869                 date_str = msg_common_get_display_date(pData->locale, pData->date_ptn_default, pData->date_ptn_year, prev_time);
 870                 if (date_str) {
 871                         snprintf(prev_date_buf, sizeof(prev_date_buf), " %s ", date_str);
 872                         free(date_str);
 873                         date_str = NULL;
 874                 }
 875         }
 876
 877         if (!prev_time ||g_strcmp0(cur_date_buf, prev_date_buf) != 0) {
 878                 dateline_data = (PMSG_APP_THREAD_DATELINE_DATA_S) calloc(1, sizeof(MSG_APP_THREAD_DATELINE_DATA_S));
 879                 MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, !dateline_data, NULL);
 880                 bzero(dateline_data, sizeof(MSG_APP_THREAD_DATELINE_DATA_S));
 881
 882                 dateline_data->thread_time = (time_t *) calloc(1, sizeof(time_t));
 883                 bzero(dateline_data->thread_time, sizeof(time_t));
 884                 memcpy(dateline_data->thread_time, cur_time, sizeof(time_t));
 885
 886                 dateline_data->subitem_cnt = 0;
 887                 dateline_data->date_it = elm_genlist_item_append(pListData->genlist, msg_ui_thread_get_itc_type(THREAD_ITC_DATE), dateline_data, NULL, ELM_GENLIST_ITEM_GROUP, NULL, NULL);
 888                 elm_genlist_item_select_mode_set(dateline_data->date_it, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 889         }
 890
 891         return dateline_data;
 892 }
 893
 894 void msg_ui_thread_list_load(PMSG_THREAD_LIST_DATA pListData, Eina_Bool bLaunch)
 895 {
 896         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 897
 898         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
 899
 900         if (!pListData){
 901                 D_MSG("[ERROR] pListData is NULL");
 902                 return;
 903         }
 904
 905         msg_error_t err = MSG_SUCCESS;
 906         msg_struct_t sort_rule_t = msg_create_struct(MSG_STRUCT_SORT_RULE);
 907         msg_struct_list_s peerList;
 908
 909         __msg_ui_thread_init_genlist(pListData);
 910
 911         msg_set_int_value(sort_rule_t, MSG_SORT_RULE_SORT_TYPE_INT, MSG_SORT_BY_THREAD_DATE);
 912         msg_set_bool_value(sort_rule_t, MSG_SORT_RULE_ACSCEND_BOOL, false);
 913
 914         err = msg_get_thread_view_list(pData->msgHandle, sort_rule_t, &peerList);
 915         msg_release_struct(&sort_rule_t);
 916
 917         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "peercount : %d, err : %d", peerList.nCount, err);
 918         pListData->item_cnt = peerList.nCount;
 919
 920         Evas_Object *swl_ly = elm_object_part_content_get(pListData->content_ly, "thread_list");
 921
 922         pListData->app_data_type = THREAD_LIST_APP_DATA_THREAD;
 923         msg_ui_thread_genlist_style_set(pListData);
 924
 925         if (peerList.nCount <= 0 || err != MSG_SUCCESS) {
 926                 if (!pListData->noc_ly)
 927                         pListData->noc_ly = msg_ui_thread_create_nocontent_layout(pData->navi_frame);
 928
 929                 if (swl_ly != pListData->noc_ly) {
 930                         evas_object_hide(swl_ly);
 931                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
 932                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->noc_ly);
 933                 }
 934
 935                 msg_ui_thread_button_disabled_set(pListData, EINA_TRUE, CONTROLBAR_ITEM_2);
 936         } else {
 937                 if (swl_ly != pListData->genlist) {
 938                         evas_object_hide(swl_ly);
 939                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
 940                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->genlist);
 941                 }
 942
 943                 msg_ui_thread_button_disabled_set(pListData, EINA_FALSE, CONTROLBAR_ITEM_2);
 944
 945                 PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
 946                 PMSG_APP_THREAD_DATA_S cur_thread = NULL;
 947                 PMSG_APP_THREAD_DATA_S prev_thread = NULL;
 948                 int row = 0;
 949                 int load_cnt = 0;
 950
 951                 if (peerList.nCount > MSG_THREAD_LIST_LAUNCH_LOAD_MAX_CNT && bLaunch == TRUE) {
 952                         pListData->loaded_cnt = MSG_THREAD_LIST_LAUNCH_LOAD_MAX_CNT;
 953                         load_cnt = pListData->loaded_cnt;
 954
 955                         if (pListData->launch_idler == NULL)
 956                                 pListData->launch_idler = ecore_idler_add(__msg_ui_thread_list_load_remain_item, pListData);
 957                 } else {
 958                         load_cnt = peerList.nCount;
 959                 }
 960
 961                 for (row = 0; row < load_cnt; row++) {
 962                         PMSG_APP_THREAD_DATELINE_DATA_S tmp_date_line = NULL;
 963                         Elm_Object_Item *item = NULL;
 964
 965                         cur_thread = (PMSG_APP_THREAD_DATA_S) calloc(1, sizeof(MSG_APP_THREAD_DATA_S));
 966                         msg_ui_thread_set_thread_data(pListData, cur_thread, peerList.msg_struct_info[row]);
 967
 968                         if (prev_thread)
 969                                 tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, cur_thread->thread_time, prev_thread->thread_time);
 970                         else
 971                                 tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, cur_thread->thread_time, NULL);
 972
 973                         if (tmp_date_line != NULL)
 974                                 dateline_data = tmp_date_line;
 975
 976                         if (dateline_data != NULL)
 977                                 item = dateline_data->date_it;
 978
 979                         if (cur_thread->unread_cnt > 0)
 980                                 elm_genlist_item_append(pListData->genlist, &pListData->itc_unread, cur_thread, item, ELM_GENLIST_ITEM_NONE, __msg_ui_thread_gl_sel, pListData);
 981                         else
 982                                 elm_genlist_item_append(pListData->genlist, &pListData->itc_default, cur_thread, item, ELM_GENLIST_ITEM_NONE, __msg_ui_thread_gl_sel, pListData);
 983
 984                         if (dateline_data != NULL)
 985                                 dateline_data->subitem_cnt++;
 986
 987                         prev_thread = cur_thread;
 988                 }
 989
 990                 msg_release_list_struct(&peerList);
 991         }
 992
 993         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 994 }
 995
 996 void msg_ui_thread_list_update(PMSG_THREAD_LIST_DATA pListData)
 997 {
 998         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 999
1000         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
1001
1002         if (!pListData){
1003                 D_MSG("[ERROR] pListData is NULL");
1004                 return;
1005         }
1006
1007         msg_error_t err = MSG_SUCCESS;
1008         msg_struct_t sort_rule_t = msg_create_struct(MSG_STRUCT_SORT_RULE);
1009         msg_struct_list_s peerList;
1010         PMSG_APP_THREAD_DATA_S cur_sel_thread = NULL;
1011         Elm_Object_Item *gen_item = NULL;
1012         int row = 0;
1013
1014         Evas_Object *swl_ly = elm_object_part_content_get(pListData->content_ly, "thread_list");
1015
1016         msg_set_int_value(sort_rule_t, MSG_SORT_RULE_SORT_TYPE_INT, MSG_SORT_BY_THREAD_DATE);
1017         msg_set_bool_value(sort_rule_t, MSG_SORT_RULE_ACSCEND_BOOL, false);
1018
1019         err = msg_get_thread_view_list(pData->msgHandle, sort_rule_t, &peerList);
1020         msg_release_struct(&sort_rule_t);
1021
1022         pListData->item_cnt = peerList.nCount;
1023
1024         if (peerList.nCount <= 0 || err != MSG_SUCCESS) {
1025                 msg_ui_thread_button_disabled_set(pListData, EINA_TRUE, CONTROLBAR_ITEM_2);
1026
1027                 if (!pListData->noc_ly)
1028                         pListData->noc_ly = msg_ui_thread_create_nocontent_layout(pData->navi_frame);
1029
1030                 if (swl_ly != pListData->noc_ly) {
1031                         evas_object_hide(swl_ly);
1032                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
1033                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->noc_ly);
1034                 }
1035
1036         } else {
1037                 msg_ui_thread_button_disabled_set(pListData, EINA_FALSE, CONTROLBAR_ITEM_2);
1038
1039                 if (swl_ly != pListData->genlist) {
1040                         evas_object_hide(swl_ly);
1041                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
1042                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->genlist);
1043                 }
1044
1045                 gen_item = elm_genlist_first_item_get(pListData->genlist);
1046
1047                 while (gen_item) {
1048                         if (elm_genlist_item_parent_get(gen_item) == NULL) {
1049                                 gen_item = elm_genlist_item_next_get(gen_item);
1050                                 continue;
1051                         }
1052
1053                         cur_sel_thread = elm_object_item_data_get(gen_item);
1054                         msg_ui_thread_set_thread_data(pListData, cur_sel_thread, peerList.msg_struct_info[row]);
1055                         if (cur_sel_thread->unread_cnt > 0)
1056                                 elm_genlist_item_item_class_update(gen_item, &pListData->itc_unread);
1057                         else
1058                                 elm_genlist_item_item_class_update(gen_item, &pListData->itc_default);
1059                         elm_object_item_data_set(gen_item, cur_sel_thread);
1060                         gen_item = elm_genlist_item_next_get(gen_item);
1061                         row++;
1062                 }
1063         }
1064
1065         msg_release_list_struct(&peerList);
1066         elm_genlist_realized_items_update(pListData->genlist);
1067
1068         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1069 }
1070
1071 Eina_Bool msg_ui_thread_list_item_update(PMSG_THREAD_LIST_DATA pListData, msg_thread_id_t thread_id)
1072 {
1073         MSG_UI_ENTER();
1074
1075         msg_error_t err = MSG_SUCCESS;
1076         msg_struct_t sort_rule_t = msg_create_struct(MSG_STRUCT_SORT_RULE);
1077         msg_struct_list_s peerList;
1078         PMSG_APP_THREAD_DATA_S old_data = NULL;
1079         PMSG_APP_THREAD_DATA_S new_data = NULL;
1080         int row = 0;
1081         Elm_Object_Item *gen_item = NULL;
1082
1083         msg_set_int_value(sort_rule_t, MSG_SORT_RULE_SORT_TYPE_INT, MSG_SORT_BY_THREAD_DATE);
1084         msg_set_bool_value(sort_rule_t, MSG_SORT_RULE_ACSCEND_BOOL, false);
1085
1086         err = msg_get_thread_view_list(msg_ui_thread_get_data_handle(), sort_rule_t, &peerList);
1087         msg_release_struct(&sort_rule_t);
1088         MSG_UI_RETV_IF(MSG_UI_LEVEL_DEBUG, err != MSG_SUCCESS, EINA_FALSE);
1089
1090         gen_item = elm_genlist_first_item_get(pListData->genlist);
1091
1092         /* Update genlist item */
1093         while (gen_item) {
1094                 if (elm_genlist_item_parent_get(gen_item) == NULL) {
1095                         gen_item = elm_genlist_item_next_get(gen_item);
1096                         continue;
1097                 }
1098
1099                 old_data = (PMSG_APP_THREAD_DATA_S) elm_object_item_data_get(gen_item);
1100                 if (old_data && thread_id == old_data->thread_id) {
1101                         break;
1102                 }
1103                 gen_item = elm_genlist_item_next_get(gen_item);
1104         }
1105
1106         if (!gen_item) {
1107                 D_EMSG("gen_item is NULL");
1108                 msg_release_list_struct(&peerList);
1109                 return EINA_FALSE;
1110         }
1111
1112         if (!old_data) {
1113                 D_EMSG("old_data is NULL");
1114                 return EINA_FALSE;
1115         }
1116
1117         for (row = 0; row < peerList.nCount; row++) {
1118                 int sel_thread_id = 0;
1119                 msg_get_int_value(peerList.msg_struct_info[row], MSG_THREAD_ID_INT, &sel_thread_id);
1120                 if (sel_thread_id == thread_id) {
1121                         new_data = (PMSG_APP_THREAD_DATA_S) calloc(1, sizeof(MSG_APP_THREAD_DATA_S));
1122                         if (!new_data)
1123                                 break;
1124
1125                         msg_ui_thread_set_thread_data(pListData, new_data, peerList.msg_struct_info[row]);
1126                         break;
1127                 }
1128         }
1129
1130         msg_release_list_struct(&peerList);
1131
1132         if (!new_data) {
1133                 D_EMSG("new_data is NULL");
1134                 return EINA_FALSE;
1135         }
1136
1137         if (new_data->thread_time && (*new_data->thread_time != *old_data->thread_time)){
1138                 msg_ui_thread_list_load(pListData, FALSE);
1139                 msg_ui_thread_select_item_by_thread_id(pListData, thread_id);
1140
1141                 free(new_data->thread_time);
1142                 new_data->thread_time = NULL;
1143
1144                 free(new_data);
1145         } else {
1146                 new_data->chk = old_data->chk;
1147                 new_data->is_check = old_data->is_check;
1148
1149                 if (new_data->unread_cnt > 0)
1150                         elm_genlist_item_item_class_update(gen_item, &pListData->itc_unread);
1151                 else
1152                         elm_genlist_item_item_class_update(gen_item, &pListData->itc_default);
1153                 elm_object_item_data_set(gen_item, new_data);
1154                 elm_genlist_item_update(gen_item);
1155                 elm_genlist_item_selected_set(gen_item, false);
1156
1157                 if (pListData->view_mode == THREAD_EDIT_VIEW) {
1158                         if (eina_list_data_find(pListData->chk_list, old_data)) {
1159                                 pListData->chk_list = eina_list_remove(pListData->chk_list, old_data);
1160                                 pListData->chk_list = eina_list_append(pListData->chk_list, new_data);
1161                         }
1162                 }
1163
1164                 if (old_data->thread_time) {
1165                         free(old_data->thread_time);
1166                         old_data->thread_time = NULL;
1167                 }
1168                 free(old_data);
1169         }
1170
1171         MSG_UI_LEAVE();
1172         return EINA_TRUE;
1173 }
1174
1175 void msg_ui_thread_list_item_delete(PMSG_THREAD_LIST_DATA pListData, msg_thread_id_t thread_id)
1176 {
1177         MSG_UI_ENTER();
1178
1179         PMSG_APP_THREAD_DATA_S item_data = NULL;
1180         Elm_Object_Item *gen_item = NULL;
1181
1182         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "thread_id = [%d] ", thread_id);
1183
1184         gen_item = elm_genlist_first_item_get(pListData->genlist);
1185
1186         while (gen_item) {
1187                 if (elm_genlist_item_parent_get(gen_item) == NULL) {
1188                         gen_item = elm_genlist_item_next_get(gen_item);
1189                         continue;
1190                 }
1191
1192                 item_data = (PMSG_APP_THREAD_DATA_S) elm_object_item_data_get(gen_item);
1193                 if (item_data && thread_id == item_data->thread_id) {
1194                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "thread_id == item_data->thread_id == [%d] ", thread_id);
1195                         break;
1196                 }
1197                 gen_item = elm_genlist_item_next_get(gen_item);
1198         }
1199
1200         if (!gen_item) {
1201                 D_EMSG("gen_item is NULL");
1202                 return;
1203         }
1204
1205         Elm_Object_Item *it_dateline = NULL;
1206         PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
1207
1208         it_dateline = elm_genlist_item_parent_get(gen_item);
1209         if (it_dateline) {
1210                 dateline_data = elm_object_item_data_get(it_dateline);
1211
1212                 if (dateline_data) {
1213                         dateline_data->subitem_cnt--;
1214                         if (dateline_data->subitem_cnt == 0)
1215                                 elm_object_item_del((Elm_Object_Item *)it_dateline);
1216                 }
1217         }
1218         elm_object_item_del((Elm_Object_Item *)gen_item);
1219         pListData->item_cnt--;
1220
1221         if (pListData->item_cnt <= 0) {
1222                 msg_ui_thread_list_load(pListData, FALSE);
1223         }
1224
1225         MSG_UI_LEAVE();
1226 }
1227
1228 void msg_ui_thread_msg_list_load(PMSG_THREAD_LIST_DATA pListData, int listType)
1229 {
1230         D_ENTER;
1231
1232         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
1233         msg_error_t err = MSG_SUCCESS;
1234         msg_struct_list_s msg_list;
1235
1236         if (!pListData){
1237                 D_MSG("[ERROR] pListData is NULL");
1238                 return;
1239         }
1240
1241         __msg_ui_thread_init_genlist(pListData);
1242
1243         switch (listType) {
1244                 case THREAD_SPAM_LIST_TYPE:
1245                         err = msg_get_message_list(pData->msgHandle, MSG_SPAMBOX_ID, 0, 0, 0, &msg_list);
1246                         break;
1247                 case THREAD_SIM_LIST_TYPE:
1248                         err = msg_get_message_list(pData->msgHandle, MSG_ALLBOX_ID, 0, MSG_TYPE_SMS, MSG_STORAGE_SIM, &msg_list);
1249                         break;
1250                 case THREAD_CBMSG_LIST_TYPE:
1251                         err = msg_get_message_list(pData->msgHandle, MSG_CBMSGBOX_ID, 0, 0, 0, &msg_list);
1252                         break;
1253                 default:
1254                         D_MSG("[WARNING] invalid view mode");
1255                         return;
1256         }
1257
1258         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1259                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "msg_get_message_list() is failed = %d", err);
1260                 return;
1261         }
1262         pListData->item_cnt = msg_list.nCount;
1263
1264         Evas_Object *swl_ly = elm_object_part_content_get(pListData->content_ly, "thread_list");
1265
1266         if (pListData->item_cnt == 0) {
1267                 msg_ui_thread_button_disabled_set(pListData, EINA_TRUE, CONTROLBAR_ITEM_1);
1268
1269                 // show non cotent
1270                 if (!pListData->noc_ly)
1271                         pListData->noc_ly = msg_ui_thread_create_nocontent_layout(pData->navi_frame);
1272
1273                 if (swl_ly != pListData->noc_ly) {
1274                         evas_object_hide(swl_ly);
1275                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
1276                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->noc_ly);
1277                 }
1278         } else {
1279                 // fill the genlist
1280                 msg_ui_thread_button_disabled_set(pListData, EINA_FALSE, CONTROLBAR_ITEM_1);
1281
1282                 pListData->app_data_type = THREAD_LIST_APP_DATA_MSG;
1283                 msg_ui_thread_genlist_style_set(pListData);
1284
1285                 if (swl_ly != pListData->genlist) {
1286                         evas_object_hide(swl_ly);
1287                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
1288                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->genlist);
1289                 }
1290
1291                 PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
1292                 PMSG_APP_THREAD_MSG_DATA_S cur_item = NULL;
1293                 PMSG_APP_THREAD_MSG_DATA_S prev_item = NULL;
1294                 int row = 0;
1295
1296                 for (row = 0; row < msg_list.nCount; row++) {
1297                         PMSG_APP_THREAD_DATELINE_DATA_S tmp_date_line = NULL;
1298                         Elm_Object_Item *item = NULL;
1299
1300                         cur_item = (PMSG_APP_THREAD_MSG_DATA_S) calloc(1, sizeof(MSG_APP_THREAD_MSG_DATA_S));
1301                         msg_ui_thread_set_msg_data(cur_item, msg_list.msg_struct_info[row]);
1302
1303                         if (prev_item)
1304                                 tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, cur_item->msg_time, prev_item->msg_time);
1305                         else
1306                                 tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, cur_item->msg_time, NULL);
1307
1308                         if (tmp_date_line != NULL)
1309                                 dateline_data = tmp_date_line;
1310
1311                         if (dateline_data != NULL)
1312                                 item = dateline_data->date_it;
1313                         elm_genlist_item_append(pListData->genlist, &pListData->itc_default, cur_item, item, ELM_GENLIST_ITEM_NONE, msg_ui_thread_msg_gl_sel, (void *)pListData);
1314
1315                         if (dateline_data != NULL)
1316                                 dateline_data->subitem_cnt++;
1317
1318                         prev_item = cur_item;
1319                 }
1320
1321                 if (pListData->item_cnt == 0) {
1322                         msg_ui_thread_button_disabled_set(pListData, EINA_TRUE, CONTROLBAR_ITEM_1);
1323
1324                         // show non cotent
1325                         if (!pListData->noc_ly)
1326                                 pListData->noc_ly = msg_ui_thread_create_nocontent_layout(pData->navi_frame);
1327
1328                         Evas_Object *swl_ly = elm_object_part_content_get(pListData->content_ly, "thread_list");
1329
1330                         if (swl_ly != pListData->noc_ly) {
1331                                 evas_object_hide(swl_ly);
1332                                 elm_object_part_content_unset(pListData->content_ly, "thread_list");
1333                                 elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->noc_ly);
1334                         }
1335                 }
1336         }
1337         msg_release_list_struct(&msg_list);
1338
1339         D_LEAVE;
1340 }
1341
1342 void msg_ui_thread_list_msg_list_update(PMSG_THREAD_LIST_DATA pListData)
1343 {
1344         MSG_UI_ENTER();
1345         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
1346
1347         if (!pListData){
1348                 D_MSG("[ERROR] pListData is NULL");
1349                 return;
1350         }
1351
1352         PMSG_APP_THREAD_MSG_DATA_S item_data = NULL;
1353         int row = 0;
1354         Elm_Object_Item *gen_item = NULL;
1355         Evas_Object *entry = NULL;
1356
1357         msg_error_t err = MSG_SUCCESS;
1358         msg_struct_list_s msg_list;
1359
1360         Evas_Object *swl_ly = elm_object_part_content_get(pListData->content_ly, "thread_list");
1361
1362         if (pListData->search_mode == THREAD_SEARCH_ON) {
1363                 msg_struct_t search_s = msg_create_struct(MSG_STRUCT_SEARCH_CONDITION);
1364                 char *search_str = NULL;
1365
1366                 if (pListData->searchbar) {
1367                         entry = elm_object_part_content_get(pListData->searchbar, "elm.swallow.content");
1368                         search_str = elm_entry_markup_to_utf8(elm_entry_entry_get(entry));
1369                 }
1370
1371                 if (!search_str || strlen(search_str) == 0) {
1372                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "empty search_str");
1373                         if (pListData->list_type == THREAD_NORMAL_LIST_TYPE) {
1374                                 msg_ui_thread_list_update(pListData);
1375                                 if (search_str)
1376                                         free(search_str);
1377                                 msg_release_struct(&search_s);
1378                                 return;
1379                         }
1380                 }
1381
1382                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Search string word = [%s] ", search_str);
1383
1384                 switch (pListData->list_type) {
1385                         case THREAD_NORMAL_LIST_TYPE:
1386                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_ALLBOX_ID);
1387                                 break;
1388                         case THREAD_SPAM_LIST_TYPE:
1389                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_SPAMBOX_ID);
1390                                 break;
1391                         case THREAD_SIM_LIST_TYPE:
1392                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_ALLBOX_ID);
1393                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
1394                                 break;
1395                         case THREAD_CBMSG_LIST_TYPE:
1396                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_CBMSGBOX_ID);
1397                                 break;
1398                         default:
1399                                 D_MSG("[WARNING] invalid view mode");
1400                                 return;
1401                 }
1402                 msg_set_str_value(search_s, MSG_SEARCH_CONDITION_SEARCH_VALUE_STR, search_str, strlen(search_str));
1403
1404                 err =  msg_search_message(pData->msgHandle, search_s, 0, 0, &msg_list);
1405                 free(search_str);
1406                 msg_release_struct(&search_s);
1407
1408                 MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, err != MSG_SUCCESS);
1409         } else {
1410                 switch (pListData->list_type) {
1411                         case THREAD_SPAM_LIST_TYPE:
1412                                 err = msg_get_message_list(pData->msgHandle, MSG_SPAMBOX_ID, 0, 0, 0, &msg_list);
1413                                 break;
1414                         case THREAD_SIM_LIST_TYPE:
1415                                 err = msg_get_message_list(pData->msgHandle, MSG_ALLBOX_ID, 0, MSG_TYPE_SMS, MSG_STORAGE_SIM, &msg_list);
1416                                 break;
1417                         case THREAD_CBMSG_LIST_TYPE:
1418                                 err = msg_get_message_list(pData->msgHandle, MSG_CBMSGBOX_ID, 0, 0, 0, &msg_list);
1419                                 break;
1420                         default:
1421                                 D_MSG("[WARNING] invalid view mode");
1422                                 return;
1423                 }
1424                 MSG_UI_RET_IF(MSG_UI_LEVEL_DEBUG, err != MSG_SUCCESS);
1425         }
1426         pListData->item_cnt = msg_list.nCount;
1427
1428         if (msg_list.nCount <= 0 || err != MSG_SUCCESS) {
1429                 if (pListData->list_type == THREAD_NORMAL_LIST_TYPE)
1430                         msg_ui_thread_button_disabled_set(pListData, EINA_TRUE, CONTROLBAR_ITEM_2);
1431                 else
1432                         msg_ui_thread_button_disabled_set(pListData, EINA_TRUE, CONTROLBAR_ITEM_1);
1433
1434                 if (!pListData->noc_ly)
1435                         pListData->noc_ly = msg_ui_thread_create_nocontent_layout(pData->navi_frame);
1436
1437                 if (swl_ly != pListData->noc_ly) {
1438                         evas_object_hide(swl_ly);
1439                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
1440                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->noc_ly);
1441                 }
1442         } else {
1443                 if (pListData->list_type == THREAD_NORMAL_LIST_TYPE)
1444                         msg_ui_thread_button_disabled_set(pListData, EINA_FALSE, CONTROLBAR_ITEM_2);
1445                 else
1446                         msg_ui_thread_button_disabled_set(pListData, EINA_FALSE, CONTROLBAR_ITEM_1);
1447
1448                 if (swl_ly != pListData->genlist) {
1449                         evas_object_hide(swl_ly);
1450                         elm_object_part_content_unset(pListData->content_ly, "thread_list");
1451                         elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->genlist);
1452                 }
1453
1454                 gen_item = elm_genlist_first_item_get(pListData->genlist);
1455
1456                 while (gen_item) {
1457                         if (elm_genlist_item_parent_get(gen_item) == NULL) {
1458                                 gen_item = elm_genlist_item_next_get(gen_item);
1459                                 continue;
1460                         }
1461
1462                         item_data = elm_object_item_data_get(gen_item);
1463                         msg_ui_thread_set_msg_data(item_data, msg_list.msg_struct_info[row]);
1464
1465                         elm_object_item_data_set(gen_item, item_data);
1466                         gen_item = elm_genlist_item_next_get(gen_item);
1467                         row++;
1468                 }
1469         }
1470
1471         msg_release_list_struct(&msg_list);
1472         elm_genlist_realized_items_update(pListData->genlist);
1473
1474         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1475 }
1476
1477 Eina_Bool msg_ui_thread_list_msg_item_update(PMSG_THREAD_LIST_DATA pListData, msg_message_id_t msg_id)
1478 {
1479         MSG_UI_ENTER();
1480
1481         PMSG_THREAD_DATA pData = msg_ui_thread_get_data();
1482         PMSG_APP_THREAD_MSG_DATA_S old_data = NULL;
1483         PMSG_APP_THREAD_MSG_DATA_S new_data = NULL;
1484         int row = 0;
1485         Elm_Object_Item *gen_item = NULL;
1486         Evas_Object *entry = NULL;
1487
1488         msg_error_t err = MSG_SUCCESS;
1489         msg_struct_list_s msg_list;
1490
1491         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "msg_id = [%d] ", msg_id);
1492
1493         if (pListData->search_mode == THREAD_SEARCH_ON) {
1494                 msg_struct_t search_s = msg_create_struct(MSG_STRUCT_SEARCH_CONDITION);
1495                 char *search_str = NULL;
1496
1497                 if (pListData->searchbar) {
1498                         entry = elm_object_part_content_get(pListData->searchbar, "elm.swallow.content");
1499                         search_str = elm_entry_markup_to_utf8(elm_entry_entry_get(entry));
1500                 }
1501
1502                 if (!search_str || strlen(search_str) == 0) {
1503                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "empty search_str");
1504                         if (pListData->list_type == THREAD_NORMAL_LIST_TYPE) {
1505                                 msg_struct_t msgInfo = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1506                                 msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
1507                                 int thread_id = 0;
1508
1509                                 err = msg_get_message(pData->msgHandle, msg_id, msgInfo, sendOpt);
1510                                 msg_get_int_value(msgInfo, MSG_MESSAGE_THREAD_ID_INT, &thread_id);
1511                                 msg_release_struct(&msgInfo);
1512                                 msg_release_struct(&sendOpt);
1513
1514                                 msg_ui_thread_list_item_update(pListData, thread_id);
1515                                 if (search_str)
1516                                         free(search_str);
1517                                 msg_release_struct(&search_s);
1518                                 return EINA_TRUE;
1519                         }
1520                 }
1521
1522                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Search string word = [%s] ", search_str);
1523
1524                 switch (pListData->list_type) {
1525                         case THREAD_NORMAL_LIST_TYPE:
1526                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_ALLBOX_ID);
1527                                 break;
1528                         case THREAD_SPAM_LIST_TYPE:
1529                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_SPAMBOX_ID);
1530                                 break;
1531                         case THREAD_SIM_LIST_TYPE:
1532                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_ALLBOX_ID);
1533                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
1534                                 break;
1535                         case THREAD_CBMSG_LIST_TYPE:
1536                                 msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_CBMSGBOX_ID);
1537                                 break;
1538                         default:
1539                                 D_MSG("[WARNING] invalid view mode");
1540                                 return EINA_FALSE;
1541                 }
1542                 msg_set_str_value(search_s, MSG_SEARCH_CONDITION_SEARCH_VALUE_STR, search_str, strlen(search_str));
1543
1544                 err =  msg_search_message(pData->msgHandle, search_s, 0, 0, &msg_list);
1545                 free(search_str);
1546                 msg_release_struct(&search_s);
1547
1548                 MSG_UI_RETV_IF(MSG_UI_LEVEL_DEBUG, err != MSG_SUCCESS, EINA_FALSE);
1549         } else {
1550                 switch (pListData->list_type) {
1551                         case THREAD_SPAM_LIST_TYPE:
1552                                 err = msg_get_message_list(pData->msgHandle, MSG_SPAMBOX_ID, 0, 0, 0, &msg_list);
1553                                 break;
1554                         case THREAD_SIM_LIST_TYPE:
1555                                 err = msg_get_message_list(pData->msgHandle, MSG_ALLBOX_ID, 0, MSG_TYPE_SMS, MSG_STORAGE_SIM, &msg_list);
1556                                 break;
1557                         case THREAD_CBMSG_LIST_TYPE:
1558                                 err = msg_get_message_list(pData->msgHandle, MSG_CBMSGBOX_ID, 0, 0, 0, &msg_list);
1559                                 break;
1560                         default:
1561                                 D_MSG("[WARNING] invalid view mode");
1562                                 return EINA_FALSE;
1563                 }
1564                 MSG_UI_RETV_IF(MSG_UI_LEVEL_DEBUG, err != MSG_SUCCESS, EINA_FALSE);
1565         }
1566
1567         gen_item = elm_genlist_first_item_get(pListData->genlist);
1568
1569         /* Update genlist item */
1570         while (gen_item) {
1571                 if (elm_genlist_item_parent_get(gen_item) == NULL) {
1572                         gen_item = elm_genlist_item_next_get(gen_item);
1573                         continue;
1574                 }
1575
1576                 old_data = (PMSG_APP_THREAD_MSG_DATA_S) elm_object_item_data_get(gen_item);
1577                 if (old_data && msg_id == old_data->msg_id) {
1578                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "msg_id == item_data->msg_id == [%d] ", msg_id);
1579                         break;
1580                 }
1581                 gen_item = elm_genlist_item_next_get(gen_item);
1582         }
1583
1584         if (!gen_item) {
1585                 D_EMSG("gen_item is NULL");
1586                 msg_release_list_struct(&msg_list);
1587                 return EINA_FALSE;
1588         }
1589
1590         if (!old_data) {
1591                 D_EMSG("old_data is NULL");
1592                 return EINA_FALSE;
1593         }
1594
1595         for (row = 0; row <msg_list.nCount; row++) {
1596                 int row_msg_id = 0;
1597                 msg_get_int_value(msg_list.msg_struct_info[row], MSG_MESSAGE_ID_INT, &row_msg_id);
1598                 if (row_msg_id == msg_id) {
1599                         new_data = (PMSG_APP_THREAD_MSG_DATA_S)calloc(1, sizeof(MSG_APP_THREAD_MSG_DATA_S));
1600                         if (!new_data)
1601                                 break;
1602
1603                         msg_ui_thread_set_msg_data(new_data, msg_list.msg_struct_info[row]);
1604                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "find row = %d ", row);
1605                         break;
1606                 }
1607         }
1608         msg_release_list_struct(&msg_list);
1609
1610         if (!new_data) {
1611                 D_EMSG("new_data is NULL");
1612                 return EINA_FALSE;
1613         }
1614
1615         new_data->chk = old_data->chk;
1616         new_data->is_check = old_data->is_check;
1617
1618         elm_object_item_data_set(gen_item, new_data);
1619         elm_genlist_item_update(gen_item);
1620         elm_genlist_item_selected_set(gen_item, false);
1621
1622         if (pListData->view_mode == THREAD_EDIT_VIEW) {
1623                 if (eina_list_data_find(pListData->chk_list, old_data)) {
1624                         pListData->chk_list = eina_list_remove(pListData->chk_list, old_data);
1625                         pListData->chk_list = eina_list_append(pListData->chk_list, new_data);
1626                 }
1627         }
1628
1629         if (old_data->msg_time) {
1630                 free(old_data->msg_time);
1631                 old_data->msg_time = NULL;
1632         }
1633         free(old_data);
1634
1635         MSG_UI_LEAVE();
1636         return EINA_TRUE;
1637 }
1638
1639 void msg_ui_thread_list_msg_item_delete(PMSG_THREAD_LIST_DATA pListData, msg_message_id_t msg_id)
1640 {
1641         MSG_UI_ENTER();
1642
1643         PMSG_APP_THREAD_MSG_DATA_S item_data = NULL;
1644         Elm_Object_Item *gen_item = NULL;
1645         Elm_Object_Item *del_item = NULL;
1646         Elm_Object_Item *it_dateline = NULL;
1647         PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
1648
1649         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "msg_id = [%d] ", msg_id);
1650
1651         gen_item = elm_genlist_first_item_get(pListData->genlist);
1652
1653         while (gen_item) {
1654                 if (elm_genlist_item_parent_get(gen_item) == NULL) {
1655                         gen_item = elm_genlist_item_next_get(gen_item);
1656                         continue;
1657                 }
1658
1659                 //120803 - can exist multiple message with the same address in search result list
1660                 item_data = (PMSG_APP_THREAD_MSG_DATA_S) elm_object_item_data_get(gen_item);
1661                 if (item_data && msg_id == item_data->msg_id) {
1662                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "msg_id == item_data->msg_id == [%d] ", msg_id);
1663
1664                         del_item = gen_item;
1665
1666                         it_dateline = elm_genlist_item_parent_get(gen_item);
1667                         if (it_dateline) {
1668                                 dateline_data = elm_object_item_data_get(it_dateline);
1669
1670                                 if (dateline_data) {
1671                                         dateline_data->subitem_cnt--;
1672                                         if (dateline_data->subitem_cnt == 0)
1673                                                 elm_object_item_del((Elm_Object_Item *)it_dateline);
1674                                 }
1675                         }
1676                 }
1677                 gen_item = elm_genlist_item_next_get(gen_item);
1678
1679                 if (del_item) {
1680                         elm_object_item_del(del_item);
1681                         pListData->item_cnt--;
1682                         del_item = NULL;
1683                 }
1684         }
1685
1686         if (pListData->item_cnt <= 0) {
1687                 if (pListData->search_mode == THREAD_SEARCH_ON) {
1688                         elm_genlist_clear(pListData->genlist);
1689                         elm_genlist_item_append(pListData->genlist, msg_ui_thread_get_itc_type(THREAD_ITC_EMPTY), NULL, NULL, ELM_GENLIST_ITEM_NONE, msg_ui_thread_gl_empty_sel, NULL);
1690                 } else {
1691                         msg_ui_thread_msg_list_load(pListData, pListData->list_type);
1692                 }
1693         }
1694
1695         MSG_UI_LEAVE();
1696 }
1697
1698 Eina_Bool  msg_ui_thread_search_msg_list_load(void *data)
1699 {
1700         MSG_UI_ENTER();
1701         MSG_UI_RETV_IF(MSG_UI_LEVEL_DEBUG, !data, EINA_FALSE);
1702
1703         PMSG_THREAD_LIST_DATA pListData = (PMSG_THREAD_LIST_DATA)data;
1704
1705         Evas_Object *entry = NULL;
1706         char *search_str = NULL;
1707
1708         msg_struct_list_s search_msg_list;
1709         msg_struct_t search_s = msg_create_struct(MSG_STRUCT_SEARCH_CONDITION);
1710         msg_error_t err = MSG_SUCCESS;
1711         int idx = 0;
1712
1713         if (pListData->searchbar) {
1714                 entry = elm_object_part_content_get(pListData->searchbar, "elm.swallow.content");
1715                 search_str = elm_entry_markup_to_utf8(elm_entry_entry_get(entry));
1716         }
1717
1718         if (pListData->search_timer) {
1719                 ecore_timer_del(pListData->search_timer);
1720                 pListData->search_timer = NULL;
1721         }
1722
1723         if (!search_str || strlen(search_str) == 0) {
1724                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "empty search_str");
1725                 if (pListData->list_type == THREAD_NORMAL_LIST_TYPE)
1726                         msg_ui_thread_list_load(pListData, FALSE);
1727                 else
1728                         msg_ui_thread_msg_list_load(pListData, pListData->list_type);
1729                 msg_release_struct(&search_s);
1730                 if (search_str)
1731                         free(search_str);
1732                 return EINA_FALSE;
1733         }
1734
1735         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Search string word = [%s] ", search_str);
1736
1737         switch (pListData->list_type) {
1738                 case THREAD_NORMAL_LIST_TYPE:
1739                         msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_ALLBOX_ID);
1740                         break;
1741                 case THREAD_SPAM_LIST_TYPE:
1742                         msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_SPAMBOX_ID);
1743                         break;
1744                 case THREAD_SIM_LIST_TYPE:
1745                         msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_ALLBOX_ID);
1746                         msg_set_int_value(search_s, MSG_SEARCH_CONDITION_MSGTYPE_INT, MSG_TYPE_SMS);
1747                         break;
1748                 case THREAD_CBMSG_LIST_TYPE:
1749                         msg_set_int_value(search_s, MSG_SEARCH_CONDITION_FOLDERID_INT, MSG_CBMSGBOX_ID);
1750                         break;
1751                 default:
1752                         D_MSG("[WARNING] invalid view mode");
1753                         return EINA_FALSE;
1754         }
1755
1756         msg_set_str_value(search_s, MSG_SEARCH_CONDITION_SEARCH_VALUE_STR, search_str, strlen(search_str));
1757         err =  msg_search_message(msg_ui_thread_get_data_handle(), search_s, 0, 0, &search_msg_list);
1758         pListData->item_cnt = search_msg_list.nCount;
1759
1760         free(search_str);
1761         msg_release_struct(&search_s);
1762
1763         if (err != MSG_SUCCESS) {
1764                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "msg_search_message failed!! [%d]", err);
1765
1766                 if (pListData->list_type == THREAD_NORMAL_LIST_TYPE)
1767                         msg_ui_thread_list_load(pListData, FALSE);
1768                 else
1769                         msg_ui_thread_msg_list_load(pListData, pListData->list_type);
1770
1771                 return EINA_FALSE;
1772         }
1773
1774         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Search result [ count = %d ] ", search_msg_list.nCount);
1775
1776         Evas_Object *swl_ly = elm_object_part_content_get(pListData->content_ly, "thread_list");
1777
1778         if (swl_ly != pListData->genlist) {
1779                 evas_object_hide(swl_ly);
1780                 elm_object_part_content_unset(pListData->content_ly, "thread_list");
1781                 elm_object_part_content_set(pListData->content_ly, "thread_list", pListData->genlist);
1782         }
1783
1784         /** hide control bar */
1785         elm_genlist_clear(pListData->genlist);
1786
1787         if (search_msg_list.nCount > 0) {
1788                 PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
1789                 PMSG_APP_THREAD_MSG_DATA_S item_data = NULL;
1790                 PMSG_APP_THREAD_MSG_DATA_S prev_data = NULL;
1791
1792                 pListData->app_data_type = THREAD_LIST_APP_DATA_MSG;
1793                 msg_ui_thread_genlist_style_set(pListData);
1794
1795                 while (idx < search_msg_list.nCount) {
1796                         PMSG_APP_THREAD_DATELINE_DATA_S tmp_date_line = NULL;
1797                         Elm_Object_Item *item = NULL;
1798
1799                         if (pListData->list_type == THREAD_SIM_LIST_TYPE) {
1800                                 int storage_id = 0;
1801                                 msg_get_int_value(search_msg_list.msg_struct_info[idx], MSG_MESSAGE_STORAGE_ID_INT, &storage_id);
1802
1803                                 if (storage_id != MSG_STORAGE_SIM) {
1804                                         idx++;
1805                                         pListData->item_cnt--;
1806                                         continue;
1807                                 }
1808                         }
1809
1810                         item_data = (PMSG_APP_THREAD_MSG_DATA_S)calloc(1, sizeof(MSG_APP_THREAD_MSG_DATA_S));
1811                         msg_ui_thread_set_msg_data(item_data, search_msg_list.msg_struct_info[idx]);
1812
1813                         if (prev_data)
1814                                 tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, item_data->msg_time, prev_data->msg_time);
1815                         else
1816                                 tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, item_data->msg_time, NULL);
1817
1818                         if (tmp_date_line != NULL)
1819                                 dateline_data = tmp_date_line;
1820
1821                         if (dateline_data != NULL)
1822                                 item = dateline_data->date_it;
1823                         elm_genlist_item_append(pListData->genlist, msg_ui_thread_get_itc_type(THREAD_ITC_SEARCH), item_data, item, ELM_GENLIST_ITEM_NONE, msg_ui_thread_msg_gl_sel, pListData);
1824
1825                         if (dateline_data != NULL)
1826                                 dateline_data->subitem_cnt++;
1827
1828                         prev_data = item_data;
1829                         idx++;
1830                 }
1831
1832                 if (pListData->item_cnt == 0)
1833                         elm_genlist_item_append(pListData->genlist, msg_ui_thread_get_itc_type(THREAD_ITC_EMPTY), NULL, NULL, ELM_GENLIST_ITEM_NONE, msg_ui_thread_gl_empty_sel, NULL);
1834         } else {
1835                 elm_genlist_item_append(pListData->genlist, msg_ui_thread_get_itc_type(THREAD_ITC_EMPTY), NULL, NULL, ELM_GENLIST_ITEM_NONE, msg_ui_thread_gl_empty_sel, NULL);
1836         }
1837
1838         msg_release_list_struct(&search_msg_list);
1839
1840         return EINA_TRUE;
1841 }
1842
1843 Eina_Bool __msg_ui_thread_list_load_remain_item(void *data)
1844 {
1845         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1846
1847         PMSG_THREAD_LIST_DATA pListData = (PMSG_THREAD_LIST_DATA)data;
1848
1849         if (pListData->app_data_type == THREAD_LIST_APP_DATA_MSG)
1850                 return FALSE;
1851
1852         msg_error_t err = MSG_SUCCESS;
1853         msg_struct_t sort_rule_t = msg_create_struct(MSG_STRUCT_SORT_RULE);
1854         msg_struct_list_s peerList;
1855
1856         msg_set_int_value(sort_rule_t, MSG_SORT_RULE_SORT_TYPE_INT, MSG_SORT_BY_THREAD_DATE);
1857         msg_set_bool_value(sort_rule_t, MSG_SORT_RULE_ACSCEND_BOOL, false);
1858
1859         err = msg_get_thread_view_list(msg_ui_thread_get_data_handle(), sort_rule_t, &peerList);
1860         msg_release_struct(&sort_rule_t);
1861
1862         PMSG_APP_THREAD_DATELINE_DATA_S dateline_data = NULL;
1863         PMSG_APP_THREAD_DATA_S cur_thread = NULL;
1864         PMSG_APP_THREAD_DATA_S prev_thread = NULL;
1865         Elm_Object_Item *gen_item = NULL;
1866         Elm_Object_Item *it_dateline = NULL;
1867         int row = 0, start = pListData->loaded_cnt;
1868
1869         gen_item = elm_genlist_last_item_get(pListData->genlist);
1870         if (gen_item)
1871                 prev_thread = elm_object_item_data_get(gen_item);
1872
1873         for (row = start; row < peerList.nCount; row++) {
1874                 PMSG_APP_THREAD_DATELINE_DATA_S tmp_date_line = NULL;
1875                 Elm_Object_Item *item = NULL;
1876
1877                 cur_thread = (PMSG_APP_THREAD_DATA_S) calloc(1, sizeof(MSG_APP_THREAD_DATA_S));
1878                 msg_ui_thread_set_thread_data(pListData, cur_thread, peerList.msg_struct_info[row]);
1879
1880                 if (prev_thread) {
1881                         tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, cur_thread->thread_time, prev_thread->thread_time);
1882                         if (tmp_date_line == NULL) {
1883                                 it_dateline = elm_genlist_item_parent_get(gen_item);
1884                                 if (it_dateline)
1885                                         tmp_date_line = elm_object_item_data_get(it_dateline);
1886                         }
1887                 } else {
1888                         tmp_date_line = msg_ui_thread_list_insert_dateline(pListData, cur_thread->thread_time, NULL);
1889                 }
1890
1891                 if (tmp_date_line != NULL)
1892                         dateline_data = tmp_date_line;
1893
1894                 if (dateline_data != NULL)
1895                         item = dateline_data->date_it;
1896
1897                 if (cur_thread->unread_cnt > 0)
1898                         elm_genlist_item_append(pListData->genlist, &pListData->itc_unread, cur_thread, item, ELM_GENLIST_ITEM_NONE, __msg_ui_thread_gl_sel, pListData);
1899                 else
1900                         elm_genlist_item_append(pListData->genlist, &pListData->itc_default, cur_thread, item, ELM_GENLIST_ITEM_NONE, __msg_ui_thread_gl_sel, pListData);
1901
1902                 if (dateline_data != NULL)
1903                         dateline_data->subitem_cnt++;
1904
1905                 prev_thread = cur_thread;
1906                 pListData->loaded_cnt++;
1907
1908                 if (pListData->loaded_cnt == peerList.nCount) {
1909                         ecore_idler_del(pListData->launch_idler);
1910                         pListData->launch_idler = NULL;
1911                 }
1912         }
1913
1914         msg_release_list_struct(&peerList);
1915
1916         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1917
1918         return TRUE;
1919 }
1920
1921 void msg_ui_thread_common_style_set(PMSG_THREAD_DATA pData)
1922 {
1923         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1924         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pData);
1925
1926         pData->itc_empty.item_style = "1text";
1927         pData->itc_empty.func.text_get = msg_ui_thread_gl_empty_get;
1928         pData->itc_empty.func.content_get = NULL;
1929         pData->itc_empty.func.state_get = NULL;
1930         pData->itc_empty.func.del = NULL;
1931
1932         pData->itc_blank.item_style = "thread_list_blank";
1933         pData->itc_blank.func.text_get = NULL;
1934         pData->itc_blank.func.content_get = NULL;
1935         pData->itc_blank.func.state_get = NULL;
1936         pData->itc_blank.func.del = NULL;
1937
1938         pData->itc_date.item_style = "grouptitle";
1939         pData->itc_date.func.text_get = msg_ui_thread_date_gl_text_get;
1940         pData->itc_date.func.content_get = NULL;
1941         pData->itc_date.func.state_get = NULL;
1942         pData->itc_date.func.del = msg_ui_thread_date_gl_del;
1943
1944         pData->itc_search.item_style = "3text.1icon.tb";
1945         pData->itc_search.func.text_get = msg_ui_thread_search_msg_gl_text_get;
1946         pData->itc_search.func.content_get = msg_ui_thread_msg_gl_content_get;
1947         pData->itc_search.func.state_get = NULL;
1948         pData->itc_search.func.del = msg_ui_thread_msg_gl_del;
1949
1950         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1951 }
1952
1953 void msg_ui_thread_genlist_style_set(PMSG_THREAD_LIST_DATA pListData)
1954 {
1955         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1956         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, !pListData);
1957
1958         if (pListData->app_data_type == THREAD_LIST_APP_DATA_THREAD) {
1959                 pListData->itc_default.item_style = "4text.1icon.2";
1960                 pListData->itc_default.decorate_item_style = "mode/slide4";
1961                 pListData->itc_default.func.text_get = __msg_ui_thread_gl_text_get;
1962                 pListData->itc_default.func.content_get = __msg_ui_thread_gl_content_get;
1963                 pListData->itc_default.func.state_get = NULL;
1964                 pListData->itc_default.func.del = __msg_ui_thread_gl_del;
1965                 pListData->itc_default.decorate_all_item_style = "edit_default";
1966
1967                 pListData->itc_unread.item_style = "4text.1icon.1";
1968                 pListData->itc_unread.decorate_item_style = "mode/slide4";
1969                 pListData->itc_unread.func.text_get = __msg_ui_thread_gl_text_get;
1970                 pListData->itc_unread.func.content_get = __msg_ui_thread_gl_content_get;
1971                 pListData->itc_unread.func.state_get = NULL;
1972                 pListData->itc_unread.func.del = __msg_ui_thread_gl_del;
1973                 pListData->itc_unread.decorate_all_item_style = "edit_default";
1974         } else {
1975                 pListData->itc_default.item_style = "3text.1icon";
1976                 pListData->itc_default.func.text_get = msg_ui_thread_msg_gl_text_get;
1977                 pListData->itc_default.func.content_get = msg_ui_thread_msg_gl_content_get;
1978                 pListData->itc_default.func.state_get = NULL;
1979                 pListData->itc_default.func.del = msg_ui_thread_msg_gl_del;
1980                 pListData->itc_default.decorate_all_item_style = "edit_default";
1981
1982                 if (pListData->list_type == THREAD_CBMSG_LIST_TYPE)
1983                         pListData->itc_default.decorate_item_style = "mode/slide";
1984                 else
1985                         pListData->itc_default.decorate_item_style = "mode/slide2";
1986         }
1987
1988         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
1989 }