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