QEdje Is Working! :D
There are quite a few
Free Software
libraries out there for making
GUIs
(graphical user interfaces). The most famous are probably
GTK+ (started by the
GIMP and used by
Gnome,
XFCE and
LXDE) and
QT (started
by Trolltech and
used by KDE), however
there are quite a few more such as
GNUStep,
Motif
(used by
CDE),
FLTK (used by
EDE) and
EFL
(used by
Enlightenment).
EFL,
the Enlightenment Foundation Libraries, are particularly interesting.
They are incredibly lightweight, running quite happily on a mobile
phone, yet allow all sorts of animation (as in, proper 2D animation
rather than just moving/spinning/stretching things) and are completely
themable. The way this works (from what I can find out) is that every
EFL program uses the
Evas
canvas (“canvas” is the name given to a widget which allows arbitrary
drawing on top, rather than imposing some kind of structure), then
Etk
and
EWL
draw on top (the canvas is created implicitly by Etk and EWL, even if
you don’t make one explicitly). This is opposite to most toolkits, like
GTK+ for example, where the widgets are drawn in the window (which is
usually divided up into a rigid structure) and canvases are implemented
as widgets.
A nice feature of the EFL is called
Edje.
Edje allows an application to be written without worrying about the GUI,
instead just requiring that an external file be called. These external
files describe the interface, and are entirely
declarative
(that is, they say “I want a button” rather than “This is how to draw a
button”), think of it like the HTML of a web page, with Edje being the
web browser which draws it (actually, this would be a more appropriate
description of XUL, but I
can’t get my head around XUL’s seemingly overcomplicated use of CSS,
JavaScript and XML :( ).
Edje files are compiled into
compressed archives (using
EET)
which act like incredibly far-reaching themes. This means that a theme
doesn’t just contain pretty pictures to use as buttons, or the
programming to draw the right lines at the right locations, it actually
contains the entire user interface. To continue the web page analogy, if
Gmail or Facebook used an analogous system then instead of merely being
able to change the theming via CSS (which may have to be specifically
forced from the browser preferences, because web-app people suck balls),
you could actually use a completely different webpage to interact with
the underlying application (no more
“New
look!” announcements, since anybody could use any look they wanted
all of the time).
Now to address the title of this post ;) As
I’ve described, Edje is a declarative system. An awesome feature of this
is that Edje can be completely replaced without the user even noticing,
since the point is to say “I want a button” and not care about how it
gets done. Well, the developers of
Canola
looked at moving to QT, since it offers more features than EFL, is more
widely developed, developed for and installed. However, they found that
Edje was too awesome to leave behind, so they ported it to QT and called
it
QEdje!
What’s particularly nice about QEdje is that a) the canvas used instead
of Evas, called QZion, is rather abstract in itself, so that different
QT systems can be used to do the work (eg. direct drawing to the screen
with the QPainter backend, more abstract layout with the QGraphicsView
backend or 3D accelerated with the KGameCanvas backend, depending on the
environment it is being used in) and b) the huge wealth of QT widgets
can be used in the program (this is pretty powerful considering that as
well as buttons, labels and tickboxes, QT also has
a
whole web browser,
Open
Document Format compatible rich text areas and an abstracted
audio/video
multimedia engine (which, so far, uses Gstreamer (Rhythmbox, Totem,
etc.), Xine (GXine, xine-ui), VLC, Mplayer, QuickTime (QuickTime Player,
etc.) on Mac and DirectShow (Windows Media Player, Media Player Classic,
etc.) on Windows).
After a little wrangling I’ve got it to
compile and the examples are working. This means I can have a play
about, so I’ll report on my findings :)