Modernize file dialogs with persistent state

Introduce FileDialogUtils to standardize open/save/folder dialogs: prefer platform-native dialogs by default, preserve recent locations, selected filters and sidebar bookmarks across sessions, and avoid synchronous volume probing that can hang the UI. Update callers across the UI (main_window, pak_tab, game_set_editor_dialog) to use the new API and add the new sources to the build. Document the change in README and CHANGELOG and add PAKFU_FORCE_QT_FILE_DIALOG to force the Qt dialog for troubleshooting.

Author: themuffinator

CHANGELOG.md

@@ -8,6 +8,8 @@ All notable changes to PakFu are documented here.
 
 ### Fixed
 - Fix stale folder listings when navigating newly added folders in a new PAK tab by using canonical archive paths for navigation/listing.
+- Revise all open/save file and folder dialogs to use platform-native navigation by default, with persistent recent locations, filters, and sidebar bookmarks across sessions.
+- Fix potential GUI hangs when opening file dialogs on systems with slow/unreachable volumes by removing synchronous volume probing from dialog state restore.
 
 ## [0.1.18.1] - 2026-02-19
 ### Other

README.md

@@ -68,6 +68,7 @@ PakFu can also check for updates at runtime (GUI) and via CLI (`--check-updates`
 - One-click `Extract Selected` and `Extract All` workflows for the active archive tab.
 - Batch conversion tool for selected assets with category tabs (images, video, archives, models, sound, maps, text, other).
 - Image batch conversion supports output to all supported image formats (`png`, `jpg`, `jpeg`, `bmp`, `gif`, `tga`, `tif`, `tiff`, `pcx`, `wal`, `swl`, `mip`, `lmp`, `ftx`, `dds`) with format-aware settings (quality, compression, palette source, dithering, alpha threshold, embedded palette where applicable).
+- Modern platform-native open/save/folder dialogs with standard breadcrumbs/bookmarks and robust cross-platform behavior.
 - 3D preview renderer selection with Vulkan/OpenGL behavior and fallback.
 - Fly camera controls for 3D preview (`Right Mouse + WASD`, `Q/E`, mouse wheel speed, `Shift` faster, `Ctrl` slower, `F` frame, `R`/`Home` reset).
 - Auto-detection and management of per-game installation profiles.
@@ -256,6 +257,7 @@ For full policy details, see `docs/RELEASES.md`.
 | `PAKFU_DISABLE_QT_MESSAGE_HOOK` | Disable Qt log interception for troubleshooting. |
 | `PAKFU_DEBUG_MEDIA` | Enable extra media diagnostics in logs. |
 | `PAKFU_AUTO_PLAY_ON_OPEN` | Auto-start playback when opening videos. |
+| `PAKFU_FORCE_QT_FILE_DIALOG` | Force Qt's non-native file dialog implementation (useful for troubleshooting platform dialog issues). |
 | `PAKFU_ALLOW_MULTI_INSTANCE` | Disable single-instance behavior and allow multiple app instances. |
 | `PAKFU_SMOKE_TABS` | Run tab smoke test automation on startup (debug/CI helper). |
 | `QT_MEDIA_BACKEND` | Override Qt multimedia backend selection. |

src/meson.build

@@ -91,6 +91,7 @@ sources = files(
   'ui/splash_screen.cpp',
   'ui/about_dialog.cpp',
   'ui/main_window.cpp',
+  'ui/file_dialog_utils.cpp',
   'ui/file_associations_dialog.cpp',
   'ui/game_set_dialog.cpp',
   'ui/game_set_editor_dialog.cpp',

src/ui/file_dialog_utils.cpp

@@ -0,0 +1,302 @@
+#include "ui/file_dialog_utils.h"
+
+#include <QByteArray>
+#include <QDialog>
+#include <QDir>
+#include <QFileDialog>
+#include <QFileInfo>
+#include <QSet>
+#include <QSettings>
+#include <QStandardPaths>
+#include <QUrl>
+
+namespace {
+constexpr int kMaxHistoryEntries = 16;
+constexpr char kDialogSettingsRoot[] = "ui/fileDialogs";
+
+bool env_var_is_truthy(const char* name) {
+	const QByteArray raw = qgetenv(name).trimmed().toLower();
+	if (raw.isEmpty()) {
+		return false;
+	}
+	return raw != "0" && raw != "false" && raw != "no" && raw != "off";
+}
+
+QString directory_key(QString path) {
+	path = QDir::cleanPath(path);
+#if defined(Q_OS_WIN)
+	path = path.toLower();
+#endif
+	return path;
+}
+
+QString normalize_directory_path(const QString& path_in) {
+	QString path = QDir::fromNativeSeparators(path_in.trimmed());
+	if (path.isEmpty()) {
+		return {};
+	}
+	path = QDir::cleanPath(path);
+	return QFileInfo(path).absoluteFilePath();
+}
+
+QString settings_prefix(const QString& key) {
+	const QString clean_key = key.trimmed().isEmpty() ? "default" : key.trimmed();
+	return QString("%1/%2").arg(QLatin1String(kDialogSettingsRoot), clean_key);
+}
+
+bool uses_qt_dialog(const QFileDialog* dialog) {
+	return dialog && dialog->testOption(QFileDialog::DontUseNativeDialog);
+}
+
+QString sidebar_url_key(const QUrl& url_in) {
+	if (!url_in.isValid()) {
+		return {};
+	}
+
+	QUrl url = url_in;
+	if (url.isLocalFile() || url.scheme().compare("file", Qt::CaseInsensitive) == 0) {
+		const QString path = normalize_directory_path(url.toLocalFile());
+		if (path.isEmpty()) {
+			return {};
+		}
+		return QString("file:%1").arg(directory_key(path));
+	}
+
+	url = url.adjusted(QUrl::NormalizePathSegments | QUrl::StripTrailingSlash);
+	return url.toString(QUrl::FullyEncoded);
+}
+
+void append_unique_sidebar_url(QList<QUrl>* out, QSet<QString>* seen, const QUrl& url_in) {
+	if (!out || !seen) {
+		return;
+	}
+
+	QUrl url = url_in;
+	if (url.scheme().isEmpty() && !url.toString().isEmpty()) {
+		url = QUrl::fromLocalFile(url.toString());
+	}
+
+	const QString key = sidebar_url_key(url);
+	if (key.isEmpty() || seen->contains(key)) {
+		return;
+	}
+
+	seen->insert(key);
+	if (url.isLocalFile() || url.scheme().compare("file", Qt::CaseInsensitive) == 0) {
+		const QString path = normalize_directory_path(url.toLocalFile());
+		if (!path.isEmpty()) {
+			out->push_back(QUrl::fromLocalFile(path));
+		}
+		return;
+	}
+	out->push_back(url);
+}
+
+QList<QUrl> default_sidebar_urls() {
+	QList<QUrl> urls;
+	QSet<QString> seen;
+
+	// Keep defaults path-only and avoid probing mounted volumes here.
+	// Synchronous volume queries can stall UI on unreachable network drives.
+	const QList<QStandardPaths::StandardLocation> locations = {
+		QStandardPaths::HomeLocation,
+		QStandardPaths::DesktopLocation,
+		QStandardPaths::DocumentsLocation,
+		QStandardPaths::DownloadLocation,
+		QStandardPaths::PicturesLocation,
+		QStandardPaths::MoviesLocation,
+		QStandardPaths::MusicLocation,
+	};
+
+	for (const QStandardPaths::StandardLocation location : locations) {
+		for (const QString& path : QStandardPaths::standardLocations(location)) {
+			append_unique_sidebar_url(&urls, &seen, QUrl::fromLocalFile(path));
+		}
+	}
+
+	append_unique_sidebar_url(&urls, &seen, QUrl::fromLocalFile(QDir::rootPath()));
+	return urls;
+}
+
+QStringList normalize_history(const QStringList& history) {
+	QStringList out;
+	QSet<QString> seen;
+	for (const QString& value : history) {
+		const QString directory = normalize_directory_path(value);
+		if (directory.isEmpty()) {
+			continue;
+		}
+
+		const QString key = directory_key(directory);
+		if (seen.contains(key)) {
+			continue;
+		}
+		seen.insert(key);
+		out.push_back(directory);
+		if (out.size() >= kMaxHistoryEntries) {
+			break;
+		}
+	}
+	return out;
+}
+
+QString selected_directory_from_dialog(const QFileDialog* dialog) {
+	if (!dialog) {
+		return {};
+	}
+
+	const QStringList selected_files = dialog->selectedFiles();
+	if (selected_files.isEmpty()) {
+		return {};
+	}
+
+	const QString first = normalize_directory_path(selected_files.first());
+	if (first.isEmpty()) {
+		return {};
+	}
+
+	if (dialog->fileMode() == QFileDialog::Directory) {
+		return first;
+	}
+
+	return normalize_directory_path(QFileInfo(first).absolutePath());
+}
+
+QString resolve_initial_directory(const QString& preferred, const QString& fallback) {
+	QString dir = normalize_directory_path(preferred);
+	if (!dir.isEmpty()) {
+		return dir;
+	}
+
+	dir = normalize_directory_path(fallback);
+	if (!dir.isEmpty()) {
+		return dir;
+	}
+
+	return QDir::homePath();
+}
+
+void apply_modern_dialog_defaults(QFileDialog* dialog) {
+	if (!dialog) {
+		return;
+	}
+
+	// Native dialogs expose platform-standard breadcrumbs/bookmarks.
+	const bool force_qt_dialog = env_var_is_truthy("PAKFU_FORCE_QT_FILE_DIALOG");
+	dialog->setOption(QFileDialog::DontUseNativeDialog, force_qt_dialog);
+	dialog->setOption(QFileDialog::HideNameFilterDetails, false);
+	dialog->setOption(QFileDialog::ReadOnly, false);
+	dialog->setViewMode(QFileDialog::Detail);
+}
+
+void restore_dialog_state(QFileDialog* dialog,
+						  const QString& key_prefix,
+						  const QString& fallback_directory,
+						  const QString& initial_selection) {
+	if (!dialog) {
+		return;
+	}
+
+	QSettings settings;
+	const bool qt_dialog = uses_qt_dialog(dialog);
+	if (qt_dialog) {
+		const QByteArray state = settings.value(key_prefix + "/state").toByteArray();
+		if (!state.isEmpty()) {
+			dialog->restoreState(state);
+		}
+
+		const QStringList history = normalize_history(settings.value(key_prefix + "/history").toStringList());
+		if (!history.isEmpty()) {
+			dialog->setHistory(history);
+		}
+	}
+
+	if (qt_dialog) {
+		const QString stored_directory = settings.value(key_prefix + "/lastDirectory").toString();
+		dialog->setDirectory(resolve_initial_directory(stored_directory, fallback_directory));
+	} else {
+		dialog->setDirectory(resolve_initial_directory(fallback_directory, QString()));
+	}
+
+	if (qt_dialog) {
+		dialog->setSidebarUrls(default_sidebar_urls());
+	}
+
+	if (!initial_selection.trimmed().isEmpty()) {
+		dialog->selectFile(initial_selection);
+	}
+
+	const QString saved_filter = settings.value(key_prefix + "/selectedNameFilter").toString();
+	if (!saved_filter.isEmpty() && dialog->nameFilters().contains(saved_filter)) {
+		dialog->selectNameFilter(saved_filter);
+	}
+}
+
+void persist_dialog_state(QFileDialog* dialog, const QString& key_prefix) {
+	if (!dialog) {
+		return;
+	}
+
+	const bool qt_dialog = uses_qt_dialog(dialog);
+	QSettings settings;
+	if (qt_dialog) {
+		settings.setValue(key_prefix + "/state", dialog->saveState());
+
+		const QStringList history = normalize_history(dialog->history());
+		if (!history.isEmpty()) {
+			settings.setValue(key_prefix + "/history", history);
+		} else {
+			settings.remove(key_prefix + "/history");
+		}
+	}
+	settings.remove(key_prefix + "/sidebar");
+
+	const QString from_selection = selected_directory_from_dialog(dialog);
+	const QString from_current_directory = normalize_directory_path(dialog->directory().absolutePath());
+	const QString last_directory = !from_selection.isEmpty() ? from_selection : from_current_directory;
+	if (!last_directory.isEmpty()) {
+		settings.setValue(key_prefix + "/lastDirectory", last_directory);
+	}
+
+	const QString selected_filter = dialog->selectedNameFilter();
+	if (!selected_filter.isEmpty()) {
+		settings.setValue(key_prefix + "/selectedNameFilter", selected_filter);
+	}
+}
+}  // namespace
+
+namespace FileDialogUtils {
+
+bool exec_with_state(QFileDialog* dialog,
+					 const Options& options,
+					 QStringList* selected_files,
+					 QString* selected_name_filter) {
+	if (selected_files) {
+		selected_files->clear();
+	}
+	if (selected_name_filter) {
+		selected_name_filter->clear();
+	}
+	if (!dialog || !selected_files) {
+		return false;
+	}
+
+	const QString key_prefix = settings_prefix(options.settings_key);
+	apply_modern_dialog_defaults(dialog);
+	restore_dialog_state(dialog, key_prefix, options.fallback_directory, options.initial_selection);
+
+	const bool accepted = dialog->exec() == QDialog::Accepted;
+	persist_dialog_state(dialog, key_prefix);
+
+	if (!accepted) {
+		return false;
+	}
+
+	*selected_files = dialog->selectedFiles();
+	if (selected_name_filter) {
+		*selected_name_filter = dialog->selectedNameFilter();
+	}
+	return !selected_files->isEmpty();
+}
+
+}  // namespace FileDialogUtils

src/ui/file_dialog_utils.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <QString>
+#include <QStringList>
+
+class QFileDialog;
+
+namespace FileDialogUtils {
+
+struct Options {
+	QString settings_key;
+	QString fallback_directory;
+	QString initial_selection;
+};
+
+bool exec_with_state(QFileDialog* dialog,
+					 const Options& options,
+					 QStringList* selected_files,
+					 QString* selected_name_filter = nullptr);
+
+}  // namespace FileDialogUtils