[boost] Re: UI++

From: Paul Hamilton (paul_at_[hidden])
Date: 2003-08-09 01:38:48

I am currently porting something called "XMLUI" to use boost/bjam etc.

The general background of XMLUI is based on the work we did at mBED for 
a "flash-like" animation system (although it predated flash).

This project is the culmination of a number of years of design of 
"widget-less" UI systems that I have been undertaking.

What XMLUI is now:

- XML based description language for UI's (windows, panes, buttons etc).
- Rendering engine for the above (only on windows at the moment, and 
not GPL or using boost).
- Dynamic loading system (just DLL's on windows).
- Tools for developing XMLUI are written in XMLUI.
- written using C++ (VC at the moment).
- heavy use of patterns and STL.

I presented a white-paper on XMLUI at an XML conference last year 
(which I can send to people who want it. It's only a 170K PDF), and the 
project has been used commercially to build a number of systems.

So where am I at?

A complete UI system may involve a complex class hierarchy of maybe 200 
to 300 objects. Each of these objects needs to interact in the 
following ways:

- settable and gettable members directly in the UI (so that a slider 
can modify a text field for example).
- observer pattern in heavy use so that a button can dim based on the 
value of another object's field (for state maintaining), and so that a 
slider can update a text field.
- each object persists to and from XML files (and complete hierarchies 
of objects need to do this).

So to support this, from the start you need:

- A "tangle" tool which can read a large object schema and build C++ 
classes for:
        - the visitor patterns so that members can be set/get.
        - the observer pattern.
        - the prototype pattern (for object inheritance and persistance).
        - the composite pattern so that one object can contain lists (vectors) 
of other objects and references to other objects.
- A schema which describes the following types of objects:
        - panes which represent the different types of UI elements.
        - commands which encapsulate the actions for the buttons etc (and for 
the undo system).
        - enablers and pipes for moving data around between objects.
        - some type of expression language.
        - generators for filling panes with data.

What I have done using boost:

- A general persistence scheme called cpppersist which is general, but 
I have written an XML persister.
- A general reflection scheme called cppreflect which allows members of 
objects to be set/get via strings (and found etc).
- A base object for all "XML persisted/reflectable" objects called 
xmlobj which combines the above two things.

These are almost ready to go up (on sourceforge probably), I just need 
to write a few more unit tests.

What I am working on right now:

- a tangle/weave literate programming system using xmlobj's called 
cppliterate which I can use to build all of the classes, create the 
Jamfiles etc.

I am a couple of weeks of work away from finishing this off. I need to 
integrate tangle into boost's build system, and I need to build a weave 
tool (it really isn't needed since I get around it now by having tangle 
build "doxygen friendly" source files, and then run doxygen on them. 
But a REAL weave will be necessary for user documentation etc).

Naturally weave and tangle will be built using weave and tangle :-) So 
it's an interesting if not recursive exercise to build (like, how much 
of tangle do you need to have written before it can start tangling 
itself?).

When I've finished cppliterate I'll let you guys know, but of course 
this still isn't anything to do with UI's, but it would be useful for 
others who need to do large scale cpp development. This will be 
released the same as boost is (using the same build system), so it 
might be cool to put it into boost at some point once it's proven 
useful.

Once this is done, you could use it to build a description system for a 
widget library, which is a necessary thing. You could probably write an 
object-widget mapper in tangle to generate the WxWindows/QT/MFC stubs 
directly which would save time.

Then it's a case of taking my existing schemas that I have for XMLUI, 
creating all the objects and then porting all of the code currently 
running on windows to this new system. This is probably a good 6 months 
away, but it will happen this year, and it will be free (probably GPL). 
It will probably only be windows/Mac OS X available, but a port to X 
would be simple.

Paul.

---------------------
Paul Hamilton
pHamtec P/L - Software Makers
http://www.phamtec.com/
mailto:paul_at_[hidden]

The information transmitted is intended only for the person or entity 
to which it is addressed and may contain confidential and/or privileged 
material. Any review, retransmission, dissemination or other use of, or 
taking of any action in reliance upon, this information by persons or 
entities other than the intended recipient is prohibited. If you 
received this in error, please contact the sender and delete the 
material from any computer.
-----------------------------------------------------