VisualMust ® - Written entirely
in the JavaTM programming language.
VisualMust is a multiplatform tool,
composed of several subsystems that will be discussed in separate
chapters. The Scope of Subsystems chapter offers a summary of the
Interface Builder, the Recovery Manager, the UndoRedo Manager, the
Properties Manager, the Events Manager, the Syntactical Editor,
the Debugger, the Generator of JavaTM
The VisualMust interface builder is a true
WYSIWYG interface builder allowing you to design your application
by using the Drag and Drop, Click operations, aso. With a
true WYSIWYG interface builder, you are sure the position of
any component will not change from click to click during the design
phase or then when you actually run the resulting application.
The interface builder offers a menu bar and popup menus all at
a right click away.
The VisualMust recovery manager has
been designed to retrieve and restore your data in any circumstances,
even after a system crash, a power failure, aso...
Data provided by the recovery manager are persistent information.
With this feature you will be able to do regression, even if you
have left the VisualMust environment, intentionally or not. That
means that, if you change your mind after having left VisualMust,
you are still able to undo your modifications.
The recovery manager is associated with a
The undo-redo manager will use the recovery
manager facilities. The undo-redo manager allows you to undo or
redo any action you made with the interface builder (even between
sessions). If a system crash occurs while you are creating a new
design (i.e. a new ODB file), or updating a previous one, just re-start
VisualMust and re-load your design : it will be automatically
updated by the recovery manager.
As you may guess, this provides you the
way of changing the properties of the beans you use in your interface.
We have done our best make it as user-friendly as possible. However,
the properties manager offers much more functionalities. Its collaboration
with the other managers included in VisualMust will allow
these beans to take advantage of the undo-redo facility, the drag
and drop support, automatic recovery and others. It is the properties
manager that controls if a given component may or not be dropped
to or from another one.
The properties manager supports any Customizer Dialogs
or Custom Editor that may come with a given bean. One of
the strength of VisualMust when compared with its competitors
is certainly that this support is not restricted to the logical
part of these editors but goes up to the visual part of
While the most evident task of the Events
Manager is to determine the list of events that a given component
may generate and allow the designer to specify the ones he wants
to handle, it performs numerous other tasks like instructing the
code generator to use a specific adapter, implement a listener.
It is also the Events Manager which is in charge of sharing the
source code with developers, respecting user modifications, user
preferences, and inserting methods that should process events.
VisualMust has a very powerful syntactic
editor which has its own recovery system. While it is automatically
called by the interface builder, you may also use it as a stand
As its competitors, VisualMust comes with
a debugging tool. The graphical JavaTM debugger
it offers is completely based on the Java Platform Debugger Architecture
(JPDA) and Java Debug Interface (JDI). It offers you all the possibilities
you may need to debug your applications or applets like break points
setting, step by step execution, runtime data visualization and
The VisualMust generator of code generates
a nice looking «.java» file wich can be modified by
VisualMust and developers. Even if a little part if this code is
inserted by VisualMust , there is no reserved parts in it :
you are totaly free to insert whatever you want at any place in
The limitation in this freedom is reduced to its bare minimum. This
file holding your work can be modified by any text editor without
starting the VisualMust application. (You can however invoke the
provided editor if you wish). It generates also a private file (that
is a file you must not alter in any way) that, in fact will hold
all the User Interface definition and implement an abstract class
that your file will extend. This structure seems to be the best
to use all the inteligence that has been put in the java architecture
by its conceptors.
The generated code respects the Object programming
recommendations. For every component you use in your User Interface,
VisualMust will generate a get_<BeanName> method that will
allow you to use this object at your convenience. Eg :
The use of this accessor guarantees that the corresponding
object has been completely instantiated before it is returned
to your application (if the above component was a container, then
upon return of the get_MyComponent() method, the container and
all the objects it holds are completely instantiated).
In order to help (or encourage) you documenting
your work, VisualMust puts Javadoc comment blocks (mainly dummy)
for all the methods it has created.