Integration of freedesktop.org standards for Menu&Desktop icons into LG3D^?

Proposal by Juan González Aguilera (opsi)

Introduction

Freedesktop.org is a "collaboration zone" working on interoperability and shared technology for X Window System desktops. While it's not a formal standards organization (like ISO), they create de facto specifications that are becoming widely used in modern Linux desktops.

They create specifications for all the typical operations of traditional desktop environments, including for example:

• A Drag and Drop standard shared betwen GTK+ and Qt
• Window Manager specifications to extend the ICCCM (Inter-Client Communication Conventions Manual) between X desktops
• Specification for the use of the X clipboard in a consensual way that is shared between Qt and GTK+
• Desktop Entry specification to describe desktop entries that include information about applications (name,icon,...), and are used to build the desktop and the menu
• A draft document that defines how to construct a user-visible hierarchy of applications, usually displayed as menu.

For this proposal, the relevant specifications are the two latest, let's look at them a bit deeper.

Desktop Entry Specification

Most widely used desktop enviroments (KDE&GNOME) have adopted a similar format for "desktop entries" which is in benefit of users because makes their desktop applications available in both (and more) desktops with no extra work, simplifiyng interoperatibilty betwen them and making developers life a bit easier.

These desktop entries are plain text files with the extension .desktop. There are also desktop entry files, that are to describe how a directory is to be formatted/displayed, which are just called .directory .

The basic format of the desktop entry file requires that there be a "group" header named [Desktop Entry]. This "group" entry denotes that all {key,value} pairs following it belong in the Desktop Entry group. There may be other groups present in the file, but this is the most important group which explicitly needs to be supported.

Compliant implementations MUST not remove any fields from the file, even if they don't support them. This is interesting for LG3D^? integration because it allows to add specific requirements that are not present in traditional desktops (like Z position), and may probe interesting to be used as the standard for LG3D^? as it's already for Gnome and KDE.

Desktop Menu Specification

This specification defines how to build a user visible hierarchy of applications. Information about each entry of this hierarchy is stored in a desktop entry (the ones defined before in this document), and the layout of them is described using an XML file which defines where and how to display all of this "desktop entries". The specification allows to restrict elements to one single desktop environment, or the reverse, allow items in all but one desktop.

Adoption of these standards

Since the "standards" proposed by freedesktop.org for desktop entries and menu definition has been adopted by the Free Standards Group, and are referenced in their Linux Standard Base specifications, most modern linux distributions (desktops) are working to get them fully integrated (since KDE3.4 and Gnome2.10 they both integrate these standards). Even Solaris is planning to integrate them when they update to Gnome 2.10 (next Nevada release).

In fact, one little survey that I started in the LG3D^? forum has shown that, at least, the following distributions already follow the standard:

• Suse linux (since 9.1 at least)
• Ubuntu/Kubuntu (since 5.10 at least)
• Gentoo (since ??)
• Mandriva (since 2006 release at least)
• Fedora Core (since release 4 at least)
• Debian (since Sarge at least (needs an extra package: menu-xdg))

LG3D^? Integration

In order to integrate the specified elements it will be necessary to first create:

1. An infraestructure to read "desktop entries" from disk and make them objects. As the "desktop entry" file is similar to an standard Java .properties file, it looks easy to create a Class containing a Map of keys/values, with keys holding the Section and the real key and the values holding, well, the values. This will be used both in Desktop and in Menu creation.
2. A parser for the XML .menu files that follows the indications of the standard to merge multiple files, and can build the complete memory tree for the menu hierarchy. This tree only includes information about the structure, and leave the information about each element in "Desktop entries" that are referenced from it.

At this point, we have the hability to read and abstractly recreate the menu and the desktop in memory, let's look at them separatly:

Desktop

Once the "menu entries" can be managed from Java, loading the user Desktop is trivial, just load all files from ~/Desktop directory and it's in memory. It looks plausible to regenerate the desktop structure in every run. The complexity comes in how to show those Desktop icons to the user. Some ideas have been tried in the past, like the abandoned Microsoft's Task Gallery palette, or the Rooms3D software, but we will have to dig on what the users think is the better way to show all this icons whithout cluttering the desktop, and using the third dimension.

The desktop layout manager is a good candidate to be pluggable.

Applications menu

This part is a little more tricky, because LG3D^? already has a way to build the menu through .lgcfg files, which leads to (at least) two possible solutions:

• Using a cached tree that's updated at startup if the .menu files in disk change. In every start of LG3D^? a single, independent, thread is started to check the timestamps of all .menu file, and if the timestamp is different than the cached one rebuild the tree, persist it and generate the necessary events to build the menu.
• Independent importer that converts from freedesktop format to LG3D^? one (.lgcfg files), and that must be manually run by the user. This importer is to be run outside LG3D^? and before it's running, so it can load it with the existing model.

It's to the comunnity to decide which one is a better option (or even propose some other), but there is time (work) before arriving to this part, and the forum will bring some light on it.

Deliverables

1. Classes to access .desktop files
2. Classes to parse and merge .menu files
3. One generic SceneManagerPlugin^? to generate the desktop icons. It must be pluggable to allow different layouts of desktop icons
4. At least two plugins for that SceneManagerPlugin^? (standard plane layout and palette layout)
5. Depending on the comunnity decisions, a one thread event source for menu entries or a independent importer
6. Of course, documentation on all the above

Here is a Gantt chart to show you the expected schedule for this deliverables:

Last point in this schedule refers to the creation of comunnity suggested plugins for the Desktop plugin.

It's expected to have a working implementation of the desktop by june mid-term evaluation, and work on menu after this.

Disclaimer

I'm very sorry for my poor english , hope you understood me ;)

1. On top of that event model, design and build a three dimensional GUI. For thi GUI, many user feedback would be greatfull.

Disclaimer

1. An abstraction layer to the GoogleApi must be built with Java to give the search queries and search results an entity of object in our Java world, this way we will ensure that lately that search items can be easily integrated in different representations. This abstraction layer should be multi-threaded enabling multiple queries, and building categories for all the results.
   
   
2. Define an event model that allows external queries for that engine, this will allow to request a query to the system and receive it as three dimensional entity.The user interface will request all it's searches through this event model, and will be the first external application for the engine.
   
   
3. Create a novel user interface to show the search results in the 3D environments, powering the aggroupation of similar results and leveraging the capabilities to condensate many results in the third dimension, so the user can have a view of group, allowing him/her to find the most relevant information. This interface should allow the advanced searches, and any other interesting application that may be found in GoogleApi. Need also to take care of the standard search options (as default language and others). All the categorization must be configurable in some way , probably through some XML file, which will allow to create afterwards a 3D interface for all that configurations.
   
   

1. A multithreaded engine to query Google and generate results built on top of the SOAP service provided through GoogleApi.

Artwork

Deliverables

Based on that requirements we can define the following deliverables:

1. A multithreaded engine to query google and generate results (Asynchronous).
2. An event model to drive that results synchronization with external applications (This may probably require some additions in LG3D^? codebase!).
3. On top of that event model, design and build a three dimensional GUI.
4. If there is time, build a three dimensional background to catch the user favorite searches.

Summer of Code - Subject #202

Motivation / Abstract

1. An abstraction layer to the GoogleApi (depends on license) must be built with Java to give the search querys and search results an entity of object in our Java world, this way we will ensure that lately that search items can be easily integrated in different representations. This abstraction layer should be multi-threaded enabling multiple querys, and building categories for all the results.
   
   
2. Define an event model that allows external querys for that engine, this will allow to request a query to the system and receive it as three dimensional entity.The user interface will request all it's searchs through this event model, and will be the first external application for the engine.
   
   
3. Create a novel user interface to show the search results in the 3D environments, powering the agroupation of similar results and leveraging the capabilities to condensate many results, so the user can have a view of group, helping to find the most relevant information. This interface should allow the advanced searches, and any other interesting application that may be found in GoogleApi. Need also to take care of the standard search options (as default language and others). All the categorization must be configurable in some way , probably through some XML file, which will allow to create afterwards a 3D interface for all that configurations.
   
   There are already some mockup videos to download, that are all open for comments. Please visit the LG3D Forum and leave your comment.

Boring (short) autobiography

Related links

Design of 3-D Visualization of Search Results: Evolution and Evaluation (Nirve paper) John Cugini and Sharon Laskowski (NIST) Proceedings of IST/SPIE's 12th Annual International Symposium: Electronic Imaging 2000: Visual Data Exploration and Analysis(SPIE 2000), San Jose, CA, 23-28 January 2000

Interactive 3D Visualization for Document Retrieval John Cugini, Christine Plato, Sharon Laskowski, Proceedings of the Workshop on New Paradigms in Information Visualization and Manipulation , ACM Conference on Information and Knowledge Management (CIKM '96), November 1996.

Grokker browser Grokker is a web browser based on yahoo's technology which provides a very interesting representation of the search results, arrangin and reagrupating them in a flat circle (or square). The interface is written in Java.

Three Dimensional Visualization of the World Wide Web Steve Benford, Ian Taylor, David Brailsford, Boriana Koleva, Mike Craven, Mike Fraser, Gail Reynard and Chris Greenhalgh

Disclaimer : I'm very sorry for my poor english

-- Main.opsi - 09 Jun 2005

I'm sorry for the codecs in the videos, but I have no way of transforming them right now, please forgiveme if your player can't handle them (my mplayer does).

Schedule

University : Almeria's public university , Almeria, Spain

Currently at : My second year in university

Relevable knowledge : i'm pretty good coding with Java, know enough XML, HTML and HTTP, and I'm a bit familiar with LG3D^? api (I did the 3D clock that's in the lg3d-incubator).

Needed knowledge : Surely i'll need to go deeper in the LG3D^? event model, and scenegraph creation. Some knowledge of the LG3D^? Scenemanager internals will probably arise also. And for sure, I will need to study the google http interface and answer system.

Motivation

Luckily, in the last few years it seems like we are getting in touch with that fact, and start interesting ourselves in building environments that was Sci-fi not much time ago. I'm talking about Project Looking Glass , which aims to build a three dimensional desktop on top of Java. This project is providing an standard API to build three-dimensional applications (and also 3D desktops). LG3D^? also integrates itself with the old fashioned 2D applications to make the transition from that foreign world of imposed bidimensionality, and as it's written in Java, which for good or for bad is a nice programming language.

So now we have, many information to search-in and a 3D environment (and API) that should allow us to enrich the user experience and that's developed in a modern object oriented language with a huge probed class base. The next step is to define a clear and easy to use interface that covers the named points as any other that may surround during development, also we need an architectural definition.

1. An abstraction layer to the GoogleApi (depends on license) must be built with Java to give the search querys and search results an entity of object in our Java world, this way we will ensure that lately that search items can be easily integrated in different representations. This abstraction layer should be threaded enabling multiple querys, and building categoriesfor all the results,providing an event model to mangle all the results.

1. Create a novel user interface to show the search results in the 3D environments, powering the agroupation of similar results and leveraging the capabilities to condensate many results, so the user can have a view of group, helping to find the most relevant information. All this categorization must be configurable in some way , probably through some XML file, which will allow to create afterwards a 3D interface for that all that configurations. This interface should allow the advanced searches, and any other interesting application that may be found in GoogleApi.

So now we have, many information to search in, a 3D environment (and API) that should allow , To develop a Google search result browser

Prerequisites

To build this up, there are a number of interesting concepts that must be developed and redefined:

1. An abstraction layer to the Google's api must be built with Java to give the search querys and search results an entity of object in our Java world, this way we will ensure that lately that search items can be easily integrated in different representations. This abstraction layer should be threaded enabling multiple querys, and building categoriesfor all the results,providing an event model to mangle all the results.

1. Create a novel user interface to show the search results in the 3D environments, powering the agroupation of similar results and leveraging the capabilities to condensate many results, so the user can have a view of group, helping to find the most relevant information. All this categorization must be configurable in some way , probably through some XML file, which will allow to create afterwards a 3D interface for that all that configurations. This interface should allow the advanced searchs, and any other interesting application that may be found in Google's API. There are already some mockup videos to download, that are all open for comments. Please visit the Forum if you have any comment.
   __Video Mockup01(Avi):__
   __Video Mockup02(Wmv):__ =With explaining text over
   

Google Results Browser

This wiki page is aimed to describe a three dimensional search result browser built on top of the Project Looking Glass. All the development for this project is expected to be done on Java, using the 1.5 extensions as it's used in LG3D^? (at least in the multiplattform part of it). Some HTML(and related technologies) will be required for sure.

Abstract

Bio

About me, well I'm from Granada,Spain (you now, it's where former US president, Bill Clinton said that words:"It is the most beautiful sunset in the world"). It's a sunny place here, and in winter we have a nice ski station 40 km away. Currently i'm a CS student in a city near to mine, Almeria, where the beach is meters away ;). I was born in 1980, so i'm 25 now, and there has been a computer in my bedroom since I was about 8. First there was games (those wonderfull CGA scrolling adventures, or pinballs and don't you remember the "two-colors" Star Wars was there ... nice time) but lately, in '96 I think, I caught one of those CDs that came with a magazine that my brother bought . It promised a "shareware operating system" inside (nice description for Linux, isn't it?). Of course, my brother told me it was very hard to install that "shareware", and as he was who made all repairs to my computer in those days, he forbide me to install that monster, and threw that CD to his drawer. Nothing else where known about it, until '98. It was the summer when I had just obtained my first 486 (w0w0w0w), and was time to install Window on it, by that time I already had a Master in windows installations, and knew pretty much the way to recover my computer from a Operating System crack, and then, as a promise, that lost CD apperared in a home clean-up, mmmm, what a temptation... It was stronger than me, so I sat before my loved 486 DX/4 (AMD of course and began the installation. I must admit in that days it was much harder to install linux than today, first I had only a 400Mb HD (and was big) but wanted to keep dual boot on it. Also my CDROM was a matshita (or something) with it's own isa controller card, and Linux didn't detect it, the cd wasn't bootable, I had no idea of unix commands (godthanks, my dad brought me a paper from the university with the equivalent commands betwen DOS/Unix), there was no internet at home (and for me, almost nowhere else), all the information in the CD was in english (hey man, don't forget I'm spanish), and all you can imagine.... But well, I did it, and you can believe it or not, but since I installed linux, I understood that all what I had done before was just gaming. Until then i didn't really know my computer. Installing linux on my own computer for the first time is, from my point of view, one of the most important decisions in my life. For your interest, what came in that CD was a beloved, but not very appreciated distribution, that I still use in a daily basis, it's Slackware. Before coming to university I had a 2 years degree on "Computer System Administration", but it was lost time, nothing you can't learn by yourself, but at least they made me dive in some programming manuals, and it got me until today. Since I installed linux for the first time my knowledge of the computer has been leveraging day by day. I like the administrative work on servers (in fact I work on it to get some extra cash) but what I really enjoy is coding, in Java, C, C++, Bash,PHP,Python ... or whatever you want (finally it's about coding, the language doesn't care, in fact it's only syntax and api ;).

Prerequisites

To build this up, there are a number of interesting concepts that must be developed and redefined:

1. An abstraction layer to the google's api must be built with Java to give the search querys and search results an entity of object in our Java world
2. Crete a novel user interface to show the search results in the 3D environments, powering the agroupation of similar results