c71f7dbc207de9c00b26de5e756ad88e3a1e420a
[blender.git] / source / blender / editors / space_file / filesel.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008 Blender Foundation.
19  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/space_file/filesel.c
28  *  \ingroup spfile
29  */
30
31
32 #include <string.h>
33 #include <stdio.h>
34 #include <math.h>
35
36 #include <sys/stat.h>
37 #include <sys/types.h>
38
39 /* path/file handeling stuff */
40 #ifdef WIN32
41 #  include <io.h>
42 #  include <direct.h>
43 #  include "BLI_winstuff.h"
44 #else
45 #  include <unistd.h>
46 #  include <sys/times.h>
47 #  include <dirent.h>
48 #endif
49
50 #include "DNA_space_types.h"
51 #include "DNA_screen_types.h"
52 #include "DNA_userdef_types.h"
53
54 #include "MEM_guardedalloc.h"
55
56 #include "BLI_blenlib.h"
57 #include "BLI_utildefines.h"
58 #include "BLI_fileops_types.h"
59 #include "BLI_fnmatch.h"
60
61 #include "BKE_appdir.h"
62 #include "BKE_context.h"
63 #include "BKE_global.h"
64 #include "BKE_main.h"
65
66 #include "BLF_api.h"
67
68
69 #include "ED_fileselect.h"
70
71 #include "WM_api.h"
72 #include "WM_types.h"
73
74
75 #include "RNA_access.h"
76
77 #include "UI_interface.h"
78 #include "UI_interface_icons.h"
79
80 #include "file_intern.h"
81 #include "filelist.h"
82
83 FileSelectParams *ED_fileselect_get_params(struct SpaceFile *sfile)
84 {
85         if (!sfile->params) {
86                 ED_fileselect_set_params(sfile);
87         }
88         return sfile->params;
89 }
90
91 /**
92  * \note RNA_struct_property_is_set_ex is used here because we want
93  *       the previously used settings to be used here rather then overriding them */
94 short ED_fileselect_set_params(SpaceFile *sfile)
95 {
96         FileSelectParams *params;
97         wmOperator *op = sfile->op;
98
99         /* create new parameters if necessary */
100         if (!sfile->params) {
101                 sfile->params = MEM_callocN(sizeof(FileSelectParams), "fileselparams");
102                 /* set path to most recently opened .blend */
103                 BLI_split_dirfile(G.main->name, sfile->params->dir, sfile->params->file, sizeof(sfile->params->dir), sizeof(sfile->params->file));
104                 sfile->params->filter_glob[0] = '\0';
105                 /* set the default thumbnails size */
106                 sfile->params->thumbnail_size = 128;
107         }
108
109         params = sfile->params;
110
111         /* set the parameters from the operator, if it exists */
112         if (op) {
113                 PropertyRNA *prop;
114                 const bool is_files = (RNA_struct_find_property(op->ptr, "files") != NULL);
115                 const bool is_filepath = (RNA_struct_find_property(op->ptr, "filepath") != NULL);
116                 const bool is_filename = (RNA_struct_find_property(op->ptr, "filename") != NULL);
117                 const bool is_directory = (RNA_struct_find_property(op->ptr, "directory") != NULL);
118                 const bool is_relative_path = (RNA_struct_find_property(op->ptr, "relative_path") != NULL);
119
120                 BLI_strncpy_utf8(params->title, RNA_struct_ui_name(op->type->srna), sizeof(params->title));
121
122                 if ((prop = RNA_struct_find_property(op->ptr, "filemode"))) {
123                         params->type = RNA_property_int_get(op->ptr, prop);
124                 }
125                 else {
126                         params->type = FILE_SPECIAL;
127                 }
128
129                 if (is_filepath && RNA_struct_property_is_set_ex(op->ptr, "filepath", false)) {
130                         char name[FILE_MAX];
131                         RNA_string_get(op->ptr, "filepath", name);
132                         if (params->type == FILE_LOADLIB) {
133                                 BLI_strncpy(params->dir, name, sizeof(params->dir));
134                                 sfile->params->file[0] = '\0';
135                         }
136                         else {
137                                 BLI_split_dirfile(name, sfile->params->dir, sfile->params->file, sizeof(sfile->params->dir), sizeof(sfile->params->file));
138                         }
139                 }
140                 else {
141                         if (is_directory && RNA_struct_property_is_set_ex(op->ptr, "directory", false)) {
142                                 RNA_string_get(op->ptr, "directory", params->dir);
143                                 sfile->params->file[0] = '\0';
144                         }
145
146                         if (is_filename && RNA_struct_property_is_set_ex(op->ptr, "filename", false)) {
147                                 RNA_string_get(op->ptr, "filename", params->file);
148                         }
149                 }
150
151                 if (params->dir[0]) {
152                         BLI_cleanup_dir(G.main->name, params->dir);
153                         BLI_path_abs(params->dir, G.main->name);
154                 }
155
156                 if (is_directory == true && is_filename == false && is_filepath == false && is_files == false) {
157                         params->flag |= FILE_DIRSEL_ONLY;
158                 }
159                 else {
160                         params->flag &= ~FILE_DIRSEL_ONLY;
161                 }
162
163                 params->filter = 0;
164                 if ((prop = RNA_struct_find_property(op->ptr, "filter_blender")))
165                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BLENDER : 0;
166                 if ((prop = RNA_struct_find_property(op->ptr, "filter_blenlib")))
167                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BLENDERLIB : 0;
168                 if ((prop = RNA_struct_find_property(op->ptr, "filter_backup")))
169                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BLENDER_BACKUP : 0;
170                 if ((prop = RNA_struct_find_property(op->ptr, "filter_image")))
171                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_IMAGE : 0;
172                 if ((prop = RNA_struct_find_property(op->ptr, "filter_movie")))
173                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_MOVIE : 0;
174                 if ((prop = RNA_struct_find_property(op->ptr, "filter_python")))
175                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_PYSCRIPT : 0;
176                 if ((prop = RNA_struct_find_property(op->ptr, "filter_font")))
177                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_FTFONT : 0;
178                 if ((prop = RNA_struct_find_property(op->ptr, "filter_sound")))
179                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_SOUND : 0;
180                 if ((prop = RNA_struct_find_property(op->ptr, "filter_text")))
181                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_TEXT : 0;
182                 if ((prop = RNA_struct_find_property(op->ptr, "filter_folder")))
183                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_FOLDER : 0;
184                 if ((prop = RNA_struct_find_property(op->ptr, "filter_btx")))
185                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BTX : 0;
186                 if ((prop = RNA_struct_find_property(op->ptr, "filter_collada")))
187                         params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_COLLADA : 0;
188                 if ((prop = RNA_struct_find_property(op->ptr, "filter_glob"))) {
189                         RNA_property_string_get(op->ptr, prop, params->filter_glob);
190                         params->filter |= (FILE_TYPE_OPERATOR | FILE_TYPE_FOLDER);
191                 }
192                 else {
193                         params->filter_glob[0] = '\0';
194                 }
195
196                 if (params->filter != 0) {
197                         if (U.uiflag & USER_FILTERFILEEXTS) {
198                                 params->flag |= FILE_FILTER;
199                         }
200                         else {
201                                 params->flag &= ~FILE_FILTER;
202                         }
203                 }
204
205                 /* For now, always init filterid to 'all true' */
206                 params->filter_id = FILTER_ID_AC | FILTER_ID_AR | FILTER_ID_BR | FILTER_ID_CA | FILTER_ID_CU | FILTER_ID_GD |
207                                     FILTER_ID_GR | FILTER_ID_IM | FILTER_ID_LA | FILTER_ID_LS | FILTER_ID_LT | FILTER_ID_MA |
208                                     FILTER_ID_MB | FILTER_ID_MC | FILTER_ID_ME | FILTER_ID_MSK | FILTER_ID_NT | FILTER_ID_OB |
209                                     FILTER_ID_PA | FILTER_ID_PAL | FILTER_ID_PC | FILTER_ID_SCE | FILTER_ID_SPK | FILTER_ID_SO |
210                                     FILTER_ID_TE | FILTER_ID_TXT | FILTER_ID_VF | FILTER_ID_WO;
211
212                 if (U.uiflag & USER_HIDE_DOT) {
213                         params->flag |= FILE_HIDE_DOT;
214                 }
215                 else {
216                         params->flag &= ~FILE_HIDE_DOT;
217                 }
218                 
219
220                 if (params->type == FILE_LOADLIB) {
221                         params->flag |= RNA_boolean_get(op->ptr, "link") ? FILE_LINK : 0;
222                         params->flag |= RNA_boolean_get(op->ptr, "autoselect") ? FILE_AUTOSELECT : 0;
223                         params->flag |= RNA_boolean_get(op->ptr, "active_layer") ? FILE_ACTIVELAY : 0;
224                 }
225
226                 if ((prop = RNA_struct_find_property(op->ptr, "display_type"))) {
227                         params->display = RNA_property_enum_get(op->ptr, prop);
228                 }
229
230                 if (params->display == FILE_DEFAULTDISPLAY) {
231                         if (U.uiflag & USER_SHOW_THUMBNAILS) {
232                                 if (params->filter & (FILE_TYPE_IMAGE | FILE_TYPE_MOVIE))
233                                         params->display = FILE_IMGDISPLAY;
234                                 else
235                                         params->display = FILE_SHORTDISPLAY;
236                         }
237                         else {
238                                 params->display = FILE_SHORTDISPLAY;
239                         }
240                 }
241
242                 if (is_relative_path) {
243                         if ((prop = RNA_struct_find_property(op->ptr, "relative_path"))) {
244                                 if (!RNA_property_is_set_ex(op->ptr, prop, false)) {
245                                         RNA_property_boolean_set(op->ptr, prop, (U.flag & USER_RELPATHS) != 0);
246                                 }
247                         }
248                 }
249         }
250         else {
251                 /* default values, if no operator */
252                 params->type = FILE_UNIX;
253                 params->flag |= FILE_HIDE_DOT;
254                 params->flag &= ~FILE_DIRSEL_ONLY;
255                 params->display = FILE_SHORTDISPLAY;
256                 params->filter = 0;
257                 params->filter_glob[0] = '\0';
258         }
259
260         /* operator has no setting for this */
261         params->sort = FILE_SORT_ALPHA;
262         params->active_file = -1;
263
264
265         /* initialize the list with previous folders */
266         if (!sfile->folders_prev)
267                 sfile->folders_prev = folderlist_new();
268
269         if (!sfile->params->dir[0]) {
270                 if (G.main->name[0]) {
271                         BLI_split_dir_part(G.main->name, sfile->params->dir, sizeof(sfile->params->dir));
272                 }
273                 else {
274                         const char *doc_path = BKE_appdir_folder_default();
275                         if (doc_path) {
276                                 BLI_strncpy(sfile->params->dir, doc_path, sizeof(sfile->params->dir));
277                         }
278                 }
279         }
280
281         folderlist_pushdir(sfile->folders_prev, sfile->params->dir);
282
283         /* switching thumbnails needs to recalc layout [#28809] */
284         if (sfile->layout) {
285                 sfile->layout->dirty = true;
286         }
287
288         return 1;
289 }
290
291 void ED_fileselect_reset_params(SpaceFile *sfile)
292 {
293         sfile->params->type = FILE_UNIX;
294         sfile->params->flag = 0;
295         sfile->params->title[0] = '\0';
296         sfile->params->active_file = -1;
297 }
298
299 /**
300  * Sets FileSelectParams->file (name of selected file)
301  */
302 void fileselect_file_set(SpaceFile *sfile, const int index)
303 {
304         const struct FileDirEntry *file = filelist_file(sfile->files, index);
305         if (file && file->relpath && file->relpath[0] && !(file->typeflag & FILE_TYPE_FOLDER)) {
306                 BLI_strncpy(sfile->params->file, file->relpath, FILE_MAXFILE);
307         }
308 }
309
310 int ED_fileselect_layout_numfiles(FileLayout *layout, ARegion *ar)
311 {
312         int numfiles;
313
314         /* Values in pixels.
315          *
316          * - *_item: size of each (row|col), (including padding)
317          * - *_view: (x|y) size of the view.
318          * - *_over: extra pixels, to take into account, when the fit isnt exact
319          *   (needed since you may see the end of the previous column and the beginning of the next).
320          *
321          * Could be more clever and take scrolling into account,
322          * but for now don't bother.
323          */
324         if (layout->flag & FILE_LAYOUT_HOR) {
325                 const int x_item = layout->tile_w + (2 * layout->tile_border_x);
326                 const int x_view = (int)(BLI_rctf_size_x(&ar->v2d.cur));
327                 const int x_over = x_item - (x_view % x_item);
328                 numfiles = (int)((float)(x_view + x_over) / (float)(x_item));
329                 return numfiles * layout->rows;
330         }
331         else {
332                 const int y_item = layout->tile_h + (2 * layout->tile_border_y);
333                 const int y_view = (int)(BLI_rctf_size_y(&ar->v2d.cur));
334                 const int y_over = y_item - (y_view % y_item);
335                 numfiles = (int)((float)(y_view + y_over) / (float)(y_item));
336                 return numfiles * layout->columns;
337         }
338 }
339
340 static bool is_inside(int x, int y, int cols, int rows)
341 {
342         return ((x >= 0) && (x < cols) && (y >= 0) && (y < rows));
343 }
344
345 FileSelection ED_fileselect_layout_offset_rect(FileLayout *layout, const rcti *rect)
346 {
347         int colmin, colmax, rowmin, rowmax;
348         FileSelection sel;
349         sel.first = sel.last = -1;
350
351         if (layout == NULL)
352                 return sel;
353         
354         colmin = (rect->xmin) / (layout->tile_w + 2 * layout->tile_border_x);
355         rowmin = (rect->ymin) / (layout->tile_h + 2 * layout->tile_border_y);
356         colmax = (rect->xmax) / (layout->tile_w + 2 * layout->tile_border_x);
357         rowmax = (rect->ymax) / (layout->tile_h + 2 * layout->tile_border_y);
358         
359         if (is_inside(colmin, rowmin, layout->columns, layout->rows) ||
360             is_inside(colmax, rowmax, layout->columns, layout->rows) )
361         {
362                 CLAMP(colmin, 0, layout->columns - 1);
363                 CLAMP(rowmin, 0, layout->rows - 1);
364                 CLAMP(colmax, 0, layout->columns - 1);
365                 CLAMP(rowmax, 0, layout->rows - 1);
366         }
367         
368         if ((colmin > layout->columns - 1) || (rowmin > layout->rows - 1)) {
369                 sel.first = -1;
370         }
371         else {
372                 if (layout->flag & FILE_LAYOUT_HOR) 
373                         sel.first = layout->rows * colmin + rowmin;
374                 else
375                         sel.first = colmin + layout->columns * rowmin;
376         }
377         if ((colmax > layout->columns - 1) || (rowmax > layout->rows - 1)) {
378                 sel.last = -1;
379         }
380         else {
381                 if (layout->flag & FILE_LAYOUT_HOR) 
382                         sel.last = layout->rows * colmax + rowmax;
383                 else
384                         sel.last = colmax + layout->columns * rowmax;
385         }
386
387         return sel;
388 }
389
390 int ED_fileselect_layout_offset(FileLayout *layout, int x, int y)
391 {
392         int offsetx, offsety;
393         int active_file;
394
395         if (layout == NULL)
396                 return -1;
397         
398         offsetx = (x) / (layout->tile_w + 2 * layout->tile_border_x);
399         offsety = (y) / (layout->tile_h + 2 * layout->tile_border_y);
400         
401         if (offsetx > layout->columns - 1) return -1;
402         if (offsety > layout->rows - 1) return -1;
403         
404         if (layout->flag & FILE_LAYOUT_HOR) 
405                 active_file = layout->rows * offsetx + offsety;
406         else
407                 active_file = offsetx + layout->columns * offsety;
408         return active_file;
409 }
410
411 void ED_fileselect_layout_tilepos(FileLayout *layout, int tile, int *x, int *y)
412 {
413         if (layout->flag == FILE_LAYOUT_HOR) {
414                 *x = layout->tile_border_x + (tile / layout->rows) * (layout->tile_w + 2 * layout->tile_border_x);
415                 *y = layout->tile_border_y + (tile % layout->rows) * (layout->tile_h + 2 * layout->tile_border_y);
416         }
417         else {
418                 *x = layout->tile_border_x + ((tile) % layout->columns) * (layout->tile_w + 2 * layout->tile_border_x);
419                 *y = layout->tile_border_y + ((tile) / layout->columns) * (layout->tile_h + 2 * layout->tile_border_y);
420         }
421 }
422
423 float file_string_width(const char *str)
424 {
425         uiStyle *style = UI_style_get();
426         float width;
427
428         UI_fontstyle_set(&style->widget);
429         if (style->widget.kerning == 1) {  /* for BLF_width */
430                 BLF_enable(style->widget.uifont_id, BLF_KERNING_DEFAULT);
431         }
432
433         width = BLF_width(style->widget.uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
434
435         if (style->widget.kerning == 1) {
436                 BLF_disable(style->widget.uifont_id, BLF_KERNING_DEFAULT);
437         }
438
439         return width;
440 }
441
442 float file_font_pointsize(void)
443 {
444 #if 0
445         float s;
446         char tmp[2] = "X";
447         uiStyle *style = UI_style_get();
448         UI_fontstyle_set(&style->widget);
449         s = BLF_height(style->widget.uifont_id, tmp);
450         return style->widget.points;
451 #else
452         uiStyle *style = UI_style_get();
453         UI_fontstyle_set(&style->widget);
454         return style->widget.points * UI_DPI_FAC;
455 #endif
456 }
457
458 static void column_widths(FileSelectParams *params, struct FileLayout *layout)
459 {
460         int i;
461         const bool small_size = SMALL_SIZE_CHECK(params->thumbnail_size);
462
463         for (i = 0; i < MAX_FILE_COLUMN; ++i) {
464                 layout->column_widths[i] = 0;
465         }
466
467         layout->column_widths[COLUMN_NAME] = ((float)params->thumbnail_size / 8.0f) * UI_UNIT_X;;
468         /* Biggest possible reasonable values... */
469         layout->column_widths[COLUMN_DATE] = file_string_width(small_size ? "23/08/89" : "23-Dec-89");
470         layout->column_widths[COLUMN_TIME] = file_string_width("23:59");
471         layout->column_widths[COLUMN_SIZE] = file_string_width(small_size ? "98.7 M" : "98.7 MiB");
472 }
473
474 void ED_fileselect_init_layout(struct SpaceFile *sfile, ARegion *ar)
475 {
476         FileSelectParams *params = ED_fileselect_get_params(sfile);
477         FileLayout *layout = NULL;
478         View2D *v2d = &ar->v2d;
479         int maxlen = 0;
480         int numfiles;
481         int textheight;
482
483         if (sfile->layout == NULL) {
484                 sfile->layout = MEM_callocN(sizeof(struct FileLayout), "file_layout");
485                 sfile->layout->dirty = true;
486         }
487         else if (sfile->layout->dirty == false) {
488                 return;
489         }
490
491         numfiles = filelist_files_ensure(sfile->files);
492         textheight = (int)file_font_pointsize();
493         layout = sfile->layout;
494         layout->textheight = textheight;
495
496         if (params->display == FILE_IMGDISPLAY) {
497                 layout->prv_w = ((float)params->thumbnail_size / 20.0f) * UI_UNIT_X;
498                 layout->prv_h = ((float)params->thumbnail_size / 20.0f) * UI_UNIT_Y;
499                 layout->tile_border_x = 0.3f * UI_UNIT_X;
500                 layout->tile_border_y = 0.3f * UI_UNIT_X;
501                 layout->prv_border_x = 0.3f * UI_UNIT_X;
502                 layout->prv_border_y = 0.3f * UI_UNIT_Y;
503                 layout->tile_w = layout->prv_w + 2 * layout->prv_border_x;
504                 layout->tile_h = layout->prv_h + 2 * layout->prv_border_y + textheight;
505                 layout->width = (int)(BLI_rctf_size_x(&v2d->cur) - 2 * layout->tile_border_x);
506                 layout->columns = layout->width / (layout->tile_w + 2 * layout->tile_border_x);
507                 if (layout->columns > 0)
508                         layout->rows = numfiles / layout->columns + 1;  // XXX dirty, modulo is zero
509                 else {
510                         layout->columns = 1;
511                         layout->rows = numfiles + 1; // XXX dirty, modulo is zero
512                 }
513                 layout->height = sfile->layout->rows * (layout->tile_h + 2 * layout->tile_border_y) + layout->tile_border_y * 2;
514                 layout->flag = FILE_LAYOUT_VER;
515         }
516         else {
517                 int column_space = 0.6f * UI_UNIT_X;
518                 int column_icon_space = 0.2f * UI_UNIT_X;
519
520                 layout->prv_w = 0;
521                 layout->prv_h = 0;
522                 layout->tile_border_x = 0.4f * UI_UNIT_X;
523                 layout->tile_border_y = 0.1f * UI_UNIT_Y;
524                 layout->prv_border_x = 0;
525                 layout->prv_border_y = 0;
526                 layout->tile_h = textheight * 3 / 2;
527                 layout->height = (int)(BLI_rctf_size_y(&v2d->cur) - 2 * layout->tile_border_y);
528                 layout->rows = layout->height / (layout->tile_h + 2 * layout->tile_border_y);
529
530                 column_widths(params, layout);
531
532                 if (params->display == FILE_SHORTDISPLAY) {
533                         maxlen = ICON_DEFAULT_WIDTH_SCALE + column_icon_space +
534                                  (int)layout->column_widths[COLUMN_NAME] + column_space +
535                                  (int)layout->column_widths[COLUMN_SIZE] + column_space;
536                 }
537                 else {
538                         maxlen = ICON_DEFAULT_WIDTH_SCALE + column_icon_space +
539                                  (int)layout->column_widths[COLUMN_NAME] + column_space +
540                                  (int)layout->column_widths[COLUMN_DATE] + column_space +
541                                  (int)layout->column_widths[COLUMN_TIME] + column_space +
542                                  (int)layout->column_widths[COLUMN_SIZE] + column_space;
543
544                 }
545                 layout->tile_w = maxlen;
546                 if (layout->rows > 0)
547                         layout->columns = numfiles / layout->rows + 1;  // XXX dirty, modulo is zero
548                 else {
549                         layout->rows = 1;
550                         layout->columns = numfiles + 1; // XXX dirty, modulo is zero
551                 }
552                 layout->width = sfile->layout->columns * (layout->tile_w + 2 * layout->tile_border_x) + layout->tile_border_x * 2;
553                 layout->flag = FILE_LAYOUT_HOR;
554         }
555         layout->dirty = false;
556 }
557
558 FileLayout *ED_fileselect_get_layout(struct SpaceFile *sfile, ARegion *ar)
559 {
560         if (!sfile->layout) {
561                 ED_fileselect_init_layout(sfile, ar);
562         }
563         return sfile->layout;
564 }
565
566 void ED_file_change_dir(bContext *C, const bool checkdir)
567 {
568         wmWindowManager *wm = CTX_wm_manager(C);
569         SpaceFile *sfile = CTX_wm_space_file(C);
570         ScrArea *sa = CTX_wm_area(C);
571
572         if (sfile->params) {
573                 ED_fileselect_clear(wm, sa, sfile);
574
575                 /* Clear search string, it is very rare to want to keep that filter while changing dir,
576                  * and usually very annoying to keep it actually! */
577                 sfile->params->filter_search[0] = '\0';
578                 sfile->params->active_file = -1;
579
580                 if (checkdir && !BLI_is_dir(sfile->params->dir)) {
581                         BLI_strncpy(sfile->params->dir, filelist_dir(sfile->files), sizeof(sfile->params->dir));
582                         /* could return but just refresh the current dir */
583                 }
584                 filelist_setdir(sfile->files, sfile->params->dir);
585
586                 if (folderlist_clear_next(sfile))
587                         folderlist_free(sfile->folders_next);
588
589                 folderlist_pushdir(sfile->folders_prev, sfile->params->dir);
590
591                 file_draw_check(C);
592         }
593 }
594
595 int file_select_match(struct SpaceFile *sfile, const char *pattern, char *matched_file)
596 {
597         int match = 0;
598         
599         int i;
600         FileDirEntry *file;
601         int n = filelist_files_ensure(sfile->files);
602
603         /* select any file that matches the pattern, this includes exact match 
604          * if the user selects a single file by entering the filename
605          */
606         for (i = 0; i < n; i++) {
607                 file = filelist_file(sfile->files, i);
608                 /* Do not check wether file is a file or dir here! Causes T44243 (we do accept dirs at this stage). */
609                 if (fnmatch(pattern, file->relpath, 0) == 0) {
610                         filelist_entry_select_set(sfile->files, file, FILE_SEL_ADD, FILE_SEL_SELECTED, CHECK_ALL);
611                         if (!match) {
612                                 BLI_strncpy(matched_file, file->relpath, FILE_MAX);
613                         }
614                         match++;
615                 }
616         }
617
618         return match;
619 }
620
621 int autocomplete_directory(struct bContext *C, char *str, void *UNUSED(arg_v))
622 {
623         SpaceFile *sfile = CTX_wm_space_file(C);
624         int match = AUTOCOMPLETE_NO_MATCH;
625
626         /* search if str matches the beginning of name */
627         if (str[0] && sfile->files) {
628                 char dirname[FILE_MAX];
629
630                 DIR *dir;
631                 struct dirent *de;
632                 
633                 BLI_split_dir_part(str, dirname, sizeof(dirname));
634
635                 dir = opendir(dirname);
636
637                 if (dir) {
638                         AutoComplete *autocpl = UI_autocomplete_begin(str, FILE_MAX);
639
640                         while ((de = readdir(dir)) != NULL) {
641                                 if (FILENAME_IS_CURRPAR(de->d_name)) {
642                                         /* pass */
643                                 }
644                                 else {
645                                         char path[FILE_MAX];
646                                         BLI_stat_t status;
647                                         
648                                         BLI_join_dirfile(path, sizeof(path), dirname, de->d_name);
649
650                                         if (BLI_stat(path, &status) == 0) {
651                                                 if (S_ISDIR(status.st_mode)) { /* is subdir */
652                                                         UI_autocomplete_update_name(autocpl, path);
653                                                 }
654                                         }
655                                 }
656                         }
657                         closedir(dir);
658
659                         match = UI_autocomplete_end(autocpl, str);
660                         if (match == AUTOCOMPLETE_FULL_MATCH) {
661                                 BLI_add_slash(str);
662                         }
663                 }
664         }
665
666         return match;
667 }
668
669 int autocomplete_file(struct bContext *C, char *str, void *UNUSED(arg_v))
670 {
671         SpaceFile *sfile = CTX_wm_space_file(C);
672         int match = AUTOCOMPLETE_NO_MATCH;
673
674         /* search if str matches the beginning of name */
675         if (str[0] && sfile->files) {
676                 AutoComplete *autocpl = UI_autocomplete_begin(str, FILE_MAX);
677                 int nentries = filelist_files_ensure(sfile->files);
678                 int i;
679
680                 for (i = 0; i < nentries; ++i) {
681                         FileDirEntry *file = filelist_file(sfile->files, i);
682                         UI_autocomplete_update_name(autocpl, file->relpath);
683                 }
684                 match = UI_autocomplete_end(autocpl, str);
685         }
686
687         return match;
688 }
689
690 void ED_fileselect_clear(wmWindowManager *wm, ScrArea *sa, SpaceFile *sfile)
691 {
692         /* only NULL in rare cases - [#29734] */
693         if (sfile->files) {
694                 filelist_readjob_stop(wm, sa);
695                 filelist_freelib(sfile->files);
696                 filelist_clear(sfile->files);
697         }
698
699         sfile->params->highlight_file = -1;
700         WM_main_add_notifier(NC_SPACE | ND_SPACE_FILE_LIST, NULL);
701 }
702
703 void ED_fileselect_exit(wmWindowManager *wm, ScrArea *sa, SpaceFile *sfile)
704 {
705         if (!sfile) return;
706         if (sfile->op) {
707                 WM_event_fileselect_event(wm, sfile->op, EVT_FILESELECT_EXTERNAL_CANCEL);
708                 sfile->op = NULL;
709         }
710
711         folderlist_free(sfile->folders_prev);
712         folderlist_free(sfile->folders_next);
713         
714         if (sfile->files) {
715                 ED_fileselect_clear(wm, sa, sfile);
716                 filelist_free(sfile->files);
717                 MEM_freeN(sfile->files);
718                 sfile->files = NULL;
719         }
720
721 }