Skip navigation.
home | news feeds | archives | search | forums | submit news
Home » view

Nautilus 2.6 - We're going all spatial

Submitted by stro on Mon, 2003-09-15 11:04. Nautilus
Nautilus

During the nautilus 2.4 cycle there was some discussion on
nautilus-list about the "Object Oriented" metaphor vs. the "Navigation
Metaphor". That thread started at
http://mail.gnome.org/archives/nautilus-list/2002-September/msg00093.html
(read that mail if you need an introduction to the OO and Navigation
metaphors).
Our general opinion coming out of that thread was that the Object
Oriented metaphor was probably easier to learn, and built a stronger
conceptual model for users, but that the convenience benefits of a
navigation window outweighed those.For the 2.6 cycle, the nautilus crew is trying out a new UI that
should give us the best of both worlds. The idea is present an object
oriented UI from the desktop, but to allow users to open navigation
windows if they prefer them. This means that opening a folder from
the desktop will give you an object window. Opening folders from
object windows will give you new object windows. You can right click
on a folder from an object window and select "Navigate Folder"[1], and
get a normal nautilus window.

I want to emphasize that we are not removing the navigation window.
People who use this window and like it can continue to. This is also
not a first step toward removing the navigation window. The
navigation window is a central part of nautilus, and will not be
removed. We think that splitting the object-oriented bits of nautilus
into their own world will let us make the navigator act more like you
expect it to.

This interface is partially inspired by the interface described in
http://arstechnica.com/paedia/f/finder/finder-1.html . Interested
parties should read that before getting involved in the discussion.

For this UI to succeed, we need to iron out all of the details. We'd
like people to pound on the object ui and take notes on the things
that bother them. After you've done this for awhile, we'd like to see
your comments on nautilus-list@gnome.org. You can get it from the
nautilus-spatial-playground branch of nautilus.

I'll be following this mail up with a more detailed list of the work
that's been done and needs to be done.

Thanks,
- The nautilus crew

[1] In the branch right now, this is Open With -> Navigation Window,
but that will be changed.

Details

I just committed the start of the spatial UI stuff to the
nautilus-spatial-playground branch. It'd be nice if people could
pound on it for a little bit.

What has changed from a UI perspective:

* Object windows are created by default from the desktop. Navigation
windows can be opened from the menus. Right now all that is
implemented is Open With -> Navigation Window, but a "New Navigation
Window" entry in the desktop context menu could pretty easily be
created.

* Object windows are one-window-per-location. They do not have the
following UI:
- Search UI
- Back and Forward
- Bookmarks menu
- Toolbars
- Side pane

* Navigation windows are basically the same as they used to be, but
they don't save their geometry anymore.

* The default window size is much smaller. This was to make the
default object window size sane, and I just haven't gotten to
fixing it for nav windows.

Unfinished UI:

* I didn't finish porting the view as combo in the location bar.

* The "New Window" stuff isn't in the desktop context menu or the
file menu.

* Lots of little bits - these things all need to be collected.

Some open UI questions:

* I moved "Open in New Window" to "Open With -> Navigation Window". I
thought that this might reinforce the idea of the browser as a
separate app. Any thoughts?

* Some ideas for differentiating the navigation window:
- give it a constant, special icon rather than the icon of the
contents
- put a "- Nautilus" (or whatever) string after the current
directory (or whatever the hig suggests for this sort of thing).

Implementation Notes:

* Unfinished parts are tagged with #if NEW_UI_COMPLETE.

* NautilusWindow has been split into a NautilusWindow base class,
a NautilusObjectWindow subclass, and a NautilusNavigationWindow
subclass. NautilusDesktopWindow now derives from
NautilusObjectWindow.

* NautilusNavigationMenu merges a new xml file into the same ui
component. This lets us keep separate files that use the same
verbs.

* I sort of abused the open_location_* functions in the idl.
open_location_in_this_window -> "open location according to the
current window (new object window or this navigation window"
open_location_prefer_existing -> "open location in new object
window"
open_location_in_new_window -> "open location in new navigation
window".

* nautilus-window-menus is pretty well separated between the different
subclasses, but nautilus-window-manage-views is still very tied
together - a lot of the nav stuff needs to be built in there.

* Some stuff is blocking on the views being able to find out what kind
of
window they're sitting in.

Some open implementation questions:

* How do we want to change the idl? Should we just stick with
abusing the open_location_* rather than trying to change things?
(it's worth noting that the old semantics of those functions
don't make much sense now).

* How do we want views to figure out what kind of window they're in?
Ambient property for the control? idl extension?

* Is it worth the bother of trying to cleanly subclass the navigation
parts of manage-views?

All backwards. How about this, instead?

Submitted by FallibleDragon on Tue, 2003-09-16 10:18.

The way I see it, there are two consistent models for interfaces. They are RELATED to the models described above, but also very different.

In the first model, you have applications. You use an application to browse the web: you select a link, you press 'follow link', and your application shows you the new address. Double-clicking directly on the link is an application shortcut, not some interaction with the 'object' (the page/link) itself. Equally, your enter data in a wordprocessor, and you use an application to navigate to a file. When you 'open' the file, you are opening the file in it's default application; not simply opening the object itself.

In the second model, EVERYTHING is an object. NOT just directories, but documents, too. You do not open a wordprocessor file in a wordprocessor; you open the wordprocessor file, period. In other words, when you open a document, a PAGE should appear, without an application around it. You might select a paragraph and drop it out of the document on to the desk. It would then become a new document in its own right, and it would be automatically stored IN your desk (not ON your desk!), since that is where you put it. In the typical object-oriented model, you might right-click for less common operations, and so you would right-click on the desk, choose 'find document', and type what you are looking for, much like what we recently saw with the 'storage' project.

I hope you can now easily see that GNOME both IS NOT and WILL NOT be an object-oriented desktop without MAJOR changes on every level. If we want to go that way, I'll be all for it. But let's not pretend that putting an object-oriented file metaphor underneath an application-oriented GNOME will be beneficial or more integral. In fact, it will be nothing short of ridiculous.

My advice and hope for Nautilus's immediate future? Just these small things: dump all the non-app, non-navigation components -- they're just plain stupid. Keep different file/navigation views, like icon, listview, CVS, etc. But dump the picture viewers, music players, webpage viewers, etc. Secondly, make it faster. FASTER for file management! Finally, make it USEFUL for file management! If I can't select 99 of my 100 files, right-click, choose the appropriate option, and then set their ACLs in one go, then it's pointless. If I can, and it feels 'natural', and it's quicker than doing it through a shell, then it's beautiful.

» parent