[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[ossig] [Fwd: [Slugnet] [Fwd: [ANNOUNCE] GtkJavaScript and RadojoWidgets]]


This is the first public announcement of my JavaScript UI ToolKit
project (hinted about it here before but this is its first time it has
been announced in the wild). It is still alpha code / proof of concept
stage but it is shaping up quite well.


-------- Original Message --------
Subject: 	[ANNOUNCE] GtkJavaScript and RadojoWidgets
Date: 	Mon, 19 Sep 2005 16:10:08 +0800
From: 	Michael Clark <michael@metaparadigm.com>
To: 	gtk-devel-list@gnome.org, gtk-app-devel-list@gnome.org,

Hi Folks,

I'l like to announce some proof-of-concept code i've been working on.
This is the first public announcement of this work.

The general problem i'm trying to address is the divergence of web
UI programming and native UI programming and I have a novel solution
(travelling on the wake of what Google have been doing with AJAX
dynamic non-page reloading web interfaces that try to appear and
respond like native UIs).

As JavaScript is the defacto web presentation-tier programming
language i.e. being supported in every major browser and the initial
teething problems of compatibility being solved by better
conformance with ECMA-262 (as i've found in my testing across
a wide range of browsers), my proposal involves developing a
UI focused JavaScript toolkit API that can be used by next generation
web applications (rather than the clumsy, not standard across all
browsers and document focused DOM API) .

Instead of inventing a new API I've studied a few of the available
APIs and settled upon Gtk due to its elegance and simplicity :).

My initial problem was a lack of JavaScript Gtk bindings. gtk.org
language bindings page: http://www.gtk.org/bindings.html lists
JsGtk although this project seems dead and the archive I found
only supported a very small number of Gtk1.2 widgets so I set about
starting off a new set of JavaScript bindings for Gtk2 as well
as an extensible shell interpreter for the Mozilla SpiderMonkey
JavaScript engine (the Gtk2 bindings are a plugin to it):


My bindings although much further along than the previous work
still need more development (i could use some help).

The next step which is the real point of my project is to
implement an API compatible implementation of the Gtk widgets
in pure JavaScript that will run in any recent browser: RadojoWidgets.

So RadojoWidgets (aka Rwt) is a lightweight GUI toolkit for JavaScript.
The API is modeled on an object oriented variant of the Gtk API
(more like Gtk-- although of course Gtk is object oriented).

It is unique as far as JavaScript GUI Toolkits go as in addition to a
DHTML/DOM implementation that runs in most recent browsers, it is able
to use the native GtkJavaScript implemtation to allow Rwt applications
to run as standalone native UI applications thus providing a platform
to convergence native and web user interfaces (my second goal). ie.
The same code can be run outside of the browser using native Gtk widgets.

Rwt abstracts away differences in the DOM implementations between browsers
and provides a much simpler and more productive GUI focused programming
interface than DOM (which is very cumbersome to use and not designed
from a GUI programming perspective).

Rwt can run in the following browsers (no plugins required):

  Firefox 1.0, Mozilla 1.7, Internet Explorer 6.0, Konqueror 3.4,
  Safari 1.2, and Opera 8

Rwt uses the following software components to enable native GUI operation:

  PluggableJavaScript: http://www.radojo.org/PluggableJavaScript
  GtkJavaScript: http://www.radojo.org/GtkJavaScript

The raison d'etre of Rwt is to be used in combination with a web-tier
RPC such as RadojoRpc http://www.radojo.org/RadojoRpc to allow dynamic
AJAX sytle communication with the server-side. Your server side can be
implemented in any number of languages that have JSON-RPC implementations
such as Java, python, ruby, PHP, ...

Rwt is still alpha code but almost enough functionality has been built
at present to create some interesting next generation web applications.
It currently implements the Gtk signal system, has some basic containers
and widgets, implements the TreeModel, ListStore, TreeStore and a partially
working version of the TreeView (quite a complex widget).

Take a look at the treeview component test (remember to enable popups):


Here are some other relevant links:


I believe this _could_ revolutionize the way web applications are
developed (or in fact not just web applications). Presently it is hard
graft building highly interactive web interfaces and they are in fact
specialized and the code will only work on the web. This system will
enable the same presentation tier code in a multi-tier system to be
deployed both as a web app and as a native app and the code is much
easier and faster to write and will have the potential to be more
portable than clumsy DOM code.

I've got it to a stage where I believe my proof-of-concept shows
me that it is in fact an achievable goal. ie. it is possible to
get the Gtk rendering and packing model overlayed on top of the
DOM constructs and I have the basic object/signal/container system
working. Of course it is early days yet - much more coding to do.

Feedback, flames, discussion most welcome. Most importantly i'd be
keen if anyone is interested in helping out :).

Michael Clark.
gtk-devel-list mailing list

Slugnet mailing list