1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include <dlfcn.h>
7 #include <gtk/gtk.h>
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <unistd.h>
11
12 #include "mozilla/Types.h"
13 #include "nsGtkUtils.h"
14 #include "nsIFileURL.h"
15 #include "nsIGIOService.h"
16 #include "nsIURI.h"
17 #include "nsIWidget.h"
18 #include "nsIFile.h"
19 #include "mozilla/Preferences.h"
20
21 #include "nsArrayEnumerator.h"
22 #include "nsMemory.h"
23 #include "nsEnumeratorUtils.h"
24 #include "nsNetUtil.h"
25 #include "nsReadableUtils.h"
26 #include "MozContainer.h"
27 #include "WidgetUtilsGtk.h"
28
29 #include "nsFilePicker.h"
30
31 #undef LOG
32 #ifdef MOZ_LOGGING
33 # include "mozilla/Logging.h"
34 # include "nsTArray.h"
35 # include "Units.h"
36 extern mozilla::LazyLogModule gWidgetLog;
37 # define LOG(args) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, args)
38 #else
39 # define LOG(args)
40 #endif /* MOZ_LOGGING */
41
42 using namespace mozilla;
43
44 #define MAX_PREVIEW_SIZE 180
45 // bug 1184009
46 #define MAX_PREVIEW_SOURCE_SIZE 4096
47
48 nsIFile* nsFilePicker::mPrevDisplayDirectory = nullptr;
49
Shutdown()50 void nsFilePicker::Shutdown() { NS_IF_RELEASE(mPrevDisplayDirectory); }
51
GetGtkFileChooserAction(int16_t aMode)52 static GtkFileChooserAction GetGtkFileChooserAction(int16_t aMode) {
53 GtkFileChooserAction action;
54
55 switch (aMode) {
56 case nsIFilePicker::modeSave:
57 action = GTK_FILE_CHOOSER_ACTION_SAVE;
58 break;
59
60 case nsIFilePicker::modeGetFolder:
61 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
62 break;
63
64 case nsIFilePicker::modeOpen:
65 case nsIFilePicker::modeOpenMultiple:
66 action = GTK_FILE_CHOOSER_ACTION_OPEN;
67 break;
68
69 default:
70 NS_WARNING("Unknown nsIFilePicker mode");
71 action = GTK_FILE_CHOOSER_ACTION_OPEN;
72 break;
73 }
74
75 return action;
76 }
77
UpdateFilePreviewWidget(GtkFileChooser * file_chooser,gpointer preview_widget_voidptr)78 static void UpdateFilePreviewWidget(GtkFileChooser* file_chooser,
79 gpointer preview_widget_voidptr) {
80 GtkImage* preview_widget = GTK_IMAGE(preview_widget_voidptr);
81 char* image_filename = gtk_file_chooser_get_preview_filename(file_chooser);
82 struct stat st_buf;
83
84 if (!image_filename) {
85 gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
86 return;
87 }
88
89 gint preview_width = 0;
90 gint preview_height = 0;
91 /* check type of file
92 * if file is named pipe, Open is blocking which may lead to UI
93 * nonresponsiveness; if file is directory/socket, it also isn't
94 * likely to get preview */
95 if (stat(image_filename, &st_buf) || (!S_ISREG(st_buf.st_mode))) {
96 g_free(image_filename);
97 gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
98 return; /* stat failed or file is not regular */
99 }
100
101 GdkPixbufFormat* preview_format =
102 gdk_pixbuf_get_file_info(image_filename, &preview_width, &preview_height);
103 if (!preview_format || preview_width <= 0 || preview_height <= 0 ||
104 preview_width > MAX_PREVIEW_SOURCE_SIZE ||
105 preview_height > MAX_PREVIEW_SOURCE_SIZE) {
106 g_free(image_filename);
107 gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
108 return;
109 }
110
111 GdkPixbuf* preview_pixbuf = nullptr;
112 // Only scale down images that are too big
113 if (preview_width > MAX_PREVIEW_SIZE || preview_height > MAX_PREVIEW_SIZE) {
114 preview_pixbuf = gdk_pixbuf_new_from_file_at_size(
115 image_filename, MAX_PREVIEW_SIZE, MAX_PREVIEW_SIZE, nullptr);
116 } else {
117 preview_pixbuf = gdk_pixbuf_new_from_file(image_filename, nullptr);
118 }
119
120 g_free(image_filename);
121
122 if (!preview_pixbuf) {
123 gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
124 return;
125 }
126
127 GdkPixbuf* preview_pixbuf_temp = preview_pixbuf;
128 preview_pixbuf = gdk_pixbuf_apply_embedded_orientation(preview_pixbuf_temp);
129 g_object_unref(preview_pixbuf_temp);
130
131 // This is the easiest way to do center alignment without worrying about
132 // containers Minimum 3px padding each side (hence the 6) just to make things
133 // nice
134 gint x_padding =
135 (MAX_PREVIEW_SIZE + 6 - gdk_pixbuf_get_width(preview_pixbuf)) / 2;
136 gtk_misc_set_padding(GTK_MISC(preview_widget), x_padding, 0);
137
138 gtk_image_set_from_pixbuf(preview_widget, preview_pixbuf);
139 g_object_unref(preview_pixbuf);
140 gtk_file_chooser_set_preview_widget_active(file_chooser, TRUE);
141 }
142
MakeCaseInsensitiveShellGlob(const char * aPattern)143 static nsAutoCString MakeCaseInsensitiveShellGlob(const char* aPattern) {
144 // aPattern is UTF8
145 nsAutoCString result;
146 unsigned int len = strlen(aPattern);
147
148 for (unsigned int i = 0; i < len; i++) {
149 if (!g_ascii_isalpha(aPattern[i])) {
150 // non-ASCII characters will also trigger this path, so unicode
151 // is safely handled albeit case-sensitively
152 result.Append(aPattern[i]);
153 continue;
154 }
155
156 // add the lowercase and uppercase version of a character to a bracket
157 // match, so it matches either the lowercase or uppercase char.
158 result.Append('[');
159 result.Append(g_ascii_tolower(aPattern[i]));
160 result.Append(g_ascii_toupper(aPattern[i]));
161 result.Append(']');
162 }
163
164 return result;
165 }
166
NS_IMPL_ISUPPORTS(nsFilePicker,nsIFilePicker)167 NS_IMPL_ISUPPORTS(nsFilePicker, nsIFilePicker)
168
169 nsFilePicker::nsFilePicker()
170 : mSelectedType(0),
171 mRunning(false),
172 mAllowURLs(false),
173 mFileChooserDelegate(nullptr) {
174 nsCOMPtr<nsIGIOService> giovfs = do_GetService(NS_GIOSERVICE_CONTRACTID);
175 // Due to Bug 1635718 always use portal for file dialog on Wayland.
176 if (widget::GdkIsWaylandDisplay()) {
177 mUseNativeFileChooser =
178 Preferences::GetBool("widget.use-xdg-desktop-portal", true);
179 } else {
180 giovfs->ShouldUseFlatpakPortal(&mUseNativeFileChooser);
181 }
182 }
183
184 nsFilePicker::~nsFilePicker() = default;
185
ReadMultipleFiles(gpointer filename,gpointer array)186 void ReadMultipleFiles(gpointer filename, gpointer array) {
187 nsCOMPtr<nsIFile> localfile;
188 nsresult rv =
189 NS_NewNativeLocalFile(nsDependentCString(static_cast<char*>(filename)),
190 false, getter_AddRefs(localfile));
191 if (NS_SUCCEEDED(rv)) {
192 nsCOMArray<nsIFile>& files = *static_cast<nsCOMArray<nsIFile>*>(array);
193 files.AppendObject(localfile);
194 }
195
196 g_free(filename);
197 }
198
ReadValuesFromFileChooser(void * file_chooser)199 void nsFilePicker::ReadValuesFromFileChooser(void* file_chooser) {
200 mFiles.Clear();
201
202 if (mMode == nsIFilePicker::modeOpenMultiple) {
203 mFileURL.Truncate();
204
205 GSList* list =
206 gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
207 g_slist_foreach(list, ReadMultipleFiles, static_cast<gpointer>(&mFiles));
208 g_slist_free(list);
209 } else {
210 gchar* filename = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(file_chooser));
211 mFileURL.Assign(filename);
212 g_free(filename);
213 }
214
215 GtkFileFilter* filter =
216 gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(file_chooser));
217 GSList* filter_list =
218 gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(file_chooser));
219
220 mSelectedType = static_cast<int16_t>(g_slist_index(filter_list, filter));
221 g_slist_free(filter_list);
222
223 // Remember last used directory.
224 nsCOMPtr<nsIFile> file;
225 GetFile(getter_AddRefs(file));
226 if (file) {
227 nsCOMPtr<nsIFile> dir;
228 file->GetParent(getter_AddRefs(dir));
229 if (dir) {
230 dir.swap(mPrevDisplayDirectory);
231 }
232 }
233 }
234
InitNative(nsIWidget * aParent,const nsAString & aTitle)235 void nsFilePicker::InitNative(nsIWidget* aParent, const nsAString& aTitle) {
236 mParentWidget = aParent;
237 mTitle.Assign(aTitle);
238 }
239
240 NS_IMETHODIMP
AppendFilters(int32_t aFilterMask)241 nsFilePicker::AppendFilters(int32_t aFilterMask) {
242 mAllowURLs = !!(aFilterMask & filterAllowURLs);
243 return nsBaseFilePicker::AppendFilters(aFilterMask);
244 }
245
246 NS_IMETHODIMP
AppendFilter(const nsAString & aTitle,const nsAString & aFilter)247 nsFilePicker::AppendFilter(const nsAString& aTitle, const nsAString& aFilter) {
248 if (aFilter.EqualsLiteral("..apps")) {
249 // No platform specific thing we can do here, really....
250 return NS_OK;
251 }
252
253 nsAutoCString filter, name;
254 CopyUTF16toUTF8(aFilter, filter);
255 CopyUTF16toUTF8(aTitle, name);
256
257 mFilters.AppendElement(filter);
258 mFilterNames.AppendElement(name);
259
260 return NS_OK;
261 }
262
263 NS_IMETHODIMP
SetDefaultString(const nsAString & aString)264 nsFilePicker::SetDefaultString(const nsAString& aString) {
265 mDefault = aString;
266
267 return NS_OK;
268 }
269
270 NS_IMETHODIMP
GetDefaultString(nsAString & aString)271 nsFilePicker::GetDefaultString(nsAString& aString) {
272 // Per API...
273 return NS_ERROR_FAILURE;
274 }
275
276 NS_IMETHODIMP
SetDefaultExtension(const nsAString & aExtension)277 nsFilePicker::SetDefaultExtension(const nsAString& aExtension) {
278 mDefaultExtension = aExtension;
279
280 return NS_OK;
281 }
282
283 NS_IMETHODIMP
GetDefaultExtension(nsAString & aExtension)284 nsFilePicker::GetDefaultExtension(nsAString& aExtension) {
285 aExtension = mDefaultExtension;
286
287 return NS_OK;
288 }
289
290 NS_IMETHODIMP
GetFilterIndex(int32_t * aFilterIndex)291 nsFilePicker::GetFilterIndex(int32_t* aFilterIndex) {
292 *aFilterIndex = mSelectedType;
293
294 return NS_OK;
295 }
296
297 NS_IMETHODIMP
SetFilterIndex(int32_t aFilterIndex)298 nsFilePicker::SetFilterIndex(int32_t aFilterIndex) {
299 mSelectedType = aFilterIndex;
300
301 return NS_OK;
302 }
303
304 NS_IMETHODIMP
GetFile(nsIFile ** aFile)305 nsFilePicker::GetFile(nsIFile** aFile) {
306 NS_ENSURE_ARG_POINTER(aFile);
307
308 *aFile = nullptr;
309 nsCOMPtr<nsIURI> uri;
310 nsresult rv = GetFileURL(getter_AddRefs(uri));
311 if (!uri) return rv;
312
313 nsCOMPtr<nsIFileURL> fileURL(do_QueryInterface(uri, &rv));
314 NS_ENSURE_SUCCESS(rv, rv);
315
316 nsCOMPtr<nsIFile> file;
317 rv = fileURL->GetFile(getter_AddRefs(file));
318 NS_ENSURE_SUCCESS(rv, rv);
319
320 file.forget(aFile);
321 return NS_OK;
322 }
323
324 NS_IMETHODIMP
GetFileURL(nsIURI ** aFileURL)325 nsFilePicker::GetFileURL(nsIURI** aFileURL) {
326 *aFileURL = nullptr;
327 return NS_NewURI(aFileURL, mFileURL);
328 }
329
330 NS_IMETHODIMP
GetFiles(nsISimpleEnumerator ** aFiles)331 nsFilePicker::GetFiles(nsISimpleEnumerator** aFiles) {
332 NS_ENSURE_ARG_POINTER(aFiles);
333
334 if (mMode == nsIFilePicker::modeOpenMultiple) {
335 return NS_NewArrayEnumerator(aFiles, mFiles, NS_GET_IID(nsIFile));
336 }
337
338 return NS_ERROR_FAILURE;
339 }
340
Show(int16_t * aReturn)341 nsresult nsFilePicker::Show(int16_t* aReturn) {
342 NS_ENSURE_ARG_POINTER(aReturn);
343
344 nsresult rv = Open(nullptr);
345 if (NS_FAILED(rv)) return rv;
346
347 while (mRunning) {
348 g_main_context_iteration(nullptr, TRUE);
349 }
350
351 *aReturn = mResult;
352 return NS_OK;
353 }
354
355 NS_IMETHODIMP
Open(nsIFilePickerShownCallback * aCallback)356 nsFilePicker::Open(nsIFilePickerShownCallback* aCallback) {
357 // Can't show two dialogs concurrently with the same filepicker
358 if (mRunning) return NS_ERROR_NOT_AVAILABLE;
359
360 NS_ConvertUTF16toUTF8 title(mTitle);
361
362 GtkWindow* parent_widget =
363 GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET));
364
365 GtkFileChooserAction action = GetGtkFileChooserAction(mMode);
366
367 const gchar* accept_button;
368 NS_ConvertUTF16toUTF8 buttonLabel(mOkButtonLabel);
369 if (!mOkButtonLabel.IsEmpty()) {
370 accept_button = buttonLabel.get();
371 } else {
372 accept_button = nullptr;
373 }
374
375 void* file_chooser =
376 GtkFileChooserNew(title.get(), parent_widget, action, accept_button);
377
378 // If we have --enable-proxy-bypass-protection, then don't allow
379 // remote URLs to be used.
380 #ifndef MOZ_PROXY_BYPASS_PROTECTION
381 if (mAllowURLs) {
382 gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser), FALSE);
383 }
384 #endif
385
386 if (action == GTK_FILE_CHOOSER_ACTION_OPEN ||
387 action == GTK_FILE_CHOOSER_ACTION_SAVE) {
388 GtkWidget* img_preview = gtk_image_new();
389 gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(file_chooser),
390 img_preview);
391 g_signal_connect(file_chooser, "update-preview",
392 G_CALLBACK(UpdateFilePreviewWidget), img_preview);
393 }
394
395 GtkFileChooserSetModal(file_chooser, parent_widget, TRUE);
396
397 NS_ConvertUTF16toUTF8 defaultName(mDefault);
398 switch (mMode) {
399 case nsIFilePicker::modeOpenMultiple:
400 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser),
401 TRUE);
402 break;
403 case nsIFilePicker::modeSave:
404 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser),
405 defaultName.get());
406 break;
407 }
408
409 nsCOMPtr<nsIFile> defaultPath;
410 if (mDisplayDirectory) {
411 mDisplayDirectory->Clone(getter_AddRefs(defaultPath));
412 } else if (mPrevDisplayDirectory) {
413 mPrevDisplayDirectory->Clone(getter_AddRefs(defaultPath));
414 }
415
416 if (defaultPath) {
417 if (!defaultName.IsEmpty() && mMode != nsIFilePicker::modeSave) {
418 // Try to select the intended file. Even if it doesn't exist, GTK still
419 // switches directories.
420 defaultPath->AppendNative(defaultName);
421 nsAutoCString path;
422 defaultPath->GetNativePath(path);
423 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser), path.get());
424 } else {
425 nsAutoCString directory;
426 defaultPath->GetNativePath(directory);
427
428 // Workaround for problematic refcounting in GTK3 before 3.16.
429 // We need to keep a reference to the dialog's internal delegate.
430 // Otherwise, if our dialog gets destroyed, we'll lose the dialog's
431 // delegate by the time this gets processed in the event loop.
432 // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1166741
433 if (GTK_IS_DIALOG(file_chooser)) {
434 GtkDialog* dialog = GTK_DIALOG(file_chooser);
435 GtkContainer* area = GTK_CONTAINER(gtk_dialog_get_content_area(dialog));
436 gtk_container_forall(
437 area,
438 [](GtkWidget* widget, gpointer data) {
439 if (GTK_IS_FILE_CHOOSER_WIDGET(widget)) {
440 auto result = static_cast<GtkFileChooserWidget**>(data);
441 *result = GTK_FILE_CHOOSER_WIDGET(widget);
442 }
443 },
444 &mFileChooserDelegate);
445
446 if (mFileChooserDelegate != nullptr) {
447 g_object_ref(mFileChooserDelegate);
448 }
449 }
450 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser),
451 directory.get());
452 }
453 }
454
455 if (GTK_IS_DIALOG(file_chooser)) {
456 gtk_dialog_set_default_response(GTK_DIALOG(file_chooser),
457 GTK_RESPONSE_ACCEPT);
458 }
459
460 int32_t count = mFilters.Length();
461 for (int32_t i = 0; i < count; ++i) {
462 // This is fun... the GTK file picker does not accept a list of filters
463 // so we need to split out each string, and add it manually.
464
465 char** patterns = g_strsplit(mFilters[i].get(), ";", -1);
466 if (!patterns) {
467 return NS_ERROR_OUT_OF_MEMORY;
468 }
469
470 GtkFileFilter* filter = gtk_file_filter_new();
471 for (int j = 0; patterns[j] != nullptr; ++j) {
472 nsAutoCString caseInsensitiveFilter =
473 MakeCaseInsensitiveShellGlob(g_strstrip(patterns[j]));
474 gtk_file_filter_add_pattern(filter, caseInsensitiveFilter.get());
475 }
476
477 g_strfreev(patterns);
478
479 if (!mFilterNames[i].IsEmpty()) {
480 // If we have a name for our filter, let's use that.
481 const char* filter_name = mFilterNames[i].get();
482 gtk_file_filter_set_name(filter, filter_name);
483 } else {
484 // If we don't have a name, let's just use the filter pattern.
485 const char* filter_pattern = mFilters[i].get();
486 gtk_file_filter_set_name(filter, filter_pattern);
487 }
488
489 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
490
491 // Set the initially selected filter
492 if (mSelectedType == i) {
493 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter);
494 }
495 }
496
497 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser),
498 TRUE);
499
500 mRunning = true;
501 mCallback = aCallback;
502 NS_ADDREF_THIS();
503 g_signal_connect(file_chooser, "response", G_CALLBACK(OnResponse), this);
504 GtkFileChooserShow(file_chooser);
505
506 return NS_OK;
507 }
508
509 /* static */
OnResponse(void * file_chooser,gint response_id,gpointer user_data)510 void nsFilePicker::OnResponse(void* file_chooser, gint response_id,
511 gpointer user_data) {
512 static_cast<nsFilePicker*>(user_data)->Done(file_chooser, response_id);
513 }
514
515 /* static */
OnDestroy(GtkWidget * file_chooser,gpointer user_data)516 void nsFilePicker::OnDestroy(GtkWidget* file_chooser, gpointer user_data) {
517 static_cast<nsFilePicker*>(user_data)->Done(file_chooser,
518 GTK_RESPONSE_CANCEL);
519 }
520
Done(void * file_chooser,gint response)521 void nsFilePicker::Done(void* file_chooser, gint response) {
522 mRunning = false;
523
524 int16_t result;
525 switch (response) {
526 case GTK_RESPONSE_OK:
527 case GTK_RESPONSE_ACCEPT:
528 ReadValuesFromFileChooser(file_chooser);
529 result = nsIFilePicker::returnOK;
530 if (mMode == nsIFilePicker::modeSave) {
531 nsCOMPtr<nsIFile> file;
532 GetFile(getter_AddRefs(file));
533 if (file) {
534 bool exists = false;
535 file->Exists(&exists);
536 if (exists) result = nsIFilePicker::returnReplace;
537 }
538 }
539 break;
540
541 case GTK_RESPONSE_CANCEL:
542 case GTK_RESPONSE_CLOSE:
543 case GTK_RESPONSE_DELETE_EVENT:
544 result = nsIFilePicker::returnCancel;
545 break;
546
547 default:
548 NS_WARNING("Unexpected response");
549 result = nsIFilePicker::returnCancel;
550 break;
551 }
552
553 // A "response" signal won't be sent again but "destroy" will be.
554 g_signal_handlers_disconnect_by_func(file_chooser, FuncToGpointer(OnDestroy),
555 this);
556
557 // When response_id is GTK_RESPONSE_DELETE_EVENT or when called from
558 // OnDestroy, the widget would be destroyed anyway but it is fine if
559 // gtk_widget_destroy is called more than once. gtk_widget_destroy has
560 // requests that any remaining references be released, but the reference
561 // count will not be decremented again if GtkWindow's reference has already
562 // been released.
563 GtkFileChooserDestroy(file_chooser);
564
565 if (mFileChooserDelegate) {
566 // Properly deref our acquired reference. We call this after
567 // gtk_widget_destroy() to try and ensure that pending file info
568 // queries caused by updating the current folder have been cancelled.
569 // However, we do not know for certain when the callback will run after
570 // cancelled.
571 g_idle_add(
572 [](gpointer data) -> gboolean {
573 g_object_unref(data);
574 return G_SOURCE_REMOVE;
575 },
576 mFileChooserDelegate);
577 mFileChooserDelegate = nullptr;
578 }
579
580 if (mCallback) {
581 mCallback->Done(result);
582 mCallback = nullptr;
583 } else {
584 mResult = result;
585 }
586 NS_RELEASE_THIS();
587 }
588
589 // All below functions available as of GTK 3.20+
GtkFileChooserNew(const gchar * title,GtkWindow * parent,GtkFileChooserAction action,const gchar * accept_label)590 void* nsFilePicker::GtkFileChooserNew(const gchar* title, GtkWindow* parent,
591 GtkFileChooserAction action,
592 const gchar* accept_label) {
593 static auto sGtkFileChooserNativeNewPtr =
594 (void* (*)(const gchar*, GtkWindow*, GtkFileChooserAction, const gchar*,
595 const gchar*))dlsym(RTLD_DEFAULT,
596 "gtk_file_chooser_native_new");
597 if (mUseNativeFileChooser && sGtkFileChooserNativeNewPtr != nullptr) {
598 return (*sGtkFileChooserNativeNewPtr)(title, parent, action, accept_label,
599 nullptr);
600 }
601 if (accept_label == nullptr) {
602 accept_label = (action == GTK_FILE_CHOOSER_ACTION_SAVE) ? GTK_STOCK_SAVE
603 : GTK_STOCK_OPEN;
604 }
605 GtkWidget* file_chooser = gtk_file_chooser_dialog_new(
606 title, parent, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
607 accept_label, GTK_RESPONSE_ACCEPT, nullptr);
608 gtk_dialog_set_alternative_button_order(
609 GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1);
610 return file_chooser;
611 }
612
GtkFileChooserShow(void * file_chooser)613 void nsFilePicker::GtkFileChooserShow(void* file_chooser) {
614 static auto sGtkNativeDialogShowPtr =
615 (void (*)(void*))dlsym(RTLD_DEFAULT, "gtk_native_dialog_show");
616 if (mUseNativeFileChooser && sGtkNativeDialogShowPtr != nullptr) {
617 const char* portalEnvString = g_getenv("GTK_USE_PORTAL");
618 bool setPortalEnv =
619 (portalEnvString && atoi(portalEnvString) == 0) || !portalEnvString;
620 if (setPortalEnv) {
621 setenv("GTK_USE_PORTAL", "1", true);
622 }
623 (*sGtkNativeDialogShowPtr)(file_chooser);
624 if (setPortalEnv) {
625 unsetenv("GTK_USE_PORTAL");
626 }
627 } else {
628 g_signal_connect(file_chooser, "destroy", G_CALLBACK(OnDestroy), this);
629 gtk_widget_show(GTK_WIDGET(file_chooser));
630 }
631 }
632
GtkFileChooserDestroy(void * file_chooser)633 void nsFilePicker::GtkFileChooserDestroy(void* file_chooser) {
634 static auto sGtkNativeDialogDestroyPtr =
635 (void (*)(void*))dlsym(RTLD_DEFAULT, "gtk_native_dialog_destroy");
636 if (mUseNativeFileChooser && sGtkNativeDialogDestroyPtr != nullptr) {
637 (*sGtkNativeDialogDestroyPtr)(file_chooser);
638 } else {
639 gtk_widget_destroy(GTK_WIDGET(file_chooser));
640 }
641 }
642
GtkFileChooserSetModal(void * file_chooser,GtkWindow * parent_widget,gboolean modal)643 void nsFilePicker::GtkFileChooserSetModal(void* file_chooser,
644 GtkWindow* parent_widget,
645 gboolean modal) {
646 static auto sGtkNativeDialogSetModalPtr = (void (*)(void*, gboolean))dlsym(
647 RTLD_DEFAULT, "gtk_native_dialog_set_modal");
648 if (mUseNativeFileChooser && sGtkNativeDialogSetModalPtr != nullptr) {
649 (*sGtkNativeDialogSetModalPtr)(file_chooser, modal);
650 } else {
651 GtkWindow* window = GTK_WINDOW(file_chooser);
652 gtk_window_set_modal(window, modal);
653 if (parent_widget != nullptr) {
654 gtk_window_set_destroy_with_parent(window, modal);
655 }
656 }
657 }
658