Qt Architect (formerly known as the Qt Dialog Editor or dlgedit)

by: 	Jeff Harris (harris@columbus.rr.com)  and 
	Klaus Ebner (klaus@gaspode.ndh.com)

Introduction:


	Qt Architect is a graphical dialog editor for the Qt widget set.
It allows for the graphical creation and placement of widgets onto a
dialog.  Various properties for the widget can also be set.  Widgets
may be mapped to variables so that you can control them once the
dialog is launched.  After the dialog is created on the screen, the
files for the dialog are created.  


Compilation and Installation:

	To compile Qt Architect, the following are needed:

		Qt 2.1
		gmake, GNU's make
		flex 
		a C++ compiler


	Currently, a source code distribution is available as well as
a Linux binary.  Simply uncompress and untar the file.  It will create
a Qt Architect directory and several sub-directories.

	To build Qt Architect, edit Makefile.common to update the necessary
paths and run make depend and then make in the Qt Architect directory.  The
makefiles in the directories currently compile with debugging
information.  As a result, a lot of disk space, over 70 Megs, is used,
so be forewarned.  The Qt Architect executable, qtarch, is about 13 Megs
unstripped.

        To install Qt Architect, edit the Makefile to change INSTALLDIR to
where you want Qt Architect to be installed to.  By default, it installs the
executable in /usr/local/bin and other files in /usr/local/lib/qtarch.  Run
make -f Makefile.install install to perform the installation.


Running Qt Architect:


        After Qt Architect is built, it can be run by executing qtarch.  Any
dialog files on the command line will be opened automatically.  Also, if the
option '-g' is given, the dialog files on the command line will have their
source files generated.

	To add widgets to your dialog, select the Insert menu item and
then the type of widget you wish to create or use the toolbar.  The widget
will appear in the upper-left corner of the dialog.  The widget can be
moved by clicking and dragging while the cursor is the cross hairs.
Clicking and dragging over one of the eight greyed boxes will cause
the widget to be resized.  Multiple widgets can be selected and manipulated 
by holding down the control key while selecting and moving.

	Properties for the widget can be changed by selecting the
widget, clicking on it, and then choosing the Edit->Properties menu
item.  Alternatively, you can right mouse click on widget to bring up
a menu and select Properties.  Once the properties dialog is opened,
use the tab bar to select which type of properties to change.  When
all your changes are finished, press OK.

	The size of the dialog itself can be changed by clicking on
the background and resizing the window.    

	The layout for the widgets initially has a 10 pixel grid that
the widgets snap to.  This behavior can be changed by selecting the
Edit->Grid menu item.

	Information about the files to be generated must be entered.
Open the property dialog for the dialog window and go to the File
Generation page.  In the first edit box, type in the name for your
class.  The other fields will be filled in with some
default values.  These can be changed at will.  The Dialog data class
name is the name of the class that will contain members for your
mapped widgets.  The dialog class is derived from its data
class.   The data class can no longer be a member of the dialog class,
as in previous versions since signal/slot connections wouldn't work.
To see an example of how the files interact, see the source for
Qt Architect, especially the prop directory which contains all the property
dialogs used.

	To generate the files, select Dialog->Generate Files from the
dialog window.  You will be prompted to generate either the dialog
class or its data or both.  If Qt Architect finds the dialog class files,
it will not overwrite them by default since you will probably add code
to the files.  Buttons contained inside of a QButtonGroup will be automatically
inserted into the group.  The buttons must have variables mapped to them.

	File saving and loading works as you might expect it to.
There is no warning, yet, about exiting with unsaved changes.  Qt Architect
saves to .dlg files for dialogs and .prj for projects.  These files
are text files that contain all the information needed for your
widgets.  It is safe to modify these files on your own, but I do not
recommend it.


Bug reports:


	If you should happen to find a bug in Qt Architect, please send me,
Jeff, a report and possible a patch if you feel up to it.  


Contributions:

	
	If you would like to contribute to Qt Architect, please do so.  I
ask that you contact me before starting on a feature to make sure no
one else is working on it.  A list of things that need to be done are
in the file TODO, but don't feel limited to just those.


License and copyright:


	We, Jeff Harris and Klaus Ebner, are the owner of the source for
Qt Architect.  We intend for the source to remain freely available to the Qt
community.  Qt Architect is distributed under the Gnu General Public
License.  Qt Architect can be freely distributed, providing that this file
be contained in the distribution.