GNOME Dashboard

"Frontend" is whatever object the user is currently interacting with.
This could be a mail message or a calendar appointment or an ongoing
IM conversation with a buddy.

The Dashboard is a persistent rectangle of screen real estate on the
right-hand-side of the user's screen.  The goal of the dashboard is to
display links to relevant objects as the user goes through his
day-to-day activities.

So, for example, while a user is reading an email, the dashboard may
display:

    - A list of related messages.

    - A list of related web pages from the user's bookmarks and
      browsing history.

    - A buddy icon for the person who sent the email, if they are
      signed onto IM.

    - A list of related documents on the user's hard drive.

Clicking on any of these items in the dashboard will bring the user to
the related object.  The message will be displayed, or the web page
will be loaded, an IM conversation will be started with the person, or
the document will be loaded in a word processor.

"Backends" are the various sources of objects which the dashboard
draws upon to create its list of related object links.

Some backend sources:

    * Bookmarks
    * IM buddies
    * IM logs
    * Documents
    * Photos
    * Music
    * Mail
    * Calendar appointments
    * Tasks
    * Mailing lists

Some example backend details:

    * Bookmarks
        - Relevant [title] bookmarks
        - Similar [URL] bookmarks
      ==> load URL

    * Mail
        - Messages to <list>
        - Messages from <person>
        - Relevant [matching subject/body keywords] messages
      ==> show message

    * IM buddies
        - Online [matching <person>] buddies
        - Recent relevant [matching <person>] buddies
      ==> IM buddy/focus conversation

    * Documents
        - Relevant [matching filename/title keywords] documents
      ==> load document

Cluepackets:

    Everytime the active object changes, the frontend constructs a
    "cluepacket" which is a set of clues.

    A clue is a piece of data which might relate the active object to
    some backend object.

    The frontend is responsible for including only relevant clues in
    its cluepacket.  So for example, the mail message frontend might
    construct a cluepacket made up of:
        - message sender
        - message subject
        - interesting strings in message body
        - names of message attachments

Backends:

    A backend is implemented as a shared library that gets loaded by
    the dashboard process.

    The shared library has a "bootup" function that gets called at
    load time.  This function does any backend-specific
    initialization.  For example, the related documents backend may
    find and index the filenames and titles for all the files in the
    user's Documents directory, and store this index in memory.

    The shared library has a "cluepacket" function that gets called
    whenever a new cluepacket comes in from any frontend.

    This function returns a list of matches, which are related backend
    objects.  Each match contains: 
        - A plaintext description of the match
        - A shell command to execute if the user clicks on the match

    For example, the bookmarks backend will return the title of the
    bookmark page and a gnome-url-show commandline to load the page.

    Backends have one final function, "backend_description", which
    returns a plaintext category name for all matches returned by the
    backend.  For example, the bookmarks backend may return the string
    "Related bookmarks:".

Design overview:

  +------------------+---+          +------------+        +---------+
  |               ___|   |          |            | <----> | backend |
  | frontend     |       | -------> | Dashboard  |        +---------+
  | application  |___    |     ^    |            |        +---------+
  |                  |   |     |    |(in-proc ui)| <----> | backend |
  +------------------+---+     |    +------------+        +---------+
                       ^       |                               ^
                       |       +--------+                      |
            -----------+                |
            |                           |           Backends are shared
     Shared library, used to            |           libraries loaded by
     send cluepackets to dashboard.     |           the dashboard at 
                                        |           startup.
                                    Opaque IPC
                                    mechanism :-)