DWI -- Data With Interaction

(aka DUI -- Data Under the Interface)

SourceForge Logo DWI is an experimental platform for exploring ways of making application development simpler. It is still hard to write large, complex, multi-user, data-driven (SQL-backed) applications. It doesn't matter if your development platform is the web and Enterprise Java Beans, C# and .net or Mono, or whether its the Gnome/GTK or KDE widget set and the Linux desktop; its still just plain hard. DWI is an effort to change this situation. DWI currently offers a simple way of developing data-driven (that is, SQL-backed) Gnome applications (designed with the Glade GUI designer). It does this by avoiding "programming" (or at least, "traditional programming" in C. C#, perl, python or any other "traditional" language), substituting instead a configuration-file like format that defines how various GUI elements should be hooked up to various objects (such as GLib GObjects) or SQL fields and tables. The current primary effort with DWI is to provide a number of well-documented, easy-to-understand, working examples that show how to use DWI. These examples currently include a stand-alone bug-tracker-like application, examples of integrating with existing GTK applications, and an example of hooking up a Glade-designed interface to a GLib GObject with almost no C programming at all (assuming you have a GLib GObject already handy :-). The "Why DWI?" Page explains the motivation for DWI at length; it includes comparisons to other similar technologies available today.

DWI in its Current Form

DWI is a fairly simple environment for quickly creating data-driven applications, that is, graphical applications that manipulate and show info from a database. This environment differs from others in that it is focused on native GTK/Gnome support through the Glade GUI designer, and thus allows you to build user interfaces as elegant as you can make them in Glade.

At this point, this system has enough features to be adequate for creating form-editing and reporting applications. Multiple SQL database vendors are supported through ODBC (http://www.iodbc.org) or libdbi (http://libdbi.sourceforge.net) drivers. There is a simple db-driver infrastructure so its easy to support for additional SQL API's. The system supports all of the basic Gtk widgets, and an additional half-dozen Gnome I/O widgets, such as GnomeDateEntry.

DWI is powered by an 'engine' that has some fairly generic procedures for mapping 'fields', such as SQL table columns or widget values, between each other, and also between other things, such as objects, hash tables and etc. In a certain sense, the engine can be thought of as an Object-to-Relational Mapping (ORM), mapping SQL to several object systems, including Glib GObjects and QOF. This engine has been designed so that it becomes easy to add support for all kinds of new object systems: i.e. for the engine to be a generic re-mapper between not just SQL and GTK but between many different types of object systems and data sources/sinks.

Built on top of this engine is a DWI application that parses an XML-based file, the "DWI file", that describes the connections between glade widgets (or objects in general) and database tables. Currently, the only way to create DWI files is by hand. Unfortunately, this can be a fairly long and laborious process itself, especially when creating something a bit more sophisticated. In the future, we hope to have an extension to Glade, or possibly an extension to a database-browsing tool that will allow you to graphically make such connections. (Work has begun on such a tool, written in DWI itself).

The grim reality is that DWI won't ever become popular without a graphical designer. Although fairly complex apps can be readily created using DWI, it does have a non-trivial learning curve. When we say "can be created quickly", we mean "days" or "weeks", as opposed to "months" for traditional database application development cycles. Graphical RAD tools have a way of being brainlessly pleasant to use, and give the impression of an even faster development cycle, even though the learning curve is identical.

Note that the design of the XML format is sufficiently generic that it is not directly tied to Glade. It should be straightforward to adopt other ORM markups to inter-operate with the DWI engine. It is also envisioned that other GUI object systems, such as PHP, could be used with DWI, so as to create data-driven web pages. That is, Glade is currently the only GUI driver, but other drivers for other GUI's should be possible.


These screenshots show a very basic note-taking bug-tracking-like application. The screenshots are not of DWI itself, but of a simple application created with it. Actually, what is shown was created by Glade; you'll have to take my word that there's a database behind this. Note that if you have good glade skills, you can create prettier interfaces than this.

Here's a screenshot of DWI using the columned-tree widget. Again, not much point to this, other than to show that DWI does support displaying the results of SQL queries as columned trees (which can be tricky).


Version 0.6.0 (July 2004)
Version 0.5.1 (April 2004)
Version 0.5.0 (March 2004)
Version 0.4.0 (October 2003)
Version 0.2.3 (April 2002)
Version 0.1.0 (March 2002)


To create a DWI application, you need to know SQL, and you need to be able to write XML files. You do not need to program in C or any other language. The dwi-run interpreter will run the entire application based on the DWI file. The testbasic.dui file describes the basic note-taking application whose screenshots are shown above. This example file works as a tutorial; it contains almost complete documentation of the file format.

The Bicycle Ride Calorie Calculator directory contains the example source for a DWI-to-GObject usage example. This example creates a GObject using GOB and hooks it up to a Glade-designed GUI using DWI. The example sources shown there is DWI file, the GOB file and the C glue-code.

A graphical editor, to automate the creation of these XML files, is being developed; its currently in the pre-pre-pre-alpha stage. Its being written in DWI itself, and so should prove that DWI can handle 'real-world' apps (as well as simplifying the bootstrapping of the editor).

The HINTS file provides some HOWTO-type suggestions for implementing application features, and should give you a hint of what is possible in DWI.

The DWI distribution also includes an example of how to query for a username/password, for database login, and an example of how to use well over a dozen different kinds of widgets within DWI.


Download from linas.org or Sourceforge; sorry, both are slow. The current version is 0.6.0. It works; we could call it 1.0, but more is planned before we call it that.

DWI is now located at SourceForge; The DWI Project Site is the right place to report bugs and submit patches.


Similar Projects

Essentially all Object-Relational Mappings are for Java, and are used for building web applications. None seem to be concerned with the GUI aspects. Thus, DWI is unique in being for teh C language, and working with desktop GUI objects.

Java ORM's:

Other ORM's:

July 2002, September 2003, March 2004, July 2004 Linas Vepstas <linas@linas.org>