Comment by torginus
4 years ago
This is a pet peeve of mine - why is it that in Linux it's idiomatic to start like 5 processes and pipe their outputs together to find a file containing a certain word from the shell, but something like a file chooser cannot be its own program?
> … but something like a file chooser cannot be its own program?
That's happening! Gtk 3 and 4 include GtkFileChooserNative[1]. It works like a file dialog except the application doesn't know about its widgets. That means it can proxy another application.
So if you're running a Gtk app in a sandbox like Flatpak or Snap, Gtk will use the Xdg file chooser portal[2]. In GNOME, this is implemented by an application (in the host) which, itself, creates a GtkFileChooser. In the future, it could be a beefier application. One benefit of that taking a while to happen is, once the implementation gets fancier, there won't be too many weird mismatched applications.
(Also, I mention GNOME, but it's important to notice the file chooser portal is itself platform neutral; KDE apps use this, too, and the implementation depends on what desktop you are running. Yay, decoupling!).
Not everything uses GtkFileChooserNative, but pretty much any recent Gtk app that doesn't have weird requirements probably does. Off the top of my head, Firefox, Secrets, Bottles, GNOME Builder and GNOME Text Editor (although they still ask for access to all of the of the files for other reasons), … even Slack and VS Code! (Electron switched over recently).
[1] https://docs.gtk.org/gtk4/class.FileChooserNative.html
[2] https://flatpak.github.io/xdg-desktop-portal/#gdbus-org.free...
What I don't understand is why it took so long.
That bundling file chooser with a GUI framework is a bad idea should be obvious since well, ... Java Swing?.
And a easy to use system interface for a file chooser isn't hard to make, could have been (preferable) a binary you call and communicate with pipes with or similar or could have been something else (e.g. shared object).
It's kinda sad that the various Linux communities where so focused on their GUI framework being the best that it didn't happen until it was technically needed (for sandboxing) ...
EDIT just to be clear 95+% of applications could use a cmd with Linux style arguments which once done emits the selected file(s) to stdout, but there are a minority of advanced use-cases which require a bit of two way communication. Through most of them are bad ideas anyway, so maybe that could have been ignored.
Was it a thing anywhere except recently? Going through some different native Windows apps, I see a host of different file choosers (many of which were once "the one" for their version of Windows), and they all belong to the same process as their respective applications. Definitely not to a privileged service. (Unless Windows is doing something exceptionally fancy here?).
A lot of this stuff was "decided" back when we had serious memory constraints, and less technology to manage them. Switching processes was costly. Running the file chooser in the same application was an excellent compromise. A solution. (I remember an article about this problem in the context of early MacOS, along with drag & drop and the like. Will share if I find it).
In addition, having the file chooser in-process makes sense if you're trying to appease app developers, who think they want the ability to change everything. In particular, they'd really like to add a custom preview widget and some other gizmos to the file chooser. Photoshop puts all sorts of buttons in its Export dialog, for instance. And because Photoshop does it, a bunch of other applications think they should, too. And they still want to, even if they're using Gtk.
Saying "this is dumb, we need this dialog to be a simpler interface for [reasons] and if your app has a weird file dialog you'll have to deal with it" is a very decisive action, and it is not without friction. So I think the reason this took so long is partly an accident of history (the bad solution stuck because it was too late by the time we could afford the good solution), and partly just luck: things reached an inflection point where app developers actually get something (sandboxing and clever app containers) in exchange for the inconvenience.
1 reply →
You'd need some way to inform the window manager that "windows from this process should be considered modals over this window of mine" - probably something that's in the realm of the possible to hack together?
>You'd need some way to inform the window manager that "windows from this process should be considered modals over this window of mine"
Why though? Am I the only one that hates modal windows? Why does the parent window have to be blocked by the dialog window? Can't it be like the color picker dialog in GIMP?
There are/were Linux window managers or desktop environments where the file picker was not held if focus above the main window. Or at least they can be configured that way. I know because I've done it.
It turns out, that when that happens, the user can accidentally focus the main window while the file picker is up, and then the file picker gets hidden underneath it. As a fun bonus, the application now _probably_ appears to be frozen/crashed because it's waiting for input from the file picker that the user can no longer see.
It's just a bad idea, man. For most people anyway.
2 replies →
As much as I hate modals they are usually a product of single threaded or poor event loop design.
What happens if I hit File->Save, then while the file picker helper process is spawning I get an urgent instant message and tab away, and when I alt-tab back focus returns to GNOME and I close the tab because I forgot I didn't finish saving? Does the file picker go away? If I type a filename in the picker afterward and hit Save, does it save the file even though I closed the tab?
1 reply →
For X11 there was no need to "hack" that - Window IDs are global so the file chooser just needs to be passed the value to set for its WM_TRANSIENT_FOR property.
Wayland might be more difficult since it likes to isolate processes more but considering this should have been common before Wayland was designed it could and should have influenced that design.
"Here are my screen coordinates, I'm going modal while you're running" seems like a perfectly adequate answer to that.
How do message box (alert) popups work?
in GTK when you instantiate the window you pass what is called the "transient for" property (https://docs.gtk.org/gtk4/method.NativeDialog.set_transient_...). That informs the dialog what it belongs to. If you were to re-engineer this to make the file picker its own process, then you would have to fundamentally change the way it functions, sadly.
Edit: And I think Wayland would make this impossible? Someone correct me if I'm wrong here, but don't you lose basically all inter-window introspection with it? There may be some negotiation process, but I don't know how you would go about accessing an entirely separate application's context under that pipeline.
7 replies →
GNOME often rejects the ideas from the rest of the ecosystem.
It's a matter of human resources, gtk3 is an extremely small team compared to its influence.
Haven't the GTK developers basically admitted that GTK exists to serve the needs of GNOME, and if anyone else gets good use out of it, that's accidental and unsupported?
I really wish we had another popular GUI toolkit that isn't Qt.
Why do you need a toolkit different from Qt? Because of the C++ API? Because the licensing (LGPL now so should be good)? Not lean enough for you? Just want something run by the community and no beholden to a single corporate overlord?
I'd much rather have one single toolkit standard so that everything can look and behave the same TBH.