This is a GUI builder for AbstractUI::ML, which is also on this homepage.
Actually it is the first GUI builder ever written in Standard ML!
It is all distributed under the GNU General Public Licence (GPL),
which (in short) only allows you to write any extensions for The Construct if
you distribute all the sourcecode for your extensions
under a GPL compatiple licence. However you may of course
use the user interfaces generated with The Construct for whatever
To use The Construct you will need one of the supported hardware platforms.
When compiling applications with user interfaces generated
with The Construct or when compiling The Construct itself,
the requirements are the same as those for AbstractUI::ML.
If you just want to see The Construct running, all you need is a binary distribution. There is one for 'MS-Windows' here (there are problems when selecting some of the UI controls in the current 'MS-Windows' version): TheConstruct19990927x86Win.zip or TheConstruct19990927x86Win.tar.gz or TheConstruct19990927x86Win.tar. And one for 'Linux/X-Windows' here: TheConstruct19990927x86Linux.tar.gz or TheConstruct19990927x86Linux.tar.
The tar.gz files are unpacked (under Linux) with 'gzip -d file.tar.gz' followed by 'tar -xvf file.tar'. For the tar files you only use 'tar -xvf file.tar' of course. Hopefully you will have some way of unpacking the zip file for Windows.
You can also download the source code which is ready for compilation with SML/NJ here: TheConstruct19990927SMLNJsrc.tar. And a version prepared for MLWorks here: TheConstruct19990927MLWsrc.tar.
These are packed with tar, so to unpack you do something like 'tar -xvf file.tar'.
Each of these distributions expect that you have installed AbstractUI::ML
and that you unpack the distribution from the same directory that
you unpacked AbstractUI::ML from. This is to make sure that
the directory called TheConstruct is put into the directory called
HardcoreProcessing in both distributions so that all paths in the
project are valid.
To compile with the SML/NJ version, go to the directory 'HardcoreProcessing/TheConstruct/srcSML' in the distribution, start the compiler with 'CM' and 'CML' and call the usual 'CM.make();'. Then call 'TheConstruct.start ();' to start it.
With MLWorks you load the project file for the desired demo in the directory
in the distribution. Then hit 'project->compile target sources'
in the menu, wait for a couple of hours, hit 'project->load targets'
and wait for a couple of hours again. Then call 'TheConstruct.start ();'
to start it.
To write applications with user interfaces built with The Construct you definately have to read the documentation for AbstractUI::ML. To get a good initial overview of both AbstractUI::ML and The Construct you should check out AbstractUI::ML and The Construct Basics. If you only wish to try The Construct, then the documentation for it is very short and follows here:
In The Construct you can either create your own user interfaces from scratch or you can load existing user interfaces and modify them. To create a completely new and empty window, use the 'Window' button in the 'UI Palette' window. To add user interface controls to the window, press the button for the control you need in the 'UI Palette' window, followed by a click on the window where the control should be.
You can customize your window and the user interface controls that you have created by clicking on them and using the 'Protocol accessor' window. Some of the protocols are marked with 'N/A' or '(only for bindings)', which means that you can't edit them in The Construct - either because it does not make sense or because a protocol editor has not yet been implemented for the protocol.
You can create a binding for a protocol by toggling the button on the left of the 'Protocol accessor' window for the desired protocol and writing the name of the binding in the textfield.
To load an existing user interface, type the name of the file in the textfield beside the button 'Load' in the 'Operator' window and press the 'Load' button. Saving a user interface is done similarly with the save button, which will export the user interface as Standard ML code ready to be compiled directly into an application or to be loaded into The Construct later.
Protocols with bindings will be accessible from your application when you compile an exported user interface file into the application. You can look at the generated file to see how.
That's it - now go create some graphical user interfaces! :)