From: Alexander Wilms <f.alexander.wilms@outlook.com> --- dlls/comdlg32/Makefile.in | 6 +- dlls/comdlg32/cdlg32.c | 4 + dlls/comdlg32/filedlg.c | 729 +++++++++++++++++++++- dlls/comdlg32/portal_dbus.c | 1172 +++++++++++++++++++++++++++++++++++ dlls/comdlg32/unixlib.c | 68 ++ dlls/comdlg32/unixlib.h | 61 ++ 6 files changed, 2028 insertions(+), 12 deletions(-) create mode 100644 dlls/comdlg32/portal_dbus.c create mode 100644 dlls/comdlg32/unixlib.c create mode 100644 dlls/comdlg32/unixlib.h diff --git a/dlls/comdlg32/Makefile.in b/dlls/comdlg32/Makefile.in index 4de12ae3487..c696696f008 100644 --- a/dlls/comdlg32/Makefile.in +++ b/dlls/comdlg32/Makefile.in @@ -3,6 +3,8 @@ MODULE = comdlg32.dll IMPORTLIB = comdlg32 IMPORTS = uuid shell32 shlwapi comctl32 user32 gdi32 advapi32 DELAYIMPORTS = ole32 winspool +UNIXLIB = comdlg32.so +UNIX_CFLAGS = $(DBUS_CFLAGS) VER_FILEDESCRIPTION_STR = "Common Dialog Boxes" VER_PRODUCTVERSION = 6,0,2900,5512 @@ -22,4 +24,6 @@ SOURCES = \ pd32_landscape.svg \ pd32_nocollate.svg \ pd32_portrait.svg \ - printdlg.c + printdlg.c \ + portal_dbus.c \ + unixlib.c diff --git a/dlls/comdlg32/cdlg32.c b/dlls/comdlg32/cdlg32.c index b3115650302..c4538e4caed 100644 --- a/dlls/comdlg32/cdlg32.c +++ b/dlls/comdlg32/cdlg32.c @@ -32,6 +32,7 @@ #include "commdlg.h" #include "cderr.h" #include "wine/debug.h" +#include "wine/unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(commdlg); @@ -65,6 +66,9 @@ BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD Reason, LPVOID Reserved) COMDLG32_hInstance = hInstance; DisableThreadLibraryCalls(hInstance); + /* Initialize Unix library for XDG Desktop Portal support */ + __wine_init_unix_call(); + actctx.cbSize = sizeof(actctx); actctx.hModule = COMDLG32_hInstance; actctx.lpResourceName = MAKEINTRESOURCEW(123); diff --git a/dlls/comdlg32/filedlg.c b/dlls/comdlg32/filedlg.c index 9d573759445..673053c17e9 100644 --- a/dlls/comdlg32/filedlg.c +++ b/dlls/comdlg32/filedlg.c @@ -52,6 +52,7 @@ #include <string.h> #define COBJMACROS +#define WIN32_NO_STATUS #include "windef.h" #include "winbase.h" #include "winternl.h" @@ -69,6 +70,11 @@ #include "shlwapi.h" #include "wine/debug.h" +#undef WIN32_NO_STATUS +#include "ntstatus.h" + +#include "wine/unixlib.h" +#include "unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(commdlg); @@ -159,6 +165,7 @@ static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd); static BOOL FILEDLG95_OnOpen(HWND hwnd); static LRESULT FILEDLG95_InitControls(HWND hwnd); static void FILEDLG95_Clean(HWND hwnd); +static BOOL should_use_portal(const OPENFILENAMEW *ofn); /* Functions used by the shell navigation */ static LRESULT FILEDLG95_SHELL_Init(HWND hwnd); @@ -425,6 +432,94 @@ static WCHAR *heap_strdupAtoW(const char *str) return ret; } +static WCHAR *heap_multisz_AtoW(const char *str) +{ + const char *s; + int n, len; + WCHAR *ret; + + if (!str) return NULL; + + s = str; + while (*s) s += strlen(s) + 1; + s++; + n = s - str; + len = MultiByteToWideChar(CP_ACP, 0, str, n, NULL, 0); + if (len <= 0) return NULL; + + ret = malloc(len * sizeof(WCHAR)); + if (!ret) return NULL; + MultiByteToWideChar(CP_ACP, 0, str, n, ret, len); + return ret; +} + +static WCHAR *heap_customfilter_AtoW(const char *str) +{ + const char *s; + int n, len; + WCHAR *ret; + + if (!str) return NULL; + + s = str; + if (*s) s += strlen(s) + 1; + if (*s) s += strlen(s) + 1; + n = s - str; + len = MultiByteToWideChar(CP_ACP, 0, str, n, NULL, 0); + if (len <= 0) return NULL; + + ret = malloc(len * sizeof(WCHAR)); + if (!ret) return NULL; + MultiByteToWideChar(CP_ACP, 0, str, n, ret, len); + return ret; +} + +static UINT get_multisz_lenW(const WCHAR *str) +{ + const WCHAR *s; + + if (!str) return 0; + s = str; + while (*s) s += lstrlenW(s) + 1; + s++; + return s - str; +} + +static BOOL copy_ofn_file_WtoA(const OPENFILENAMEW *ofnW, OPENFILENAMEA *ofnA, BOOL multiselect) +{ + int src_lenW, dst_lenA; + + if (!ofnA->lpstrFile || !ofnW->lpstrFile) + return FALSE; + + src_lenW = multiselect ? (int)get_multisz_lenW(ofnW->lpstrFile) : lstrlenW(ofnW->lpstrFile) + 1; + dst_lenA = WideCharToMultiByte(CP_ACP, 0, ofnW->lpstrFile, src_lenW, NULL, 0, NULL, NULL); + if (dst_lenA <= 0 || (UINT)dst_lenA > ofnA->nMaxFile) + { + if (ofnA->lpstrFile) + *(WORD *)ofnA->lpstrFile = (dst_lenA > 0xffff) ? 0xffff : (WORD)max(dst_lenA, 0); + COMDLG32_SetCommDlgExtendedError(FNERR_BUFFERTOOSMALL); + return FALSE; + } + + WideCharToMultiByte(CP_ACP, 0, ofnW->lpstrFile, src_lenW, ofnA->lpstrFile, ofnA->nMaxFile, NULL, NULL); + ofnA->nFilterIndex = ofnW->nFilterIndex; + + if (multiselect && ofnW->nFileOffset) + { + ofnA->nFileOffset = WideCharToMultiByte(CP_ACP, 0, ofnW->lpstrFile, ofnW->nFileOffset, NULL, 0, NULL, NULL); + ofnA->nFileExtension = 0; + } + else + { + ofnA->nFileOffset = WideCharToMultiByte(CP_ACP, 0, ofnW->lpstrFile, ofnW->nFileOffset, NULL, 0, NULL, NULL); + ofnA->nFileExtension = ofnW->nFileExtension ? + WideCharToMultiByte(CP_ACP, 0, ofnW->lpstrFile, ofnW->nFileExtension - 1, NULL, 0, NULL, NULL) + 1 : 0; + } + + return TRUE; +} + static void init_filedlg_infoW(OPENFILENAMEW *ofn, FileOpenDlgInfos *info) { INITCOMMONCONTROLSEX icc; @@ -589,7 +684,7 @@ static BOOL GetFileDialog95(FileOpenDlgInfos *info, UINT dlg_type) static BOOL COMDLG32_GetDisplayNameOf(LPCITEMIDLIST pidl, LPWSTR pwszPath) { LPSHELLFOLDER psfDesktop; STRRET strret; - + if (FAILED(SHGetDesktopFolder(&psfDesktop))) return FALSE; @@ -724,9 +819,9 @@ static void ArrangeCtrlPositions(HWND hwndChildDlg, HWND hwndParentDlg, BOOL hid However, if there is a static text component with the stc32 id, a special case happens. The x and y coordinates of stc32 indicate the top left corner where to place the standard file dialog box in the window and the cx and cy indicate how to size the window. - Moreover, if the new component's coordinates are on the left of the stc32 , it is placed on the left + Moreover, if the new component's coordinates are on the left of the stc32 , it is placed on the left of the standard file dialog box. If they are above the stc32 component, it is placed above and so on.... - + */ GetClientRect(hwndParentDlg, &rectParent); @@ -1029,14 +1124,14 @@ static INT_PTR FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM case CDM_GETFOLDERPATH: TRACE("CDM_GETFOLDERPATH:\n"); COMDLG32_GetDisplayNameOf(fodInfos->ShellInfos.pidlAbsCurrent, lpstrPath); - if (lParam) + if (lParam) { if (fodInfos->unicode) lstrcpynW((LPWSTR)lParam, lpstrPath, (int)wParam); else - WideCharToMultiByte(CP_ACP, 0, lpstrPath, -1, + WideCharToMultiByte(CP_ACP, 0, lpstrPath, -1, (LPSTR)lParam, (int)wParam, NULL, NULL); - } + } retval = lstrlenW(lpstrPath) + 1; break; @@ -2705,7 +2800,7 @@ BOOL FILEDLG95_OnOpen(HWND hwnd) { /* if no extension is specified with file name, then */ /* attach the extension from file filter or default one */ - + WCHAR *filterExt = NULL; LPWSTR lpstrFilter = NULL; int PathLength = lstrlenW(lpstrPathAndFile); @@ -3265,8 +3360,8 @@ static void FILEDLG95_FILETYPE_Clean(HWND hwnd) * Initialisation of the look in combo box */ -/* Small helper function, to determine if the unixfs shell extension is rooted - * at the desktop. Copied from dlls/shell32/shfldr_unixfs.c. +/* Small helper function, to determine if the unixfs shell extension is rooted + * at the desktop. Copied from dlls/shell32/shfldr_unixfs.c. */ static inline BOOL FILEDLG95_unixfs_is_rooted_at_desktop(void) { HKEY hKey; @@ -3326,7 +3421,7 @@ static void FILEDLG95_LOOKIN_Init(HWND hwndCombo) FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND); /* If the unixfs extension is rooted, we don't expand the drives by default */ - if (!FILEDLG95_unixfs_is_rooted_at_desktop()) + if (!FILEDLG95_unixfs_is_rooted_at_desktop()) { /* special handling for CSIDL_DRIVES */ if (ILIsEqual(pidlTmp, pidlDrives)) @@ -4131,6 +4226,9 @@ static inline BOOL is_win16_looks(DWORD flags) */ BOOL WINAPI GetOpenFileNameA(OPENFILENAMEA *ofn) { + OPENFILENAMEW ofnW; + WCHAR *titleW = NULL, *initdirW = NULL, *defextW = NULL, *filterW = NULL, *customW = NULL, *fileW = NULL; + TRACE("flags 0x%08lx\n", ofn->Flags); if (!valid_struct_size( ofn->lStructSize )) @@ -4143,6 +4241,54 @@ BOOL WINAPI GetOpenFileNameA(OPENFILENAMEA *ofn) if (ofn->Flags & OFN_FILEMUSTEXIST) ofn->Flags |= OFN_PATHMUSTEXIST; + if (!is_win16_looks(ofn->Flags)) + { + OPENFILENAMEW policy_ofn = {0}; + BOOL retW; + + policy_ofn.Flags = ofn->Flags; + if (should_use_portal(&policy_ofn)) + { + memset(&ofnW, 0, sizeof(ofnW)); + ofnW.lStructSize = sizeof(ofnW); + ofnW.hwndOwner = ofn->hwndOwner; + ofnW.hInstance = ofn->hInstance; + ofnW.lpstrFilter = filterW = heap_multisz_AtoW(ofn->lpstrFilter); + ofnW.lpstrCustomFilter = customW = heap_customfilter_AtoW(ofn->lpstrCustomFilter); + ofnW.nMaxCustFilter = ofn->nMaxCustFilter; + ofnW.nFilterIndex = ofn->nFilterIndex; + ofnW.lpstrFile = fileW = calloc(ofn->nMaxFile ? ofn->nMaxFile : 1, sizeof(WCHAR)); + ofnW.nMaxFile = ofn->nMaxFile; + ofnW.lpstrFileTitle = NULL; + ofnW.nMaxFileTitle = 0; + ofnW.lpstrInitialDir = initdirW = heap_strdupAtoW(ofn->lpstrInitialDir); + ofnW.lpstrTitle = titleW = heap_strdupAtoW(ofn->lpstrTitle); + ofnW.Flags = ofn->Flags; + ofnW.nFileOffset = ofn->nFileOffset; + ofnW.nFileExtension = ofn->nFileExtension; + ofnW.lpstrDefExt = defextW = heap_strdupAtoW(ofn->lpstrDefExt); + ofnW.lCustData = ofn->lCustData; + ofnW.pvReserved = ofn->pvReserved; + ofnW.dwReserved = ofn->dwReserved; + ofnW.FlagsEx = ofn->FlagsEx; + + if (fileW && ofn->lpstrFile && ofn->nMaxFile) + MultiByteToWideChar(CP_ACP, 0, ofn->lpstrFile, -1, fileW, ofn->nMaxFile); + + retW = GetOpenFileNameW(&ofnW); + if (retW) + retW = copy_ofn_file_WtoA(&ofnW, ofn, !!(ofn->Flags & OFN_ALLOWMULTISELECT)); + + free(titleW); + free(initdirW); + free(defextW); + free(filterW); + free(customW); + free(fileW); + return retW; + } + } + if (is_win16_looks(ofn->Flags)) return GetFileName31A(ofn, OPEN_DIALOG); else @@ -4154,6 +4300,304 @@ BOOL WINAPI GetOpenFileNameA(OPENFILENAMEA *ofn) } } +/*********************************************************************** + * XDG Desktop Portal Integration + */ + +#define UNIX_CALL( func, params ) WINE_UNIX_CALL( unix_ ## func, params ) + +static NTSTATUS call_unix_portal(enum comdlg32_unix_funcs code, void *params) +{ + NTSTATUS status; + + TRACE("call_unix_portal: code=%d, params=%p\n", code, params); + + if (!__wine_unixlib_handle) + { + TRACE("call_unix_portal: __wine_unixlib_handle is NULL, returning STATUS_NOT_SUPPORTED\n"); + return STATUS_NOT_SUPPORTED; + } + + TRACE("call_unix_portal: Calling WINE_UNIX_CALL with code=%d...\n", code); + status = WINE_UNIX_CALL( code, params ); + TRACE("call_unix_portal: WINE_UNIX_CALL returned 0x%08lx\n", (unsigned long)status); + return status; +} + +static void copy_wchar_to_utf8(char *dst, size_t dst_len, const WCHAR *wstr) +{ + int len; + char *tmp; + + if (!dst_len) return; + if (!wstr) + { + dst[0] = 0; + return; + } + + len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL); + if (len <= 0) + { + dst[0] = 0; + return; + } + + if ((size_t)len <= dst_len) + { + WideCharToMultiByte(CP_UTF8, 0, wstr, -1, dst, dst_len, NULL, NULL); + return; + } + + tmp = malloc(len); + if (!tmp) + { + dst[0] = 0; + return; + } + + WideCharToMultiByte(CP_UTF8, 0, wstr, -1, tmp, len, NULL, NULL); + memcpy(dst, tmp, dst_len - 1); + dst[dst_len - 1] = 0; + free(tmp); +} + +static void copy_wchar_to_unix_path(char *dst, size_t dst_len, const WCHAR *wstr) +{ + char *unix_path; + size_t len; + + if (!dst_len) return; + dst[0] = 0; + if (!wstr || !*wstr) return; + + unix_path = wine_get_unix_file_name(wstr); + if (unix_path) + { + len = strlen(unix_path); + if (len >= dst_len) len = dst_len - 1; + memcpy(dst, unix_path, len); + dst[len] = 0; + HeapFree(GetProcessHeap(), 0, unix_path); + return; + } + + /* Fallback: best-effort conversion in Unix codepage */ + WideCharToMultiByte(CP_UNIXCP, 0, wstr, -1, dst, dst_len, NULL, NULL); +} + +static WCHAR *alloc_dir_from_path(const WCHAR *path) +{ + const WCHAR *last; + size_t len; + WCHAR *dir; + + if (!path || !*path) return NULL; + last = wcsrchr(path, '\\'); + if (!last) last = wcsrchr(path, '/'); + if (!last) return NULL; + + len = (size_t)(last - path + 1); /* include trailing slash */ + dir = malloc((len + 1) * sizeof(WCHAR)); + if (!dir) return NULL; + + memcpy(dir, path, len * sizeof(WCHAR)); + dir[len] = 0; + return dir; +} + +static const WCHAR *file_part_from_path(const WCHAR *path) +{ + const WCHAR *last; + + if (!path) return NULL; + last = wcsrchr(path, '\\'); + if (!last) last = wcsrchr(path, '/'); + return last ? last + 1 : path; +} + +static BOOL append_utf8_to_blob(char *dst, size_t dst_len, size_t *pos, const WCHAR *wstr) +{ + int len; + + if (!dst || !dst_len || !pos) return FALSE; + if (!wstr) wstr = L""; + + len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL); + if (len <= 0) return FALSE; + + if (*pos + (size_t)len > dst_len) + return FALSE; + + WideCharToMultiByte(CP_UTF8, 0, wstr, -1, dst + *pos, len, NULL, NULL); + *pos += len; + return TRUE; +} + +static void build_filters_blob_utf8(char *dst, size_t dst_len, const WCHAR *filter, + const WCHAR *custom, UINT *out_count, UINT *out_len) +{ + const WCHAR *p; + UINT count = 0; + size_t pos = 0; + + if (out_count) *out_count = 0; + if (out_len) *out_len = 0; + if (!dst_len) return; + dst[0] = 0; + + /* custom filter (pair of strings) */ + if (custom && *custom) + { + const WCHAR *name = custom; + const WCHAR *pattern = custom + lstrlenW(custom) + 1; + if (*pattern) + { + if (!append_utf8_to_blob(dst, dst_len, &pos, name)) goto done; + if (!append_utf8_to_blob(dst, dst_len, &pos, pattern)) goto done; + count++; + } + } + + /* standard filters list (pairs of strings) */ + p = filter; + while (p && *p) + { + const WCHAR *name = p; + p += lstrlenW(p) + 1; + if (!*p) break; + if (!append_utf8_to_blob(dst, dst_len, &pos, name)) goto done; + if (!append_utf8_to_blob(dst, dst_len, &pos, p)) goto done; + count++; + p += lstrlenW(p) + 1; + } + +done: + /* Ensure final NUL terminator */ + if (pos < dst_len) dst[pos++] = 0; + else dst[dst_len - 1] = 0; + + if (out_count) *out_count = count; + if (out_len) *out_len = (UINT)pos; +} + +enum portal_policy +{ + PORTAL_POLICY_AUTO, + PORTAL_POLICY_FORCE, + PORTAL_POLICY_NEVER, +}; + +static BOOL get_portal_policy_value(WCHAR *buffer, DWORD size) +{ + HKEY defkey = 0, appkey = 0, tmpkey; + DWORD type, len; + WCHAR appname[MAX_PATH + 16]; + WCHAR *p; + + if (RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Wine\\X11 Driver", &defkey)) + defkey = 0; + + if (!RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Wine\\AppDefaults", &tmpkey)) + { + len = GetModuleFileNameW(NULL, appname, ARRAY_SIZE(appname)); + if (len && len < ARRAY_SIZE(appname)) + { + if ((p = wcsrchr(appname, '\\'))) p++; + else if ((p = wcsrchr(appname, '/'))) p++; + else p = appname; + + lstrcpynW(appname, p, ARRAY_SIZE(appname)); + if (lstrlenW(appname) + lstrlenW(L"\\X11 Driver") < ARRAY_SIZE(appname)) + { + lstrcatW(appname, L"\\X11 Driver"); + if (RegOpenKeyW(tmpkey, appname, &appkey)) appkey = 0; + } + } + RegCloseKey(tmpkey); + } + + if (appkey) + { + len = size; + if (!RegQueryValueExW(appkey, L"FileDialogPortal", 0, &type, (BYTE *)buffer, &len) && + (type == REG_SZ || type == REG_EXPAND_SZ)) + { + RegCloseKey(appkey); + if (defkey) RegCloseKey(defkey); + buffer[(len / sizeof(WCHAR)) ? (len / sizeof(WCHAR) - 1) : 0] = 0; + return TRUE; + } + RegCloseKey(appkey); + } + + if (defkey) + { + len = size; + if (!RegQueryValueExW(defkey, L"FileDialogPortal", 0, &type, (BYTE *)buffer, &len) && + (type == REG_SZ || type == REG_EXPAND_SZ)) + { + RegCloseKey(defkey); + buffer[(len / sizeof(WCHAR)) ? (len / sizeof(WCHAR) - 1) : 0] = 0; + return TRUE; + } + RegCloseKey(defkey); + } + + return FALSE; +} + +static enum portal_policy get_portal_policy(void) +{ + const char *force_portal = getenv("WINE_FORCE_PORTAL"); + WCHAR value[32]; + + if (force_portal && *force_portal == '1') + return PORTAL_POLICY_FORCE; + + if (get_portal_policy_value(value, sizeof(value))) + { + if (!wcsicmp(value, L"always")) + return PORTAL_POLICY_FORCE; + if (!wcsicmp(value, L"never")) + return PORTAL_POLICY_NEVER; + if (!wcsicmp(value, L"auto")) + return PORTAL_POLICY_AUTO; + } + + return PORTAL_POLICY_AUTO; +} + +static BOOL should_use_portal(const OPENFILENAMEW *ofn) +{ + enum portal_policy policy; + + TRACE("should_use_portal: Checking portal eligibility: flags=0x%08lx\n", (unsigned long)ofn->Flags); + + policy = get_portal_policy(); + if (policy == PORTAL_POLICY_FORCE) + return TRUE; + if (policy == PORTAL_POLICY_NEVER) + return FALSE; + + /* Don't use portal if hooks or templates are present */ + if (ofn->Flags & (OFN_ENABLEHOOK | OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE)) + { + TRACE("Portal disabled: hooks/templates present (flags=0x%08lx)\n", (unsigned long)ofn->Flags); + return FALSE; + } + + /* Only use for Explorer-style dialogs */ + if (!(ofn->Flags & OFN_EXPLORER)) + { + TRACE("Portal disabled: not Explorer-style dialog\n"); + return FALSE; + } + + TRACE("Portal eligible!\n"); + return TRUE; +} + /*********************************************************************** * GetOpenFileNameW (COMDLG32.@) * @@ -4166,7 +4610,10 @@ BOOL WINAPI GetOpenFileNameA(OPENFILENAMEA *ofn) */ BOOL WINAPI GetOpenFileNameW(OPENFILENAMEW *ofn) { - TRACE("flags 0x%08lx\n", ofn->Flags); + NTSTATUS status; + struct portal_open_file_params params; + + TRACE("GetOpenFileNameW called! flags 0x%08lx\n", ofn->Flags); if (!valid_struct_size( ofn->lStructSize )) { @@ -4178,6 +4625,108 @@ BOOL WINAPI GetOpenFileNameW(OPENFILENAMEW *ofn) if (ofn->Flags & OFN_FILEMUSTEXIST) ofn->Flags |= OFN_PATHMUSTEXIST; + TRACE("Calling should_use_portal...\n"); + /* Try XDG portal first if applicable */ + if (should_use_portal(ofn)) + { + UINT max_results = (ofn->Flags & OFN_ALLOWMULTISELECT) ? 1024 : 1; + BOOL ret = FALSE; + + TRACE("Portal enabled! Attempting to use XDG portal...\n"); + + memset(¶ms, 0, sizeof(params)); + copy_wchar_to_utf8(params.title_utf8, sizeof(params.title_utf8), ofn->lpstrTitle); + params.initial_dir_utf8[0] = 0; + if (ofn->lpstrInitialDir && *ofn->lpstrInitialDir) + { + copy_wchar_to_unix_path(params.initial_dir_utf8, sizeof(params.initial_dir_utf8), ofn->lpstrInitialDir); + } + else if (ofn->lpstrFile && *ofn->lpstrFile) + { + WCHAR *dir = alloc_dir_from_path(ofn->lpstrFile); + if (dir) + { + copy_wchar_to_unix_path(params.initial_dir_utf8, sizeof(params.initial_dir_utf8), dir); + free(dir); + } + } + + build_filters_blob_utf8(params.filters_blob, sizeof(params.filters_blob), + ofn->lpstrFilter, ofn->lpstrCustomFilter, + ¶ms.filter_count, ¶ms.filters_blob_len); + params.current_filter_index = 0; + if (params.filter_count) + { + if (ofn->nFilterIndex >= 1 && ofn->nFilterIndex <= params.filter_count) + params.current_filter_index = ofn->nFilterIndex; + else + params.current_filter_index = 1; + } + params.flags = 0; + if (ofn->Flags & OFN_ALLOWMULTISELECT) + params.flags |= PORTAL_OPEN_FLAG_MULTIPLE; + params.max_results = max_results; + + TRACE("Calling unix_portal_open_file...\n"); + status = call_unix_portal(unix_portal_open_file, ¶ms); + TRACE("Portal returned status: 0x%08lx\n", (long)status); + + if (status == STATUS_BUFFER_TOO_SMALL) + { + WORD size = (params.result_buffer_len > 0xffffu) ? 0xffffu : (WORD)params.result_buffer_len; + TRACE("Portal returned STATUS_BUFFER_TOO_SMALL (needed %u WCHARs)\n", params.result_buffer_len); + if (ofn->lpstrFile) *(WORD *)ofn->lpstrFile = size; + COMDLG32_SetCommDlgExtendedError(FNERR_BUFFERTOOSMALL); + return FALSE; + } + else if (status == STATUS_SUCCESS && params.result_buffer_len && params.result_buffer[0]) + { + TRACE("Portal SUCCESS with result!\n"); + /* Copy packed result to output buffer */ + if (ofn->lpstrFile && params.result_buffer_len <= ofn->nMaxFile) + { + memcpy(ofn->lpstrFile, params.result_buffer, params.result_buffer_len * sizeof(WCHAR)); + + if ((ofn->Flags & OFN_ALLOWMULTISELECT) && params.result_count > 1) + { + ofn->nFileOffset = lstrlenW(ofn->lpstrFile) + 1; + ofn->nFileExtension = 0; + } + else + { + const WCHAR *filepart = file_part_from_path(ofn->lpstrFile); + const WCHAR *ext = PathFindExtensionW(ofn->lpstrFile); + ofn->nFileOffset = filepart ? (filepart - ofn->lpstrFile) : 0; + ofn->nFileExtension = (*ext) ? (ext - ofn->lpstrFile) + 1 : 0; + } + TRACE("Returning TRUE from portal path\n"); + ret = TRUE; + } + else + { + WORD size = (params.result_buffer_len > 0xffffu) ? 0xffffu : (WORD)params.result_buffer_len; + TRACE("Buffer too small for portal result (needed %u WCHARs, have %lu)\n", + params.result_buffer_len, (unsigned long)ofn->nMaxFile); + if (ofn->lpstrFile) *(WORD *)ofn->lpstrFile = size; + COMDLG32_SetCommDlgExtendedError(FNERR_BUFFERTOOSMALL); + return FALSE; + } + /* Result paths freed below */ + } + else if (status == STATUS_CANCELLED) + { + TRACE("Portal was cancelled, returning FALSE\n"); + } + else + { + TRACE("Portal failed or not supported, falling back to Wine dialog\n"); + ret = -1; /* Indicate fallback */ + } + + if (ret != -1) return ret; + } + + TRACE("Using fallback Wine dialog\n"); if (is_win16_looks(ofn->Flags)) return GetFileName31W(ofn, OPEN_DIALOG); else @@ -4202,12 +4751,63 @@ BOOL WINAPI GetOpenFileNameW(OPENFILENAMEW *ofn) */ BOOL WINAPI GetSaveFileNameA(OPENFILENAMEA *ofn) { + OPENFILENAMEW ofnW; + WCHAR *titleW = NULL, *initdirW = NULL, *defextW = NULL, *filterW = NULL, *customW = NULL, *fileW = NULL; + if (!valid_struct_size( ofn->lStructSize )) { COMDLG32_SetCommDlgExtendedError( CDERR_STRUCTSIZE ); return FALSE; } + if (!is_win16_looks(ofn->Flags)) + { + OPENFILENAMEW policy_ofn = {0}; + BOOL retW; + + policy_ofn.Flags = ofn->Flags; + if (should_use_portal(&policy_ofn)) + { + memset(&ofnW, 0, sizeof(ofnW)); + ofnW.lStructSize = sizeof(ofnW); + ofnW.hwndOwner = ofn->hwndOwner; + ofnW.hInstance = ofn->hInstance; + ofnW.lpstrFilter = filterW = heap_multisz_AtoW(ofn->lpstrFilter); + ofnW.lpstrCustomFilter = customW = heap_customfilter_AtoW(ofn->lpstrCustomFilter); + ofnW.nMaxCustFilter = ofn->nMaxCustFilter; + ofnW.nFilterIndex = ofn->nFilterIndex; + ofnW.lpstrFile = fileW = calloc(ofn->nMaxFile ? ofn->nMaxFile : 1, sizeof(WCHAR)); + ofnW.nMaxFile = ofn->nMaxFile; + ofnW.lpstrFileTitle = NULL; + ofnW.nMaxFileTitle = 0; + ofnW.lpstrInitialDir = initdirW = heap_strdupAtoW(ofn->lpstrInitialDir); + ofnW.lpstrTitle = titleW = heap_strdupAtoW(ofn->lpstrTitle); + ofnW.Flags = ofn->Flags; + ofnW.nFileOffset = ofn->nFileOffset; + ofnW.nFileExtension = ofn->nFileExtension; + ofnW.lpstrDefExt = defextW = heap_strdupAtoW(ofn->lpstrDefExt); + ofnW.lCustData = ofn->lCustData; + ofnW.pvReserved = ofn->pvReserved; + ofnW.dwReserved = ofn->dwReserved; + ofnW.FlagsEx = ofn->FlagsEx; + + if (fileW && ofn->lpstrFile && ofn->nMaxFile) + MultiByteToWideChar(CP_ACP, 0, ofn->lpstrFile, -1, fileW, ofn->nMaxFile); + + retW = GetSaveFileNameW(&ofnW); + if (retW) + retW = copy_ofn_file_WtoA(&ofnW, ofn, FALSE); + + free(titleW); + free(initdirW); + free(defextW); + free(filterW); + free(customW); + free(fileW); + return retW; + } + } + if (is_win16_looks(ofn->Flags)) return GetFileName31A(ofn, SAVE_DIALOG); else @@ -4232,12 +4832,119 @@ BOOL WINAPI GetSaveFileNameA(OPENFILENAMEA *ofn) BOOL WINAPI GetSaveFileNameW( LPOPENFILENAMEW ofn) /* [in/out] address of init structure */ { + NTSTATUS status; + struct portal_save_file_params params; + + TRACE("GetSaveFileNameW called! flags 0x%08lx\n", ofn->Flags); + if (!valid_struct_size( ofn->lStructSize )) { COMDLG32_SetCommDlgExtendedError( CDERR_STRUCTSIZE ); return FALSE; } + /* Try XDG portal first if applicable */ + TRACE("Calling should_use_portal...\n"); + if (should_use_portal(ofn)) + { + BOOL ret = FALSE; + + TRACE("Portal enabled! Attempting to use XDG portal for Save...\n"); + + memset(¶ms, 0, sizeof(params)); + copy_wchar_to_utf8(params.title_utf8, sizeof(params.title_utf8), ofn->lpstrTitle); + params.initial_dir_utf8[0] = 0; + params.initial_filename_utf8[0] = 0; + params.current_file_unix[0] = 0; + + if (ofn->lpstrFile && *ofn->lpstrFile) + { + const WCHAR *name = file_part_from_path(ofn->lpstrFile); + BOOL has_wildcards = name && wcspbrk(name, L"*?") != NULL; + BOOL has_path = (name && name != ofn->lpstrFile) || wcschr(ofn->lpstrFile, L':'); + + if (name && *name && !has_wildcards) + copy_wchar_to_utf8(params.initial_filename_utf8, + sizeof(params.initial_filename_utf8), name); + + if (has_path && !has_wildcards) + copy_wchar_to_unix_path(params.current_file_unix, + sizeof(params.current_file_unix), ofn->lpstrFile); + + if (name && name != ofn->lpstrFile) + { + WCHAR *dir = alloc_dir_from_path(ofn->lpstrFile); + if (dir) + { + copy_wchar_to_unix_path(params.initial_dir_utf8, + sizeof(params.initial_dir_utf8), dir); + free(dir); + } + } + } + + if (!params.initial_dir_utf8[0] && ofn->lpstrInitialDir && *ofn->lpstrInitialDir) + copy_wchar_to_unix_path(params.initial_dir_utf8, + sizeof(params.initial_dir_utf8), ofn->lpstrInitialDir); + + build_filters_blob_utf8(params.filters_blob, sizeof(params.filters_blob), + ofn->lpstrFilter, ofn->lpstrCustomFilter, + ¶ms.filter_count, ¶ms.filters_blob_len); + params.current_filter_index = 0; + if (params.filter_count) + { + if (ofn->nFilterIndex >= 1 && ofn->nFilterIndex <= params.filter_count) + params.current_filter_index = ofn->nFilterIndex; + else + params.current_filter_index = 1; + } + params.flags = ofn->Flags; + + TRACE("Calling unix_portal_save_file...\n"); + status = call_unix_portal(unix_portal_save_file, ¶ms); + TRACE("Portal returned status: 0x%08lx\n", (unsigned long)status); + + if (status == STATUS_BUFFER_TOO_SMALL) + { + WORD size = (params.result_path_len + 1 > 0xffffu) ? 0xffffu : (WORD)(params.result_path_len + 1); + TRACE("Portal returned STATUS_BUFFER_TOO_SMALL (needed %u WCHARs)\n", params.result_path_len + 1); + if (ofn->lpstrFile) *(WORD *)ofn->lpstrFile = size; + COMDLG32_SetCommDlgExtendedError(FNERR_BUFFERTOOSMALL); + return FALSE; + } + else if (status == STATUS_SUCCESS && params.result_path[0]) + { + TRACE("Portal SUCCESS with result!\n"); + /* Copy result to output buffer */ + if (ofn->lpstrFile && lstrlenW(params.result_path) + 1 <= ofn->nMaxFile) + { + lstrcpyW(ofn->lpstrFile, params.result_path); + TRACE("Returning TRUE from portal save path\n"); + ret = TRUE; + } + else + { + WORD size = (lstrlenW(params.result_path) + 1 > 0xffffu) ? 0xffffu : (WORD)(lstrlenW(params.result_path) + 1); + TRACE("Buffer too small for portal save result\n"); + if (ofn->lpstrFile) *(WORD *)ofn->lpstrFile = size; + COMDLG32_SetCommDlgExtendedError(FNERR_BUFFERTOOSMALL); + return FALSE; + } + } + else if (status == STATUS_CANCELLED) + { + TRACE("Portal was cancelled, returning FALSE\n"); + } + else + { + TRACE("Portal failed or not supported, falling back to Wine dialog\n"); + ret = -1; /* Indicate fallback */ + } + + if (ret != -1) return ret; + } + + TRACE("Using fallback Wine dialog for Save\n"); if (is_win16_looks(ofn->Flags)) return GetFileName31W(ofn, SAVE_DIALOG); else diff --git a/dlls/comdlg32/portal_dbus.c b/dlls/comdlg32/portal_dbus.c new file mode 100644 index 00000000000..e14a5a41e9a --- /dev/null +++ b/dlls/comdlg32/portal_dbus.c @@ -0,0 +1,1172 @@ +/* + * XDG Desktop Portal File Chooser D-Bus integration + * + * Copyright 2026 Wine Project + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#if 0 +#pragma makedep unix +#endif + +#include "config.h" +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <time.h> +#include <dlfcn.h> +#include <dbus/dbus.h> + +#define WIN32_NO_STATUS +#include "windef.h" +#include "winternl.h" +#undef WIN32_NO_STATUS +#include "ntstatus.h" +#include "wine/debug.h" +#include "unixlib.h" + +WINE_DEFAULT_DEBUG_CHANNEL(comdlg32); + +/* We dlopen libdbus at runtime, so don't hard-require the development package. + * When configure can't determine the SONAME (e.g. missing libdbus-devel for + * 32-bit builds), fall back to the common Linux SONAME. + */ +#ifndef SONAME_LIBDBUS_1 +#define SONAME_LIBDBUS_1 "libdbus-1.so.3" +#endif + +/* D-Bus function pointers */ +#define DBUS_FUNCS \ + DO_FUNC(dbus_bus_add_match); \ + DO_FUNC(dbus_bus_remove_match); \ + DO_FUNC(dbus_bus_get); \ + DO_FUNC(dbus_connection_add_filter); \ + DO_FUNC(dbus_connection_remove_filter); \ + DO_FUNC(dbus_connection_read_write_dispatch); \ + DO_FUNC(dbus_connection_send_with_reply_and_block); \ + DO_FUNC(dbus_connection_unref); \ + DO_FUNC(dbus_error_free); \ + DO_FUNC(dbus_error_init); \ + DO_FUNC(dbus_error_is_set); \ + DO_FUNC(dbus_message_get_args); \ + DO_FUNC(dbus_message_get_interface); \ + DO_FUNC(dbus_message_get_member); \ + DO_FUNC(dbus_message_get_path); \ + DO_FUNC(dbus_message_get_type); \ + DO_FUNC(dbus_message_is_signal); \ + DO_FUNC(dbus_message_iter_append_basic); \ + DO_FUNC(dbus_message_iter_close_container); \ + DO_FUNC(dbus_message_iter_get_arg_type); \ + DO_FUNC(dbus_message_iter_get_basic); \ + DO_FUNC(dbus_message_iter_get_fixed_array); \ + DO_FUNC(dbus_message_iter_init); \ + DO_FUNC(dbus_message_iter_init_append); \ + DO_FUNC(dbus_message_iter_next); \ + DO_FUNC(dbus_message_iter_open_container); \ + DO_FUNC(dbus_message_iter_recurse); \ + DO_FUNC(dbus_message_new_method_call); \ + DO_FUNC(dbus_message_iter_append_fixed_array); \ + DO_FUNC(dbus_message_unref); + +#define DO_FUNC(f) static typeof(f) * p_##f +DBUS_FUNCS; +#undef DO_FUNC + +static BOOL load_dbus_functions(void) +{ + void *handle; + + handle = dlopen(SONAME_LIBDBUS_1, RTLD_NOW); + if (!handle) + { + WARN("Failed to load %s: %s\n", SONAME_LIBDBUS_1, dlerror()); + return FALSE; + } + +#define DO_FUNC(f) \ + if (!(p_##f = dlsym(handle, #f))) \ + { \ + WARN("Failed to load symbol %s: %s\n", #f, dlerror()); \ + return FALSE; \ + } + DBUS_FUNCS; +#undef DO_FUNC + + return TRUE; +} + +/* Portal context for tracking async request */ +struct portal_context +{ + DBusConnection *connection; + char *request_path; /* Portal request object path */ + BOOL filter_added; + BOOL response_received; + UINT response_code; /* 0=success, 1=cancelled, 2=error */ + char **result_uris; /* file:// URIs from portal */ + UINT result_uri_count; +}; + +/* Helper: Split pattern string by semicolons (e.g., "*.txt;*.doc" -> ["*.txt", "*.doc"]) */ +static char **split_pattern(const char *pattern, UINT *count) +{ + char *copy, *token, *saveptr; + char **result = NULL; + UINT capacity = 4, size = 0; + + *count = 0; + if (!pattern || !*pattern) return NULL; + + copy = strdup(pattern); + result = malloc(capacity * sizeof(char*)); + + token = strtok_r(copy, ";", &saveptr); + while (token) + { + /* Trim spaces */ + while (*token == ' ') token++; + + if (*token) + { + if (size >= capacity) + { + capacity *= 2; + result = realloc(result, capacity * sizeof(char*)); + } + result[size++] = strdup(token); + } + token = strtok_r(NULL, ";", &saveptr); + } + + free(copy); + *count = size; + return result; +} + +/* Helper: Append a single filter to D-Bus message */ +static void append_single_filter(DBusMessageIter *filters_array, const char *name, const char *pattern) +{ + DBusMessageIter filter_struct, patterns_array, pattern_struct; + char **patterns; + UINT pattern_count, i; + dbus_uint32_t type = 0; /* 0 = glob pattern */ + + /* Open filter struct: (sa(us)) */ + p_dbus_message_iter_open_container(filters_array, DBUS_TYPE_STRUCT, NULL, &filter_struct); + + /* Append filter name */ + p_dbus_message_iter_append_basic(&filter_struct, DBUS_TYPE_STRING, &name); + + /* Open patterns array: a(us) */ + p_dbus_message_iter_open_container(&filter_struct, DBUS_TYPE_ARRAY, "(us)", &patterns_array); + + /* Split pattern by semicolons */ + patterns = split_pattern(pattern, &pattern_count); + if (patterns) + { + for (i = 0; i < pattern_count; i++) + { + /* Open pattern struct: (us) */ + p_dbus_message_iter_open_container(&patterns_array, DBUS_TYPE_STRUCT, NULL, &pattern_struct); + p_dbus_message_iter_append_basic(&pattern_struct, DBUS_TYPE_UINT32, &type); + p_dbus_message_iter_append_basic(&pattern_struct, DBUS_TYPE_STRING, &patterns[i]); + p_dbus_message_iter_close_container(&patterns_array, &pattern_struct); + + free(patterns[i]); + } + free(patterns); + } + + p_dbus_message_iter_close_container(&filter_struct, &patterns_array); + p_dbus_message_iter_close_container(filters_array, &filter_struct); +} + +/* Build filter array option for D-Bus: a(sa(us)) */ +static BOOL get_next_filter_pair(const char **cursor, const char *end, + const char **name, const char **pattern) +{ + const char *p = *cursor; + const char *q; + + if (!p || p >= end || !*p) return FALSE; + + /* name */ + q = p; + while (q < end && *q) q++; + if (q >= end) return FALSE; + *name = p; + p = q + 1; + + if (p >= end || !*p) return FALSE; + + /* pattern */ + q = p; + while (q < end && *q) q++; + if (q >= end) return FALSE; + *pattern = p; + p = q + 1; + + *cursor = p; + return TRUE; +} + +static void append_current_filter_option(DBusMessageIter *options_dict, const char *name, const char *pattern) +{ + DBusMessageIter entry, variant, filter_struct, patterns_array, pattern_struct; + const char *key = "current_filter"; + char **patterns; + UINT pattern_count, i; + dbus_uint32_t type = 0; /* 0 = glob pattern */ + + if (!name || !pattern) return; + + /* Open dict entry: {sv} */ + p_dbus_message_iter_open_container(options_dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + p_dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + + /* Open variant containing (sa(us)) */ + p_dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "(sa(us))", &variant); + + /* Open filter struct: (sa(us)) */ + p_dbus_message_iter_open_container(&variant, DBUS_TYPE_STRUCT, NULL, &filter_struct); + p_dbus_message_iter_append_basic(&filter_struct, DBUS_TYPE_STRING, &name); + + p_dbus_message_iter_open_container(&filter_struct, DBUS_TYPE_ARRAY, "(us)", &patterns_array); + patterns = split_pattern(pattern, &pattern_count); + if (patterns) + { + for (i = 0; i < pattern_count; i++) + { + p_dbus_message_iter_open_container(&patterns_array, DBUS_TYPE_STRUCT, NULL, &pattern_struct); + p_dbus_message_iter_append_basic(&pattern_struct, DBUS_TYPE_UINT32, &type); + p_dbus_message_iter_append_basic(&pattern_struct, DBUS_TYPE_STRING, &patterns[i]); + p_dbus_message_iter_close_container(&patterns_array, &pattern_struct); + free(patterns[i]); + } + free(patterns); + } + + p_dbus_message_iter_close_container(&filter_struct, &patterns_array); + p_dbus_message_iter_close_container(&variant, &filter_struct); + p_dbus_message_iter_close_container(&entry, &variant); + p_dbus_message_iter_close_container(options_dict, &entry); +} + +static void append_filters_option(DBusMessageIter *options_dict, const char *filters_blob, + UINT filters_len, UINT filter_count, UINT current_filter_index) +{ + DBusMessageIter entry, variant, filters_array; + const char *key = "filters"; + const char *cursor, *end; + const char *name = NULL, *pattern = NULL; + const char *sel_name = NULL, *sel_pattern = NULL; + UINT i; + + if (!filters_blob || !filters_len || !filter_count) return; + + /* Open dict entry: {sv} */ + p_dbus_message_iter_open_container(options_dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + p_dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + + /* Open variant containing a(sa(us)) */ + p_dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "a(sa(us))", &variant); + p_dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, "(sa(us))", &filters_array); + + cursor = filters_blob; + end = filters_blob + filters_len; + + /* Add each filter pair (name, pattern) */ + for (i = 1; i <= filter_count; i++) + { + if (!get_next_filter_pair(&cursor, end, &name, &pattern)) + break; + + append_single_filter(&filters_array, name ? name : "", pattern ? pattern : ""); + + if (current_filter_index && i == current_filter_index) + { + sel_name = name; + sel_pattern = pattern; + } + } + + p_dbus_message_iter_close_container(&variant, &filters_array); + p_dbus_message_iter_close_container(&entry, &variant); + p_dbus_message_iter_close_container(options_dict, &entry); + + if (sel_name && sel_pattern) + append_current_filter_option(options_dict, sel_name, sel_pattern); +} + +/* Append boolean option to options dictionary */ +static void append_boolean_option(DBusMessageIter *options_dict, const char *key, dbus_bool_t value) +{ + DBusMessageIter entry, variant; + + p_dbus_message_iter_open_container(options_dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + p_dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + p_dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "b", &variant); + p_dbus_message_iter_append_basic(&variant, DBUS_TYPE_BOOLEAN, &value); + p_dbus_message_iter_close_container(&entry, &variant); + p_dbus_message_iter_close_container(options_dict, &entry); +} + +/* Append string option to options dictionary */ +static void append_string_option(DBusMessageIter *options_dict, const char *key, const char *value) +{ + DBusMessageIter entry, variant; + + if (!value) return; + + p_dbus_message_iter_open_container(options_dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + p_dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + p_dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant); + p_dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &value); + p_dbus_message_iter_close_container(&entry, &variant); + p_dbus_message_iter_close_container(options_dict, &entry); +} + +/* Signal filter to capture Response from portal */ +static DBusHandlerResult portal_response_filter(DBusConnection *conn, DBusMessage *msg, void *user_data) +{ + struct portal_context *ctx = user_data; + const char *path, *interface, *member; + DBusMessageIter args, dict, entry, variant, array; + dbus_uint32_t response; + const char *key; + + if (p_dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + interface = p_dbus_message_get_interface(msg); + member = p_dbus_message_get_member(msg); + path = p_dbus_message_get_path(msg); + + if (!interface || !member || !path) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + /* Check if this is a Response signal on org.freedesktop.portal.Request */ + if (strcmp(interface, "org.freedesktop.portal.Request") != 0 || + strcmp(member, "Response") != 0) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + /* Check if this is our request */ + if (!ctx->request_path || strcmp(path, ctx->request_path) != 0) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + TRACE("portal_response_filter: Received Response signal for %s\n", path); + + /* Parse response: (uint32 response_code, a{sv} results) */ + if (!p_dbus_message_iter_init(msg, &args)) + { + WARN("Failed to init message iterator\n"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + /* Get response code */ + if (p_dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_UINT32) + { + WARN("Expected UINT32 for response code\n"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + p_dbus_message_iter_get_basic(&args, &response); + ctx->response_code = response; + + TRACE("portal_response_filter: Response code: %u\n", response); + + /* If success, parse results dict */ + if (response == 0 && p_dbus_message_iter_next(&args)) + { + if (p_dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY) + { + WARN("Expected ARRAY for results dict\n"); + goto done; + } + + p_dbus_message_iter_recurse(&args, &dict); + + /* Iterate over dict entries looking for result URIs */ + while (p_dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) + { + p_dbus_message_iter_recurse(&dict, &entry); + + if (p_dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) + { + p_dbus_message_iter_next(&dict); + continue; + } + + p_dbus_message_iter_get_basic(&entry, &key); + + TRACE("portal_response_filter: key=%s\n", key); + + if (strcmp(key, "uris") == 0) + { + DBusMessageIter count_iter; + UINT i; + + /* Get variant containing array of strings */ + if (!p_dbus_message_iter_next(&entry)) + break; + + if (p_dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) + break; + + p_dbus_message_iter_recurse(&entry, &variant); + + TRACE("portal_response_filter: uris variant type=%c\n", + p_dbus_message_iter_get_arg_type(&variant)); + + if (p_dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_ARRAY) + { + int elem_type; + + p_dbus_message_iter_recurse(&variant, &array); + elem_type = p_dbus_message_iter_get_arg_type(&array); + + TRACE("portal_response_filter: uris array elem type=%c\n", elem_type); + + if (elem_type == DBUS_TYPE_STRING || elem_type == DBUS_TYPE_OBJECT_PATH) + { + /* Count URIs first */ + count_iter = array; + ctx->result_uri_count = 0; + while (p_dbus_message_iter_get_arg_type(&count_iter) == elem_type) + { + ctx->result_uri_count++; + p_dbus_message_iter_next(&count_iter); + } + + TRACE("portal_response_filter: Found %u URIs\n", ctx->result_uri_count); + + /* Allocate and copy URIs */ + if (ctx->result_uri_count > 0) + { + ctx->result_uris = calloc(ctx->result_uri_count + 1, sizeof(char*)); + for (i = 0; i < ctx->result_uri_count; i++) + { + const char *uri; + p_dbus_message_iter_get_basic(&array, &uri); + ctx->result_uris[i] = strdup(uri); + TRACE("portal_response_filter: URI[%u]: %s\n", i, uri); + p_dbus_message_iter_next(&array); + } + } + break; + } + else if (elem_type == DBUS_TYPE_BYTE) + { + const unsigned char *bytes = NULL; + int len = 0; + + p_dbus_message_iter_get_fixed_array(&array, &bytes, &len); + if (bytes && len > 0) + { + ctx->result_uri_count = 1; + ctx->result_uris = calloc(2, sizeof(char*)); + if (ctx->result_uris) + ctx->result_uris[0] = strndup((const char*)bytes, len); + } + break; + } + } + else if (p_dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_STRING || + p_dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_OBJECT_PATH) + { + const char *uri = NULL; + p_dbus_message_iter_get_basic(&variant, &uri); + if (uri && *uri) + { + ctx->result_uri_count = 1; + ctx->result_uris = calloc(2, sizeof(char*)); + if (ctx->result_uris) + ctx->result_uris[0] = strdup(uri); + } + break; + } + } + else if (strcmp(key, "uri") == 0 || strcmp(key, "current_file") == 0) + { + const char *uri = NULL; + + /* Get variant containing a single string */ + if (!p_dbus_message_iter_next(&entry)) + break; + + if (p_dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) + break; + + p_dbus_message_iter_recurse(&entry, &variant); + + TRACE("portal_response_filter: %s variant type=%c\n", + key, p_dbus_message_iter_get_arg_type(&variant)); + + if (p_dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_ARRAY) + { + const unsigned char *bytes = NULL; + int len = 0; + + p_dbus_message_iter_recurse(&variant, &array); + if (p_dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_BYTE) + { + p_dbus_message_iter_get_fixed_array(&array, &bytes, &len); + if (bytes && len > 0) + { + ctx->result_uri_count = 1; + ctx->result_uris = calloc(2, sizeof(char*)); + if (ctx->result_uris) + ctx->result_uris[0] = strndup((const char*)bytes, len); + } + } + break; + } + + if (p_dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_STRING) + break; + + p_dbus_message_iter_get_basic(&variant, &uri); + if (uri && *uri) + { + ctx->result_uri_count = 1; + ctx->result_uris = calloc(2, sizeof(char*)); + if (ctx->result_uris) + ctx->result_uris[0] = strdup(uri); + } + break; + } + else + { + /* Unknown key, skip it */ + } + + p_dbus_message_iter_next(&dict); + } + } + else if (response != 0) + { + TRACE("portal_response_filter: response code=%u (non-success)\n", response); + } + +done: + ctx->response_received = TRUE; + if (!ctx->result_uris || !ctx->result_uri_count) + TRACE("portal_response_filter: no result URIs found\n"); + return DBUS_HANDLER_RESULT_HANDLED; +} + +/* Initialize portal connection */ +static NTSTATUS portal_init(struct portal_context *ctx) +{ + DBusError error; + + memset(ctx, 0, sizeof(*ctx)); + + TRACE("portal_init: Loading D-Bus functions...\n"); + if (!load_dbus_functions()) + { + WARN("portal_init: Failed to load D-Bus functions\n"); + return STATUS_NOT_SUPPORTED; + } + + TRACE("portal_init: Connecting to session bus...\n"); + p_dbus_error_init(&error); + ctx->connection = p_dbus_bus_get(DBUS_BUS_SESSION, &error); + if (!ctx->connection) + { + WARN("portal_init: Failed to connect to session bus: %s\n", error.message); + p_dbus_error_free(&error); + return STATUS_NOT_SUPPORTED; + } + p_dbus_error_free(&error); + + TRACE("Successfully connected to D-Bus session bus\n"); + return STATUS_SUCCESS; +} + +/* Cleanup portal context */ +static void portal_cleanup(struct portal_context *ctx) +{ + UINT i; + char match_rule[512]; + DBusError error; + + if (ctx->request_path) + { + if (ctx->connection) + { + p_dbus_error_init(&error); + snprintf(match_rule, sizeof(match_rule), + "type='signal',interface='org.freedesktop.portal.Request',path='%s'", + ctx->request_path); + p_dbus_bus_remove_match(ctx->connection, match_rule, &error); + if (p_dbus_error_is_set(&error)) + { + WARN("portal_cleanup: bus_remove_match failed for '%s': %s (%s)\n", + match_rule, + error.message ? error.message : "(no message)", + error.name ? error.name : "(no name)"); + p_dbus_error_free(&error); + } + } + + free(ctx->request_path); + ctx->request_path = NULL; + } + + if (ctx->result_uris) + { + for (i = 0; i < ctx->result_uri_count; i++) + free(ctx->result_uris[i]); + free(ctx->result_uris); + ctx->result_uris = NULL; + } + + if (ctx->connection) + { + if (ctx->filter_added) + { + p_dbus_connection_remove_filter(ctx->connection, portal_response_filter, ctx); + ctx->filter_added = FALSE; + } + p_dbus_connection_unref(ctx->connection); + ctx->connection = NULL; + } +} + +/* Call portal method and wait for response */ +static NTSTATUS portal_call_and_wait(struct portal_context *ctx, + const char *method, + const char *title_utf8, + const char *initial_dir_utf8, + const char *initial_filename_utf8, + const char *current_file_unix, + const char *filters_blob, + UINT filters_len, + UINT filter_count, + UINT current_filter_index, + DWORD flags) +{ + DBusMessage *request, *reply; + DBusMessageIter args, options_dict; + DBusError error; + const char *parent_window = ""; + const char *request_handle; + char match_rule[512]; + char token[64]; + NTSTATUS status = STATUS_INTERNAL_ERROR; + static unsigned int token_seq; + + const char *title_ptr = title_utf8 ? title_utf8 : ""; + + TRACE("portal_call_and_wait: %s title=%s dir=%s file=%s\n", method, + title_ptr, + initial_dir_utf8 ? initial_dir_utf8 : "(null)", + initial_filename_utf8 ? initial_filename_utf8 : "(null)"); + + /* Build method call */ + request = p_dbus_message_new_method_call( + "org.freedesktop.portal.Desktop", + "/org/freedesktop/portal/desktop", + "org.freedesktop.portal.FileChooser", + method); + + if (!request) + { + WARN("portal_call_and_wait: dbus_message_new_method_call failed\n"); + return STATUS_NO_MEMORY; + } + + p_dbus_message_iter_init_append(request, &args); + p_dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &parent_window); + p_dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &title_ptr); + + /* Open Options Dictionary */ + p_dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "{sv}", &options_dict); + + /* 1. handle_token */ + snprintf(token, sizeof(token), "wine%u_%u", (UINT)getpid(), __sync_add_and_fetch(&token_seq, 1)); + append_string_option(&options_dict, "handle_token", token); + + /* 2. Open dialog mode flags */ + if (strcmp(method, "OpenFile") == 0) + { + if (flags & PORTAL_OPEN_FLAG_MULTIPLE) + append_boolean_option(&options_dict, "multiple", TRUE); + if (flags & PORTAL_OPEN_FLAG_DIRECTORY) + append_boolean_option(&options_dict, "directory", TRUE); + } + + /* 3. Directory (current_folder expects 'ay' - array of bytes) */ + if (initial_dir_utf8 && initial_dir_utf8[0]) + { + DBusMessageIter entry, variant, array; + const char *folder_key = "current_folder"; + int len = strlen(initial_dir_utf8) + 1; + const unsigned char *bytes = (const unsigned char *)initial_dir_utf8; + + p_dbus_message_iter_open_container(&options_dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + p_dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &folder_key); + p_dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "ay", &variant); + p_dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, "y", &array); + p_dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &bytes, len); + p_dbus_message_iter_close_container(&variant, &array); + p_dbus_message_iter_close_container(&entry, &variant); + p_dbus_message_iter_close_container(&options_dict, &entry); + } + + /* 4. Initial filename (Save dialog only) */ + if (initial_filename_utf8 && strcmp(method, "SaveFile") == 0) + { + /* Strip path if application passed one, portal just wants the name */ + const char *name_only = strrchr(initial_filename_utf8, '/'); + if (!name_only) name_only = strrchr(initial_filename_utf8, '\\'); + name_only = name_only ? name_only + 1 : initial_filename_utf8; + + /* Skip wildcard patterns like "*.txt" */ + if (name_only[0] && !strpbrk(name_only, "*?")) + { + append_string_option(&options_dict, "current_name", name_only); + } + } + + /* 5. Current file (Save dialog only) */ + if (current_file_unix && current_file_unix[0] && strcmp(method, "SaveFile") == 0) + { + DBusMessageIter entry, variant, array; + const char *file_key = "current_file"; + int len = strlen(current_file_unix) + 1; + const unsigned char *bytes = (const unsigned char *)current_file_unix; + + p_dbus_message_iter_open_container(&options_dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + p_dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &file_key); + p_dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "ay", &variant); + p_dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, "y", &array); + p_dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &bytes, len); + p_dbus_message_iter_close_container(&variant, &array); + p_dbus_message_iter_close_container(&entry, &variant); + p_dbus_message_iter_close_container(&options_dict, &entry); + } + + /* 6. Filters */ + if (filters_blob && filters_len && filter_count) + { + append_filters_option(&options_dict, filters_blob, filters_len, filter_count, current_filter_index); + } + + p_dbus_message_iter_close_container(&args, &options_dict); + + /* Send method call */ + p_dbus_error_init(&error); + /* Avoid a fixed timeout here: some portal backends may take longer than a few seconds + * to create the request object. If we time out, the dialog may still appear and we'd + * fall back to Wine's dialog, resulting in two dialogs. + */ + reply = p_dbus_connection_send_with_reply_and_block(ctx->connection, request, -1, &error); + p_dbus_message_unref(request); + + if (!reply) + { + WARN("Portal method call failed: %s (%s)\n", + error.message ? error.message : "(no message)", + error.name ? error.name : "(no name)"); + p_dbus_error_free(&error); + return STATUS_NOT_SUPPORTED; + } + if (!p_dbus_message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH, &request_handle, DBUS_TYPE_INVALID)) + { + WARN("portal_call_and_wait: dbus_message_get_args failed for request_handle\n"); + p_dbus_message_unref(reply); + return STATUS_INTERNAL_ERROR; + } + + if (ctx->request_path) free(ctx->request_path); + ctx->request_path = strdup(request_handle); + p_dbus_message_unref(reply); + + /* Signal filter setup */ + p_dbus_connection_add_filter(ctx->connection, portal_response_filter, ctx, NULL); + ctx->filter_added = TRUE; + + p_dbus_error_init(&error); + snprintf(match_rule, sizeof(match_rule), + "type='signal',interface='org.freedesktop.portal.Request',path='%s'", + ctx->request_path); + + p_dbus_bus_add_match(ctx->connection, match_rule, &error); + if (p_dbus_error_is_set(&error)) + { + WARN("portal_call_and_wait: bus_add_match failed for '%s': %s (%s)\n", + match_rule, + error.message ? error.message : "(no message)", + error.name ? error.name : "(no name)"); + p_dbus_error_free(&error); + return STATUS_INTERNAL_ERROR; + } + + /* Wait for response */ + ctx->response_received = FALSE; + + while (!ctx->response_received) + { + if (!p_dbus_connection_read_write_dispatch(ctx->connection, -1)) + { + WARN("portal_call_and_wait: read_write_dispatch failed\n"); + return STATUS_INTERNAL_ERROR; + } + } + + TRACE("portal_call_and_wait: response_received=%d response_code=%u\n", + ctx->response_received, ctx->response_code); + status = (ctx->response_code == 0) ? STATUS_SUCCESS : + (ctx->response_code == 1) ? STATUS_CANCELLED : STATUS_INTERNAL_ERROR; + return status; +} + +/* Convert file:// URI to Unix path, then to Win32 path */ +static NTSTATUS uri_to_win32_path(const char *uri, WCHAR **dos_path, BOOL allow_missing) +{ + const char *unix_path; + char *decoded_path; + WCHAR *result = NULL; + NTSTATUS status; + UINT disposition = allow_missing ? FILE_OPEN_IF : FILE_OPEN; + const char *p; + char *q; + + TRACE("uri_to_win32_path: Converting URI: %s\n", uri); + + /* Strip file:// prefix */ + if (strncmp(uri, "file://", 7) == 0) + unix_path = uri + 7; + else + unix_path = uri; + + TRACE("uri_to_win32_path: Unix path: %s\n", unix_path); + + /* URL-decode the path (handle %20 etc.) */ + decoded_path = malloc(strlen(unix_path) + 1); + if (!decoded_path) + return STATUS_NO_MEMORY; + + p = unix_path; + q = decoded_path; + + while (*p) + { + if (*p == '%' && p[1] && p[2]) + { + int value; + if (sscanf(p + 1, "%2x", &value) == 1) + { + *q++ = (char)value; + p += 3; + continue; + } + } + *q++ = *p++; + } + *q = '\0'; + + TRACE("uri_to_win32_path: Decoded path: %s\n", decoded_path); + + /* Convert Unix path to DOS path using Wine's proper conversion function */ + status = ntdll_get_dos_file_name(decoded_path, &result, disposition); + + TRACE("uri_to_win32_path: ntdll_get_dos_file_name returned: 0x%08x\n", status); + if (status == STATUS_SUCCESS && result) + { + TRACE("uri_to_win32_path: DOS path: %s\n", debugstr_w(result)); + } + + free(decoded_path); + + if (status != STATUS_SUCCESS) + { + if (allow_missing && status == STATUS_NO_SUCH_FILE && result) + { + TRACE("uri_to_win32_path: allowing STATUS_NO_SUCH_FILE for save, DOS path: %s\n", + debugstr_w(result)); + *dos_path = result; + return STATUS_SUCCESS; + } + if (result) free(result); + return status; + } + + *dos_path = result; + return STATUS_SUCCESS; +} + +static UINT split_dir_and_name(const WCHAR *path, WCHAR *dir, UINT dir_cap, const WCHAR **name_out) +{ + const WCHAR *slash; + UINT dir_len; + + if (name_out) *name_out = path; + if (!path || !*path) return 0; + + slash = wcsrchr(path, '\\'); + if (!slash) slash = wcsrchr(path, '/'); + if (!slash || slash == path) return 0; + + if (name_out) *name_out = slash + 1; + dir_len = (UINT)(slash - path); + if (dir && dir_cap) + { + if (dir_len >= dir_cap) dir_len = dir_cap - 1; + memcpy(dir, path, dir_len * sizeof(WCHAR)); + dir[dir_len] = 0; + } + return dir_len; +} + +/* Public entry point: OpenFile */ +NTSTATUS CDECL portal_open_file(void *args) +{ + struct portal_open_file_params *params = args; + struct portal_context ctx = {0}; + NTSTATUS status; + UINT i, count, out_count; + BOOL want_multi; + + TRACE("portal_open_file: flags=0x%08x max_results=%u\n", + (unsigned int)params->flags, params->max_results); + + status = portal_init(&ctx); + if (status != STATUS_SUCCESS) + return status; + + status = portal_call_and_wait(&ctx, "OpenFile", + params->title_utf8[0] ? params->title_utf8 : NULL, + params->initial_dir_utf8[0] ? params->initial_dir_utf8 : NULL, + NULL, + NULL, + params->filters_blob, + params->filters_blob_len, + params->filter_count, + params->current_filter_index, + params->flags); + TRACE("portal_open_file: portal_call_and_wait returned 0x%08x\n", (unsigned int)status); + + params->result_count = 0; + params->result_grouped = 0; + params->result_buffer_len = 0; + params->result_buffer[0] = 0; + + want_multi = (params->flags & PORTAL_OPEN_FLAG_MULTIPLE) != 0; + + if (status == STATUS_SUCCESS && ctx.result_uris && ctx.result_uri_count) + { + WCHAR **dos_paths = NULL; + WCHAR dir[PORTAL_PATH_MAX]; + const WCHAR *first_name = NULL; + UINT dir_len = 0; + UINT required = 0; + WCHAR *out = params->result_buffer; + UINT out_cap = ARRAY_SIZE(params->result_buffer); + UINT pos = 0; + BOOL same_dir = TRUE; + + count = ctx.result_uri_count; + if (params->max_results && params->max_results < count) count = params->max_results; + if (!count) goto open_done; + + dos_paths = calloc(count, sizeof(*dos_paths)); + if (!dos_paths) + { + status = STATUS_NO_MEMORY; + goto open_done; + } + + out_count = 0; + for (i = 0; i < count; i++) + { + if (uri_to_win32_path(ctx.result_uris[i], &dos_paths[out_count], FALSE) == STATUS_SUCCESS && dos_paths[out_count]) + out_count++; + } + if (!out_count) goto open_done; + + if (want_multi && out_count > 1) + { + dir_len = split_dir_and_name(dos_paths[0], dir, ARRAY_SIZE(dir), &first_name); + if (!dir_len || !first_name) same_dir = FALSE; + + if (same_dir) + { + for (i = 1; i < out_count; i++) + { + const WCHAR *name; + WCHAR other_dir[PORTAL_PATH_MAX]; + UINT other_len = split_dir_and_name(dos_paths[i], other_dir, ARRAY_SIZE(other_dir), &name); + if (other_len != dir_len || wcscmp(other_dir, dir) || !name) + { + same_dir = FALSE; + break; + } + } + } + } + + /* Compute required length in WCHARs, including final NUL(s). */ + if (!want_multi || out_count == 1) + { + required = (UINT)wcslen(dos_paths[0]) + 1; + if (want_multi) required += 1; /* extra NUL termination */ + } + else if (same_dir) + { + required = dir_len + 1; /* dir + NUL */ + for (i = 0; i < out_count; i++) + { + const WCHAR *name; + split_dir_and_name(dos_paths[i], NULL, 0, &name); + required += (UINT)wcslen(name) + 1; + } + required += 1; /* extra NUL */ + } + else + { + /* Fallback: pack full paths as NUL-separated strings. */ + required = 0; + for (i = 0; i < out_count; i++) required += (UINT)wcslen(dos_paths[i]) + 1; + required += 1; /* extra NUL */ + } + + params->result_count = out_count; + params->result_grouped = (want_multi && out_count > 1 && same_dir); + params->result_buffer_len = required; + + if (required > out_cap) + { + status = STATUS_BUFFER_TOO_SMALL; + goto open_done; + } + + /* Write packed result. */ + if (!want_multi || out_count == 1) + { + UINT len = (UINT)wcslen(dos_paths[0]); + memcpy(out, dos_paths[0], len * sizeof(WCHAR)); + pos = len; + out[pos++] = 0; + if (want_multi) out[pos++] = 0; + } + else if (same_dir) + { + memcpy(out + pos, dir, dir_len * sizeof(WCHAR)); + pos += dir_len; + out[pos++] = 0; + for (i = 0; i < out_count; i++) + { + const WCHAR *name; + UINT len; + split_dir_and_name(dos_paths[i], NULL, 0, &name); + len = (UINT)wcslen(name); + memcpy(out + pos, name, len * sizeof(WCHAR)); + pos += len; + out[pos++] = 0; + } + out[pos++] = 0; + } + else + { + for (i = 0; i < out_count; i++) + { + UINT len = (UINT)wcslen(dos_paths[i]); + memcpy(out + pos, dos_paths[i], len * sizeof(WCHAR)); + pos += len; + out[pos++] = 0; + } + out[pos++] = 0; + } + + status = STATUS_SUCCESS; + +open_done: + if (dos_paths) + { + for (i = 0; i < count; i++) free(dos_paths[i]); + free(dos_paths); + } + } + + portal_cleanup(&ctx); + return status; +} + +/* Public entry point: SaveFile */ +NTSTATUS CDECL portal_save_file(void *args) +{ + struct portal_save_file_params *params = args; + struct portal_context ctx = {0}; + NTSTATUS status; + + TRACE("portal_save_file: flags=0x%08x\n", (unsigned int)params->flags); + + status = portal_init(&ctx); + if (status != STATUS_SUCCESS) + return status; + + status = portal_call_and_wait(&ctx, "SaveFile", + params->title_utf8[0] ? params->title_utf8 : NULL, + params->initial_dir_utf8[0] ? params->initial_dir_utf8 : NULL, + params->initial_filename_utf8[0] ? params->initial_filename_utf8 : NULL, + params->current_file_unix[0] ? params->current_file_unix : NULL, + params->filters_blob, + params->filters_blob_len, + params->filter_count, + params->current_filter_index, + params->flags); + TRACE("portal_save_file: portal_call_and_wait returned 0x%08x\n", (unsigned int)status); + + if (status == STATUS_SUCCESS && ctx.result_uris && ctx.result_uris[0]) + { + WCHAR *dos_path = NULL; + if (uri_to_win32_path(ctx.result_uris[0], &dos_path, TRUE) == STATUS_SUCCESS) + { + UINT len = wcslen(dos_path); + if (len < PORTAL_PATH_MAX) + { + memcpy(params->result_path, dos_path, (len + 1) * sizeof(WCHAR)); + params->result_path_len = len; + } + else + { + params->result_path[0] = 0; + params->result_path_len = len; + status = STATUS_BUFFER_TOO_SMALL; + } + free(dos_path); + } + } + + portal_cleanup(&ctx); + return status; +} + +/* Public entry point: availability probe */ +NTSTATUS CDECL portal_is_available(void *args) +{ + struct portal_is_available_params *params = args; + struct portal_context ctx = {0}; + NTSTATUS status; + + if (params) params->reserved = 0; + status = portal_init(&ctx); + portal_cleanup(&ctx); + return status; +} diff --git a/dlls/comdlg32/unixlib.c b/dlls/comdlg32/unixlib.c new file mode 100644 index 00000000000..89ce9b37f3a --- /dev/null +++ b/dlls/comdlg32/unixlib.c @@ -0,0 +1,68 @@ +/* + * Unix library entry point for comdlg32 + * + * Copyright 2026 Wine Project + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#if 0 +#pragma makedep unix +#endif + +#include "config.h" + +#include <stdarg.h> + +#include "ntstatus.h" +#define WIN32_NO_STATUS +#include "windef.h" +#include "winbase.h" +#include "winternl.h" + +#include "unixlib.h" + +/* Forward declarations from portal_dbus.c */ +NTSTATUS CDECL portal_open_file(void *args); +NTSTATUS CDECL portal_save_file(void *args); +NTSTATUS CDECL portal_is_available(void *args); + +/****************************************************************************** + * Unix library entry points - function table approach + */ + +static NTSTATUS CDECL unix_portal_open_file_wrapper(void *args) +{ + return portal_open_file(args); +} + +static NTSTATUS CDECL unix_portal_save_file_wrapper(void *args) +{ + return portal_save_file(args); +} + +static NTSTATUS CDECL unix_portal_is_available_wrapper(void *args) +{ + return portal_is_available(args); +} + +const unixlib_entry_t __wine_unix_call_funcs[] = +{ + unix_portal_open_file_wrapper, + unix_portal_save_file_wrapper, + unix_portal_is_available_wrapper, +}; + +C_ASSERT( ARRAYSIZE(__wine_unix_call_funcs) == unix_portal_is_available + 1 ); diff --git a/dlls/comdlg32/unixlib.h b/dlls/comdlg32/unixlib.h new file mode 100644 index 00000000000..6ce10b74516 --- /dev/null +++ b/dlls/comdlg32/unixlib.h @@ -0,0 +1,61 @@ +#ifndef __WINE_COMDLG32_UNIXLIB_H +#define __WINE_COMDLG32_UNIXLIB_H + +#include "windef.h" +#include "winternl.h" +#include "wine/unixlib.h" + +#define PORTAL_STR_MAX 4096 +#define PORTAL_PATH_MAX 4096 +#define PORTAL_FILTERS_MAX 8192 +/* Packed OPENFILENAMEW multi-select results can be large. */ +#define PORTAL_RESULT_MAX 65536 + +/* Internal portal request flags carried in portal_open_file_params.flags. */ +#define PORTAL_OPEN_FLAG_MULTIPLE 0x00000001 +#define PORTAL_OPEN_FLAG_DIRECTORY 0x00000002 + +struct portal_open_file_params +{ + char title_utf8[PORTAL_STR_MAX]; + char initial_dir_utf8[PORTAL_PATH_MAX]; + char filters_blob[PORTAL_FILTERS_MAX]; + UINT filters_blob_len; + UINT filter_count; /* number of (name, pattern) pairs */ + UINT current_filter_index; /* 1-based index, 0 if unset */ + DWORD flags; + UINT max_results; + UINT result_count; /* 0 if none */ + UINT result_grouped; /* nonzero if buffer is dir + filenames */ + UINT result_buffer_len; /* WCHARs, including final NUL(s); may be required length on overflow */ + WCHAR result_buffer[PORTAL_RESULT_MAX]; /* Out: packed OPENFILENAMEW result */ +}; + +struct portal_save_file_params +{ + char title_utf8[PORTAL_STR_MAX]; + char initial_dir_utf8[PORTAL_PATH_MAX]; + char initial_filename_utf8[PORTAL_PATH_MAX]; + char current_file_unix[PORTAL_PATH_MAX]; + char filters_blob[PORTAL_FILTERS_MAX]; + UINT filters_blob_len; + UINT filter_count; /* number of (name, pattern) pairs */ + UINT current_filter_index; /* 1-based index, 0 if unset */ + DWORD flags; + WCHAR result_path[PORTAL_PATH_MAX]; /* Out: selected path */ + UINT result_path_len; /* characters, excluding NUL; 0 if none */ +}; + +struct portal_is_available_params +{ + UINT reserved; +}; + +enum comdlg32_unix_funcs +{ + unix_portal_open_file, + unix_portal_save_file, + unix_portal_is_available, +}; + +#endif /* __WINE_COMDLG32_UNIXLIB_H */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10060