SHA256
616 lines
21 KiB
C#
616 lines
21 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using MelonLoader;
|
|
|
|
namespace ADOFAIRenderer.Util.OS;
|
|
|
|
[SuppressMessage("ReSharper", "InconsistentNaming")]
|
|
[SuppressMessage("ReSharper", "UnusedMember.Local")]
|
|
internal static class FolderDialogUtil
|
|
{
|
|
private static int _isDialogOpen;
|
|
|
|
public static void OpenFolderBrowser(string initialDirectory, Action<string?> onSelected)
|
|
{
|
|
if (Interlocked.CompareExchange(ref _isDialogOpen, 1, 0) != 0)
|
|
{
|
|
MelonLogger.Msg("[FolderDialogUtil] Folder dialog is already open.");
|
|
return;
|
|
}
|
|
|
|
var syncContext = SynchronizationContext.Current;
|
|
|
|
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
|
{
|
|
var ownerHandle = GetGameWindowHandle();
|
|
|
|
var thread = new Thread(() =>
|
|
{
|
|
string? selected = null;
|
|
int oleHr = -1;
|
|
try
|
|
{
|
|
oleHr = OleInitialize(IntPtr.Zero);
|
|
selected = OpenWindowsFolderBrowser(initialDirectory, ownerHandle);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Windows folder dialog error: {ex.Message}");
|
|
}
|
|
finally
|
|
{
|
|
if (oleHr >= 0)
|
|
{
|
|
try
|
|
{
|
|
OleUninitialize();
|
|
}
|
|
catch
|
|
{
|
|
// Ignore uninitialize error
|
|
}
|
|
}
|
|
Interlocked.Exchange(ref _isDialogOpen, 0);
|
|
}
|
|
|
|
DispatchResult(syncContext, onSelected, selected);
|
|
})
|
|
{
|
|
IsBackground = true,
|
|
Name = "FolderDialog-Win"
|
|
};
|
|
thread.SetApartmentState(ApartmentState.STA);
|
|
thread.Start();
|
|
}
|
|
else
|
|
{
|
|
Task.Run(() =>
|
|
{
|
|
string? selected = null;
|
|
try
|
|
{
|
|
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
|
|
{
|
|
selected = OpenMacFolderBrowser(initialDirectory);
|
|
}
|
|
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
|
|
{
|
|
selected = OpenLinuxFolderBrowser(initialDirectory);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Failed to open folder browser: {ex.Message}");
|
|
}
|
|
finally
|
|
{
|
|
Interlocked.Exchange(ref _isDialogOpen, 0);
|
|
}
|
|
|
|
DispatchResult(syncContext, onSelected, selected);
|
|
});
|
|
}
|
|
}
|
|
|
|
private static void DispatchResult(SynchronizationContext? syncContext, Action<string?> onSelected, string? selected)
|
|
{
|
|
if (syncContext != null)
|
|
{
|
|
syncContext.Post(_ =>
|
|
{
|
|
try
|
|
{
|
|
onSelected(selected);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Error in folder selected callback: {ex.Message}");
|
|
}
|
|
}, null);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
onSelected(selected);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Error in folder selected callback: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Windows Implementation
|
|
|
|
private static readonly Guid CLSID_FileOpenDialog = new("DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7");
|
|
private static readonly Guid IID_IFileOpenDialog = new("d57c7288-d4ad-4768-be02-9d969532d960");
|
|
private static readonly Guid IID_IShellItem = new("43826D1E-E718-42EE-BC55-A1E261C37BFE");
|
|
private const int ERROR_CANCELLED_HR = unchecked((int)0x800704C7);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr GetActiveWindow();
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr GetForegroundWindow();
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
|
|
|
|
private static IntPtr GetGameWindowHandle()
|
|
{
|
|
try
|
|
{
|
|
var active = GetActiveWindow();
|
|
if (active != IntPtr.Zero) return active;
|
|
|
|
var currentPid = (uint)Process.GetCurrentProcess().Id;
|
|
var fg = GetForegroundWindow();
|
|
if (fg != IntPtr.Zero)
|
|
{
|
|
GetWindowThreadProcessId(fg, out var fgPid);
|
|
if (fgPid == currentPid)
|
|
{
|
|
return fg;
|
|
}
|
|
}
|
|
|
|
var mainHandle = Process.GetCurrentProcess().MainWindowHandle;
|
|
if (mainHandle != IntPtr.Zero)
|
|
{
|
|
return mainHandle;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Ignore failure to detect window handle
|
|
}
|
|
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
private static string? OpenWindowsFolderBrowser(string initialDirectory, IntPtr ownerHandle)
|
|
{
|
|
try
|
|
{
|
|
return OpenWindowsFolderBrowserModern(initialDirectory, ownerHandle);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Modern folder dialog failed ({ex.Message}), falling back to legacy dialog.");
|
|
return OpenWindowsFolderBrowserLegacy(initialDirectory, ownerHandle);
|
|
}
|
|
}
|
|
|
|
private static string? OpenWindowsFolderBrowserModern(string initialDirectory, IntPtr ownerHandle)
|
|
{
|
|
// 1. Try native CoCreateInstance first (works on Mono and .NET without class registration)
|
|
var clsid = CLSID_FileOpenDialog;
|
|
var iid = IID_IFileOpenDialog;
|
|
int createHr = CoCreateInstance(ref clsid, IntPtr.Zero, 1 /* CLSCTX_INPROC_SERVER */, ref iid, out var dialog);
|
|
|
|
if (createHr != 0)
|
|
{
|
|
// 2. Fallback to Activator via Type.GetTypeFromCLSID
|
|
var comType = Type.GetTypeFromCLSID(CLSID_FileOpenDialog);
|
|
if (comType != null)
|
|
{
|
|
var instance = Activator.CreateInstance(comType);
|
|
dialog = instance as IFileOpenDialog;
|
|
}
|
|
}
|
|
|
|
if (dialog == null)
|
|
{
|
|
throw new COMException("Failed to instantiate IFileOpenDialog via COM.", createHr);
|
|
}
|
|
|
|
try
|
|
{
|
|
dialog.SetOptions(FOS.FOS_PICKFOLDERS | FOS.FOS_FORCEFILESYSTEM | FOS.FOS_PATHMUSTEXIST);
|
|
dialog.SetTitle("Select Output Directory");
|
|
|
|
if (!string.IsNullOrWhiteSpace(initialDirectory))
|
|
{
|
|
try
|
|
{
|
|
var normalized = Path.GetFullPath(initialDirectory).TrimEnd('\\', '/');
|
|
if (Directory.Exists(normalized))
|
|
{
|
|
var shellItemGuid = IID_IShellItem;
|
|
int itemHr = SHCreateItemFromParsingName(normalized, IntPtr.Zero, ref shellItemGuid, out var initialItem);
|
|
if (itemHr == 0)
|
|
{
|
|
try
|
|
{
|
|
dialog.SetFolder(initialItem);
|
|
dialog.SetDefaultFolder(initialItem);
|
|
}
|
|
finally
|
|
{
|
|
Marshal.ReleaseComObject(initialItem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Ignore failure to set initial folder
|
|
}
|
|
}
|
|
|
|
int hr = dialog.Show(ownerHandle);
|
|
if (hr != 0 && hr != ERROR_CANCELLED_HR && ownerHandle != IntPtr.Zero)
|
|
{
|
|
// If Show failed with ownerHandle (e.g. cross-thread or invalid handle), retry without owner
|
|
MelonLogger.Msg($"[FolderDialogUtil] dialog.Show(ownerHandle) returned 0x{hr:X8}, retrying with IntPtr.Zero.");
|
|
hr = dialog.Show(IntPtr.Zero);
|
|
}
|
|
|
|
if (hr == ERROR_CANCELLED_HR)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (hr != 0)
|
|
{
|
|
throw new COMException("IFileOpenDialog.Show failed", hr);
|
|
}
|
|
|
|
dialog.GetResult(out var resultItem);
|
|
|
|
try
|
|
{
|
|
if (resultItem.GetDisplayName(SIGDN.SIGDN_FILESYSPATH, out var pszPath) == 0 && pszPath != IntPtr.Zero)
|
|
{
|
|
try
|
|
{
|
|
var path = Marshal.PtrToStringUni(pszPath);
|
|
return !string.IsNullOrEmpty(path) && Directory.Exists(path) ? path : null;
|
|
}
|
|
finally
|
|
{
|
|
Marshal.FreeCoTaskMem(pszPath);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Marshal.ReleaseComObject(resultItem);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
Marshal.ReleaseComObject(dialog);
|
|
}
|
|
}
|
|
|
|
private static string? OpenWindowsFolderBrowserLegacy(string initialDirectory, IntPtr ownerHandle)
|
|
{
|
|
IntPtr pszDisplayName = Marshal.AllocHGlobal(260 * sizeof(char));
|
|
IntPtr initialDirPtr = IntPtr.Zero;
|
|
BrowseCallbackProc? callback = null;
|
|
IntPtr pidl = IntPtr.Zero;
|
|
|
|
try
|
|
{
|
|
var bi = new BROWSEINFO
|
|
{
|
|
hwndOwner = ownerHandle,
|
|
pidlRoot = IntPtr.Zero,
|
|
pszDisplayName = pszDisplayName,
|
|
lpszTitle = "Select Output Directory",
|
|
ulFlags = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE | BIF_EDITBOX
|
|
};
|
|
|
|
if (!string.IsNullOrWhiteSpace(initialDirectory))
|
|
{
|
|
try
|
|
{
|
|
var normalized = Path.GetFullPath(initialDirectory).TrimEnd('\\', '/');
|
|
if (Directory.Exists(normalized))
|
|
{
|
|
initialDirPtr = Marshal.StringToHGlobalUni(normalized);
|
|
callback = (hwnd, uMsg, _, lpData) =>
|
|
{
|
|
if (uMsg == BFFM_INITIALIZED && lpData != IntPtr.Zero)
|
|
{
|
|
SendMessage(hwnd, BFFM_SETSELECTIONW, (IntPtr)1, lpData);
|
|
}
|
|
return 0;
|
|
};
|
|
bi.lpfn = callback;
|
|
bi.lParam = initialDirPtr;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Ignore failure to prepare initial directory
|
|
}
|
|
}
|
|
|
|
pidl = SHBrowseForFolderW(ref bi);
|
|
if (pidl == IntPtr.Zero && ownerHandle != IntPtr.Zero)
|
|
{
|
|
// If it returned null with ownerHandle, check if retry with IntPtr.Zero is appropriate
|
|
// But note: cancelling also returns Zero. We do not redundantly re-prompt if cancelled.
|
|
}
|
|
|
|
if (pidl != IntPtr.Zero)
|
|
{
|
|
var sb = new StringBuilder(260);
|
|
if (SHGetPathFromIDListW(pidl, sb))
|
|
{
|
|
var path = sb.ToString();
|
|
return !string.IsNullOrEmpty(path) && Directory.Exists(path) ? path : null;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
if (pidl != IntPtr.Zero)
|
|
{
|
|
Marshal.FreeCoTaskMem(pidl);
|
|
}
|
|
if (initialDirPtr != IntPtr.Zero)
|
|
{
|
|
Marshal.FreeHGlobal(initialDirPtr);
|
|
}
|
|
if (pszDisplayName != IntPtr.Zero)
|
|
{
|
|
Marshal.FreeHGlobal(pszDisplayName);
|
|
}
|
|
GC.KeepAlive(callback);
|
|
}
|
|
}
|
|
|
|
#region COM & Win32 Interop Definitions
|
|
|
|
[Flags]
|
|
private enum FOS : uint
|
|
{
|
|
FOS_NOCHANGEDIR = 0x00000008,
|
|
FOS_PICKFOLDERS = 0x00000020,
|
|
FOS_FORCEFILESYSTEM = 0x00000040,
|
|
FOS_PATHMUSTEXIST = 0x00000800,
|
|
FOS_FILEMUSTEXIST = 0x00001000,
|
|
}
|
|
|
|
private enum SIGDN : uint
|
|
{
|
|
SIGDN_FILESYSPATH = 0x80058000
|
|
}
|
|
|
|
[ComImport]
|
|
[Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE")]
|
|
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
private interface IShellItem
|
|
{
|
|
void BindToHandler(IntPtr pbc, [In] ref Guid bhid, [In] ref Guid riid, out IntPtr ppv);
|
|
void GetParent(out IShellItem ppsi);
|
|
[PreserveSig]
|
|
int GetDisplayName(SIGDN sigdnName, out IntPtr ppszName);
|
|
void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
|
|
void Compare(IShellItem psi, uint hint, out int piOrder);
|
|
}
|
|
|
|
[ComImport]
|
|
[Guid("d57c7288-d4ad-4768-be02-9d969532d960")]
|
|
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
private interface IFileOpenDialog
|
|
{
|
|
[PreserveSig]
|
|
int Show(IntPtr parent);
|
|
void SetFileTypes(uint cFileTypes, IntPtr rgFilterSpec);
|
|
void SetFileTypeIndex(uint iFileType);
|
|
void GetFileTypeIndex(out uint piFileType);
|
|
void Advise(IntPtr pfde, out uint pdwCookie);
|
|
void Unadvise(uint dwCookie);
|
|
void SetOptions(FOS fos);
|
|
void GetOptions(out FOS pfos);
|
|
void SetDefaultFolder(IShellItem psi);
|
|
void SetFolder(IShellItem psi);
|
|
void GetFolder(out IShellItem ppsi);
|
|
void GetCurrentSelection(out IShellItem ppsi);
|
|
void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
|
|
void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string pszName);
|
|
void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
|
|
void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
|
|
void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
|
|
void GetResult(out IShellItem ppsi);
|
|
void AddPlace(IShellItem psi, int fdap);
|
|
void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
|
|
void Close(int hr);
|
|
void SetClientGuid(ref Guid guid);
|
|
void ClearClientData();
|
|
void SetFilter(IntPtr pFilter);
|
|
void GetResults(out IntPtr ppenum);
|
|
void GetSelectedItems(out IntPtr ppsai);
|
|
}
|
|
|
|
[DllImport("ole32.dll", ExactSpelling = true)]
|
|
private static extern int OleInitialize(IntPtr pvReserved);
|
|
|
|
[DllImport("ole32.dll", ExactSpelling = true)]
|
|
private static extern void OleUninitialize();
|
|
|
|
[DllImport("ole32.dll", ExactSpelling = true)]
|
|
private static extern int CoCreateInstance(
|
|
[In] ref Guid rclsid,
|
|
IntPtr pUnkOuter,
|
|
uint dwClsContext,
|
|
[In] ref Guid riid,
|
|
[Out, MarshalAs(UnmanagedType.Interface)] out IFileOpenDialog ppv);
|
|
|
|
[DllImport("shell32.dll", CharSet = CharSet.Unicode, PreserveSig = true)]
|
|
private static extern int SHCreateItemFromParsingName(
|
|
[MarshalAs(UnmanagedType.LPWStr)] string pszPath,
|
|
IntPtr pbc,
|
|
[In] ref Guid riid,
|
|
[Out, MarshalAs(UnmanagedType.Interface)] out IShellItem ppv);
|
|
|
|
private const uint BIF_RETURNONLYFSDIRS = 0x0001;
|
|
private const uint BIF_NEWDIALOGSTYLE = 0x0040;
|
|
private const uint BIF_EDITBOX = 0x0010;
|
|
private const uint BFFM_INITIALIZED = 1;
|
|
private const uint BFFM_SETSELECTIONW = 0x0400 + 103;
|
|
|
|
private delegate int BrowseCallbackProc(IntPtr hwnd, uint uMsg, IntPtr lParam, IntPtr lpData);
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
private struct BROWSEINFO
|
|
{
|
|
public IntPtr hwndOwner;
|
|
public IntPtr pidlRoot;
|
|
public IntPtr pszDisplayName;
|
|
public string lpszTitle;
|
|
public uint ulFlags;
|
|
public BrowseCallbackProc? lpfn;
|
|
public IntPtr lParam;
|
|
public int iImage;
|
|
}
|
|
|
|
[DllImport("shell32.dll", CharSet = CharSet.Unicode)]
|
|
private static extern IntPtr SHBrowseForFolderW(ref BROWSEINFO lpbi);
|
|
|
|
[DllImport("shell32.dll", CharSet = CharSet.Unicode)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool SHGetPathFromIDListW(IntPtr pidl, StringBuilder pszPath);
|
|
|
|
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
|
|
private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region macOS Implementation
|
|
|
|
private static string? OpenMacFolderBrowser(string initialDirectory)
|
|
{
|
|
try
|
|
{
|
|
string script;
|
|
if (!string.IsNullOrEmpty(initialDirectory) && Directory.Exists(initialDirectory))
|
|
{
|
|
var escaped = initialDirectory.Replace("\\", "\\\\").Replace("\"", "\\\"");
|
|
script = $"POSIX path of (choose folder with prompt \"Select Output Directory\" default location (POSIX file \"{escaped}\"))";
|
|
}
|
|
else
|
|
{
|
|
script = "POSIX path of (choose folder with prompt \"Select Output Directory\")";
|
|
}
|
|
|
|
var startInfo = new ProcessStartInfo
|
|
{
|
|
FileName = "osascript",
|
|
CreateNoWindow = true,
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true,
|
|
WindowStyle = ProcessWindowStyle.Hidden
|
|
};
|
|
startInfo.ArgumentList.Add("-e");
|
|
startInfo.ArgumentList.Add(script);
|
|
|
|
using var process = Process.Start(startInfo);
|
|
if (process == null) return null;
|
|
|
|
var output = process.StandardOutput.ReadToEnd().Trim();
|
|
process.WaitForExit();
|
|
|
|
return !string.IsNullOrEmpty(output) && Directory.Exists(output) ? output : null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Mac folder dialog error: {ex.Message}");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Linux Implementation
|
|
|
|
private static string? OpenLinuxFolderBrowser(string initialDirectory)
|
|
{
|
|
try
|
|
{
|
|
var startInfo = new ProcessStartInfo
|
|
{
|
|
FileName = "zenity",
|
|
CreateNoWindow = true,
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true,
|
|
WindowStyle = ProcessWindowStyle.Hidden
|
|
};
|
|
startInfo.ArgumentList.Add("--file-selection");
|
|
startInfo.ArgumentList.Add("--directory");
|
|
startInfo.ArgumentList.Add("--title=Select Output Directory");
|
|
if (!string.IsNullOrEmpty(initialDirectory) && Directory.Exists(initialDirectory))
|
|
{
|
|
startInfo.ArgumentList.Add($"--filename={initialDirectory}");
|
|
}
|
|
|
|
try
|
|
{
|
|
using var process = Process.Start(startInfo);
|
|
if (process != null)
|
|
{
|
|
var output = process.StandardOutput.ReadToEnd().Trim();
|
|
process.WaitForExit();
|
|
|
|
if (process.ExitCode == 0 && !string.IsNullOrEmpty(output) && Directory.Exists(output))
|
|
{
|
|
return output;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Fallback to kdialog if zenity fails to start
|
|
}
|
|
|
|
var kdialogInfo = new ProcessStartInfo
|
|
{
|
|
FileName = "kdialog",
|
|
CreateNoWindow = true,
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true,
|
|
WindowStyle = ProcessWindowStyle.Hidden
|
|
};
|
|
kdialogInfo.ArgumentList.Add("--getexistingdirectory");
|
|
if (!string.IsNullOrEmpty(initialDirectory) && Directory.Exists(initialDirectory))
|
|
{
|
|
kdialogInfo.ArgumentList.Add(initialDirectory);
|
|
}
|
|
kdialogInfo.ArgumentList.Add("--title");
|
|
kdialogInfo.ArgumentList.Add("Select Output Directory");
|
|
|
|
using var kdialogProcess = Process.Start(kdialogInfo);
|
|
if (kdialogProcess == null) return null;
|
|
|
|
var koutput = kdialogProcess.StandardOutput.ReadToEnd().Trim();
|
|
kdialogProcess.WaitForExit();
|
|
|
|
return !string.IsNullOrEmpty(koutput) && Directory.Exists(koutput) ? koutput : null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MelonLogger.Warning($"[FolderDialogUtil] Linux folder dialog error: {ex.Message}");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|