Jigloo GUI Builder User's Guide
Introduction
Cloudgarden's Jigloo GUI Builder is
an Eclipse plugin which allows you
to build
and manage GUIs using both Sun's Swing and Eclipse's SWT toolkits.
It is free for non-commercial use, but a Professional license must
be purchased for commercial use - please visit the www.cloudgarden.com
website.
It creates and manages code to create
all the parts of the GUI as well
as
handle events, and shows you the GUIs as
they are being built, allowing you to experiment with the more complex
features of the Swing GridBagLayout or SWT's FormLayout, for instance.
It also offers very advanced and powerful code-handling features -
fine-grained control over code-generation and parsing, as well as
visual inheritance and custom controls.
It can lead to a very large time-saving (over
hand-coding) for GUI
development and maintainance tasks, and because the Jigloo GUI builder
is integrated with the
Eclipse IDE the invaluable code-management features of Eclipse are
immediately available to further modify the code generated by Jigloo.
It can manage java classes created
previously by hand, or using an IDE such as JBuilder, Netbeans etc. It
is able to handle most common ways of constructing GUI code,
though it is not able to handle certain exceptional cases - but these
limitations are described in the documentation.
It supports visual inheritance - Jigloo
can be used to build classes which are extensions of other visual
classes (an example might be a generic ShopFrame which extends
JFrame and has generic labels and containers designed to be customized,
and a FlowerShop class which extends ShopFrame and customizes the
inherited generic components). Jigloo can be used to design classes
which extend any type of visual class - though abstract or non-public
classes require a small modification to the code.
In detail, the Jigloo GUI builder offers the
following features:
Basic:
- Builds complete Java
classes for GUIs in
SWT or Swing with an easy-to-use WYSIWYG editor.
- Two-way
(or round-trip) java code editing - changes made in the Form Editor are reflected in
the code, and changes made to the code are also reflected in the Form
Editor.
- Can recognize and manipulate code generated by hand or by IDE (eg, Netbeans, JBuilder, VEP etc).
- Supports visual ineritance - can be used to edit classes which extend other custom visual classes.
- Palette for adding
components and
setting layouts.
- Easy navigation
between source and form editors, with the selection in
the form editor following the location of the cursor in the source
editor, and the source editor scrolling to the code relevant to the selected element in the form editor.
- Multi-selection of
components - for setting
of properties, layout parameters, and copy/cut/paste/delete.
- Context-menu options for adding
components and setting layouts (use of palette and/or context menu
controlled by preferences page).
- Manipulates most
properties of the GUI
components, such as colors,
fonts, images, sizes, borders etc,
- Creates event handlers
for any
and all of the component's events.
- When creating components, initial
text,
image and layout properties can be quickly set using a single
creation
dialog.
- Basic
editing commands, copy/cut/paste/delete, as
well as "Move up/down", to rearrange components.
- Infinite Undo/Redo
capability for all actions (setting of properties, layouts, layout
constraints, cut, paste, add, delete and move).
- The GUI editor and Outline view can
be used to drag/copy-and-drop components inside and between
containers.
- Java
code and GUI form viewed in single editor - either a split-pane
(horizontal or vertical) or tabbed-pane layout is selectable.
- Generates stub models for certain elements (eg, JTable, JSpinner, JList etc), and can parse models from code.
Code Handling:
- There are many ways to customize the parsing of the Java code.
- Blocks of code which are not directly involved in building the GUI can be hidden from Jigloo by user-customizable comment tags.
- The classes which Jigloo will instantiate while parsing the code can be controlled on a fine-grain level.
- The code generated by Jigloo can also be customized:
- It can follow
the convention of the existing code (eg, JBuilder code uses
getter methods to initialize it's components, and Jigloo can detect and
use this format).
- It can separate elements with braces, blank lines, or user-defined comments.
Layout:
- Handles all Swing and
SWT layouts
(including GridBag, Form and
absolute layouts).
- Delphi/Visual Studio
layout-manager
mode for SWT FormLayout (and Swing AnchorLayout).
- Intuitive (mouse-dragging) method
for changing the grid properties of Swing GridBagLayouts.
- Snap grid allows components
to be
located and resized to a uniform 5 to 20 pixel grid.
- Components can be
drag-and-dropped
(and copy-and-dropped) between containers, re-ordered and
resized by mouse-dragging.
Advanced:
- Visual Inheritance is supported - Jigloo can be used to build classes which are extensions of other visual classes.
- Custom classes extending
Component
(Swing) or Control (SWT) can be added to the GUI.
- Non-visual classes can also
be added to the GUI, and their properties edited with the property
editor.
- The class of a GUI element can be
changed (eg, changing a Composite to a Group, or to a custom class)
with a context-menu option.
- Parts of a GUI class can be extracted and
saved as a new class.
- Easy
access
to the Javadoc for
Swing and SWT components and
layouts
- Ability to preview or
run the generated java
code from a toolbar button.
- Converts between
Swing and SWT GUIs (both ways).