src/widget/mf-genlist.c

   1 /*
   2  * Copyright 2013         Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *  http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18
  19
  20 #include <math.h>
  21
  22 #include <vconf-keys.h>
  23 #include <vconf.h>
  24 #include <media_content.h>
  25
  26 #include "mf-main.h"
  27 #include "mf-widget.h"
  28 #include "mf-util.h"
  29 #include "mf-fm-svc-wrapper.h"
  30 #include "mf-fs-util.h"
  31 #include "mf-gadget.h"
  32 #include "mf-dlog.h"
  33 #include "mf-ta.h"
  34 #include "mf-delete.h"
  35 #include "mf-launch.h"
  36 #include "mf-resource.h"
  37 #include "mf-language-mgr.h"
  38
  39 #define NUM_OF_GENLIST_STYLES 4
  40 #define NUM_OF_ITEMS 50
  41 #define MF_DATE_FORMAT_DD_MM_YYYY "%d-%b-%Y "
  42 #define MF_DATE_FORMAT_MM_DD_YYYY "%b-%d-%Y "
  43 #define MF_DATE_FORMAT_YYYY_MM_DD "%Y-%b-%d "
  44 #define MF_DATE_FORMAT_YYYY_DD_MM "%Y-%d-%b "
  45 #define MF_TIME_FORMAT_12HOUR "%l:%M%p"
  46 #define MF_TIME_FORMAT_24HOUR "%H:%M"
  47 #define MF_ROUND_D(x, dig) (floor((x) * pow(10, dig+1) + 0.5) / pow(10, dig+1))
  48
  49 typedef struct {
  50         void *data;
  51         Evas_Object *pGenlist;
  52 } renameData_s;
  53
  54 /****   Global definition       ****/
  55 Elm_Genlist_Item_Class itc, userfolderitc, categoryitc, newfolderitc, indexitc;
  56 Elm_Genlist_Item_Class left_itc;
  57 Elm_Genlist_Item_Class search_itc;
  58 static Elm_Genlist_Item_Class itch;
  59
  60
  61 /***    static function declare ***/
  62 static char *__mf_genlist_gl_label_get(void *data, Evas_Object *obj, const char *part);
  63 static Evas_Object *__mf_genlist_gl_default_icon_get(void *data, Evas_Object *obj, const char *part);
  64 static Evas_Object *__mf_genlist_gl_edit_icon_get(void *data, Evas_Object *obj, const char *part);
  65 static void __mf_genlist_gl_del(void *data, Evas_Object *obj);
  66 static Eina_Bool __mf_genlist_gl_state_get(void *data, Evas_Object *obj, const char *part);
  67 static inline void __mf_genlist_get_thumbnail(mfItemData_s *params);
  68
  69 static void __mf_genlist_reset_serch_sweep_item(void *data)
  70 {
  71         struct appdata *ap = data;
  72         mf_retm_if(ap == NULL, "input ad is NULL");
  73         mf_retm_if(ap->mf_Status.more != MORE_SEARCH, "more is not MORE_SEARCH");
  74         mf_retm_if(ap->mf_MainWindow.pNaviGenlist == NULL, "input pNaviGenlist is NULL");
  75         mf_retm_if(ap->mf_MainWindow.pSearchViewSweepItem == NULL, "input pSearchViewSweepItem is NULL");
  76         const Elm_Object_Item *decorated_item = elm_genlist_decorated_item_get(ap->mf_MainWindow.pNaviGenlist);
  77         Elm_Object_Item *item = NULL;
  78         if(decorated_item) {
  79                 mf_debug("it is decorate status");
  80                 ap->mf_MainWindow.pSearchViewSweepItem = decorated_item;
  81                 return;
  82         }
  83
  84         for(item =  elm_genlist_first_item_get(ap->mf_MainWindow.pNaviGenlist); item != NULL; item = elm_genlist_item_next_get(item)) {
  85                 if(item == ap->mf_MainWindow.pSearchViewSweepItem) {
  86                         //elm_object_scroll_freeze_push(ap->mf_MainWindow.pNaviGenlist);
  87                         elm_genlist_item_decorate_mode_set(item, "slide", EINA_TRUE);
  88                         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_NONE);
  89                         //elm_object_scroll_freeze_pop(ap->mf_MainWindow.pNaviGenlist);
  90                         return;
  91                 }
  92         }
  93 }
  94
  95 void mf_genlist_rename_done(void *data, Evas_Object *obj, void *event_info)
  96 {
  97         MF_TRACE_BEGIN;
  98         struct appdata *ap = (struct appdata *)data;
  99         mf_retm_if(ap == NULL, "input ad is NULL");
 100
 101         if (ap->mf_FileOperation.rename_item && elm_genlist_item_flip_get(ap->mf_FileOperation.rename_item)) {
 102                 //elm_genlist_item_flip_set(ap->mf_FileOperation.rename_item, EINA_FALSE);
 103                 //elm_genlist_item_select_mode_set(ap->mf_FileOperation.rename_item, ELM_OBJECT_SELECT_MODE_DEFAULT);
 104         }
 105         mf_callback_rename_save_cb(ap, obj, event_info);
 106         MF_TRACE_END;
 107 }
 108
 109
 110 static Evas_Object *__mf_genlist_rename_editfiled_create(void *data, Evas_Object *parent)
 111 {
 112         MF_TRACE_BEGIN;
 113         mfItemData_s *params = (mfItemData_s *) data;
 114         mf_retvm_if(params == NULL, NULL, "param is NULL");
 115         mf_retvm_if(params->m_ItemName == NULL, NULL, "m_ItemName is NULL");
 116
 117         struct appdata *ap = (struct appdata *)params->ap;
 118         mf_retvm_if(ap == NULL, NULL, "input parameter data error");
 119
 120         static Elm_Entry_Filter_Limit_Size limit_filter_data;
 121         Evas_Object *edit_field = NULL;
 122         Evas_Object *entry = NULL;
 123         GString *filename = NULL;
 124
 125         edit_field = mf_widget_create_editfield(parent, &entry);
 126
 127         evas_object_size_hint_weight_set(edit_field, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 128         evas_object_size_hint_align_set(edit_field, EVAS_HINT_FILL, EVAS_HINT_FILL);
 129
 130
 131         elm_entry_single_line_set(entry, EINA_TRUE);
 132         elm_entry_scrollable_set(entry, EINA_TRUE);
 133         elm_object_signal_emit(edit_field, "elm,state,eraser,show", "elm");
 134         //elm_editfield_eraser_set(edit_field, EINA_TRUE);
 135
 136         elm_entry_autocapital_type_set(entry, ELM_AUTOCAPITAL_TYPE_NONE);
 137         elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NORMAL);
 138         params->ap->mf_MainWindow.pEntry = entry;
 139         params->ap->mf_MainWindow.pEditField = edit_field;
 140
 141         if (params->ap->mf_FileOperation.to_rename != NULL) {
 142                 g_string_free(params->ap->mf_FileOperation.to_rename, TRUE);
 143                 params->ap->mf_FileOperation.to_rename = NULL;
 144         }
 145         params->ap->mf_FileOperation.to_rename = g_string_new((char *)params->m_ItemName->str);
 146
 147
 148         /* the below is sample code for control entry. It is not mandatory.*/
 149
 150         /* set guide text */
 151         filename = mf_fm_svc_wrapper_get_file_name(ap->mf_FileOperation.to_rename);
 152         char *guide_text = NULL;
 153         SAFE_FREE_CHAR(ap->mf_FileOperation.file_name_suffix);
 154         if (!mf_file_attr_is_dir(ap->mf_FileOperation.to_rename->str)) {
 155                 mf_debug();
 156                 char *ext = NULL;
 157                 char *name_without_ext = NULL;
 158                 name_without_ext = g_strdup(ap->mf_FileOperation.to_rename->str);
 159                 mf_file_attr_get_file_ext(ap->mf_FileOperation.to_rename->str, &ext);
 160                 mf_debug("ext is %s", ext);
 161                 if (ext && strlen(ext) != 0) {
 162                         mf_debug();
 163                         name_without_ext[strlen(name_without_ext) - strlen(ext) - 1] = '\0';
 164                         ap->mf_FileOperation.file_name_suffix = strdup(ext);
 165                         mf_debug("name_without_ext is [%s]\n", name_without_ext);
 166                         if (strlen(name_without_ext)) {
 167                                 guide_text = elm_entry_utf8_to_markup(ecore_file_file_get(name_without_ext));
 168                         } else {
 169                                 guide_text = elm_entry_utf8_to_markup(filename->str);
 170                         }
 171                 } else {
 172                         guide_text = elm_entry_utf8_to_markup(filename->str);
 173                 }
 174
 175                 SAFE_FREE_CHAR(ext);
 176                 SAFE_FREE_CHAR(name_without_ext);
 177         } else {
 178                 guide_text = elm_entry_utf8_to_markup(filename->str);
 179         }
 180
 181         if (ap->mf_FileOperation.file_name_suffix) {
 182                 limit_filter_data.max_char_count = (MYFILE_FILE_NAME_LEN_MAX - mf_util_character_count_get(ap->mf_FileOperation.file_name_suffix) - 1);
 183         } else {
 184                 limit_filter_data.max_char_count = MYFILE_FILE_NAME_LEN_MAX;
 185         }
 186
 187         limit_filter_data.max_byte_count = 0;
 188         elm_entry_markup_filter_append(ap->mf_MainWindow.pEntry, elm_entry_filter_limit_size, &limit_filter_data);
 189         elm_entry_input_panel_return_key_type_set(ap->mf_MainWindow.pEntry, ELM_INPUT_PANEL_RETURN_KEY_TYPE_DONE);
 190
 191         elm_entry_entry_set(ap->mf_MainWindow.pEntry, guide_text);
 192         /*elm_entry_entry_set(entry, ecore_file_file_get(params->m_ItemName->str));*/
 193         elm_entry_cursor_end_set(entry);
 194
 195         SAFE_FREE_CHAR(guide_text);
 196         SAFE_FREE_GSTRING(filename);
 197
 198         evas_object_smart_callback_add(entry, "activated", mf_genlist_rename_done, params->ap);
 199         evas_object_smart_callback_add(entry, "changed", mf_callback_imf_changed_cb, params->ap);
 200         evas_object_smart_callback_add(entry, "maxlength,reached", mf_callback_max_len_reached_cb, params->ap);
 201         evas_object_smart_callback_add(entry, "preedit,changed",
 202                                        mf_callback_imf_preedit_change_cb, ap);
 203
 204         elm_object_signal_callback_add(edit_field, "elm,eraser,clicked", "elm", mf_callback_eraser_clicked_cb, entry);
 205         evas_object_show(entry);
 206         elm_object_focus_set(entry, EINA_TRUE);
 207
 208         MF_TRACE_END;
 209         return edit_field;
 210 }
 211
 212 static Eina_Bool __mf_genlist_timer_cb(void *data)
 213 {
 214         struct appdata *ap = (struct appdata *)data;
 215         mf_retvm_if(ap == NULL, EINA_FALSE, "ap is null");
 216
 217         if (ap->mf_MainWindow.pPreSearchViewSweepItem)
 218                 elm_genlist_item_update(ap->mf_MainWindow.pPreSearchViewSweepItem);
 219
 220         if(ap->mf_MainWindow.pSearchViewTimer) {
 221                 ecore_timer_del(ap->mf_MainWindow.pSearchViewTimer);
 222                 ap->mf_MainWindow.pSearchViewTimer = NULL;
 223         }
 224         return false;
 225 }
 226
 227 void mf_genlist_gl_mode_sweep_set(void *data, Evas_Object *obj, void *event_info)
 228 {
 229         MF_TRACE_BEGIN;
 230         mf_retm_if(event_info == NULL, "event_info is NULL");
 231         struct appdata *ap = (struct appdata *)data;
 232         mf_retm_if(ap == NULL, "ap is null");
 233
 234 #ifndef MYFILE_ADD_TO_HOME
 235 #ifndef MYFILE_DETAILS
 236         if (ap->mf_Status.view_type == mf_view_root)
 237                 return;
 238 #endif
 239 #endif
 240
 241         if (ap->mf_Status.more == MORE_RENAME) {
 242                 mf_genlist_rename_done(ap, NULL, NULL);
 243                 return;
 244         } else if(ap->mf_Status.more == MORE_EDIT) {
 245                 return;
 246         }
 247
 248         if (ap->mf_Status.more == MORE_RENAME) {
 249                 mf_callback_destory_rename(ap);
 250         }
 251         /* Start genlist sweep */
 252         Elm_Object_Item *it = (Elm_Object_Item *)elm_genlist_decorated_item_get(obj);
 253         mf_debug("it=%p, event_info=%p, pSearchViewSweepItem=%p",
 254                 it, event_info, ap->mf_MainWindow.pSearchViewSweepItem);
 255         if (it && (it != event_info)) {
 256                 elm_genlist_item_decorate_mode_set(it, "slide", EINA_FALSE);
 257                 elm_genlist_item_select_mode_set(it, ELM_OBJECT_SELECT_MODE_DEFAULT);
 258         } else {
 259                 mf_debug("no decorated mode item");
 260         }
 261
 262         elm_genlist_item_decorate_mode_set(event_info, "slide", EINA_TRUE);
 263         elm_genlist_item_select_mode_set(event_info, ELM_OBJECT_SELECT_MODE_NONE);
 264
 265         if (ap->mf_Status.more == MORE_SEARCH && event_info) {
 266                 if(ap->mf_MainWindow.pSearchViewTimer) {
 267                         ecore_timer_del(ap->mf_MainWindow.pSearchViewTimer);
 268                         ap->mf_MainWindow.pSearchViewTimer = NULL;
 269                 }
 270                 ap->mf_MainWindow.pSearchViewTimer = ecore_timer_add(0.3, __mf_genlist_timer_cb, ap);
 271                 ap->mf_MainWindow.pPreSearchViewSweepItem = it;
 272                 ap->mf_MainWindow.pSearchViewSweepItem = event_info;
 273         }
 274
 275         MF_TRACE_END;
 276 }
 277
 278 void mf_genlist_gl_mode_sweep_unset(void *data, Evas_Object *obj, void *event_info)
 279 {
 280         MF_TRACE_BEGIN;
 281
 282         struct appdata *ap = (struct appdata *)data;
 283         mf_retm_if(ap == NULL, "ap is null");
 284 #ifndef MYFILE_ADD_TO_HOME
 285 #ifndef MYFILE_DETAILS
 286         if (ap->mf_Status.view_type == mf_view_root)
 287                 return;
 288 #endif
 289 #endif
 290
 291         if (!event_info)
 292                 return;
 293
 294         if (ap->mf_Status.more == MORE_RENAME) {
 295                 mf_genlist_rename_done(ap, NULL, NULL);
 296                 return;
 297         } else if(ap->mf_Status.more == MORE_EDIT) {
 298                 return;
 299         }
 300
 301         if (obj)
 302                 //elm_object_scroll_freeze_push(obj);
 303
 304         if (ap->mf_Status.more == MORE_SEARCH && ap->mf_MainWindow.pSearchViewSweepItem) {
 305                 if(ap->mf_MainWindow.pSearchViewTimer) {
 306                         ecore_timer_del(ap->mf_MainWindow.pSearchViewTimer);
 307                         ap->mf_MainWindow.pSearchViewTimer = NULL;
 308                 }
 309                 ap->mf_MainWindow.pSearchViewTimer = ecore_timer_add(0.3, __mf_genlist_timer_cb, ap);
 310                 ap->mf_MainWindow.pPreSearchViewSweepItem = ap->mf_MainWindow.pSearchViewSweepItem;
 311                 ap->mf_MainWindow.pSearchViewSweepItem = NULL;
 312         }
 313
 314         /* Finish genlist sweep */
 315         elm_genlist_item_decorate_mode_set(event_info, "slide", EINA_FALSE);
 316         elm_genlist_item_select_mode_set(event_info, ELM_OBJECT_SELECT_MODE_DEFAULT);
 317         MF_TRACE_END;
 318 }
 319
 320 void mf_genlist_gl_mode_cancel(void *data, Evas_Object * obj, void *event_info)
 321 {
 322         MF_TRACE_BEGIN;
 323         struct appdata *ap = (struct appdata *)data;
 324         mf_retm_if(ap == NULL, "ap is null");
 325 #ifndef MYFILE_ADD_TO_HOME
 326 #ifndef MYFILE_DETAILS
 327         if (ap->mf_Status.view_type == mf_view_root)
 328                 return;
 329 #endif
 330 #endif
 331         if (!obj)
 332                 return;
 333
 334         if (ap->mf_Status.more == MORE_RENAME) {
 335                 mf_genlist_rename_done(ap, NULL, NULL);
 336                 return;
 337         } else if(ap->mf_Status.more == MORE_EDIT) {
 338                 return;
 339         }
 340         /* Get sweeped item */
 341         Elm_Object_Item *it = (Elm_Object_Item *) elm_genlist_decorated_item_get(obj);
 342
 343         if (ap->mf_Status.more == MORE_SEARCH)
 344                 ap->mf_MainWindow.pSearchViewSweepItem = NULL;
 345
 346         /* Finish genlist sweep */
 347         if (it) {
 348                 elm_genlist_item_decorate_mode_set(it, "slide", EINA_FALSE);
 349                 elm_genlist_item_select_mode_set(it, ELM_OBJECT_SELECT_MODE_DEFAULT);
 350         }
 351         MF_TRACE_END;
 352 }
 353
 354 /**     label related   **/
 355 static char *__mf_genlist_gl_label_get(void *data, Evas_Object * obj, const char *part)
 356 {
 357
 358         mfItemData_s *params = (mfItemData_s *) data;
 359         mf_retv_if(params == NULL, NULL);
 360         mf_debug("part=%s", part);
 361         __mf_genlist_reset_serch_sweep_item(params->ap);
 362         if (strcmp(part, "elm.text") == 0) {
 363                 /* supporting multi-lang for default folders */
 364                 if (g_strcmp0(params->m_ItemName->str, PHONE_FOLDER) == 0) {
 365                         return g_strdup(GET_SYS_STR(MF_LABEL_PHONE));
 366                 } else if (g_strcmp0(params->m_ItemName->str, MEMORY_FOLDER) == 0) {
 367                         return g_strdup(GET_SYS_STR(MF_LABEL_MMC));
 368                 } else if (g_strcmp0(params->m_ItemName->str, OTG_FOLDER) == 0) {
 369                         return g_strdup(GET_STR(MF_LABEL_OTG));
 370                 } else {
 371                         if (params->ap->mf_Status.more == MORE_SEARCH &&params->ap->mf_Status.search_filter) {
 372                                 char *markup_name = NULL;
 373                                 bool res = false;
 374                                 markup_name = (char *)mf_util_search_markup_keyword(ecore_file_file_get(params->m_ItemName->str), params->ap->mf_Status.search_filter, &res);
 375                                 if(res) {
 376                                         return g_strdup(markup_name);
 377                                 }
 378                         }
 379                         if (params->ap->mf_Status.iExtensionState == MF_EXTENSION_HIDE && !mf_file_attr_is_dir(params->m_ItemName->str)) {
 380                                 return mf_fm_svc_get_file_name(params->m_ItemName);
 381
 382                         } else {
 383                                 return g_strdup(ecore_file_file_get(params->m_ItemName->str));
 384                         }
 385                 }
 386         } else if (strcmp(part, "elm.uptitle.text") == 0) {
 387                 return g_strdup(params->m_ItemName->str);
 388         } else if (strcmp(part, "elm.slide_base.text") == 0) {
 389                 return g_strdup(ecore_file_file_get(params->m_ItemName->str));
 390         } else if (strcmp(part, "elm.slide.text.1") == 0) {
 391                 return g_strdup(ecore_file_file_get(params->m_ItemName->str));
 392         } else if (strcmp(part, "elm.text.1") == 0) {
 393                 if (g_strcmp0(params->m_ItemName->str, PHONE_FOLDER) == 0) {
 394                         return g_strdup(GET_SYS_STR(MF_LABEL_PHONE));
 395                 } else if (g_strcmp0(params->m_ItemName->str, MEMORY_FOLDER) == 0) {
 396                         return g_strdup(GET_SYS_STR(MF_LABEL_MMC));
 397                 } else if (g_strcmp0(params->m_ItemName->str, OTG_FOLDER) == 0) {
 398                         return g_strdup(GET_STR(MF_LABEL_OTG));
 399                 } else if (params->ap->mf_Status.more == MORE_SEARCH &&params->ap->mf_Status.search_filter) {
 400                         char *markup_name = NULL;
 401                         bool res = false;
 402                         markup_name = (char *)mf_util_search_markup_keyword(ecore_file_file_get(params->m_ItemName->str), params->ap->mf_Status.search_filter, &res);
 403                         if(res) {
 404                                 return g_strdup(markup_name);
 405                         }
 406                 }
 407                 if (params->ap->mf_Status.iExtensionState == MF_EXTENSION_HIDE && !mf_file_attr_is_dir(params->m_ItemName->str)) {
 408                         return mf_fm_svc_get_file_name(params->m_ItemName);
 409
 410                 } else {
 411                         return g_strdup(ecore_file_file_get(params->m_ItemName->str));
 412                 }
 413         } else if (strcmp(part, "elm.text.2") == 0) {
 414
 415                 if (params->ap->mf_Status.more == MORE_SEARCH &&params->ap->mf_Status.search_filter) {
 416                         int root_len = 0;
 417                         char *new_path = NULL;
 418                         GString *parent_path = NULL;
 419                         parent_path = mf_fm_svc_wrapper_get_file_parent_path(params->m_ItemName);
 420                         if (parent_path) {
 421                                 switch(mf_fm_svc_wrapper_get_location(parent_path->str)) {
 422                                 case MYFILE_PHONE:
 423                                         root_len = strlen(PHONE_FOLDER);
 424                                         new_path = g_strconcat(GET_SYS_STR(MF_LABEL_PHONE), parent_path->str + root_len, NULL);
 425                                         break;
 426                                 case MYFILE_MMC:
 427                                         root_len = strlen(MEMORY_FOLDER);
 428                                         new_path = g_strconcat(GET_SYS_STR(MF_LABEL_MMC), parent_path->str + root_len, NULL);
 429                                         break;
 430                                 case MYFILE_OTG:
 431                                         root_len = strlen(OTG_FOLDER);
 432                                         new_path = g_strconcat(GET_STR(MF_LABEL_OTG), parent_path->str + root_len, NULL);
 433                                         break;
 434                                 default:
 435                                         break;
 436                                 }
 437                                 SAFE_FREE_GSTRING(parent_path);
 438                         }
 439
 440                         return new_path;
 441                 } else if (params->ap->mf_Status.more != MORE_SEARCH
 442                                                         && params->ap->mf_Status.view_type == mf_view_root_category) {
 443                         int root_len = 0;
 444                         char *new_path = NULL;
 445                         GString *parent_path = NULL;
 446                         parent_path = mf_fm_svc_wrapper_get_file_parent_path(params->m_ItemName);
 447                         if (parent_path) {
 448                                 switch(mf_fm_svc_wrapper_get_location(parent_path->str)) {
 449                                 case MYFILE_PHONE:
 450                                         root_len = strlen(PHONE_FOLDER);
 451                                         new_path = g_strconcat(GET_SYS_STR(MF_LABEL_PHONE), parent_path->str + root_len, NULL);
 452                                         break;
 453                                 case MYFILE_MMC:
 454                                         root_len = strlen(MEMORY_FOLDER);
 455                                         new_path = g_strconcat(GET_SYS_STR(MF_LABEL_MMC), parent_path->str + root_len, NULL);
 456                                         break;
 457                                 case MYFILE_OTG:
 458                                         root_len = strlen(OTG_FOLDER);
 459                                         new_path = g_strconcat(GET_SYS_STR(MF_LABEL_OTG), parent_path->str + root_len, NULL);
 460                                         break;
 461                                 default:
 462                                         break;
 463                                 }
 464                                 SAFE_FREE_GSTRING(parent_path);
 465                         }
 466
 467                         return new_path;
 468                 } else {
 469                         if (params->ap->mf_Status.flagViewType != MF_VIEW_SYTLE_LIST_DETAIL) {
 470                                 int iSortTypeValue = 0;
 471                                 mf_util_get_vconf_value(VCONF_TYPE_SORT_TYPE, &iSortTypeValue);
 472                                 if (iSortTypeValue == MYFILE_SORT_BY_SIZE_S2L || iSortTypeValue == MYFILE_SORT_BY_SIZE_L2S) {
 473                                         if (params->size) {
 474                                                 return g_strdup(params->size);
 475                                         } else {
 476                                                 return NULL;
 477                                         }
 478                                 } else if (iSortTypeValue == MYFILE_SORT_BY_DATE_O2R || iSortTypeValue == MYFILE_SORT_BY_DATE_R2O) {
 479                                         if (params->create_date) {
 480                                                 return g_strdup(params->create_date);
 481                                         } else {
 482                                                 return NULL;
 483                                         }
 484                                 } else {
 485                                         return NULL;
 486                                 }
 487                         } else {
 488                                 if (ecore_file_is_dir(params->m_ItemName->str)) {
 489                                         Eina_List *file_list = NULL;
 490                                         Eina_List *folder_list = NULL;
 491                                         int ret = 0;
 492                                         ret = mf_fs_oper_read_dir(params->m_ItemName->str, &folder_list, &file_list);
 493                                         if (ret == MYFILE_ERR_NONE) {
 494                                                 int count = 0;
 495                                                 count = eina_list_count(file_list) + eina_list_count(folder_list);
 496                                                 mf_util_free_eina_list_with_data(&file_list, MYFILE_TYPE_FSNODE);
 497                                                 mf_util_free_eina_list_with_data(&folder_list, MYFILE_TYPE_FSNODE);
 498                                                 return g_strdup_printf("%d items", count);
 499                                         } else {
 500                                                 return g_strdup(_(""));
 501                                         }
 502                                 } else {
 503                                         if (params->size) {
 504                                                 return g_strdup(params->size);
 505                                         } else {
 506                                                 return NULL;
 507                                         }
 508                                 }
 509                         }
 510
 511                 }
 512         } else if (strcmp(part, "elm.text.3") == 0) {
 513                 if (params->create_date) {
 514                         return g_strdup(params->create_date);
 515                 } else {
 516                         return NULL;
 517                 }
 518
 519         } else {
 520                 return g_strdup(_(""));
 521         }
 522 }
 523
 524 /**     icon related    **/
 525 static Evas_Object *__mf_genlist_gl_default_icon_get(void *data, Evas_Object * obj, const char *part)
 526 {
 527         Evas_Object *layout = NULL;
 528         mfItemData_s *params = (mfItemData_s *) data;
 529
 530         mf_retvm_if(params == NULL, NULL, "param is NULL");
 531         mf_retvm_if(params->m_ItemName == NULL, NULL, "m_ItemName is NULL");
 532         mf_retvm_if(part == NULL, NULL, "part is NULL");
 533         mf_retvm_if(obj == NULL, NULL, "obj is NULL");
 534         mf_debug("part=%s", part);
 535         __mf_genlist_reset_serch_sweep_item(params->ap);
 536
 537         if (!strcmp(part, "elm.icon") || !strcmp(part, "elm.icon.1")) {
 538                 Evas_Object *thumb = NULL;
 539                 Evas_Object *ic_memory = NULL;
 540                 MF_STORAGE is_in_mmc = FALSE;
 541                 char *key = NULL;
 542                 const char *memory_icon_path = MF_ICON_MEMORY_SUB;
 543
 544                 __mf_genlist_get_thumbnail(params);
 545                 layout = mf_widget_create_layout(obj, EDJ_NAME, GRP_THUMBNAIL_ONLY);
 546                 evas_object_size_hint_aspect_set(layout, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 547                 if (layout) {
 548                         thumb = elm_image_add(layout);
 549                         elm_object_focus_set(thumb, EINA_FALSE);
 550                         if (thumb == NULL) {
 551                                 mf_error("thumb is NULL");
 552                                 return NULL;
 553                         }
 554                         elm_image_file_set(thumb, params->thumb_path, NULL);
 555                         elm_object_part_content_set(layout, "thumbnail", thumb);
 556
 557                         mf_file_attr_get_store_type_by_full(params->m_ItemName->str, &is_in_mmc);
 558                         if (is_in_mmc == MYFILE_MMC) {
 559                                 ic_memory = elm_image_add(layout);
 560                                 elm_object_focus_set(ic_memory, EINA_FALSE);
 561                                 elm_image_file_set(ic_memory, memory_icon_path, key);
 562                                 evas_object_show(ic_memory);
 563                                 elm_object_part_content_set(layout, "myfile.memory_icon_multi.sub", ic_memory);
 564                         }
 565
 566                         fsFileType type = FILE_TYPE_NONE;
 567                         type = mf_file_attr_get_file_type_by_mime(params->m_ItemName->str);
 568                         if (type == FILE_TYPE_VIDEO) {
 569                                 const char *play_icon_path = MF_ICON_VIDEO_PLAY;
 570                                 Evas_Object *play_icon = NULL;
 571                                 play_icon = elm_image_add(layout);
 572                                 elm_object_focus_set(play_icon, EINA_FALSE);
 573                                 elm_image_file_set(play_icon, play_icon_path, key);
 574                                 evas_object_show(play_icon);
 575                                 elm_object_part_content_set(layout, "video_play", play_icon);
 576                         }
 577                 }
 578         } else if (!strcmp(part, "elm.icon.2")) {
 579                 if (params->ap->mf_Status.more == MORE_EDIT) {
 580                         return NULL;
 581                 }
 582                 Evas_Object *entry_button = NULL;
 583                 Evas_Object *entry_icon = NULL;
 584                 entry_button = elm_button_add(obj);
 585                 elm_object_style_set(entry_button, "circle/empty");
 586
 587                 entry_icon = elm_image_add(entry_button);
 588                 char *play_icon = strdup(MF_ICON_ENTRY_FOLDER);
 589                 elm_image_file_set(entry_icon, play_icon, NULL);
 590                 evas_object_size_hint_aspect_set(entry_icon, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
 591                 elm_object_part_content_set(entry_button, "icon", entry_icon);
 592                 evas_object_propagate_events_set(entry_button, EINA_FALSE);
 593                 evas_object_smart_callback_add(entry_button, "pressed", mf_callback_entry_button_pressed_cb, play_icon);
 594                 evas_object_smart_callback_add(entry_button, "unpressed", mf_callback_entry_button_unpressed_cb, play_icon);
 595                 evas_object_smart_callback_add(entry_button, "clicked", (Evas_Smart_Cb)mf_callback_entry_cb, (void*)params);
 596                 return entry_button;
 597         }
 598         else if (!strcmp(part, "elm.base.swallow.detail")) {
 599         } else if (!strcmp(part, "elm.slide.swallow.1")) {
 600                 if (params->ap->mf_Status.view_type == mf_view_root && params->ap->mf_Status.more != MORE_SEARCH) {
 601                 }
 602                 else
 603                 {
 604                         layout = elm_button_add(obj);
 605                         elm_object_style_set(layout, "sweep/multiline");
 606                         elm_object_text_set(layout, GET_SYS_STR(LABEL_RENAME));
 607                         mf_language_mgr_register_object(layout, OBJ_TYPE_ELM_OBJECT, NULL, LABEL_RENAME);
 608                         evas_object_smart_callback_add(layout, "clicked", (Evas_Smart_Cb) mf_callback_rename_button_callback, data);
 609                 }
 610         } else if (!strcmp(part, "elm.slide.swallow.2")) {
 611
 612                 if (params->ap->mf_Status.view_type == mf_view_root && params->ap->mf_Status.more != MORE_SEARCH) {
 613
 614                 } else {
 615                         layout = elm_button_add(obj);
 616                         elm_object_style_set(layout, "sweep/delete");
 617                         elm_object_text_set(layout, GET_SYS_STR(LABEL_DELETE));
 618                         mf_language_mgr_register_object(layout, OBJ_TYPE_ELM_OBJECT, NULL, LABEL_DELETE);
 619                         evas_object_smart_callback_add(layout, "clicked", mf_callback_delete_button_cb, data);
 620                 }
 621         } else if (!strcmp(part, "elm.slide.swallow.3")) {
 622                 layout = elm_button_add(obj);
 623                 elm_object_style_set(layout, "sweep/delete");
 624                 elm_object_text_set(layout, GET_SYS_STR(LABEL_DELETE));
 625                 mf_language_mgr_register_object(layout, OBJ_TYPE_ELM_OBJECT, NULL, LABEL_DELETE);
 626                 evas_object_smart_callback_add(layout, "clicked", mf_callback_delete_button_cb, data);
 627         } else if (!strcmp(part, "elm.slide.swallow.4")) {
 628                 layout = elm_button_add(obj);
 629                 elm_object_style_set(layout, "sweep/delete");
 630                 elm_object_text_set(layout, GET_SYS_STR(LABEL_DELETE));
 631                 mf_language_mgr_register_object(layout, OBJ_TYPE_ELM_OBJECT, NULL, LABEL_DELETE);
 632                 evas_object_smart_callback_add(layout, "clicked", mf_callback_delete_button_cb, data);
 633         } else if (!strcmp(part, "elm.flip.content")) { /* this is used when the rename mode is enabled.*/
 634                 Evas_Object *edit_field = NULL;
 635                 edit_field = __mf_genlist_rename_editfiled_create(params, obj);
 636                 evas_object_propagate_events_set(edit_field, EINA_FALSE);
 637                 return edit_field;
 638         } else if (!strcmp(part, "elm.flip.icon")) {
 639                 Evas_Object *cancel_btn = mf_widget_util_create_button(obj, NULL, LABEL_CANCEL, NULL,
 640                                 mf_callback_cancel_cb, params->ap);
 641                 evas_object_show(cancel_btn);
 642                 return cancel_btn;
 643         }
 644         return layout;
 645 }
 646
 647 static void __mf_genlist_item_check_changed_callback(void *data, Evas_Object * obj, void *event_info)
 648 {
 649         MF_TRACE_BEGIN;
 650         mfItemData_s *params = (mfItemData_s *) data;
 651         mf_retm_if(params == NULL, "param is NULL");
 652
 653         struct appdata *ap = (struct appdata *)params->ap;
 654         mf_retm_if(ap == NULL, "input parameter data error");
 655         mf_retm_if(obj == NULL, "obj is NULL");
 656
 657         if (ap->mf_Status.more == MORE_RENAME) {
 658                 mf_genlist_rename_done(ap, NULL, NULL);
 659                 params->m_checked = !params->m_checked;
 660                 elm_check_state_pointer_set(obj, &params->m_checked);
 661                 return;
 662         }
 663
 664         if (params->m_checked) {
 665                 ap->mf_MainWindow.pEditView.iCheckedCount++;
 666         } else {
 667                 ap->mf_MainWindow.pEditView.iCheckedCount--;
 668         }
 669
 670
 671         if (ap->mf_MainWindow.pEditView.iTotalCount == ap->mf_MainWindow.pEditView.iCheckedCount) {
 672                 ap->mf_MainWindow.pEditView.bSelectAllChecked = EINA_TRUE;
 673         } else {
 674                 ap->mf_MainWindow.pEditView.bSelectAllChecked = EINA_FALSE;
 675         }
 676         mf_genlist_gl_edit_item_selected(ap);
 677         MF_TRACE_END;
 678 }
 679
 680 static void __mf_genlist_selected_all_items_set(Evas_Object *genlist, int value)
 681 {
 682         MF_TRACE_BEGIN;
 683         mf_retm_if(genlist == NULL, "genlist is NULL");
 684
 685         mfItemData_s *it_data;
 686         Elm_Object_Item *it;
 687
 688         it = elm_genlist_first_item_get(genlist);
 689         while (it) {
 690                 it_data = elm_object_item_data_get(it);
 691                 if (it_data)
 692                         it_data->m_checked = value;
 693                 //elm_check_state_pointer_set(it_data->pCheckBox, it_data->m_checked);
 694                 elm_genlist_item_fields_update(it, "elm.edit.icon.1", ELM_GENLIST_ITEM_FIELD_CONTENT);
 695                 it = elm_genlist_item_next_get(it);
 696         }
 697         MF_TRACE_END;
 698 }
 699
 700 static void __mf_genlist_check_select_all(void *data)
 701 {
 702         MF_TRACE_BEGIN;
 703         struct appdata *ap = (struct appdata *)data;
 704         mf_retm_if(ap == NULL, "input parameter data error");
 705
 706         if (ap->mf_MainWindow.pEditView.bSelectAllChecked) {
 707                 ap->mf_MainWindow.pEditView.iCheckedCount = ap->mf_MainWindow.pEditView.iTotalCount;
 708         } else {
 709                 ap->mf_MainWindow.pEditView.iCheckedCount = 0;
 710         }
 711
 712         if (ap->mf_Status.flagViewType == MF_VIEW_STYLE_LIST || ap->mf_Status.flagViewType == MF_VIEW_SYTLE_LIST_DETAIL) {
 713                 __mf_genlist_selected_all_items_set(ap->mf_MainWindow.pEditView.pGenlist, ap->mf_MainWindow.pEditView.bSelectAllChecked);
 714         }else {
 715                 mf_gengrid_select_all(ap);
 716         }
 717         mf_genlist_gl_edit_item_selected(ap);
 718         MF_TRACE_END;
 719 }
 720
 721
 722 void __mf_genlist_select_all_layout_mouse_down_cb(void *data, Evas * evas, Evas_Object * obj, void *event_info)
 723 {
 724         MF_TRACE_BEGIN;
 725         struct appdata *ap = (struct appdata *)data;
 726         mf_retm_if(ap == NULL, "input parameter data error");
 727
 728         if (ap->mf_Status.more == MORE_RENAME) {
 729                 mf_genlist_rename_done(ap, NULL, NULL);
 730                 return;
 731         }
 732
 733         ap->mf_MainWindow.pEditView.bSelectAllChecked = !ap->mf_MainWindow.pEditView.bSelectAllChecked;
 734         //elm_check_state_pointer_set(ap->mf_MainWindow.pEditView.pSelectAllCheckBox, &ap->mf_MainWindow.pEditView.bSelectAllChecked);
 735
 736         __mf_genlist_check_select_all(ap);
 737         MF_TRACE_END;
 738 }
 739
 740
 741 void __mf_genlist_select_all_check_changed_cb(void *data, Evas_Object * obj, void *event_info)
 742 {
 743         MF_TRACE_BEGIN;
 744         struct appdata *ap = (struct appdata *)data;
 745         mf_retm_if(ap == NULL, "input parameter data error");
 746
 747         if (ap->mf_Status.more == MORE_RENAME) {
 748                 mf_genlist_rename_done(ap, NULL, NULL);
 749                 ap->mf_MainWindow.pEditView.bSelectAllChecked = !ap->mf_MainWindow.pEditView.bSelectAllChecked;
 750                 //elm_check_state_pointer_set(ap->mf_MainWindow.pEditView.pSelectAllCheckBox, &ap->mf_MainWindow.pEditView.bSelectAllChecked);
 751                 return;
 752         }
 753
 754         __mf_genlist_check_select_all(ap);
 755
 756         MF_TRACE_END;
 757 }
 758
 759 static Evas_Object *__mf_genlist_gl_edit_icon_get(void *data, Evas_Object * obj, const char *part)
 760 {
 761         Evas_Object *layout = NULL;
 762         mfItemData_s *params = (mfItemData_s *) data;
 763         struct appdata *ap = (struct appdata *)params->ap;
 764
 765         mf_retvm_if(params == NULL, NULL, "param is NULL");
 766         mf_retvm_if(params->m_ItemName == NULL, NULL, "m_ItemName is NULL");
 767         mf_retvm_if(part == NULL, NULL, "part is NULL");
 768         mf_retvm_if(obj == NULL, NULL, "obj is NULL");
 769         mf_retvm_if(ap == NULL, NULL, "ap is NULL");
 770
 771         if (elm_genlist_decorate_mode_get(obj)) {
 772                 if (!strcmp(part, "elm.edit.icon.1")) {
 773                         Evas_Object *check = NULL;
 774                         check = elm_check_add(obj);
 775                         elm_object_focus_set(check, EINA_FALSE);
 776                         evas_object_propagate_events_set(check, EINA_FALSE);
 777                         elm_check_state_pointer_set(check, &params->m_checked);
 778                         evas_object_smart_callback_add(check, "changed", __mf_genlist_item_check_changed_callback, params);
 779                         return check;
 780                 } else if (!strcmp(part, "elm.edit.icon.2")) {
 781                         layout = elm_button_add(obj);
 782                         elm_object_style_set(layout, "rename");
 783                         evas_object_propagate_events_set(layout, EINA_FALSE);
 784                         evas_object_smart_callback_add(layout, "clicked", mf_callback_rename_button_callback, params);
 785                         return layout;
 786                 }
 787         }
 788         if (!strcmp(part, "elm.icon") || !strcmp(part, "elm.icon.1")) {
 789                 Evas_Object *thumb = NULL;
 790                 Evas_Object *ic_memory = NULL;
 791                 MF_STORAGE is_in_mmc = FALSE;
 792                 char *key = NULL;
 793                 const char *memory_icon_path = MF_ICON_MEMORY_SUB;
 794
 795                 __mf_genlist_get_thumbnail(params);
 796 #ifdef USE_IMAGE_OBJECT
 797                 thumb = evas_object_image_add(evas_object_evas_get(obj));
 798 #else
 799                 thumb = elm_image_add(obj);
 800                 elm_object_focus_set(thumb, EINA_FALSE);
 801 #endif
 802                 if (thumb == NULL)
 803                         mf_error("thumb is NULL");
 804
 805                 if (thumb) {
 806 #ifdef USE_IMAGE_OBJECT
 807                         int load_err = EVAS_LOAD_ERROR_NONE;
 808                         evas_object_image_file_set(thumb, params->thumb_path, NULL);
 809                         load_err = evas_object_image_load_error_get(thumb);
 810
 811                         if (load_err != EVAS_LOAD_ERROR_NONE) {
 812                                 evas_object_del(thumb);
 813                                 mf_error("load error code : %d", load_err);
 814                         } else {
 815                                 evas_object_image_filled_set(thumb, EINA_TRUE);
 816                         }
 817 #else
 818                         elm_image_file_set(thumb, params->thumb_path, NULL);
 819 #endif
 820                         layout = elm_layout_add(obj);
 821                         elm_object_focus_set(layout, EINA_FALSE);
 822                         elm_layout_file_set(layout, EDJ_NAME, GRP_THUMBNAIL_ONLY);
 823                         elm_object_part_content_set(layout, "thumbnail", thumb);
 824
 825                         mf_file_attr_get_store_type_by_full(params->m_ItemName->str, &is_in_mmc);
 826                         if (is_in_mmc == MYFILE_MMC) {
 827                                 ic_memory = elm_image_add(obj);
 828                                 elm_object_focus_set(ic_memory, EINA_FALSE);
 829                                 elm_image_file_set(ic_memory, memory_icon_path, key);
 830                                 evas_object_show(ic_memory);
 831                                 elm_object_part_content_set(layout, "myfile.memory_icon_multi.sub", ic_memory);
 832                         }
 833                         fsFileType type = FILE_TYPE_NONE;
 834                         type = mf_file_attr_get_file_type_by_mime(params->m_ItemName->str);
 835                         if (type == FILE_TYPE_VIDEO) {
 836                                 const char *play_icon_path = MF_ICON_VIDEO_PLAY;
 837                                 Evas_Object *play_icon = NULL;
 838                                 play_icon = elm_image_add(layout);
 839                                 elm_object_focus_set(play_icon, EINA_FALSE);
 840                                 elm_image_file_set(play_icon, play_icon_path, key);
 841                                 evas_object_show(play_icon);
 842                                 elm_object_part_content_set(layout, "video_play", play_icon);
 843                         }
 844                 }
 845         } else if (!strcmp(part, "elm.icon.2")) {
 846                 if (params->ap->mf_Status.more == MORE_EDIT || (params->ap->mf_Status.preMore == MORE_EDIT && params->ap->mf_Status.more == MORE_RENAME)) {
 847                         return NULL;
 848                 }
 849                 Evas_Object *entry_button = NULL;
 850                 Evas_Object *entry_icon = NULL;
 851                 entry_button = elm_button_add(obj);
 852                 elm_object_style_set(entry_button, "circle/empty");
 853
 854                 entry_icon = elm_image_add(entry_button);
 855                 char *play_icon = strdup(MF_ICON_ENTRY_FOLDER);
 856                 elm_image_file_set(entry_icon, play_icon, NULL);
 857                 evas_object_size_hint_aspect_set(entry_icon, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
 858                 elm_object_part_content_set(entry_button, "icon", entry_icon);
 859                 evas_object_propagate_events_set(entry_button, EINA_FALSE);
 860                 evas_object_smart_callback_add(entry_button, "clicked", (Evas_Smart_Cb)mf_callback_entry_cb, (void*)params);
 861                 evas_object_smart_callback_add(entry_button, "pressed", mf_callback_entry_button_pressed_cb, play_icon);
 862                 evas_object_smart_callback_add(entry_button, "unpressed", mf_callback_entry_button_unpressed_cb, play_icon);
 863                 return entry_button;
 864         } else if (!strcmp(part, "elm.swallow.end")) {
 865                 if (ap->mf_Status.rotation_type != MF_ROTATE_LANDSCAPE) {
 866                         //bool systemfolder = false;
 867                         //int error_code = 0;
 868 #if 0
 869                         error_code = mf_fm_svc_wrapper_get_folder_foldersystem(params->m_ItemName, &systemfolder);
 870                         if (systemfolder == FALSE) {
 871 #endif
 872                         /*__mf_genlist_add_rename_button*/
 873                         layout = elm_button_add(obj);
 874                         //elm_object_focus_set(layout, EINA_FALSE);
 875                         elm_object_style_set(layout, "rename");
 876                         evas_object_propagate_events_set(layout, EINA_FALSE);
 877                         evas_object_smart_callback_add(layout, "clicked", mf_callback_rename_button_callback, params);
 878                         /*evas_object_event_callback_add(layout, EVAS_CALLBACK_MOUSE_UP, mf_callback_rename_button_callback, params);*/
 879                         //}
 880                 }
 881         } else if (!strcmp(part, "elm.flip.content")) { /* this is used when the rename mode is enabled.*/
 882                 Evas_Object *edit_field = NULL;
 883                 edit_field = __mf_genlist_rename_editfiled_create(params, obj);
 884                 evas_object_propagate_events_set(edit_field, EINA_FALSE);
 885                 return edit_field;
 886         } else if (!strcmp(part, "elm.flip.icon")) {
 887                 Evas_Object *cancel_btn = mf_widget_util_create_button(obj, NULL, LABEL_CANCEL, NULL,
 888                                 mf_callback_cancel_cb, params->ap);
 889                 evas_object_show(cancel_btn);
 890                 return cancel_btn;
 891         }
 892
 893         return layout;
 894 }
 895
 896
 897 static Evas_Object *__mf_genlist_gl_new_folder_icon_get(void *data, Evas_Object * obj, const char *part)
 898 {
 899         struct appdata *ap = (struct appdata *)data;
 900         mf_retvm_if(ap == NULL, NULL, "ap is NULL");
 901
 902         if (!strcmp(part, "elm.icon")) {
 903                 int error_code = 0;
 904                 char *fileName = NULL;
 905                 char *fullpath = (char *)malloc(sizeof(char) * MYFILE_FILE_PATH_LEN_MAX);
 906                 if (fullpath == NULL) {
 907                         return NULL;
 908                 }
 909                 GString *dest_fullpath;
 910                 static Elm_Entry_Filter_Limit_Size limit_filter;
 911                 Evas_Object *entry = ap->mf_MainWindow.pEntry;
 912
 913                 Evas_Object *edit_field = ap->mf_MainWindow.pEditField;
 914
 915                 limit_filter.max_char_count = MYFILE_FILE_NAME_LEN_MAX;
 916                 limit_filter.max_byte_count = 0;
 917
 918                 memset(fullpath, 0, MYFILE_FILE_PATH_LEN_MAX);
 919                 fileName = elm_entry_markup_to_utf8(GET_SYS_STR(MF_LABEL_FOLDER));
 920                 snprintf(fullpath, (MYFILE_FILE_PATH_LEN_MAX), "%s/%s", (char *)ap->mf_Status.path->str, fileName);
 921
 922                 dest_fullpath = g_string_new(fullpath);
 923
 924                 elm_entry_markup_filter_append(ap->mf_MainWindow.pEntry, elm_entry_filter_limit_size, &limit_filter);
 925                 evas_object_smart_callback_add(ap->mf_MainWindow.pEntry, "maxlength,reached", mf_callback_max_len_reached_cb, ap);
 926
 927                 if (mf_fm_svc_wrapper_detect_duplication(dest_fullpath)) {
 928                         mf_debug("dectetion result is TRUE\ndest_fullpath is %s\n", dest_fullpath->str);
 929                         error_code = mf_fm_svc_wrapper_file_auto_rename(ap, dest_fullpath, FILE_NAME_WITH_BRACKETS, &dest_fullpath);
 930                         mf_debug("rename result is %s\n", dest_fullpath->str);
 931                         memset(fullpath, 0, strlen(fullpath));
 932                         int len = strlen(ap->mf_Status.path->str) + 1;
 933                         strncpy(fullpath, dest_fullpath->str + len, MYFILE_FILE_PATH_LEN_MAX);
 934                         /*memset(fileName,0,strlen(fileName));*/
 935
 936                         SAFE_FREE_CHAR(fileName);
 937                         fileName = elm_entry_markup_to_utf8(fullpath);
 938                 }
 939
 940                 /*elm_entry_entry_set(entry, ecore_file_file_get(params->m_ItemName->str));*/
 941
 942                 elm_entry_entry_set(entry, fileName);
 943                 elm_entry_cursor_end_set(entry);
 944
 945                 SAFE_FREE_CHAR(fullpath);
 946                 SAFE_FREE_GSTRING(dest_fullpath);
 947                 SAFE_FREE_CHAR(fileName);
 948                 return edit_field;
 949         }
 950         return NULL;
 951 }
 952
 953 static Evas_Object *__mf_genlist_gl_rename_icon_get(void *data, Evas_Object * obj, const char *part)
 954 {
 955         struct appdata *ap = (struct appdata *)data;
 956         mf_retvm_if(ap == NULL, NULL, "ap is NULL");
 957
 958         if (!strcmp(part, "elm.icon")) {
 959                 static Elm_Entry_Filter_Limit_Size limit_filter_data;
 960                 Evas_Object *edit_field = NULL;
 961                 Evas_Object *entry = NULL;
 962                 GString *filename = NULL;
 963
 964                 edit_field = mf_widget_create_editfield(obj, &entry);
 965
 966                 evas_object_size_hint_weight_set(edit_field, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 967                 evas_object_size_hint_align_set(edit_field, EVAS_HINT_FILL, EVAS_HINT_FILL);
 968
 969
 970                 elm_entry_single_line_set(entry, EINA_TRUE);
 971                 elm_entry_scrollable_set(entry, EINA_TRUE);
 972                 elm_object_signal_emit(edit_field, "elm,state,eraser,show", "elm");
 973                 //elm_editfield_eraser_set(edit_field, EINA_TRUE);
 974
 975                 elm_entry_autocapital_type_set(entry, ELM_AUTOCAPITAL_TYPE_NONE);
 976                 elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NORMAL);
 977                 ap->mf_MainWindow.pEntry = entry;
 978                 ap->mf_MainWindow.pEditField = edit_field;
 979
 980
 981                 /* set guide text */
 982                 filename = mf_fm_svc_wrapper_get_file_name(ap->mf_FileOperation.to_rename);
 983                 char *guide_text = NULL;
 984                 SAFE_FREE_CHAR(ap->mf_FileOperation.file_name_suffix);
 985                 if (!mf_file_attr_is_dir(ap->mf_FileOperation.to_rename->str)) {
 986                         mf_debug();
 987                         char *ext = NULL;
 988                         char *name_without_ext = NULL;
 989                         name_without_ext = g_strdup(ap->mf_FileOperation.to_rename->str);
 990                         mf_file_attr_get_file_ext(ap->mf_FileOperation.to_rename->str, &ext);
 991                         mf_debug("ext is %s", ext);
 992                         if (ext && strlen(ext) != 0) {
 993                                 mf_debug();
 994                                 name_without_ext[strlen(name_without_ext) - strlen(ext) - 1] = '\0';
 995                                 ap->mf_FileOperation.file_name_suffix = strdup(ext);
 996                                 mf_debug("name_without_ext is [%s]\n", name_without_ext);
 997                                 if (strlen(name_without_ext)) {
 998                                         guide_text = elm_entry_utf8_to_markup(ecore_file_file_get(name_without_ext));
 999                                 } else {
1000                                         guide_text = elm_entry_utf8_to_markup(filename->str);
1001                                 }
1002                         } else {
1003                                 guide_text = elm_entry_utf8_to_markup(filename->str);
1004                         }
1005
1006                         SAFE_FREE_CHAR(ext);
1007                         SAFE_FREE_CHAR(name_without_ext);
1008                 } else {
1009                         guide_text = elm_entry_utf8_to_markup(filename->str);
1010                 }
1011
1012                 if (ap->mf_FileOperation.file_name_suffix) {
1013                         limit_filter_data.max_char_count = (MYFILE_FILE_NAME_LEN_MAX - mf_util_character_count_get(ap->mf_FileOperation.file_name_suffix) - 1);
1014                 } else {
1015                         limit_filter_data.max_char_count = MYFILE_FILE_NAME_LEN_MAX;
1016                 }
1017
1018                 limit_filter_data.max_byte_count = 0;
1019                 elm_entry_markup_filter_append(ap->mf_MainWindow.pEntry, elm_entry_filter_limit_size, &limit_filter_data);
1020
1021
1022                 elm_entry_entry_set(ap->mf_MainWindow.pEntry, guide_text);
1023                 /*elm_entry_entry_set(entry, ecore_file_file_get(params->m_ItemName->str));*/
1024                 elm_entry_cursor_end_set(entry);
1025
1026                 SAFE_FREE_CHAR(guide_text);
1027                 SAFE_FREE_GSTRING(filename);
1028
1029                 //evas_object_smart_callback_add(entry, "activated", mf_genlist_rename_done, ap);
1030                 evas_object_smart_callback_add(entry, "changed", mf_callback_imf_changed_cb, ap);
1031                 evas_object_smart_callback_add(entry, "maxlength,reached", mf_callback_max_len_reached_cb, ap);
1032                 evas_object_smart_callback_add(entry, "preedit,changed",
1033                                                mf_callback_imf_preedit_change_cb, ap);
1034                 elm_object_signal_callback_add(edit_field, "elm,eraser,clicked", "elm", mf_callback_eraser_clicked_cb, entry);
1035                 evas_object_show(entry);
1036                 elm_object_focus_set(entry, EINA_TRUE);
1037                 return edit_field;
1038         }
1039         return NULL;
1040 }
1041
1042 /**     delete related  **/
1043 static void __mf_genlist_gl_del(void *data, Evas_Object * obj)
1044 {
1045         MF_TRACE_BEGIN;
1046         mfItemData_s *params = (mfItemData_s *) data;
1047         assert(params);
1048         if (params->ap->mf_Status.more == MORE_RENAME) {
1049                 if (params->item == params->ap->mf_FileOperation.rename_item) {
1050                         mf_callback_destory_rename(params->ap);
1051                 }
1052         }
1053         if (params->m_ItemName) {
1054                 g_string_free(params->m_ItemName, TRUE);
1055                 params->m_ItemName = NULL;
1056         }
1057         if (params->thumb_path) {
1058                 free(params->thumb_path);
1059                 params->thumb_path = NULL;
1060         }
1061         if (params->create_date) {
1062                 free(params->create_date);
1063                 params->create_date = NULL;
1064         }
1065         if (params->size) {
1066                 free(params->size);
1067                 params->size = NULL;
1068         }
1069         if (params->flagExpand) {
1070                 params->flagExpand = false;
1071         }
1072         if (params->media) {
1073                 media_info_cancel_thumbnail(params->media);
1074                 media_info_destroy(params->media);
1075                 params->media = NULL;
1076         }
1077         free(params);
1078         MF_TRACE_END;
1079         return;
1080 }
1081
1082 /**     state related   **/
1083 static Eina_Bool __mf_genlist_gl_state_get(void *data, Evas_Object * obj, const char *part)
1084 {
1085         return EINA_FALSE;
1086 }
1087
1088 /**     select related  **/
1089 /**     this function will be splited into several functions    **/
1090 void mf_genlist_gl_selected(void *data, Evas_Object * obj, void *event_info)
1091 {
1092         MF_TRACE_BEGIN;
1093         struct appdata *ap = (struct appdata *)data;
1094         mf_retvm_if(ap == NULL, NULL, "ap is NULL");
1095
1096         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1097         if (item != NULL) {
1098                 mfItemData_s *selected = (mfItemData_s *) elm_object_item_data_get(item);
1099
1100                 elm_genlist_item_selected_set(item, FALSE);
1101
1102                 if (ap->mf_Status.flagNaviPush) {
1103                         mf_debug("the transition of the naviframe is not finished");
1104                         return;
1105                 }
1106                 if (ap->mf_Status.more == MORE_RENAME) {
1107                         if (elm_genlist_item_flip_get(item)) {
1108                                 MF_TRACE_END;
1109                                 return;
1110                         } else {
1111                                 mf_callback_rename_save_cb(ap, NULL, NULL);
1112                                 return;
1113                         }
1114                 } else if (ap->mf_Status.more != MORE_EDIT) {
1115 #ifdef MYFILE_SPLIT_VIEW
1116                         if (ap->mf_Status.rotation_type == MF_ROTATE_LANDSCAPE) {
1117                                 mf_split_view_left_genlist_refresh(ap);
1118                         }
1119 #endif
1120                         mf_callback_click_cb(data, MFACTION_CLICK, selected->m_ItemName);
1121                 }
1122         }
1123         MF_TRACE_END;
1124 }
1125 #ifdef MYFILE_SPLIT_VIEW
1126
1127 static void mf_genlist_split_left_items_sel(void *data, Evas_Object *obj, void *event_info)
1128 {
1129         MF_TRACE_BEGIN;
1130         struct appdata *ap = (struct appdata *)data;
1131
1132         mfItemData_s *selected = (mfItemData_s *) elm_object_item_data_get(event_info);
1133         elm_genlist_item_selected_set(event_info, EINA_FALSE);
1134         if (ap->mf_Status.flagNaviPush) {
1135                 mf_debug("the transition of the naviframe is not finished");
1136                 return;
1137         }
1138         Eina_Bool expanded = EINA_FALSE;
1139         if (event_info) {
1140                 expanded = elm_genlist_item_expanded_get(event_info);
1141                 selected->flagExpand = !expanded;
1142                 mf_error("selected->flagExpand is [%d]", selected->flagExpand);
1143                 elm_object_item_data_set(selected->item, selected);
1144                 elm_genlist_item_fields_update(selected->item, "elm.icon", ELM_GENLIST_ITEM_FIELD_CONTENT);
1145                 elm_genlist_item_expanded_set(event_info, !expanded);
1146         }
1147         MF_TRACE_END;
1148 }
1149
1150 Elm_Object_Item *mf_genlist_split_left_items_append( void *data, Evas_Object *pGenlist, Elm_Object_Item *parent_item, Eina_List *dir_list)
1151 {
1152         MF_TRACE_BEGIN;
1153         struct appdata *ap = (struct appdata *)data;
1154         mf_retvm_if(ap == NULL, NULL, "input parameter data error");
1155
1156         mf_retvm_if(pGenlist == NULL, NULL, "input parameter pGenlist error");
1157         mf_retvm_if(parent_item == NULL, NULL, "input parameter parent_item error");
1158
1159         fsNodeInfo *pNode = NULL;
1160         mfItemData_s *m_TempItem = NULL;
1161         Eina_List *l = NULL;
1162         Elm_Object_Item *expand = NULL;
1163
1164         int real_len = 0;
1165         int current_len = 0;
1166         bool flagExpand = false;
1167
1168         EINA_LIST_FOREACH(dir_list, l, pNode) {
1169                 char *real_name = NULL;
1170                 real_name = g_strconcat(pNode->path, "/", pNode->name, NULL);
1171                 if (real_name == NULL) {
1172                         continue;
1173                 }
1174
1175                 m_TempItem = (mfItemData_s *) malloc(sizeof(mfItemData_s));
1176                 if (m_TempItem == NULL) {
1177                         free(real_name);
1178                         real_name = NULL;
1179                         continue;
1180                 }
1181
1182
1183                 Elm_Object_Item *it = NULL;
1184                 m_TempItem->m_ItemName = g_string_new(real_name);
1185                 m_TempItem->size = NULL;
1186                 m_TempItem->create_date = NULL;
1187                 m_TempItem->m_checked = FALSE;
1188                 m_TempItem->pCheckBox = NULL;
1189                 m_TempItem->thumb_path = NULL;
1190                 m_TempItem->flagExpand = false;
1191                 m_TempItem->real_thumb_flag = FALSE;
1192                 m_TempItem->unregister_lang_mgr = TRUE;
1193                 m_TempItem->media = NULL;
1194                 m_TempItem->ap = ap;
1195
1196                 if (ap->mf_Status.flagViewType == MF_VIEW_SYTLE_LIST_DETAIL) {
1197                         char *tempdate = mf_util_icu_translate(ap, pNode->date);
1198                         if (tempdate == NULL)
1199                                 m_TempItem->create_date = g_strdup("N/A");
1200                         else {
1201                                 m_TempItem->create_date = g_strdup(tempdate);
1202                                 free(tempdate);
1203                         }
1204
1205                 }
1206
1207                 it = elm_genlist_item_append(pGenlist, &left_itc, m_TempItem, parent_item, ELM_GENLIST_ITEM_TREE, mf_genlist_split_left_items_sel, ap);
1208                 real_len = strlen(real_name);
1209                 current_len = strlen(ap->mf_Status.path->str);
1210                 if (real_len > current_len && !flagExpand) {
1211                         expand = NULL;
1212                 } else {
1213                         if (strncmp(real_name, ap->mf_Status.path->str, strlen(real_name)) == 0) {
1214                                 mf_debug("real_name is [%s] currnet path is [%s]", real_name, ap->mf_Status.path->str);
1215                                 expand = it;
1216                                 flagExpand = true;
1217                         }
1218                 }
1219                 m_TempItem->item = it;
1220                 free(real_name);
1221         }
1222         MF_TRACE_END;
1223         return expand;
1224 }
1225
1226
1227 Elm_Object_Item *mf_genlist_split_root_item_append(void *data, Evas_Object *pGenlist, const char *name)
1228 {
1229         MF_TRACE_BEGIN;
1230         mf_retvm_if(data == NULL, NULL, "input parameter data error");
1231         mf_retvm_if(pGenlist == NULL, NULL, "input parameter pGenlist error");
1232
1233         struct appdata *ap = (struct appdata *)data;
1234
1235         mfItemData_s *m_TempItem = NULL;
1236         Elm_Object_Item *it = NULL;
1237
1238         mf_genlist_data_init(ap, &m_TempItem, name);
1239         m_TempItem->unregister_lang_mgr = TRUE;
1240
1241         it = elm_genlist_item_append(pGenlist, &left_itc, m_TempItem, NULL, ELM_GENLIST_ITEM_TREE, mf_genlist_split_left_items_sel, ap);
1242
1243         m_TempItem->item = it;
1244         return it;
1245 }
1246
1247 void mf_genlist_split_root_items_append(Evas_Object *pGenlist, void *data)
1248 {
1249         MF_TRACE_BEGIN;
1250         /*0.    variable definition and parameter check*/
1251         struct appdata *ap = (struct appdata *)data;
1252         mf_retm_if(ap == NULL, "input parameter data error");
1253
1254         mf_retm_if(pGenlist == NULL, "input parameter pGenlist error");
1255
1256         /*4.    append items to the genlist*/
1257         Elm_Object_Item *it = NULL;
1258
1259         //mf_genlist_data_init(ap, &m_TempItem, PHONE_FOLDER);
1260
1261         it = mf_genlist_split_root_item_append(ap, pGenlist, PHONE_FOLDER);
1262         //it = elm_genlist_item_append(pGenlist, &left_itc, m_TempItem, NULL, ELM_GENLIST_ITEM_NONE, mf_genlist_gl_sel, m_TempItem);
1263
1264         //m_TempItem->item = it;
1265         ap->mf_MainWindow.sSplitData.phone_item = it;
1266
1267         if (ap->mf_Status.iStorageState & MYFILE_MMC) {
1268                 it = mf_genlist_split_root_item_append(ap, pGenlist, MEMORY_FOLDER);
1269                 ap->mf_MainWindow.sSplitData.mmc_item = it;
1270
1271         }
1272
1273         if (ap->mf_Status.iStorageState & MYFILE_OTG) {
1274
1275                 it = mf_genlist_split_root_item_append(ap, pGenlist, OTG_FOLDER);
1276                 ap->mf_MainWindow.sSplitData.otg_item = it;
1277
1278         }
1279         MF_TRACE_END;
1280
1281 }
1282
1283 void mf_genlist_split_left_genlist_style(void *data)
1284 {
1285         struct appdata *ap = (struct appdata *)data;
1286         mf_retm_if(ap == NULL, "input parameter data error");
1287         left_itc.item_style = "1text.2/expandable_n_depth";
1288         left_itc.func.text_get = __mf_genlist_gl_label_get;
1289         left_itc.func.content_get  = __mf_genlist_gl_default_icon_get;
1290         left_itc.func.state_get = __mf_genlist_gl_state_get;
1291         left_itc.func.del = __mf_genlist_gl_del;
1292
1293         elm_genlist_decorate_mode_set(ap->mf_MainWindow.sSplitData.pSplitLeftGenlist, EINA_FALSE);
1294
1295 }
1296
1297 #endif
1298 /**     edit mode related       **/
1299 void mf_genlist_gl_sel(void *data, Evas_Object * obj, void *event_info)
1300 {
1301         MF_TRACE_BEGIN;
1302         mfItemData_s *selected = data;
1303
1304         struct appdata *ap = (struct appdata *)selected->ap;
1305         mf_retm_if(ap == NULL, "input parameter data error");
1306
1307         if (ap->mf_Status.more != MORE_EDIT) {
1308                 return;
1309         }
1310
1311         Evas_Object *genlist = elm_object_item_widget_get(selected->item);
1312
1313         if (genlist && elm_genlist_decorate_mode_get(genlist)) {
1314
1315                 selected->m_checked = !selected->m_checked;
1316                 if (selected->m_checked) {
1317                         ap->mf_MainWindow.pEditView.iCheckedCount++;
1318                 } else {
1319                         ap->mf_MainWindow.pEditView.iCheckedCount--;
1320                 }
1321                 //if (ap->mf_MainWindow.pEditView.pSelectAllCheckBox) {
1322                         if (ap->mf_MainWindow.pEditView.iTotalCount == ap->mf_MainWindow.pEditView.iCheckedCount) {
1323                                 ap->mf_MainWindow.pEditView.bSelectAllChecked = EINA_TRUE;
1324                         } else {
1325                                 ap->mf_MainWindow.pEditView.bSelectAllChecked = EINA_FALSE;
1326                         }
1327                         //elm_check_state_pointer_set(ap->mf_MainWindow.pEditView.pSelectAllCheckBox, &ap->mf_MainWindow.pEditView.bSelectAllChecked);
1328                 //}
1329                 elm_genlist_item_fields_update(selected->item, "elm.edit.icon.1", ELM_GENLIST_ITEM_FIELD_CONTENT);
1330         }
1331         mf_genlist_gl_edit_item_selected(ap);
1332         MF_TRACE_END;
1333 }
1334
1335 void mf_genlist_genlist_item_select(void *data, Evas_Object *pGenlist, int *file_count, int *dir_count)
1336 {
1337         mf_retm_if(data == NULL, "data is NULL");
1338         mf_retm_if(pGenlist == NULL, "pGenlist is NULL");
1339
1340         MF_TRACE_BEGIN;
1341         struct appdata *ap = (struct appdata *)data;
1342         mfItemData_s *itemData = NULL;
1343         Elm_Object_Item *it = NULL;
1344         //int error_code = 0;
1345         it = elm_genlist_first_item_get(pGenlist);
1346         while (it) {
1347                 itemData = elm_object_item_data_get(it);
1348                 if (itemData->m_checked) {
1349                         if (itemData->m_ItemName == NULL || itemData->m_ItemName->str == NULL) {
1350                                 continue;
1351                         }
1352                         if (ecore_file_is_dir(itemData->m_ItemName->str)) {
1353                                 //bool systemfolder = FALSE;
1354                                 ap->mf_Status.flagFolderSelect = TRUE;
1355                                 (*dir_count)++;
1356                         } else {
1357                                 ap->mf_Status.flagFileSelect = TRUE;
1358                                 (*file_count)++;
1359                         }
1360                 }
1361
1362                 it = elm_genlist_item_next_get(it);
1363
1364         }
1365         MF_TRACE_END;
1366 }
1367
1368 void mf_genlist_gl_edit_item_selected(void *data)
1369 {
1370         mf_retm_if(data == NULL, "data is NULL");
1371         struct appdata *ap = (struct appdata *)data;
1372
1373         if (ap->mf_Status.more != MORE_EDIT)
1374                 return;
1375         Evas_Object *notify_popup = NULL;
1376         char *label = NULL;
1377         int count_dir = 0;
1378         int count_file = 0;
1379
1380         ap->mf_Status.flagFolderSelect = FALSE;
1381         ap->mf_Status.flagFileSelect = FALSE;
1382         if (ap->mf_Status.flagViewType == MF_VIEW_STYLE_LIST || ap->mf_Status.flagViewType == MF_VIEW_SYTLE_LIST_DETAIL) {
1383                 Evas_Object *pGenlist = ap->mf_MainWindow.pEditView.pGenlist;
1384                 mf_genlist_genlist_item_select(ap, pGenlist, &count_file, &count_dir);
1385
1386         } else {
1387                 Evas_Object *pGengrid = ap->mf_MainWindow.pEditView.pGengrid;
1388                 mf_gengrid_item_select(ap, pGengrid, &count_file, &count_dir);
1389         }
1390
1391         if (ap->mf_Status.flagFolderSelect) {
1392                 mf_navi_bar_button_set_disable(ap->mf_MainWindow.pNaviItem, CTRL_DISABLE_EDIT_ALL, true);
1393                 mf_navi_bar_button_set_disable(ap->mf_MainWindow.pNaviItem, CTRL_DISABLE_USER_FOLDER_SEL, false);
1394         } else if (ap->mf_Status.flagFileSelect){
1395                 mf_navi_bar_button_set_disable(ap->mf_MainWindow.pNaviItem, CTRL_DISABLE_EDIT_ALL, false);
1396         } else {
1397                 mf_navi_bar_button_set_disable(ap->mf_MainWindow.pNaviItem, CTRL_DISABLE_EDIT_ALL, true);
1398         }
1399
1400         char lable_file[MYFILE_LABEL_STRING_LENGTH] = { '\0', };
1401         int count = 0;
1402         /*1 TODO: need to update for multi-language*/
1403         count = count_file + count_dir;
1404         snprintf(lable_file, sizeof(lable_file), "%d", (count));
1405         label = g_strconcat(GET_SYS_STR(MF_LABEL_SELECTED), " (", lable_file, ")", NULL);
1406
1407         if (count > 0) {
1408                 notify_popup = mf_widget_create_notify_popup(ap, ap->mf_MainWindow.pNaviLayout, label, mf_notify_popup_normal, true, NULL);
1409                 ap->mf_MainWindow.pLabelLayout = notify_popup;
1410         }else {
1411                 SAFE_FREE_OBJ(ap->mf_MainWindow.pLabelLayout);
1412         }
1413         SAFE_FREE_CHAR(label);
1414 }
1415
1416
1417 /**     button related  **/
1418
1419
1420 static inline void __mf_genlist_get_thumbnail(mfItemData_s *params)
1421 {
1422         int error_code = 0;
1423         if (params->thumb_path == NULL) {
1424                 if (ecore_file_is_dir(params->m_ItemName->str)) {
1425                         if (params->ap->mf_Status.view_type == mf_view_root) {
1426                                 params->thumb_path = strdup(MF_ICON_FOLDER);
1427                         } else if (mf_fm_svc_wrapper_is_root_path(params->ap->mf_Status.path->str) == MYFILE_OTG) {
1428                                 params->thumb_path = strdup(MF_ICON_EXTERNAL_DEVICE);
1429                         } else {
1430                                 if (params->flagExpand == true) {
1431                                         params->thumb_path = strdup(MF_ICON_FOLDER_OPEN);
1432                                 } else {
1433                                         params->thumb_path = strdup(MF_ICON_FOLDER);
1434                                 }
1435                         }
1436                         params->real_thumb_flag = TRUE;
1437                 } else {
1438                         const char *icon_path = NULL;
1439                         int thumbnail_type = 0;
1440                         thumbnail_type = mf_file_attr_get_file_icon(params->m_ItemName->str, &error_code, MF_ROTATE_PORTRAIT, &icon_path, &params->media);
1441                         if (icon_path && ecore_file_exists(icon_path)) {
1442                                 params->thumb_path = strdup(icon_path);
1443                                 params->real_thumb_flag = TRUE;
1444                         } else {        /*must be image/video file*/
1445                                 fsFileType type = FILE_TYPE_NONE;
1446                                 type = mf_file_attr_get_file_type_by_mime(params->m_ItemName->str);
1447
1448                                 if (type == FILE_TYPE_VIDEO) {
1449                                         params->thumb_path = strdup(MF_ICON_VIDEO);
1450                                 } else if (type == FILE_TYPE_IMAGE) {
1451                                         params->thumb_path = strdup(MF_ICON_IMAGE);
1452                                 } else {
1453                                         params->thumb_path = strdup(DEFAULT_ICON);
1454                                 }
1455                                 params->real_thumb_flag = FALSE;
1456                                 error_code = MYFILE_ERR_GET_THUMBNAIL_FAILED;
1457                         }
1458                 }
1459         } else if (params->thumb_path && ecore_file_exists(params->thumb_path)) {
1460
1461                 if (ecore_file_is_dir(params->m_ItemName->str)) {
1462                         if (mf_fm_svc_wrapper_is_root_path(params->ap->mf_Status.path->str) == MYFILE_OTG) {
1463                                 params->thumb_path = strdup(MF_ICON_EXTERNAL_DEVICE);
1464                         } else {
1465                                 if (params->flagExpand == true) {
1466                                         params->thumb_path = strdup(MF_ICON_FOLDER_OPEN);
1467                                 } else {
1468                                         params->thumb_path = strdup(MF_ICON_FOLDER);
1469                                 }
1470                         }
1471                 }
1472                 if (params->real_thumb_flag == FALSE) {
1473                         error_code = MYFILE_ERR_GET_THUMBNAIL_FAILED;
1474                 }
1475         } else if (!ecore_file_exists(params->thumb_path)) {
1476                 mf_error("thumb_path[%s] is not exist", params->thumb_path);
1477                 free(params->thumb_path);
1478                 params->thumb_path = NULL;
1479
1480                 fsFileType type = FILE_TYPE_NONE;
1481                 type = mf_file_attr_get_file_type_by_mime(params->m_ItemName->str);
1482                 if (ecore_file_is_dir(params->m_ItemName->str)) {
1483                         if (mf_fm_svc_wrapper_is_root_path(params->ap->mf_Status.path->str) == MYFILE_OTG) {
1484                                 params->thumb_path = strdup(MF_ICON_EXTERNAL_DEVICE);
1485                         } else {
1486                                 if (params->flagExpand == true) {
1487                                         params->thumb_path = strdup(MF_ICON_FOLDER_OPEN);
1488                                 } else {
1489                                         params->thumb_path = strdup(MF_ICON_FOLDER);
1490                                 }
1491                         }
1492
1493                 } else {
1494                         if (type == FILE_TYPE_VIDEO) {
1495                                 params->thumb_path = strdup(MF_ICON_VIDEO);
1496                         } else if (type == FILE_TYPE_IMAGE) {
1497                                 params->thumb_path = strdup(MF_ICON_IMAGE);
1498                         } else {
1499                                 params->thumb_path = strdup(DEFAULT_ICON);
1500                         }
1501                 }
1502                 /*set default icon*/
1503                 params->real_thumb_flag = FALSE;
1504                 error_code = MYFILE_ERR_GET_THUMBNAIL_FAILED;
1505         }
1506         if (error_code != 0) {
1507                 mf_callback_create_thumbnail(params, mf_callback_thumb_created_cb);
1508         }
1509 }
1510
1511
1512 void mf_genlist_update_edit_view_item_style(void *data)
1513 {
1514         struct appdata *ap = (struct appdata *)data;
1515         mf_retm_if(ap == NULL, "input parameter data error");
1516         myfileNaviBar *pNavi_s = mf_navi_bar_get_in_use(ap);
1517         mf_retm_if(pNavi_s == NULL, "get navigation bar in use failed");
1518
1519         userfolderitc.decorate_item_style = NULL;
1520         userfolderitc.func.text_get = __mf_genlist_gl_label_get;
1521         userfolderitc.func.content_get = __mf_genlist_gl_edit_icon_get;
1522         userfolderitc.func.del = __mf_genlist_gl_del;
1523         userfolderitc.decorate_all_item_style = "edit_default";
1524
1525         itc.decorate_item_style = NULL;
1526         itc.func.text_get = __mf_genlist_gl_label_get;
1527         itc.func.content_get = __mf_genlist_gl_edit_icon_get;
1528         itc.func.del = __mf_genlist_gl_del;
1529         itc.decorate_all_item_style = "edit_default";
1530
1531         categoryitc.decorate_item_style = NULL;
1532         categoryitc.func.text_get = __mf_genlist_gl_label_get;
1533         categoryitc.func.content_get = __mf_genlist_gl_edit_icon_get;
1534         categoryitc.func.del = __mf_genlist_gl_del;
1535         categoryitc.decorate_all_item_style = "edit_default";
1536
1537 }
1538
1539
1540 void mf_genlist_set_category_list_style()
1541 {
1542         categoryitc.item_style = "2text.2icon.4";
1543         categoryitc.decorate_item_style = "mode/slide2";
1544         categoryitc.func.text_get = __mf_genlist_gl_label_get;
1545         categoryitc.func.content_get  = __mf_genlist_gl_default_icon_get;
1546         categoryitc.func.state_get = __mf_genlist_gl_state_get;
1547         categoryitc.func.del = __mf_genlist_gl_del;
1548         categoryitc.decorate_all_item_style = "edit_default";
1549 }
1550 void mf_genlist_data_init(void *data, mfItemData_s **itemData, const char *item_name)
1551 {
1552
1553         MF_TRACE_BEGIN;
1554         /*0.    variable definition and parameter check*/
1555         struct appdata *ap = (struct appdata *)data;
1556         mf_retm_if(ap == NULL, "input parameter data error");
1557
1558
1559         *itemData = (mfItemData_s *)malloc(sizeof(mfItemData_s));
1560         if (*itemData == NULL) {
1561                 mf_debug("itemData malloc failed");
1562         } else {
1563                 memset(*itemData, 0, sizeof(mfItemData_s));
1564                 if (item_name) {
1565                         (*itemData)->m_ItemName = g_string_new(item_name);
1566                 } else {
1567                         (*itemData)->m_ItemName = NULL;
1568                 }
1569                 (*itemData)->m_checked = false;
1570                 (*itemData)->size = NULL;
1571                 (*itemData)->create_date = NULL;
1572                 (*itemData)->thumb_path = 0;
1573                 (*itemData)->pCheckBox = NULL;
1574                 (*itemData)->item = NULL;
1575                 (*itemData)->real_thumb_flag = false;
1576                 (*itemData)->flagExpand = false;
1577                 (*itemData)->media = NULL;
1578                 (*itemData)->ap = ap;
1579         }
1580 }
1581
1582
1583 void mf_genlist_update_default_view_item_style(void *data)
1584 {
1585         struct appdata *ap = (struct appdata *)data;
1586         mf_retm_if(ap == NULL, "input parameter data error");
1587         myfileNaviBar *pNavi_s = mf_navi_bar_get_in_use(ap);
1588         mf_retm_if(pNavi_s == NULL, "get navigation bar in use failed");
1589
1590         categoryitc.decorate_item_style = userfolderitc.decorate_item_style = itc.decorate_item_style = "mode/slide";
1591         categoryitc.func.text_get = userfolderitc.func.text_get = itc.func.text_get = __mf_genlist_gl_label_get;
1592         categoryitc.func.content_get = userfolderitc.func.content_get = itc.func.content_get = __mf_genlist_gl_default_icon_get;
1593         categoryitc.func.state_get = userfolderitc.func.state_get = itc.func.state_get = __mf_genlist_gl_state_get;
1594         categoryitc.func.del = userfolderitc.func.del = itc.func.del = __mf_genlist_gl_del;
1595
1596         elm_genlist_decorate_mode_set(ap->mf_MainWindow.pNaviGenlist, EINA_FALSE);
1597 }
1598
1599 void mf_genlist_create_search_itc()
1600 {
1601         MF_TRACE_BEGIN;
1602         search_itc.item_style = "2text.1icon.4.tb";
1603         search_itc.decorate_item_style = "mode/slide";
1604         search_itc.func.text_get = __mf_genlist_gl_label_get;
1605         search_itc.func.content_get = __mf_genlist_gl_default_icon_get;
1606         search_itc.func.state_get = __mf_genlist_gl_state_get;
1607         search_itc.func.del = __mf_genlist_gl_del;
1608         search_itc.decorate_all_item_style = "edit_default";
1609
1610 }
1611
1612
1613 void mf_genlist_create_data(mfItemData_s **m_TempItem, const char *name, void *data)
1614 {
1615         mf_retm_if(m_TempItem == NULL, "m_TempItem is NULL");
1616         mf_retm_if(name == NULL, "name is NULL");
1617
1618         *m_TempItem = (mfItemData_s *) calloc(1, sizeof(mfItemData_s));
1619         if (*m_TempItem == NULL) {
1620                 return;
1621         }
1622
1623         (*m_TempItem)->m_ItemName = g_string_new(name);
1624         (*m_TempItem)->size = NULL;
1625         (*m_TempItem)->create_date = NULL;
1626         (*m_TempItem)->m_checked = FALSE;
1627         (*m_TempItem)->pCheckBox = NULL;
1628         (*m_TempItem)->thumb_path = NULL;
1629         (*m_TempItem)->real_thumb_flag = FALSE;
1630         (*m_TempItem)->media = NULL;
1631         (*m_TempItem)->ap = (struct appdata *)data;
1632
1633 }
1634 void mf_genlist_create_list_default_style(Evas_Object *pGenlist, void *data, Eina_List *dir_list,
1635                                           Eina_List *file_list)
1636 {
1637         MF_TRACE_BEGIN;
1638         /*0.    variable definition and parameter check*/
1639         struct appdata *ap = (struct appdata *)data;
1640         mf_retm_if(ap == NULL, "input parameter data error");
1641
1642         mf_retm_if(pGenlist == NULL, "input parameter pGenlist error");
1643         /*0.5.  data list varaible set*/
1644         /*1.    item style set */
1645         MF_TA_ACUM_ITEM_BEGIN("        init genlist item class", 0);
1646
1647         userfolderitc.decorate_all_item_style = "edit_default";
1648         itc.decorate_all_item_style = "edit_default";
1649
1650         if (ap->mf_Status.flagViewType == MF_VIEW_SYTLE_LIST_DETAIL) {
1651                 userfolderitc.item_style = itc.item_style = "3text.1icon.1";
1652
1653         } else {
1654                 userfolderitc.item_style = itc.item_style = "1text.1icon.2";
1655
1656         }
1657         if (ap->mf_Status.view_type == mf_view_root) {
1658         } else {
1659                 userfolderitc.decorate_item_style = itc.decorate_item_style = "mode/slide2";
1660         }
1661         userfolderitc.func.text_get = itc.func.text_get = __mf_genlist_gl_label_get;
1662         userfolderitc.func.content_get = itc.func.content_get = __mf_genlist_gl_default_icon_get;
1663         userfolderitc.func.state_get = itc.func.state_get = __mf_genlist_gl_state_get;
1664         userfolderitc.func.del = itc.func.del = __mf_genlist_gl_del;
1665
1666         MF_TA_ACUM_ITEM_END("        init genlist item class", 0);
1667         /*3.    check if we need give no content view*/
1668         /*4.    append items to the genlist*/
1669         fsNodeInfo *pNode = NULL;
1670         Eina_List *l = NULL;
1671
1672         MF_TA_ACUM_ITEM_BEGIN("        append genlist items", 0);
1673
1674         mf_debug("dir_list count is [%d] file is [%d]", eina_list_count(dir_list), eina_list_count(file_list));
1675         /*      add default folder items into the genlist       */
1676         EINA_LIST_FOREACH(dir_list, l, pNode) {
1677                 mf_widget_item_append(pGenlist, pNode, ap);
1678         }
1679         /*      add file items into the genlist */
1680         mf_debug("view_type is [%d]", ap->mf_Status.view_type);
1681         if (ap->mf_Status.view_type != mf_view_root) {
1682                 EINA_LIST_FOREACH(file_list, l, pNode) {
1683                         mf_widget_item_append(pGenlist, pNode, ap);
1684                 }
1685         }
1686         MF_TA_ACUM_ITEM_END("        append genlist items", 0);
1687         MF_TRACE_BEGIN;
1688 }
1689
1690 Evas_Object *mf_genlist_create_list(void *data,Evas_Object *parent)
1691 {
1692         MF_TRACE_BEGIN;
1693         mf_retvm_if(data == NULL, NULL, "data is NULL");
1694         mf_retvm_if(parent == NULL, NULL, "parent is NULL");
1695
1696         struct appdata *ap = (struct appdata *)data;
1697         Evas_Object *genlist = NULL;
1698         Eina_List *file_list = NULL;
1699         Eina_List *dir_list = NULL;
1700
1701         /*      generate raw data list*/
1702
1703         if (ap->mf_Status.view_type == mf_view_root_category) {
1704                 file_list = ap->mf_FileOperation.category_list;
1705         } else {
1706                 file_list = ap->mf_FileOperation.file_list;
1707                 dir_list = ap->mf_FileOperation.folder_list;
1708         }
1709
1710 /*      create Genlist*/
1711         MF_TA_ACUM_ITEM_BEGIN("        create genlist", 0);
1712         genlist = mf_widget_create_genlist(parent);
1713         if (genlist == NULL) {
1714                 return NULL;
1715         }
1716         MF_TA_ACUM_ITEM_END("        create genlist", 0);
1717         mf_debug("More is [%d]", ap->mf_Status.more);
1718         switch (ap->mf_Status.more) {
1719         MF_TA_ACUM_ITEM_BEGIN("        register smart callback for genlist", 0);
1720         case MORE_DEFAULT:
1721                         evas_object_smart_callback_add(genlist, "drag,start,right", mf_genlist_gl_mode_sweep_set, ap);
1722                         evas_object_smart_callback_add(genlist, "drag,start,left", mf_genlist_gl_mode_sweep_unset, ap);
1723                         evas_object_smart_callback_add(genlist, "drag,start,up", mf_genlist_gl_mode_cancel, ap);
1724                         evas_object_smart_callback_add(genlist, "drag,start,down", mf_genlist_gl_mode_cancel, ap);
1725         case MORE_INTERNAL_COPY:
1726         case MORE_INTERNAL_MOVE:
1727         case MORE_INTERNAL_COPY_MOVE:
1728         case MORE_DATA_COPYING:
1729         case MORE_DATA_MOVING:
1730                 evas_object_smart_callback_add(genlist, "selected", mf_genlist_gl_selected, ap);
1731                 MF_TA_ACUM_ITEM_END("        register smart callback for genlist", 0);
1732                 mf_genlist_create_list_default_style(genlist, ap, dir_list, file_list);
1733                 break;
1734         default:
1735                 break;
1736         }
1737 /*4.    add watcher:*/
1738 /*5.    clear temporary data*/
1739         MF_TRACE_END;
1740         return genlist;
1741 }
1742
1743 void mf_genlist_get_list_selected_files(Evas_Object * pGenlist, Eina_List **list)
1744 {
1745         MF_TRACE_BEGIN;
1746         mf_retm_if(pGenlist == NULL, "pGenlist is NULL");
1747         Elm_Object_Item *item = NULL;
1748         mfItemData_s *itemData = NULL;
1749         GString *pTemp = NULL;
1750
1751         item = elm_genlist_first_item_get(pGenlist);
1752         while (item) {
1753                 itemData = elm_object_item_data_get(item);
1754                 if (itemData->m_checked) {
1755                         pTemp = g_string_new(itemData->m_ItemName->str);
1756                         *list = eina_list_append(*list, pTemp);
1757                 }
1758                 item = elm_genlist_item_next_get(item);
1759         }
1760         MF_TRACE_END;
1761 }
1762
1763 void mf_genlist_get_list_selected_items(Evas_Object * pGenlist, Eina_List **list)
1764 {
1765         MF_TRACE_BEGIN;
1766         mf_retm_if(pGenlist == NULL, "pGenlist is NULL");
1767         Elm_Object_Item *item = NULL;
1768         mfItemData_s *itemData = NULL;
1769
1770         item = elm_genlist_first_item_get(pGenlist);
1771         while (item) {
1772                 itemData = elm_object_item_data_get(item);
1773                 if (itemData->m_checked) {
1774                         *list = eina_list_append(*list, itemData);
1775                 }
1776                 item = elm_genlist_item_next_get(item);
1777         }
1778         MF_TRACE_END;
1779 }
1780
1781 Evas_Object *mf_genlist_create_list_new_folder_style(void *data)
1782 {
1783
1784         struct appdata *ap = (struct appdata *)data;
1785         mf_retvm_if(ap == NULL, NULL, "ap is NULL");
1786
1787         Evas_Object *genlist = NULL;
1788         Evas_Object *pNaviBar = NULL;
1789
1790         pNaviBar = ap->mf_MainWindow.pNaviBar;
1791
1792         genlist = elm_genlist_add(pNaviBar);
1793         //elm_genlist_homogeneous_set(genlist, EINA_TRUE);
1794         elm_object_focus_set(genlist, EINA_FALSE);
1795
1796         newfolderitc.item_style = "dialogue/bg/1icon";
1797         newfolderitc.func.text_get = NULL;
1798         newfolderitc.func.content_get = __mf_genlist_gl_new_folder_icon_get;
1799         newfolderitc.func.state_get = NULL;
1800         newfolderitc.func.del = NULL;
1801
1802         elm_genlist_item_append(genlist, &newfolderitc, ap, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1803
1804         return genlist;
1805 }
1806
1807 Evas_Object *mf_genlist_create_list_rename_style(void *data)
1808 {
1809         mf_retvm_if(data == NULL, NULL, "data is NULL");
1810
1811         struct appdata *ap = (struct appdata *)data;
1812         mf_retvm_if(ap == NULL, NULL, "ap is NULL");
1813
1814         Evas_Object *genlist = NULL;
1815         Evas_Object *pNaviBar = NULL;
1816
1817         pNaviBar = ap->mf_MainWindow.pNaviBar;
1818
1819         genlist = elm_genlist_add(pNaviBar);
1820
1821         //elm_genlist_homogeneous_set(genlist, EINA_TRUE);
1822         elm_object_focus_set(genlist, EINA_FALSE);
1823
1824         newfolderitc.item_style = "dialogue/bg/1icon";
1825         newfolderitc.func.text_get = NULL;
1826         newfolderitc.func.content_get = __mf_genlist_gl_rename_icon_get;
1827         newfolderitc.func.state_get = NULL;
1828         newfolderitc.func.del = NULL;
1829
1830         elm_genlist_item_append(genlist, &newfolderitc, ap, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1831
1832         return genlist;
1833 }
1834
1835
1836 void mf_genlist_clear(Evas_Object *genlist)
1837 {
1838         assert(genlist);
1839
1840         Elm_Object_Item *it;
1841         it = elm_genlist_first_item_get(genlist);
1842         while (it) {
1843                 elm_object_item_del(it);
1844                 it = elm_genlist_first_item_get(genlist);
1845         }
1846
1847 }
1848
1849 void mf_genlist_sweep_item_recover(Evas_Object *obj)
1850 {
1851
1852         mf_retm_if(obj == NULL, "obj is NULL");
1853         Elm_Object_Item *it = (Elm_Object_Item *) elm_genlist_decorated_item_get(obj);
1854
1855         /* Finish genlist sweep*/
1856         if (it) {
1857                 elm_genlist_item_decorate_mode_set(it, "slide", EINA_FALSE);
1858                 elm_genlist_item_select_mode_set(it, ELM_OBJECT_SELECT_MODE_DEFAULT);
1859                 elm_genlist_item_update(it);
1860         }
1861
1862 }
1863
1864 static char *__get_title_gl_text(void *data, Evas_Object *obj, const char *part)
1865 {
1866         MF_TRACE_BEGIN;
1867         if (data)
1868                 return g_strdup((char *)data);
1869         else
1870                 return NULL;
1871 }
1872 static void __del_title_gl(void *data, Evas_Object * obj)
1873 {
1874         SAFE_FREE_CHAR(data);
1875 }
1876
1877 Evas_Object *mf_genlist_create_path_info(Evas_Object *parent, char *info)
1878 {
1879         MF_TRACE_BEGIN;
1880         mf_retvm_if(parent == NULL, NULL, "parent is NULL");
1881
1882         Evas_Object *genlist = NULL;
1883         Elm_Object_Item *git=NULL;
1884
1885         genlist = elm_genlist_add(parent);
1886         //elm_genlist_homogeneous_set(genlist, EINA_TRUE);
1887
1888         itch.item_style = "groupindex";
1889         itch.func.text_get = __get_title_gl_text;
1890         itch.func.del = __del_title_gl;
1891
1892         git = elm_genlist_item_append(genlist, &itch, info, NULL, ELM_GENLIST_ITEM_GROUP, NULL, NULL);
1893         elm_genlist_item_select_mode_set(git, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1894         MF_TRACE_END;
1895
1896         return genlist;
1897 }