Merge "[elm_datetime.h] Datetime default minimum year is changed to 1902 and document...
[framework/uifw/elementary.git] / src / lib / elc_fileselector.c
1 /*
2  * TODO:
3  *  - child elements focusing support
4  *  - user defined icon/label cb
5  *  - show/hide/add buttons ???
6  *  - show/hide hidden files
7  *  - double click to choose a file
8  *  - multi-selection
9  *  - make variable/function names that are sensible
10  *  - Filter support
11  */
12
13 #ifdef HAVE_CONFIG_H
14 # include "elementary_config.h"
15 #endif
16
17 #ifdef HAVE_EIO
18 # include <Eio.h>
19 #endif
20
21 #include <Elementary.h>
22 #include "elm_priv.h"
23
24 typedef struct _Widget_Data Widget_Data;
25
26 struct _Widget_Data
27 {
28    EINA_REFCOUNT;
29
30    Evas_Object *edje;
31    Evas_Object *filename_entry;
32    Evas_Object *path_entry;
33    Evas_Object *files_list;
34    Evas_Object *files_grid;
35    Evas_Object *up_button;
36    Evas_Object *home_button;
37
38    Evas_Object *ok_button;
39    Evas_Object *cancel_button;
40
41    const char  *path;
42    const char  *selection;
43    Ecore_Idler *sel_idler;
44
45    const char  *path_separator;
46
47 #ifdef HAVE_EIO
48    Eio_File    *current;
49 #endif
50
51    Elm_Fileselector_Mode mode;
52
53    Eina_Bool    only_folder : 1;
54    Eina_Bool    expand : 1;
55 };
56
57 struct sel_data
58 {
59    Evas_Object *fs;
60    const char  *path;
61 };
62
63 typedef struct _Widget_Request Widget_Request;
64 struct _Widget_Request
65 {
66    Widget_Data *wd;
67    Elm_Object_Item *parent;
68
69    Evas_Object *obj;
70    const char *path;
71    Eina_Bool first : 1;
72 };
73
74 typedef enum {
75   ELM_DIRECTORY = 0,
76   ELM_FILE_IMAGE = 1,
77   ELM_FILE_UNKNOW = 2,
78   ELM_FILE_LAST
79 } Elm_Fileselector_Type;
80
81 static Elm_Genlist_Item_Class *list_itc[ELM_FILE_LAST];
82 static Elm_Gengrid_Item_Class *grid_itc[ELM_FILE_LAST];
83
84 static const char *widtype = NULL;
85
86 static const char SIG_DIRECTORY_OPEN[] = "directory,open";
87 static const char SIG_DONE[] = "done";
88 static const char SIG_SELECTED[] = "selected";
89 static const Evas_Smart_Cb_Description _signals[] = {
90    {SIG_DIRECTORY_OPEN, "s"},
91    {SIG_DONE, "s"},
92    {SIG_SELECTED, "s"},
93    {NULL, NULL}
94 };
95
96 static void _populate(Evas_Object      *obj,
97                       const char       *path,
98                       Elm_Object_Item  *parent);
99 static void _do_anchors(Evas_Object *obj,
100                         const char  *path);
101
102 /***  ELEMENTARY WIDGET  ***/
103 static void
104 _widget_data_free(Widget_Data *wd)
105 {
106    if (wd->path) eina_stringshare_del(wd->path);
107    if (wd->selection) eina_stringshare_del(wd->selection);
108    if (wd->sel_idler)
109      {
110         void *sd;
111
112         sd = ecore_idler_del(wd->sel_idler);
113         free(sd);
114      }
115    free(wd);
116 }
117
118 static void
119 _del_hook(Evas_Object *obj)
120 {
121    Widget_Data *wd;
122    int i;
123
124    wd = elm_widget_data_get(obj);
125    if (!wd) return;
126
127    for (i = 0; i < ELM_FILE_LAST; ++i)
128      {
129         elm_genlist_item_class_free(list_itc[i]);
130         elm_gengrid_item_class_free(grid_itc[i]);
131      }
132
133 #ifdef HAVE_EIO
134    if (wd->current)
135      eio_file_cancel(wd->current);
136 #endif
137
138    wd->files_list = NULL;
139    wd->files_grid = NULL;
140
141    EINA_REFCOUNT_UNREF(wd)
142      _widget_data_free(wd);
143 }
144
145 static void
146 _sizing_eval(Evas_Object *obj)
147 {
148    Widget_Data *wd = elm_widget_data_get(obj);
149    Evas_Coord minw = -1, minh = -1;
150    if (!wd) return;
151    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
152    edje_object_size_min_restricted_calc(wd->edje, &minw, &minh, minw, minh);
153    evas_object_size_hint_min_set(obj, minw, minh);
154 }
155
156 static void
157 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
158 {
159    Widget_Data *wd = elm_widget_data_get(obj);
160    if (!wd) return;
161    elm_widget_mirrored_set(wd->cancel_button, rtl);
162    elm_widget_mirrored_set(wd->ok_button, rtl);
163    elm_widget_mirrored_set(wd->files_list, rtl);
164    elm_widget_mirrored_set(wd->up_button, rtl);
165    elm_widget_mirrored_set(wd->home_button, rtl);
166    edje_object_mirrored_set(wd->edje, rtl);
167 }
168
169 static void
170 _theme_hook(Evas_Object *obj)
171 {
172    Widget_Data *wd = elm_widget_data_get(obj);
173    const char *style = elm_widget_style_get(obj);
174    const char *data;
175    char buf[1024];
176
177    if (!wd) return;
178    _elm_widget_mirrored_reload(obj);
179
180    _elm_theme_object_set(obj, wd->edje, "fileselector", "base", style);
181
182    if (elm_object_disabled_get(obj))
183      edje_object_signal_emit(wd->edje, "elm,state,disabled", "elm");
184
185    data = edje_object_data_get(wd->edje, "path_separator");
186    if (data)
187      wd->path_separator = data;
188    else
189      wd->path_separator = "/";
190
191    if (!style) style = "default";
192    snprintf(buf, sizeof(buf), "fileselector/%s", style);
193
194 #define SWALLOW(part_name, object_ptn)                                \
195   if (object_ptn)                                                     \
196     {                                                                 \
197        elm_widget_style_set(object_ptn, buf);                         \
198        if (edje_object_part_swallow(wd->edje, part_name, object_ptn)) \
199          evas_object_show(object_ptn);                                \
200        else                                                           \
201          evas_object_hide(object_ptn);                                \
202     }
203    SWALLOW("elm.swallow.up", wd->up_button);
204    SWALLOW("elm.swallow.home", wd->home_button);
205
206    if (wd->mode == ELM_FILESELECTOR_LIST)
207      {
208         if (edje_object_part_swallow(wd->edje, "elm.swallow.files",
209                                      wd->files_list))
210           {
211              evas_object_show(wd->files_list);
212              evas_object_hide(wd->files_grid);
213           }
214         else
215           evas_object_hide(wd->files_list);
216      }
217    else
218      {
219         if (edje_object_part_swallow(wd->edje, "elm.swallow.files",
220                                      wd->files_grid))
221           {
222              evas_object_show(wd->files_grid);
223              evas_object_hide(wd->files_list);
224           }
225         else
226           evas_object_hide(wd->files_grid);
227      }
228
229    SWALLOW("elm.swallow.filename", wd->filename_entry);
230    SWALLOW("elm.swallow.path", wd->path_entry);
231
232    snprintf(buf, sizeof(buf), "fileselector/actions/%s", style);
233    SWALLOW("elm.swallow.cancel", wd->cancel_button);
234    SWALLOW("elm.swallow.ok", wd->ok_button);
235 #undef SWALLOW
236
237    edje_object_message_signal_process(wd->edje);
238    _mirrored_set(obj, elm_widget_mirrored_get(obj));
239    edje_object_scale_set
240      (wd->edje, elm_widget_scale_get(obj) * _elm_config->scale);
241    _sizing_eval(obj);
242 }
243
244 /***  GENLIST "MODEL"  ***/
245 static char *
246 _itc_text_get(void              *data,
247                Evas_Object *obj   __UNUSED__,
248                const char *source __UNUSED__)
249 {
250    return elm_entry_utf8_to_markup(ecore_file_file_get(data)); /* NOTE this will be
251                                                                 * free() by the
252                                                                 * caller */
253 }
254
255 static Evas_Object *
256 _itc_icon_folder_get(void        *data __UNUSED__,
257                      Evas_Object *obj,
258                      const char  *source)
259 {
260    Evas_Object *ic;
261
262    if (strcmp(source, "elm.swallow.icon")) return NULL;
263
264    ic = elm_icon_add(obj);
265    elm_icon_standard_set(ic, "folder");
266
267    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL,
268                                     1, 1);
269    return ic;
270 }
271
272 static Evas_Object *
273 _itc_icon_image_get(void        *data,
274                     Evas_Object *obj,
275                     const char  *source)
276 {
277    const char *filename = data;
278    Evas_Object *ic;
279
280    if (strcmp(source, "elm.swallow.icon")) return NULL;
281
282    ic = elm_icon_add(obj);
283    elm_icon_standard_set(ic, "image");
284    elm_icon_thumb_set(ic, filename, NULL);
285
286    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL,
287                                     1, 1);
288    return ic;
289 }
290
291 static Evas_Object *
292 _itc_icon_file_get(void        *data __UNUSED__,
293                    Evas_Object *obj,
294                    const char  *source)
295 {
296    Evas_Object *ic;
297
298    if (strcmp(source, "elm.swallow.icon")) return NULL;
299
300    ic = elm_icon_add(obj);
301    elm_icon_standard_set(ic, "file");
302
303    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL,
304                                     1, 1);
305    return ic;
306 }
307
308 static Eina_Bool
309 _itc_state_get(void *data         __UNUSED__,
310                Evas_Object *obj   __UNUSED__,
311                const char *source __UNUSED__)
312 {
313    return EINA_FALSE;
314 }
315
316 static void
317 _itc_del(void            *data,
318          Evas_Object *obj __UNUSED__)
319 {
320    eina_stringshare_del(data);
321 }
322
323 static void
324 _expand_done(void            *data,
325              Evas_Object *obj __UNUSED__,
326              void            *event_info)
327 {
328    Elm_Object_Item *it = event_info;
329    const char *path = elm_object_item_data_get(it);
330    _populate(data, path, it);
331 }
332
333 static void
334 _contract_done(void *data       __UNUSED__,
335                Evas_Object *obj __UNUSED__,
336                void            *event_info)
337 {
338    Elm_Object_Item *it = event_info;
339    elm_genlist_item_subitems_clear(it);
340 }
341
342 static void
343 _expand_req(void *data       __UNUSED__,
344             Evas_Object *obj __UNUSED__,
345             void            *event_info)
346 {
347    Elm_Object_Item *it = event_info;
348    elm_genlist_item_expanded_set(it, EINA_TRUE);
349 }
350
351 static void
352 _contract_req(void *data       __UNUSED__,
353               Evas_Object *obj __UNUSED__,
354               void            *event_info)
355 {
356    Elm_Object_Item *it = event_info;
357    elm_genlist_item_expanded_set(it, EINA_FALSE);
358 }
359
360 /***  PRIVATES  ***/
361 static Eina_Bool
362 _sel_do(void *data)
363 {
364    struct sel_data *sd;
365    const char *path;
366    Widget_Data *wd;
367    const char *p;
368
369    sd = data;
370    wd = elm_widget_data_get(sd->fs);
371    path = sd->path;
372
373    if ((!wd->only_folder) && ecore_file_is_dir(path))
374      {
375         if (wd->expand && wd->mode == ELM_FILESELECTOR_LIST)
376           {
377              _do_anchors(sd->fs, path);
378              elm_object_text_set(wd->filename_entry, "");
379           }
380         else
381           {
382              /* keep a ref to path 'couse it will be destroyed by _populate */
383              p = eina_stringshare_add(path);
384              _populate(sd->fs, p, NULL);
385              eina_stringshare_del(p);
386           }
387         goto end;
388      }
389    else /* navigating through folders only or file is not a dir. */
390      {
391         char *s;
392         
393         if (wd->expand && wd->mode == ELM_FILESELECTOR_LIST)
394           _do_anchors(sd->fs, path);
395         else if (wd->only_folder)
396           {
397              /* keep a ref to path 'couse it will be destroyed by _populate */
398              p = eina_stringshare_add(path);
399              _populate(sd->fs, p, NULL);
400              eina_stringshare_del(p);
401           }
402         s = elm_entry_utf8_to_markup(ecore_file_file_get(path));
403         if (s)
404           {
405              elm_object_text_set(wd->filename_entry, s);
406              free(s);
407           }
408         else
409           elm_object_text_set(wd->filename_entry, "");
410      }
411
412    evas_object_smart_callback_call(sd->fs, SIG_SELECTED, (void *)path);
413
414 end:
415    wd->sel_idler = NULL;
416    free(sd);
417    return ECORE_CALLBACK_CANCEL;
418 }
419
420 static void
421 _sel(void            *data,
422      Evas_Object *obj __UNUSED__,
423      void            *event_info)
424 {
425    struct sel_data *sd;
426    Widget_Data *wd;
427    void *old_sd;
428    char *dir;
429    //This event_info could be a list or gengrid item
430    Elm_Object_Item *it = event_info;
431
432    wd = elm_widget_data_get(data);
433    if (!wd) return;
434
435    sd = malloc(sizeof(*sd));
436    sd->fs = data;
437    sd->path = elm_object_item_data_get(it);
438
439    if (!sd->path)
440      {
441         eina_stringshare_replace(&wd->path, "");
442         goto end;
443      }
444
445    dir = wd->only_folder ? strdup(sd->path) : ecore_file_dir_get(sd->path);
446    if (dir)
447      {
448         eina_stringshare_replace(&wd->path, dir);
449         free(dir);
450      }
451    else
452      {
453         eina_stringshare_replace(&wd->path, "");
454      }
455
456 end:
457    if (wd->sel_idler)
458      {
459         old_sd = ecore_idler_del(wd->sel_idler);
460         free(old_sd);
461      }
462    wd->sel_idler = ecore_idler_add(_sel_do, sd);
463 }
464
465 static void
466 _up(void            *data,
467     Evas_Object *obj __UNUSED__,
468     void *event_info __UNUSED__)
469 {
470    Evas_Object *fs = data;
471    char *parent;
472
473    Widget_Data *wd = elm_widget_data_get(fs);
474    if (!wd) return;
475    parent = ecore_file_dir_get(wd->path);
476    _populate(fs, parent, NULL);
477    free(parent);
478 }
479
480 static void
481 _home(void            *data,
482       Evas_Object *obj __UNUSED__,
483       void *event_info __UNUSED__)
484 {
485    Evas_Object *fs = data;
486    _populate(fs, getenv("HOME"), NULL);
487 }
488
489 static void
490 _ok(void            *data,
491     Evas_Object *obj __UNUSED__,
492     void *event_info __UNUSED__)
493 {
494    Evas_Object *fs = data;
495    evas_object_smart_callback_call(fs, SIG_DONE,
496                                    (void *)elm_fileselector_selected_get(fs));
497 }
498
499 static void
500 _canc(void            *data,
501       Evas_Object *obj __UNUSED__,
502       void *event_info __UNUSED__)
503 {
504    Evas_Object *fs = data;
505    evas_object_smart_callback_call(fs, SIG_DONE, NULL);
506 }
507
508 static void
509 _anchor_clicked(void            *data,
510                 Evas_Object *obj __UNUSED__,
511                 void            *event_info)
512 {
513    Evas_Object *fs = data;
514    Widget_Data *wd = elm_widget_data_get(fs);
515    Elm_Entry_Anchor_Info *info = event_info;
516    const char *p;
517    if (!wd) return;
518    // keep a ref to path 'couse it will be destroyed by _populate
519    p = eina_stringshare_add(info->name);
520    _populate(fs, p, NULL);
521    evas_object_smart_callback_call(data, SIG_SELECTED, (void *)p);
522    eina_stringshare_del(p);
523 }
524
525 static void
526 _do_anchors(Evas_Object *obj,
527             const char  *path)
528 {
529    Widget_Data *wd = elm_widget_data_get(obj);
530    char **tok, buf[PATH_MAX * 3], *s;
531    int i, j;
532    
533    if (!wd) return;
534    s = elm_entry_utf8_to_markup(path);
535    if (!s) return;
536    buf[0] = '\0';
537    tok = eina_str_split(s, "/", 0);
538    free(s);
539    eina_strlcat(buf, "<a href=/>root</a>", sizeof(buf));
540    for (i = 0; tok[i]; i++)
541      {
542         if ((!tok[i]) || (!tok[i][0])) continue;
543         eina_strlcat(buf, wd->path_separator, sizeof(buf));
544         eina_strlcat(buf, "<a href=", sizeof(buf));
545         for (j = 0; j <= i; j++)
546           {
547              if (strlen(tok[j]) < 1) continue;
548              eina_strlcat(buf, "/", sizeof(buf));
549              eina_strlcat(buf, tok[j], sizeof(buf));
550           }
551         eina_strlcat(buf, ">", sizeof(buf));
552         eina_strlcat(buf, tok[i], sizeof(buf));
553         eina_strlcat(buf, "</a>", sizeof(buf));
554      }
555    free(tok[0]);
556    free(tok);
557
558    elm_object_text_set(wd->path_entry, buf);
559 }
560
561 #ifdef HAVE_EIO
562 static Eina_Bool
563 _filter_cb(void *data __UNUSED__, Eio_File *handler, const Eina_File_Direct_Info *info)
564 {
565    const char *filename;
566
567    if (info->path[info->name_start] == '.')
568      return EINA_FALSE;
569
570    filename = eina_stringshare_add(info->path);
571    eio_file_associate_direct_add(handler, "filename", filename, EINA_FREE_CB(eina_stringshare_del));
572
573    if (info->type == EINA_FILE_DIR)
574      {
575         eio_file_associate_direct_add(handler, "type/grid", grid_itc[ELM_DIRECTORY], NULL);
576         eio_file_associate_direct_add(handler, "type/list", list_itc[ELM_DIRECTORY], NULL);
577      }
578    else
579      {
580         if (evas_object_image_extension_can_load_get(info->path + info->name_start))
581           {
582              eio_file_associate_direct_add(handler, "type/grid", grid_itc[ELM_FILE_IMAGE], NULL);
583              eio_file_associate_direct_add(handler, "type/list", list_itc[ELM_FILE_IMAGE], NULL);
584           }
585         else
586           {
587              eio_file_associate_direct_add(handler, "type/grid", grid_itc[ELM_FILE_UNKNOW], NULL);
588              eio_file_associate_direct_add(handler, "type/list", list_itc[ELM_FILE_UNKNOW], NULL);
589           }
590      }
591
592    return EINA_TRUE;
593 }
594
595 static int
596 _file_grid_cmp(const void *a, const void *b)
597 {
598    const Elm_Object_Item *ga = a;
599    const Elm_Object_Item *gb = b;
600    const Elm_Gengrid_Item_Class *ca = elm_gengrid_item_item_class_get(ga);
601    const Elm_Gengrid_Item_Class *cb = elm_gengrid_item_item_class_get(gb);
602
603    if (ca == grid_itc[ELM_DIRECTORY])
604      {
605         if (cb != grid_itc[ELM_DIRECTORY])
606           return -1;
607      }
608    else if (cb == grid_itc[ELM_DIRECTORY])
609      {
610         return 1;
611      }
612
613    return strcoll(elm_object_item_data_get(ga), elm_object_item_data_get(gb));
614 }
615
616 static int
617 _file_list_cmp(const void *a, const void *b)
618 {
619    const Elm_Object_Item *la = a;
620    const Elm_Object_Item *lb = b;
621    const Elm_Genlist_Item_Class *ca = elm_genlist_item_item_class_get(la);
622    const Elm_Genlist_Item_Class *cb = elm_genlist_item_item_class_get(lb);
623
624    if (ca == list_itc[ELM_DIRECTORY])
625      {
626         if (cb != list_itc[ELM_DIRECTORY])
627           return -1;
628      }
629    else if (cb == list_itc[ELM_DIRECTORY])
630      {
631         return 1;
632      }
633
634    return strcoll(elm_object_item_data_get(la), elm_object_item_data_get(lb));
635 }
636
637 static void
638 _signal_first(Widget_Request *wr)
639 {
640    if (!wr->first) return ;
641    evas_object_smart_callback_call(wr->obj, SIG_DIRECTORY_OPEN, (void *)wr->path);
642    if (!wr->parent)
643      {
644         elm_genlist_clear(wr->wd->files_list);
645         elm_gengrid_clear(wr->wd->files_grid);
646         eina_stringshare_replace(&wr->wd->path, wr->path);
647         _do_anchors(wr->obj, wr->path);
648      }
649
650    if (wr->wd->filename_entry) elm_object_text_set(wr->wd->filename_entry, "");
651
652    wr->first = EINA_FALSE;
653 }
654
655 static void
656 _main_cb(void *data, Eio_File *handler, const Eina_File_Direct_Info *info __UNUSED__)
657 {
658    Widget_Request *wr = data;
659
660    if (eio_file_check(handler))
661      return ;
662    if (!wr->wd->files_list || !wr->wd->files_grid || wr->wd->current != handler)
663      {
664         eio_file_cancel(handler);
665         return ;
666      }
667
668    _signal_first(wr);
669
670    if (wr->wd->mode == ELM_FILESELECTOR_LIST)
671      {
672         Eina_Bool is_dir = (eio_file_associate_find(handler, "type/list") == list_itc[ELM_DIRECTORY]);
673
674         elm_genlist_item_sorted_insert(wr->wd->files_list, eio_file_associate_find(handler, "type/list"),
675                                        eina_stringshare_ref(eio_file_associate_find(handler, "filename")),
676                                        wr->parent, wr->wd->expand && is_dir ? ELM_GENLIST_ITEM_TREE : ELM_GENLIST_ITEM_NONE,
677                                        _file_list_cmp, NULL, NULL);
678      }
679    else if (wr->wd->mode == ELM_FILESELECTOR_GRID)
680      elm_gengrid_item_sorted_insert(wr->wd->files_grid, eio_file_associate_find(handler, "type/grid"),
681                                            eina_stringshare_ref(eio_file_associate_find(handler, "filename")),
682                                            _file_grid_cmp, NULL, NULL);
683 }
684
685 static void
686 _widget_request_cleanup(Widget_Request *wr)
687 {
688    EINA_REFCOUNT_UNREF(wr->wd)
689      _widget_data_free(wr->wd);
690
691    eina_stringshare_del(wr->path);
692    free(wr);
693 }
694
695 static void
696 _done_cb(void *data, Eio_File *handler __UNUSED__)
697 {
698    Widget_Request *wr = data;
699
700    _signal_first(wr);
701
702    wr->wd->current = NULL;
703    _widget_request_cleanup(wr);
704 }
705
706 static void
707 _error_cb(void *data, Eio_File *handler, int error __UNUSED__)
708 {
709    Widget_Request *wr = data;
710
711    if (wr->wd->current == handler)
712      wr->wd->current = NULL;
713    _widget_request_cleanup(wr);
714 }
715
716 #endif
717
718 static void
719 _populate(Evas_Object      *obj,
720           const char       *path,
721           Elm_Object_Item  *parent)
722 {
723    Widget_Data *wd = elm_widget_data_get(obj);
724 #ifdef HAVE_EIO
725    Widget_Request *wr;
726 #else
727    Eina_File_Direct_Info *file;
728    Eina_Iterator *it;
729    const char *real;
730    Eina_List *files = NULL, *dirs = NULL;
731 #endif
732
733    if (!wd) return;
734 #ifndef HAVE_EIO
735    if (!ecore_file_is_dir(path)) return ;
736    it = eina_file_stat_ls(path);
737    if (!it) return ;
738    evas_object_smart_callback_call(obj, SIG_DIRECTORY_OPEN, (void *)path);
739    if (!parent)
740      {
741         elm_genlist_clear(wd->files_list);
742         elm_gengrid_clear(wd->files_grid);
743         eina_stringshare_replace(&wd->path, path);
744         _do_anchors(obj, path);
745      }
746
747    if (wd->filename_entry) elm_object_text_set(wd->filename_entry, "");
748    EINA_ITERATOR_FOREACH(it, file)
749      {
750         const char *filename;
751
752         if (file->path[file->name_start] == '.')
753           continue ;
754
755         filename = eina_stringshare_add(file->path);
756         if (file->type == EINA_FILE_DIR)
757           dirs = eina_list_append(dirs, filename);
758         else if (!wd->only_folder)
759           files = eina_list_append(files, filename);
760      }
761    eina_iterator_free(it);
762
763    files = eina_list_sort(files, eina_list_count(files),
764                           EINA_COMPARE_CB(strcoll));
765    dirs = eina_list_sort(dirs, eina_list_count(dirs), EINA_COMPARE_CB(strcoll));
766    EINA_LIST_FREE(dirs, real)
767      {
768         if (wd->mode == ELM_FILESELECTOR_LIST)
769           elm_genlist_item_append(wd->files_list, list_itc[ELM_DIRECTORY],
770                                   real, /* item data */
771                                   parent,
772                                   wd->expand ? ELM_GENLIST_ITEM_TREE :
773                                   ELM_GENLIST_ITEM_NONE,
774                                   NULL, NULL);
775         else if (wd->mode == ELM_FILESELECTOR_GRID)
776           elm_gengrid_item_append(wd->files_grid, grid_itc[ELM_DIRECTORY],
777                                   real, /* item data */
778                                   NULL, NULL);
779      }
780
781    EINA_LIST_FREE(files, real)
782      {
783         Elm_Fileselector_Type type = evas_object_image_extension_can_load_fast_get(real) ?
784           ELM_FILE_IMAGE : ELM_FILE_UNKNOW;
785
786         if (wd->mode == ELM_FILESELECTOR_LIST)
787           elm_genlist_item_append(wd->files_list, list_itc[type],
788                                   real, /* item data */
789                                   parent, ELM_GENLIST_ITEM_NONE,
790                                   NULL, NULL);
791         else if (wd->mode == ELM_FILESELECTOR_GRID)
792           elm_gengrid_item_append(wd->files_grid, grid_itc[type],
793                                   real, /* item data */
794                                   NULL, NULL);
795      }
796 #else
797    if (wd->expand && wd->current) return ;
798    if (wd->current)
799      eio_file_cancel(wd->current);
800    wr = malloc(sizeof (Widget_Request));
801    if (!wr) return ;
802    wr->wd = wd;
803    EINA_REFCOUNT_REF(wr->wd);
804    wr->parent = parent; /* FIXME: should we refcount the parent ? */
805    wr->obj = obj;
806    wr->path = eina_stringshare_add(path);
807    wr->first = EINA_TRUE;
808
809    wd->current = eio_file_stat_ls(path,
810                                   _filter_cb,
811                                   _main_cb,
812                                   _done_cb,
813                                   _error_cb,
814                                   wr);
815 #endif
816 }
817
818 /***  API  ***/
819
820 EAPI Evas_Object *
821 elm_fileselector_add(Evas_Object *parent)
822 {
823    Evas *e;
824    Evas_Object *obj, *ic, *bt, *li, *en, *grid;
825    Widget_Data *wd;
826    unsigned int i;
827    int s;
828
829    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
830
831    EINA_REFCOUNT_INIT(wd);
832
833    ELM_SET_WIDTYPE(widtype, "fileselector");
834    elm_widget_type_set(obj, "fileselector");
835    elm_widget_sub_object_add(parent, obj);
836    elm_widget_data_set(obj, wd);
837    elm_widget_del_hook_set(obj, _del_hook);
838    elm_widget_theme_hook_set(obj, _theme_hook);
839    elm_widget_can_focus_set(obj, EINA_FALSE);
840
841    wd->expand = !!_elm_config->fileselector_expand_enable;
842
843    wd->edje = edje_object_add(e);
844    _elm_theme_object_set(obj, wd->edje, "fileselector", "base", "default");
845    elm_widget_resize_object_set(obj, wd->edje);
846
847    // up btn
848    ic = elm_icon_add(parent);
849    elm_icon_standard_set(ic, "arrow_up");
850    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
851    bt = elm_button_add(parent);
852    elm_widget_mirrored_automatic_set(bt, EINA_FALSE);
853    elm_object_part_content_set(bt, "icon", ic);
854    elm_object_domain_translatable_text_set(bt, PACKAGE, N_("Up"));
855    evas_object_size_hint_align_set(bt, 0.0, 0.0);
856
857    evas_object_smart_callback_add(bt, "clicked", _up, obj);
858
859    elm_widget_sub_object_add(obj, bt);
860    wd->up_button = bt;
861
862    // home btn
863    ic = elm_icon_add(parent);
864    elm_icon_standard_set(ic, "home");
865    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
866    bt = elm_button_add(parent);
867    elm_widget_mirrored_automatic_set(bt, EINA_FALSE);
868    elm_object_part_content_set(bt, "icon", ic);
869    elm_object_domain_translatable_text_set(bt, PACKAGE, N_("Home"));
870    evas_object_size_hint_align_set(bt, 0.0, 0.0);
871
872    evas_object_smart_callback_add(bt, "clicked", _home, obj);
873
874    elm_widget_sub_object_add(obj, bt);
875    wd->home_button = bt;
876
877    for (i = 0; i < ELM_FILE_LAST; ++i)
878      {
879         list_itc[i] = elm_genlist_item_class_new();
880         grid_itc[i] = elm_gengrid_item_class_new();
881
882         list_itc[i]->item_style = "default";
883         list_itc[i]->func.text_get = grid_itc[i]->func.text_get = _itc_text_get;
884         list_itc[i]->func.state_get = grid_itc[i]->func.state_get = _itc_state_get;
885         list_itc[i]->func.del = grid_itc[i]->func.del = _itc_del;
886      }
887
888    list_itc[ELM_DIRECTORY]->func.content_get =
889      grid_itc[ELM_DIRECTORY]->func.content_get = _itc_icon_folder_get;
890    list_itc[ELM_FILE_IMAGE]->func.content_get =
891      grid_itc[ELM_FILE_IMAGE]->func.content_get = _itc_icon_image_get;
892    list_itc[ELM_FILE_UNKNOW]->func.content_get =
893      grid_itc[ELM_FILE_UNKNOW]->func.content_get = _itc_icon_file_get;
894
895    li = elm_genlist_add(parent);
896    elm_widget_mirrored_automatic_set(li, EINA_FALSE);
897    evas_object_size_hint_align_set(li, EVAS_HINT_FILL, EVAS_HINT_FILL);
898    evas_object_size_hint_weight_set(li, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
899    evas_object_size_hint_min_set(li, 100, 100);
900
901    grid = elm_gengrid_add(parent);
902    elm_widget_mirrored_automatic_set(grid, EINA_FALSE);
903    evas_object_size_hint_align_set(grid, EVAS_HINT_FILL, EVAS_HINT_FILL);
904    evas_object_size_hint_weight_set(grid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
905
906    // XXX: will fail for dynamic finger size changing
907    s = _elm_config->finger_size * 2;
908    elm_gengrid_item_size_set(grid, s, s);
909    elm_gengrid_align_set(grid, 0.0, 0.0);
910
911    evas_object_smart_callback_add(li, "selected", _sel, obj);
912    evas_object_smart_callback_add(li, "expand,request", _expand_req, obj);
913    evas_object_smart_callback_add(li, "contract,request", _contract_req, obj);
914    evas_object_smart_callback_add(li, "expanded", _expand_done, obj);
915    evas_object_smart_callback_add(li, "contracted", _contract_done, obj);
916
917    evas_object_smart_callback_add(grid, "selected", _sel, obj);
918
919    elm_widget_sub_object_add(obj, li);
920    elm_widget_sub_object_add(obj, grid);
921    wd->files_list = li;
922    wd->files_grid = grid;
923
924    // path entry
925    en = elm_entry_add(parent);
926    elm_entry_scrollable_set(en, EINA_TRUE);
927    elm_widget_mirrored_automatic_set(en, EINA_FALSE);
928    elm_entry_editable_set(en, EINA_FALSE);
929    elm_entry_single_line_set(en, EINA_TRUE);
930    elm_entry_line_wrap_set(en, ELM_WRAP_CHAR);
931    evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
932    evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
933
934    evas_object_smart_callback_add(en, "anchor,clicked", _anchor_clicked, obj);
935
936    elm_widget_sub_object_add(obj, en);
937    wd->path_entry = en;
938
939    // filename entry
940    en = elm_entry_add(parent);
941    elm_entry_scrollable_set(en, EINA_TRUE);
942    elm_widget_mirrored_automatic_set(en, EINA_FALSE);
943    elm_entry_editable_set(en, EINA_TRUE);
944    elm_entry_single_line_set(en, EINA_TRUE);
945    elm_entry_line_wrap_set(en, ELM_WRAP_CHAR);
946    evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
947    evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
948
949    elm_widget_sub_object_add(obj, en);
950    wd->filename_entry = en;
951
952    elm_fileselector_buttons_ok_cancel_set(obj, EINA_TRUE);
953    elm_fileselector_is_save_set(obj, EINA_FALSE);
954
955    _theme_hook(obj);
956
957    evas_object_smart_callbacks_descriptions_set(obj, _signals);
958    return obj;
959 }
960
961 EAPI void
962 elm_fileselector_is_save_set(Evas_Object *obj,
963                              Eina_Bool    is_save)
964 {
965    ELM_CHECK_WIDTYPE(obj, widtype);
966    Widget_Data *wd = elm_widget_data_get(obj);
967    if (!wd) return;
968
969    elm_object_disabled_set(wd->filename_entry, !is_save);
970
971    if (is_save)
972      edje_object_signal_emit(wd->edje, "elm,state,save,on", "elm");
973    else
974      edje_object_signal_emit(wd->edje, "elm,state,save,off", "elm");
975 }
976
977 EAPI Eina_Bool
978 elm_fileselector_is_save_get(const Evas_Object *obj)
979 {
980    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
981    Widget_Data *wd = elm_widget_data_get(obj);
982    if (!wd) return EINA_FALSE;
983    return !elm_object_disabled_get(wd->filename_entry);
984 }
985
986 EAPI void
987 elm_fileselector_folder_only_set(Evas_Object *obj,
988                                  Eina_Bool    only)
989 {
990    ELM_CHECK_WIDTYPE(obj, widtype);
991    Widget_Data *wd = elm_widget_data_get(obj);
992    if (!wd) return;
993    if (wd->only_folder == only) return;
994    wd->only_folder = !!only;
995    if (wd->path) _populate(obj, wd->path, NULL);
996 }
997
998 EAPI Eina_Bool
999 elm_fileselector_folder_only_get(const Evas_Object *obj)
1000 {
1001    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1002    Widget_Data *wd = elm_widget_data_get(obj);
1003    if (!wd) return EINA_FALSE;
1004    return wd->only_folder;
1005 }
1006
1007 EAPI void
1008 elm_fileselector_buttons_ok_cancel_set(Evas_Object *obj,
1009                                        Eina_Bool    visible)
1010 {
1011    ELM_CHECK_WIDTYPE(obj, widtype);
1012    Widget_Data *wd = elm_widget_data_get(obj);
1013    Evas_Object *bt;
1014    if (!wd) return;
1015
1016    if (visible)
1017      {
1018         // cancel btn
1019         bt = elm_button_add(obj);
1020         elm_widget_mirrored_automatic_set(bt, EINA_FALSE);
1021         elm_object_domain_translatable_text_set(bt, PACKAGE, N_("Cancel"));
1022
1023         evas_object_smart_callback_add(bt, "clicked", _canc, obj);
1024
1025         elm_widget_sub_object_add(obj, bt);
1026         wd->cancel_button = bt;
1027
1028         // ok btn
1029         bt = elm_button_add(obj);
1030         elm_widget_mirrored_automatic_set(bt, EINA_FALSE);
1031         elm_object_domain_translatable_text_set(bt, PACKAGE, N_("OK"));
1032
1033         evas_object_smart_callback_add(bt, "clicked", _ok, obj);
1034
1035         elm_widget_sub_object_add(obj, bt);
1036         wd->ok_button = bt;
1037
1038         _theme_hook(obj);
1039      }
1040    else
1041      {
1042         evas_object_del(wd->cancel_button);
1043         wd->cancel_button = NULL;
1044         evas_object_del(wd->ok_button);
1045         wd->ok_button = NULL;
1046      }
1047 }
1048
1049 EAPI Eina_Bool
1050 elm_fileselector_buttons_ok_cancel_get(const Evas_Object *obj)
1051 {
1052    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1053    Widget_Data *wd = elm_widget_data_get(obj);
1054    if (!wd) return EINA_FALSE;
1055    return wd->ok_button ? EINA_TRUE : EINA_FALSE;
1056 }
1057
1058 EAPI void
1059 elm_fileselector_expandable_set(Evas_Object *obj,
1060                                 Eina_Bool    expand)
1061 {
1062    ELM_CHECK_WIDTYPE(obj, widtype);
1063    Widget_Data *wd;
1064
1065    wd = elm_widget_data_get(obj);
1066    if (!wd) return;
1067
1068    wd->expand = !!expand;
1069
1070    if (wd->path) _populate(obj, wd->path, NULL);
1071 }
1072
1073 EAPI Eina_Bool
1074 elm_fileselector_expandable_get(const Evas_Object *obj)
1075 {
1076    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1077    Widget_Data *wd = elm_widget_data_get(obj);
1078    if (!wd) return EINA_FALSE;
1079    return wd->expand;
1080 }
1081
1082 EAPI void
1083 elm_fileselector_path_set(Evas_Object *obj,
1084                           const char  *_path)
1085 {
1086    ELM_CHECK_WIDTYPE(obj, widtype);
1087    char *path;
1088    path = ecore_file_realpath(_path);
1089    _populate(obj, path, NULL);
1090    free(path);
1091 }
1092
1093 EAPI const char *
1094 elm_fileselector_path_get(const Evas_Object *obj)
1095 {
1096    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1097    Widget_Data *wd = elm_widget_data_get(obj);
1098    if (!wd) return NULL;
1099    return wd->path;
1100 }
1101
1102 EAPI void
1103 elm_fileselector_mode_set(Evas_Object          *obj,
1104                           Elm_Fileselector_Mode mode)
1105 {
1106    ELM_CHECK_WIDTYPE(obj, widtype);
1107
1108    Widget_Data *wd = elm_widget_data_get(obj);
1109    if (!wd) return;
1110
1111    if (mode == wd->mode) return;
1112
1113    if (mode == ELM_FILESELECTOR_LIST)
1114      {
1115         if (edje_object_part_swallow(wd->edje, "elm.swallow.files",
1116                                      wd->files_list))
1117           {
1118              evas_object_show(wd->files_list);
1119              evas_object_hide(wd->files_grid);
1120           }
1121         else
1122           evas_object_hide(wd->files_list);
1123      }
1124    else
1125      {
1126         if (edje_object_part_swallow(wd->edje, "elm.swallow.files",
1127                                      wd->files_grid))
1128           {
1129              evas_object_show(wd->files_grid);
1130              evas_object_hide(wd->files_list);
1131           }
1132         else
1133           evas_object_hide(wd->files_grid);
1134      }
1135
1136    wd->mode = mode;
1137
1138    _populate(obj, wd->path, NULL);
1139 }
1140
1141 EAPI Elm_Fileselector_Mode
1142 elm_fileselector_mode_get(const Evas_Object *obj)
1143 {
1144    ELM_CHECK_WIDTYPE(obj, widtype) ELM_FILESELECTOR_LAST;
1145
1146    Widget_Data *wd = elm_widget_data_get(obj);
1147    if (!wd) return ELM_FILESELECTOR_LAST;
1148
1149    return wd->mode;
1150 }
1151
1152 EAPI const char *
1153 elm_fileselector_selected_get(const Evas_Object *obj)
1154 {
1155    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1156    Widget_Data *wd = elm_widget_data_get(obj);
1157    if (!wd) return NULL;
1158
1159    if (!wd->path) return NULL;
1160    
1161    if (wd->filename_entry)
1162      {
1163         const char *name;
1164         char buf[PATH_MAX];
1165         char *dir, *s;
1166
1167         dir = wd->only_folder ? ecore_file_dir_get(wd->path) : strdup(wd->path);
1168         name = elm_object_text_get(wd->filename_entry);
1169         if (name)
1170           {
1171              s = elm_entry_markup_to_utf8(name);
1172              if (s)
1173                {
1174                   snprintf(buf, sizeof(buf), "%s/%s", dir, s);
1175                   free(s);
1176                }
1177              else
1178                snprintf(buf, sizeof(buf), "%s", dir);
1179           }
1180         else
1181           {
1182              snprintf(buf, sizeof(buf), "%s", dir);
1183           }
1184         if (wd->only_folder && !ecore_file_is_dir(buf))
1185           eina_stringshare_replace(&wd->selection, ecore_file_dir_get(buf));
1186         else
1187           eina_stringshare_replace(&wd->selection, buf);
1188         if (dir) free(dir);
1189         return wd->selection;
1190      }
1191
1192    if (wd->mode == ELM_FILESELECTOR_LIST)
1193      {
1194         Elm_Object_Item *gl_it = elm_genlist_selected_item_get(wd->files_list);
1195         if (gl_it) return elm_object_item_data_get(gl_it);
1196      }
1197    else
1198      {
1199         Elm_Object_Item *gg_it = elm_gengrid_selected_item_get(wd->files_grid);
1200         if (gg_it) return elm_object_item_data_get(gg_it);
1201      }
1202
1203    return wd->path;
1204 }
1205
1206 EAPI Eina_Bool
1207 elm_fileselector_selected_set(Evas_Object *obj,
1208                               const char  *_path)
1209 {
1210    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1211    Widget_Data *wd = elm_widget_data_get(obj);
1212    if (!wd) return EINA_FALSE;
1213
1214    Eina_Bool ret = EINA_TRUE;
1215    char *path;
1216    path = ecore_file_realpath(_path);
1217
1218    if (ecore_file_is_dir(path))
1219      _populate(obj, path, NULL);
1220    else
1221      {
1222         if (!ecore_file_exists(path))
1223           {
1224              ret = EINA_FALSE;
1225              goto clean_up;
1226           }
1227
1228         _populate(obj, ecore_file_dir_get(path), NULL);
1229         if (wd->filename_entry)
1230           {
1231              char *s;
1232              
1233              s = elm_entry_utf8_to_markup(ecore_file_file_get(path));
1234              if (s)
1235                {
1236                   elm_object_text_set(wd->filename_entry, s);
1237                   free(s);
1238                }
1239              else
1240                elm_object_text_set(wd->filename_entry, "");
1241              eina_stringshare_replace(&wd->selection, path);
1242           }
1243      }
1244
1245 clean_up:
1246    free(path);
1247    return ret;
1248 }
1249