1 files changed, 287 insertions, 82 deletions

diff --git a/source/blender/editors/space_file/filesel.c b/source/blender/editors/space_file/filesel.c
index db42d007b8e..e2c9bb8d6e5 100644
--- a/source/blender/editors/space_file/filesel.c
+++ b/source/blender/editors/space_file/filesel.c
@@ -49,6 +49,10 @@
 #include "BLI_utildefines.h"
 #include "BLI_fnmatch.h"
 
+#include "BLO_readfile.h"
+
+#include "BLT_translation.h"
+
 #include "BKE_appdir.h"
 #include "BKE_context.h"
 #include "BKE_main.h"
@@ -69,6 +73,8 @@
 #include "file_intern.h"
 #include "filelist.h"
 
+#define VERTLIST_MAJORCOLUMN_WIDTH (25 * UI_UNIT_X)
+
 FileSelectParams *ED_fileselect_get_params(struct SpaceFile *sfile)
 {
   if (!sfile->params) {
@@ -98,7 +104,9 @@ short ED_fileselect_set_params(SpaceFile *sfile)
                       sizeof(sfile->params->file));
     sfile->params->filter_glob[0] = '\0';
     /* set the default thumbnails size */
-    sfile->params->thumbnail_size = 128;
+    sfile->params->thumbnail_size = U_default.file_space_data.thumbnail_size;
+    /* Show size column by default. */
+    sfile->params->details_flags = U_default.file_space_data.details_flags;
   }
 
   params = sfile->params;
@@ -161,6 +169,13 @@ short ED_fileselect_set_params(SpaceFile *sfile)
       params->flag &= ~FILE_DIRSEL_ONLY;
     }
 
+    if ((prop = RNA_struct_find_property(op->ptr, "check_existing"))) {
+      params->flag |= RNA_property_boolean_get(op->ptr, prop) ? FILE_CHECK_EXISTING : 0;
+    }
+    if ((prop = RNA_struct_find_property(op->ptr, "hide_props_region"))) {
+      params->flag |= RNA_property_boolean_get(op->ptr, prop) ? FILE_HIDE_TOOL_PROPS : 0;
+    }
+
     params->filter = 0;
     if ((prop = RNA_struct_find_property(op->ptr, "filter_blender"))) {
       params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_BLENDER : 0;
@@ -189,6 +204,9 @@ short ED_fileselect_set_params(SpaceFile *sfile)
     if ((prop = RNA_struct_find_property(op->ptr, "filter_text"))) {
       params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_TEXT : 0;
     }
+    if ((prop = RNA_struct_find_property(op->ptr, "filter_archive"))) {
+      params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_ARCHIVE : 0;
+    }
     if ((prop = RNA_struct_find_property(op->ptr, "filter_folder"))) {
       params->filter |= RNA_property_boolean_get(op->ptr, prop) ? FILE_TYPE_FOLDER : 0;
     }
@@ -258,26 +276,11 @@ short ED_fileselect_set_params(SpaceFile *sfile)
       params->sort = RNA_property_enum_get(op->ptr, prop);
     }
     else {
-      params->sort = FILE_SORT_ALPHA;
+      params->sort = U_default.file_space_data.sort_type;
     }
 
     if (params->display == FILE_DEFAULTDISPLAY) {
-      if (params->display_previous == FILE_DEFAULTDISPLAY) {
-        if (U.uiflag & USER_SHOW_THUMBNAILS) {
-          if (params->filter & (FILE_TYPE_IMAGE | FILE_TYPE_MOVIE | FILE_TYPE_FTFONT)) {
-            params->display = FILE_IMGDISPLAY;
-          }
-          else {
-            params->display = FILE_SHORTDISPLAY;
-          }
-        }
-        else {
-          params->display = FILE_SHORTDISPLAY;
-        }
-      }
-      else {
-        params->display = params->display_previous;
-      }
+      params->display = U_default.file_space_data.display_type;
     }
 
     if (is_relative_path) {
@@ -291,10 +294,9 @@ short ED_fileselect_set_params(SpaceFile *sfile)
   else {
     /* default values, if no operator */
     params->type = FILE_UNIX;
-    params->flag |= FILE_HIDE_DOT;
+    params->flag |= U_default.file_space_data.flag;
     params->flag &= ~FILE_DIRSEL_ONLY;
-    params->display = FILE_SHORTDISPLAY;
-    params->display_previous = FILE_DEFAULTDISPLAY;
+    params->display = FILE_VERTICALDISPLAY;
     params->sort = FILE_SORT_ALPHA;
     params->filter = 0;
     params->filter_glob[0] = '\0';
@@ -330,6 +332,63 @@ short ED_fileselect_set_params(SpaceFile *sfile)
   return 1;
 }
 
+/* The subset of FileSelectParams.flag items we store into preferences. */
+#define PARAMS_FLAGS_REMEMBERED (FILE_HIDE_DOT | FILE_SORT_INVERT)
+
+void ED_fileselect_set_params_from_userdef(SpaceFile *sfile)
+{
+  wmOperator *op = sfile->op;
+  UserDef_FileSpaceData *sfile_udata = &U.file_space_data;
+
+  ED_fileselect_set_params(sfile);
+
+  if (!op) {
+    return;
+  }
+
+  if (!RNA_struct_property_is_set(op->ptr, "display_type")) {
+    sfile->params->display = sfile_udata->display_type;
+  }
+  if (!RNA_struct_property_is_set(op->ptr, "sort_method")) {
+    sfile->params->sort = sfile_udata->sort_type;
+  }
+  sfile->params->thumbnail_size = sfile_udata->thumbnail_size;
+  sfile->params->details_flags = sfile_udata->details_flags;
+
+  /* Combine flags we take from params with the flags we take from userdef. */
+  sfile->params->flag = (sfile->params->flag & ~PARAMS_FLAGS_REMEMBERED) |
+                        (sfile_udata->flag & PARAMS_FLAGS_REMEMBERED);
+}
+
+/**
+ * Update the user-preference data for the file space. In fact, this also contains some
+ * non-FileSelectParams data, but it's neglectable.
+ *
+ * \param temp_win_size: If the browser was opened in a temporary window, pass its size here so we
+ *                       can store that in the preferences. Otherwise NULL.
+ */
+void ED_fileselect_params_to_userdef(SpaceFile *sfile, int temp_win_size[2])
+{
+  UserDef_FileSpaceData *sfile_udata_new = &U.file_space_data;
+  UserDef_FileSpaceData sfile_udata_old = U.file_space_data;
+
+  sfile_udata_new->display_type = sfile->params->display;
+  sfile_udata_new->thumbnail_size = sfile->params->thumbnail_size;
+  sfile_udata_new->sort_type = sfile->params->sort;
+  sfile_udata_new->details_flags = sfile->params->details_flags;
+  sfile_udata_new->flag = sfile->params->flag & PARAMS_FLAGS_REMEMBERED;
+
+  if (temp_win_size) {
+    sfile_udata_new->temp_win_sizex = temp_win_size[0];
+    sfile_udata_new->temp_win_sizey = temp_win_size[1];
+  }
+
+  /* Tag prefs as dirty if something has changed. */
+  if (memcmp(sfile_udata_new, &sfile_udata_old, sizeof(sfile_udata_old)) != 0) {
+    U.runtime.is_dirty = true;
+  }
+}
+
 void ED_fileselect_reset_params(SpaceFile *sfile)
 {
   sfile->params->type = FILE_UNIX;
@@ -344,7 +403,7 @@ void ED_fileselect_reset_params(SpaceFile *sfile)
 void fileselect_file_set(SpaceFile *sfile, const int index)
 {
   const struct FileDirEntry *file = filelist_file(sfile->files, index);
-  if (file && file->relpath && file->relpath[0] && !(file->typeflag & FILE_TYPE_FOLDER)) {
+  if (file && file->relpath && file->relpath[0] && !(file->typeflag & FILE_TYPE_DIR)) {
     BLI_strncpy(sfile->params->file, file->relpath, FILE_MAXFILE);
   }
 }
@@ -372,10 +431,10 @@ int ED_fileselect_layout_numfiles(FileLayout *layout, ARegion *ar)
   }
   else {
     const int y_item = layout->tile_h + (2 * layout->tile_border_y);
-    const int y_view = (int)(BLI_rctf_size_y(&ar->v2d.cur));
+    const int y_view = (int)(BLI_rctf_size_y(&ar->v2d.cur)) - layout->offset_top;
     const int y_over = y_item - (y_view % y_item);
     numfiles = (int)((float)(y_view + y_over) / (float)(y_item));
-    return numfiles * layout->columns;
+    return numfiles * layout->flow_columns;
   }
 }
 
@@ -395,19 +454,19 @@ FileSelection ED_fileselect_layout_offset_rect(FileLayout *layout, const rcti *r
   }
 
   colmin = (rect->xmin) / (layout->tile_w + 2 * layout->tile_border_x);
-  rowmin = (rect->ymin) / (layout->tile_h + 2 * layout->tile_border_y);
+  rowmin = (rect->ymin - layout->offset_top) / (layout->tile_h + 2 * layout->tile_border_y);
   colmax = (rect->xmax) / (layout->tile_w + 2 * layout->tile_border_x);
-  rowmax = (rect->ymax) / (layout->tile_h + 2 * layout->tile_border_y);
+  rowmax = (rect->ymax - layout->offset_top) / (layout->tile_h + 2 * layout->tile_border_y);
 
-  if (is_inside(colmin, rowmin, layout->columns, layout->rows) ||
-      is_inside(colmax, rowmax, layout->columns, layout->rows)) {
-    CLAMP(colmin, 0, layout->columns - 1);
+  if (is_inside(colmin, rowmin, layout->flow_columns, layout->rows) ||
+      is_inside(colmax, rowmax, layout->flow_columns, layout->rows)) {
+    CLAMP(colmin, 0, layout->flow_columns - 1);
     CLAMP(rowmin, 0, layout->rows - 1);
-    CLAMP(colmax, 0, layout->columns - 1);
+    CLAMP(colmax, 0, layout->flow_columns - 1);
     CLAMP(rowmax, 0, layout->rows - 1);
   }
 
-  if ((colmin > layout->columns - 1) || (rowmin > layout->rows - 1)) {
+  if ((colmin > layout->flow_columns - 1) || (rowmin > layout->rows - 1)) {
     sel.first = -1;
   }
   else {
@@ -415,10 +474,10 @@ FileSelection ED_fileselect_layout_offset_rect(FileLayout *layout, const rcti *r
       sel.first = layout->rows * colmin + rowmin;
     }
     else {
-      sel.first = colmin + layout->columns * rowmin;
+      sel.first = colmin + layout->flow_columns * rowmin;
     }
   }
-  if ((colmax > layout->columns - 1) || (rowmax > layout->rows - 1)) {
+  if ((colmax > layout->flow_columns - 1) || (rowmax > layout->rows - 1)) {
     sel.last = -1;
   }
   else {
@@ -426,7 +485,7 @@ FileSelection ED_fileselect_layout_offset_rect(FileLayout *layout, const rcti *r
       sel.last = layout->rows * colmax + rowmax;
     }
     else {
-      sel.last = colmax + layout->columns * rowmax;
+      sel.last = colmax + layout->flow_columns * rowmax;
     }
   }
 
@@ -443,9 +502,9 @@ int ED_fileselect_layout_offset(FileLayout *layout, int x, int y)
   }
 
   offsetx = (x) / (layout->tile_w + 2 * layout->tile_border_x);
-  offsety = (y) / (layout->tile_h + 2 * layout->tile_border_y);
+  offsety = (y - layout->offset_top) / (layout->tile_h + 2 * layout->tile_border_y);
 
-  if (offsetx > layout->columns - 1) {
+  if (offsetx > layout->flow_columns - 1) {
     return -1;
   }
   if (offsety > layout->rows - 1) {
@@ -456,27 +515,123 @@ int ED_fileselect_layout_offset(FileLayout *layout, int x, int y)
     active_file = layout->rows * offsetx + offsety;
   }
   else {
-    active_file = offsetx + layout->columns * offsety;
+    active_file = offsetx + layout->flow_columns * offsety;
   }
   return active_file;
 }
 
+/**
+ * Get the currently visible bounds of the layout in screen space. Matches View2D.mask minus the
+ * top column-header row.
+ */
+void ED_fileselect_layout_maskrect(const FileLayout *layout, const View2D *v2d, rcti *r_rect)
+{
+  *r_rect = v2d->mask;
+  r_rect->ymax -= layout->offset_top;
+}
+
+bool ED_fileselect_layout_is_inside_pt(const FileLayout *layout, const View2D *v2d, int x, int y)
+{
+  rcti maskrect;
+  ED_fileselect_layout_maskrect(layout, v2d, &maskrect);
+  return BLI_rcti_isect_pt(&maskrect, x, y);
+}
+
+bool ED_fileselect_layout_isect_rect(const FileLayout *layout,
+                                     const View2D *v2d,
+                                     const rcti *rect,
+                                     rcti *r_dst)
+{
+  rcti maskrect;
+  ED_fileselect_layout_maskrect(layout, v2d, &maskrect);
+  return BLI_rcti_isect(&maskrect, rect, r_dst);
+}
+
 void ED_fileselect_layout_tilepos(FileLayout *layout, int tile, int *x, int *y)
 {
   if (layout->flag == FILE_LAYOUT_HOR) {
     *x = layout->tile_border_x +
          (tile / layout->rows) * (layout->tile_w + 2 * layout->tile_border_x);
-    *y = layout->tile_border_y +
+    *y = layout->offset_top + layout->tile_border_y +
          (tile % layout->rows) * (layout->tile_h + 2 * layout->tile_border_y);
   }
   else {
     *x = layout->tile_border_x +
-         ((tile) % layout->columns) * (layout->tile_w + 2 * layout->tile_border_x);
-    *y = layout->tile_border_y +
-         ((tile) / layout->columns) * (layout->tile_h + 2 * layout->tile_border_y);
+         ((tile) % layout->flow_columns) * (layout->tile_w + 2 * layout->tile_border_x);
+    *y = layout->offset_top + layout->tile_border_y +
+         ((tile) / layout->flow_columns) * (layout->tile_h + 2 * layout->tile_border_y);
   }
 }
 
+/**
+ * Check if the region coordinate defined by \a x and \a y are inside the column header.
+ */
+bool file_attribute_column_header_is_inside(const View2D *v2d,
+                                            const FileLayout *layout,
+                                            int x,
+                                            int y)
+{
+  rcti header_rect = v2d->mask;
+  header_rect.ymin = header_rect.ymax - layout->attribute_column_header_h;
+  return BLI_rcti_isect_pt(&header_rect, x, y);
+}
+
+bool file_attribute_column_type_enabled(const FileSelectParams *params,
+                                        FileAttributeColumnType column)
+{
+  switch (column) {
+    case COLUMN_NAME:
+      /* Always enabled */
+      return true;
+    case COLUMN_DATETIME:
+      return (params->details_flags & FILE_DETAILS_DATETIME) != 0;
+    case COLUMN_SIZE:
+      return (params->details_flags & FILE_DETAILS_SIZE) != 0;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Find the column type at region coordinate given by \a x (y doesn't matter for this).
+ */
+FileAttributeColumnType file_attribute_column_type_find_isect(const View2D *v2d,
+                                                              const FileSelectParams *params,
+                                                              FileLayout *layout,
+                                                              int x)
+{
+  float mx, my;
+  int offset_tile;
+
+  UI_view2d_region_to_view(v2d, x, v2d->mask.ymax - layout->offset_top - 1, &mx, &my);
+  offset_tile = ED_fileselect_layout_offset(
+      layout, (int)(v2d->tot.xmin + mx), (int)(v2d->tot.ymax - my));
+  if (offset_tile > -1) {
+    int tile_x, tile_y;
+    int pos_x = 0;
+    int rel_x; /* x relative to the hovered tile */
+
+    ED_fileselect_layout_tilepos(layout, offset_tile, &tile_x, &tile_y);
+    /* Column header drawing doesn't use left tile border, so subtract it. */
+    rel_x = mx - (tile_x - layout->tile_border_x);
+
+    for (FileAttributeColumnType column = 0; column < ATTRIBUTE_COLUMN_MAX; column++) {
+      if (!file_attribute_column_type_enabled(params, column)) {
+        continue;
+      }
+      const int width = layout->attribute_columns[column].width;
+
+      if (IN_RANGE(rel_x, pos_x, pos_x + width)) {
+        return column;
+      }
+
+      pos_x += width;
+    }
+  }
+
+  return COLUMN_NONE;
+}
+
 float file_string_width(const char *str)
 {
   uiStyle *style = UI_style_get();
@@ -512,20 +667,52 @@ float file_font_pointsize(void)
 #endif
 }
 
-static void column_widths(FileSelectParams *params, struct FileLayout *layout)
+static void file_attribute_columns_widths(const FileSelectParams *params, FileLayout *layout)
 {
-  int i;
+  FileAttributeColumn *columns = layout->attribute_columns;
   const bool small_size = SMALL_SIZE_CHECK(params->thumbnail_size);
+  const int pad = small_size ? 0 : ATTRIBUTE_COLUMN_PADDING * 2;
 
-  for (i = 0; i < MAX_FILE_COLUMN; ++i) {
-    layout->column_widths[i] = 0;
+  for (int i = 0; i < ATTRIBUTE_COLUMN_MAX; i++) {
+    layout->attribute_columns[i].width = 0;
   }
 
-  layout->column_widths[COLUMN_NAME] = ((float)params->thumbnail_size / 8.0f) * UI_UNIT_X;
   /* Biggest possible reasonable values... */
-  layout->column_widths[COLUMN_DATE] = file_string_width(small_size ? "23/08/89" : "23-Dec-89");
-  layout->column_widths[COLUMN_TIME] = file_string_width("23:59");
-  layout->column_widths[COLUMN_SIZE] = file_string_width(small_size ? "98.7 M" : "98.7 MiB");
+  columns[COLUMN_DATETIME].width = file_string_width(small_size ? "23/08/89" :
+                                                                  "23 Dec 6789, 23:59") +
+                                   pad;
+  columns[COLUMN_SIZE].width = file_string_width(small_size ? "98.7 M" : "098.7 MiB") + pad;
+  if (params->display == FILE_IMGDISPLAY) {
+    columns[COLUMN_NAME].width = ((float)params->thumbnail_size / 8.0f) * UI_UNIT_X;
+  }
+  /* Name column uses remaining width */
+  else {
+    int remwidth = layout->tile_w;
+    for (FileAttributeColumnType column_type = ATTRIBUTE_COLUMN_MAX - 1; column_type >= 0;
+         column_type--) {
+      if ((column_type == COLUMN_NAME) ||
+          !file_attribute_column_type_enabled(params, column_type)) {
+        continue;
+      }
+      remwidth -= columns[column_type].width;
+    }
+    columns[COLUMN_NAME].width = remwidth;
+  }
+}
+
+static void file_attribute_columns_init(const FileSelectParams *params, FileLayout *layout)
+{
+  file_attribute_columns_widths(params, layout);
+
+  layout->attribute_columns[COLUMN_NAME].name = N_("Name");
+  layout->attribute_columns[COLUMN_NAME].sort_type = FILE_SORT_ALPHA;
+  layout->attribute_columns[COLUMN_NAME].text_align = UI_STYLE_TEXT_LEFT;
+  layout->attribute_columns[COLUMN_DATETIME].name = N_("Date Modified");
+  layout->attribute_columns[COLUMN_DATETIME].sort_type = FILE_SORT_TIME;
+  layout->attribute_columns[COLUMN_DATETIME].text_align = UI_STYLE_TEXT_LEFT;
+  layout->attribute_columns[COLUMN_SIZE].name = N_("Size");
+  layout->attribute_columns[COLUMN_SIZE].sort_type = FILE_SORT_SIZE;
+  layout->attribute_columns[COLUMN_SIZE].text_align = UI_STYLE_TEXT_RIGHT;
 }
 
 void ED_fileselect_init_layout(struct SpaceFile *sfile, ARegion *ar)
@@ -533,7 +720,6 @@ void ED_fileselect_init_layout(struct SpaceFile *sfile, ARegion *ar)
   FileSelectParams *params = ED_fileselect_get_params(sfile);
   FileLayout *layout = NULL;
   View2D *v2d = &ar->v2d;
-  int maxlen = 0;
   int numfiles;
   int textheight;
 
@@ -560,61 +746,69 @@ void ED_fileselect_init_layout(struct SpaceFile *sfile, ARegion *ar)
     layout->tile_w = layout->prv_w + 2 * layout->prv_border_x;
     layout->tile_h = layout->prv_h + 2 * layout->prv_border_y + textheight;
     layout->width = (int)(BLI_rctf_size_x(&v2d->cur) - 2 * layout->tile_border_x);
-    layout->columns = layout->width / (layout->tile_w + 2 * layout->tile_border_x);
-    if (layout->columns > 0) {
-      layout->rows = numfiles / layout->columns + 1;  // XXX dirty, modulo is zero
+    layout->flow_columns = layout->width / (layout->tile_w + 2 * layout->tile_border_x);
+    layout->attribute_column_header_h = 0;
+    layout->offset_top = 0;
+    if (layout->flow_columns > 0) {
+      layout->rows = numfiles / layout->flow_columns + 1;  // XXX dirty, modulo is zero
     }
     else {
-      layout->columns = 1;
+      layout->flow_columns = 1;
       layout->rows = numfiles + 1;  // XXX dirty, modulo is zero
     }
     layout->height = sfile->layout->rows * (layout->tile_h + 2 * layout->tile_border_y) +
-                     layout->tile_border_y * 2;
+                     layout->tile_border_y * 2 - layout->offset_top;
     layout->flag = FILE_LAYOUT_VER;
   }
-  else {
-    int column_space = 0.6f * UI_UNIT_X;
-    int column_icon_space = 0.2f * UI_UNIT_X;
+  else if (params->display == FILE_VERTICALDISPLAY) {
+    int rowcount;
 
-    layout->prv_w = 0;
-    layout->prv_h = 0;
+    layout->prv_w = ((float)params->thumbnail_size / 20.0f) * UI_UNIT_X;
+    layout->prv_h = ((float)params->thumbnail_size / 20.0f) * UI_UNIT_Y;
+    layout->tile_border_x = 0.4f * UI_UNIT_X;
+    layout->tile_border_y = 0.1f * UI_UNIT_Y;
+    layout->tile_h = textheight * 3 / 2;
+    layout->width = (int)(BLI_rctf_size_x(&v2d->cur) - 2 * layout->tile_border_x);
+    layout->tile_w = layout->width;
+    layout->flow_columns = 1;
+    layout->attribute_column_header_h = layout->tile_h * 1.2f + 2 * layout->tile_border_y;
+    layout->offset_top = layout->attribute_column_header_h;
+    rowcount = (int)(BLI_rctf_size_y(&v2d->cur) - layout->offset_top - 2 * layout->tile_border_y) /
+               (layout->tile_h + 2 * layout->tile_border_y);
+    file_attribute_columns_init(params, layout);
+
+    layout->rows = MAX2(rowcount, numfiles);
+    BLI_assert(layout->rows != 0);
+    layout->height = sfile->layout->rows * (layout->tile_h + 2 * layout->tile_border_y) +
+                     layout->tile_border_y * 2 + layout->offset_top;
+    layout->flag = FILE_LAYOUT_VER;
+  }
+  else if (params->display == FILE_HORIZONTALDISPLAY) {
+    layout->prv_w = ((float)params->thumbnail_size / 20.0f) * UI_UNIT_X;
+    layout->prv_h = ((float)params->thumbnail_size / 20.0f) * UI_UNIT_Y;
     layout->tile_border_x = 0.4f * UI_UNIT_X;
     layout->tile_border_y = 0.1f * UI_UNIT_Y;
-    layout->prv_border_x = 0;
-    layout->prv_border_y = 0;
     layout->tile_h = textheight * 3 / 2;
+    layout->attribute_column_header_h = 0;
+    layout->offset_top = layout->attribute_column_header_h;
     layout->height = (int)(BLI_rctf_size_y(&v2d->cur) - 2 * layout->tile_border_y);
     /* Padding by full scrollbar H is too much, can overlap tile border Y. */
     layout->rows = (layout->height - V2D_SCROLL_HEIGHT + layout->tile_border_y) /
                    (layout->tile_h + 2 * layout->tile_border_y);
+    layout->tile_w = VERTLIST_MAJORCOLUMN_WIDTH;
+    file_attribute_columns_init(params, layout);
 
-    column_widths(params, layout);
-
-    if (params->display == FILE_SHORTDISPLAY) {
-      maxlen = ICON_DEFAULT_WIDTH_SCALE + column_icon_space +
-               (int)layout->column_widths[COLUMN_NAME] + column_space +
-               (int)layout->column_widths[COLUMN_SIZE] + column_space;
-    }
-    else {
-      maxlen = ICON_DEFAULT_WIDTH_SCALE + column_icon_space +
-               (int)layout->column_widths[COLUMN_NAME] + column_space +
-               (int)layout->column_widths[COLUMN_DATE] + column_space +
-               (int)layout->column_widths[COLUMN_TIME] + column_space +
-               (int)layout->column_widths[COLUMN_SIZE] + column_space;
-    }
-    layout->tile_w = maxlen;
     if (layout->rows > 0) {
-      layout->columns = numfiles / layout->rows + 1;  // XXX dirty, modulo is zero
+      layout->flow_columns = numfiles / layout->rows + 1;  // XXX dirty, modulo is zero
     }
     else {
       layout->rows = 1;
-      layout->columns = numfiles + 1;  // XXX dirty, modulo is zero
+      layout->flow_columns = numfiles + 1;  // XXX dirty, modulo is zero
     }
-    layout->width = sfile->layout->columns * (layout->tile_w + 2 * layout->tile_border_x) +
+    layout->width = sfile->layout->flow_columns * (layout->tile_w + 2 * layout->tile_border_x) +
                     layout->tile_border_x * 2;
     layout->flag = FILE_LAYOUT_HOR;
   }
-  params->display_previous = params->display;
   layout->dirty = false;
 }
 
@@ -742,7 +936,7 @@ int autocomplete_file(struct bContext *C, char *str, void *UNUSED(arg_v))
     int nentries = filelist_files_ensure(sfile->files);
     int i;
 
-    for (i = 0; i < nentries; ++i) {
+    for (i = 0; i < nentries; i++) {
       FileDirEntry *file = filelist_file(sfile->files, i);
       UI_autocomplete_update_name(autocpl, file->relpath);
     }
@@ -771,6 +965,17 @@ void ED_fileselect_exit(wmWindowManager *wm, ScrArea *sa, SpaceFile *sfile)
     return;
   }
   if (sfile->op) {
+    wmWindow *temp_win = WM_window_is_temp_screen(wm->winactive) ? wm->winactive : NULL;
+    int win_size[2];
+
+    if (temp_win) {
+      /* Get DPI/pixelsize independent size to be stored in preferences. */
+      WM_window_set_dpi(temp_win); /* Ensure the DPI is taken from the right window. */
+      win_size[0] = WM_window_pixels_x(temp_win) / UI_DPI_FAC;
+      win_size[1] = WM_window_pixels_y(temp_win) / UI_DPI_FAC;
+    }
+    ED_fileselect_params_to_userdef(sfile, temp_win ? win_size : NULL);
+
     WM_event_fileselect_event(wm, sfile->op, EVT_FILESELECT_EXTERNAL_CANCEL);
     sfile->op = NULL;
   }