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