Design of a Gtk GUI builder written in Ada.

Name
====

The name of the project is currently not chosen.
Several propositions:
 - quicky : reference to rapid by Martin Carlisle
 - radical: RApid Development of Interfaces, Components, Applications and
            Libraries

Key points and general goals
============================

* As generic and general as possible

* Object Oriented

* Pluggable
  Adding support for other libraries (like GNOME) shouldn't mean that
  this extra library is always needed to run the GUI builder.

* Support for multiple-languages
    This is partly done if we have backward-compatibility with Glade.

* Easy to add support for new widgets
   Widgets should be definable through either XML or the gtk's .defs files
   For instance, containers should define the function to use to add
   new widgets, so as to ease as much as possible the work done by the
   actual code generators.
   Ideally, the files used to define new widgets could be used to automatically
   generate part of GtkAda or other bindings.

* Compatible with Glade
   At least as a converter, since Glade's file is probably too simple
   We will need new tags for required libraries,...

* Bootstrapped

* Take ideas from Delphi:
   Simple Menu Editor
   Simple Properties editor, 2 tabs:
     - properties
     - callbacks (with complete list, and click to enable a callback, double
       click to jump to the code)

* Easy to define common callback behavior: open other widget, close widget
   More generally, have a "scenario editor" based either on the Canvas or
   drag-and-drop to replace as much as possible explicit code with graphic
   manipulations.
   Contextual menus for instance should be doable entirely with the GUI,
   likewise for cut-and-paste (?)

* Can design non top-level window widgets

* Can easily be integrated with other tools (editor, project builder, cvs, ...)

* Easy handling of big GUIs with multiple developpers
   Handling of merges, .... It should provide an easy way to split a
   project into several smaller projects, or merge several projects.

* Infinite Undo/Redo capability

* Copy/Paste, with the capability to have multiple copies in a buffer

* Drag'n'Drop

* External code generators
  This provides compatibility with potentially all languages that have Gtk
  bindings.

* Possibility to edit the styles of the widgets (colors, ...)

* Should provide an easy way to set up the contextual help (per-widget,
  per window,...

* Component-based
  The gui builder should be component based, ie it should be possible to
  easily create components like menus, widgets, forms,... that can be reused
  possibly multiple times in the rest of the interface. For instance, create
  a component that is the contents of a notebook, and associate it with each
  page of the notebook.

* Possibility to create new signals for components

* High-level definition and implementation of standard functions:
  - Creating a tree from a file or a tree (tab-separated for instance)
  - Setting up tooltips
  - "Busy cursor" around a callback.
  - Initial banner a la Windows when starting an application
  - Sorting columns of ctree/clists when clicking on the title of the
    columns.
  - Modal windows with new event loop (GtkAda.Dialogs)

* Predefined callbacks
  - for instance for "delete_event" when we should not close the dialog.

* Command line mode
  - Ability to access to most functionalities from a command line, e.g:

   $ glade-shell some-file.glade
   Loading from some-file.glade..
   gladesh> cut menu1                     ###  from menubar1
   gladesh> select menubar2
   gladesh> paste menu1
   gladesh> save some-file2
   Saving to some-file2.glade..

