Hi,

While we (the project) make regular progress (at least judging from
commits ;-) it seems to me that we are a bit lacking in actual
objectives -- that is, we have a rough idea of what we would like,
grand plan about very sophisticated architectures, but nothing very
well defined short and mid term. And most of the work so far has been
about frameworks, not applications -- the wished workflow / UI vision
is rather fuzzy. I think it could be good to try something on the
application side as well :-) and before doing that, we should have
precise idea of what we want to do, and how we want to do it.

Let me cite the wishlist (from
http://dromasoftware.com/etoile/mediawiki/index.php?title=EtoileWiki:About):

1 - Light, focused applications, cooperating together to provide a
rich user experience, using GNUstep services and our own Services
model

2 - Fast, simple data sharing between tasks and documents without
involving lot of context switches (between applications, windows,
selection etc.)

3 - Facility provided by default to composite, layout unrelated
elements in first-class objects like documents, folders etc.

4 - Workflow based on project inspired management (versioning,
indexing, sharing etc.)

5 - Easy communication/collaboration among users, where users are
first-class objects in the environment

6 - Assistant technology similar to the Newton's approach.

how can we actually fulfill these goals ? What I think is important
(in contrast to existing desktop such as KDE/GNOME) is the emphasis
on:
- project management
- versioning
- first class objects (e.g., persons, locations, devices, etc.)
- indexing and search

For versioning, I think we should have a specific framework to manage
that, that applications and the filemanager can relay on to
retrieve/commit modifications. Such a framework will very likely relay
itself on libsvn or equivalent for other versioning systems. The
framework could also provides distributed features that way.

For indexing and search, LuceneKit is the obvious choice.

I won't talk further about these two items, as I don't think they are
important in the short term (ie they won't change much the
UI/workflow). So what about Project Management, First Class Objects
and the overall UI ?

Basic UI
=======

Here is the UI I propose:

1) a file manager (GWorkspace for the moment) to present the
filesystem. You can present a folder content using different kind of
representations (list, icons, mini icons, "spatial", etc.)

2) a tabbed shelf where you can drag and drop anything on it, not just
applications (although of course it will be used mainly to put and
access applications). The existence of tabs let you categorize easily
the applications, and have specific tabs for holding running apps for
example. Basically I want that:
http://www.roard.com/screenshots/Dock6.png

3) a desktop area where you can drag and drop objects (more on that later)

You interact with folders and files on your computer via the
filemanager. Indexing/search can also allow for categorizing and
"intelligent folders" (showing the result of a search).

Project Management:
================

In addition to that basic model, a folder could be a "project" -- a
bit like an application on GNUstep is a "special" folder, which
contains the binary and the resources of the application.

Now, if you open such a project bundle, what does it contains ? Well,
it will contains all the files you use for this particular project,
plus a certain number of specific information for managing the
project. So in a way, it's really "just" a normal folder, with some
structure/specific files. The kind of informations a project can
contains is, for example, the list of applications used in the project
(with their windows position, etc.) so that they can be restarted
automatically, the persons working on the project, possibly all that
hosted on a svn repository, etc.

When you actually open the project, it doesn't open in the filemanager
though. Its content is displayed.. on the desktop itself. So the
desktop is NOT a global area like on MacOS/Windows/KDE/GNOME -- it's
the content of a project.

In addition, the desktop should be able to display more than simple
icons -- it should display images, specific objects (draw lines, type
some text, etc), or even "mini apps" ala Konfabulator.

In that way, opening a project will actually put you back where you
were; and the desktop can finally be again used as a *work* desktop,
where you can drag and drop stuff you're working on, organizing them
(we could have some things like what aperture does, or piles, etc.).

With support from the window manager, the projects will in fact be
able to act as virtual desktop, and you could easily switch from one
project to another.

First Class Objects
==============

For managing first class object, I'm thinking of a very simple
mechanism. Basically, when we talk about that, we want to have
"objects" we interact with, represented as icons most of the time.
What we should have then is a specific role for an application, in
addition to the current Editor/Viewer roles defined and used by
GNUstep.

We could simply have a "Well" role, where anything drag and dropped
*on* such a proxy icon will be passed over to the corresponding
application in the "well" role.
Same way, double-clicking on such proxy icon should launch an
associated application with the file as parameter.

For example, imagine that I have a project which I want to add a
person to. Project opened, content displayed on the desktop; I can
launch the address book application, drag and drop the person on the
desktop -- voila, the person is "on" the project.

Now, if I want to talk to that person, I can simply double-click on
the person's icon on the desktop to launch a jabber client. If I want
to send him a file, I can drag and drop the file on the person and be
presented with a dialog to choose how (could be jabber, ftp, mail,
whatever) [for that a good move would perhaps be to build a light
infrastructure on top of the services system, to actually have
applications define roles]

Now imagine I want to add a webdav resources, same way, I'll just dnd
it on the desktop. Same for a printer icon, and files dropped on it
will be sent to a printer application.

Proposed steps
============

For now, unless somebody wants to work on other things, I think we
could simply focus on the basic desktop elements:
- the desktop
- the shelf
- the filemanager
- a display manager for X

For the display manager, garma had one that we could possibly reuse;
for the file manager, we could use gworkspace for the moment (we'll
see for later). For the shelf and desktop elements, .. well, that's
what we need to do :-)

Before starting anything though, what are your opinions about what I
outlined ? Specifically, the desktop/project management and the first
class objects ?

If everybody agrees to this outline, I can probably start coding a
shelf (I wrote one a long time ago which was half-working ;-) , well,
after I move forward wrt camaelon/gnustep (but definitely before the
fosdem).

The goal would be a major release of étoilé before the fosdem. A
release of the current frameworks could also be nice before that !

All comments welcome.

--
Nicolas Roard
"Any sufficiently advanced technology is indistinguishable from magic."
  -Arthur C. Clarke

Reply via email to