RFP: File chooser user interface

GtkFileChooser is the next generation file selection widget for GTK+
that will appear in GTK+-2.4. Quite a bit of work has been done on the
application programming interfaces and on the internal implementation,
but there is, as yet, no firm design for how the file selector should
look and work.

This is a request for proposals for how the file selection user
interface; what we are hoping to do is to get a number of user
interface proposals, pick one or combine elements from multiple
proposals, implement a first draft, and then refine from there.

How the programming interface works
The basic scheme is that the application creates a GtkFileChooser
dialog with a number of buttons that it specifies; this buttons will
be displayed along the bottom in the fashion of a standard dialog.

At any point, the application can query the selected file or files,
and get notification when the selected files changes.

There are various configurable parameters:

 - The action of the file chooser: open mode or save mode.

 - Whether the user can select multiple files at once

 - Whether the user is selecting files or folders.

There are also several ways that the application can customize
the user interface:

 - The application can provide a set of filters for the user to choose 
   between. (JPEG files, etc)

 - The application can provide a widget that previews the currently
   select file.

 - The application can provide an arbitrary extra widget to packed
   into the GtkFileChooser interface. (for example, a "open read-only 
   checkbox" to the interface.)

General considerations

 - The design should strike a balance between ease of learning
   and ease of use. It should be approachable for new users,
   but also efficient for experienced users.
 - The design should take into account the fact that users 
   will typically be familiar with and even switching between
   this and the file selectors in other toolkits and operating
   systems. A radically different user interface approach may
   in fact be correct, but the tradeoffs of such should be

 - The design should be accessible. As examples: all operations 
   should be accessible through the keyboard. The design should
   not use color as the exclusive way of indicating information.

 - The design should allow selecting arbitrary files within
   a heirarchical set of folders. The folder heirarcharchy
   will generally depend on the environment, and may not match the
   underlying filesystem. When run within GNOME, it will match 
   that of Nautilus, when run within Windows, it will match
   that of Windows Explorer.

   (The particular heirarchy should thus generally not be part
   of the proposal.)

Limitations of what is implementable

 - For GTK+-2.4, we'll need to stick to linear lists of
   files, rather than grids of icons. Later revision of
   the user interface to use a gridded display is possible,
   so a design that woudl ideally use a grid, but can
   initially use a list is a possibility.

 - Designs should generally use standard GTK+ controls; while
   writing simple new controls may be possible, it's going
   to make the implementation tricker

What to include in the proposal

 - What elements should be present and how they should interact

 - Some rational for the above (how will people be using the file
   selector, what are the important tasks that should be easy to do,
   what is the relationship to file selectors that people are already
   familiar with, if any.)

 - Composed mockups or screenshots done with Glade are not necessary
   but may help to elucidate a proposal.

 - If you have, or can find, someone with the right skills, it
   wouldn't hurt to have a working or partially working implementation
   based on the code in the gtkfilechooser/ module in GNOME CVS,
   but this is far from necessary.

[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]