Bongo Programmer's Documentation
The general mechanism for creating Java applications with Marimba Bongo
is fairly easy. You can use scripts for all operations or use the user
interface - developed in Bongo - in your existing Java application. The
first option, everything with scripting, is a nice solution for simple
applications. For more complex applications it is better to create your
user interface using Bongo and do the operations with a regular Java application.
A Bongo application is called a presentation. Once you have created
a presentation it is saved in a .gui file.
If you use scripting you are done now: you have a fully operational application.
In the other case you now have to write a small main Java application which
loads the previously created presentation and shows it on the screen using
a PlayerPanel (see below). Your application will then receive normal
AWT events from the presentation and it can access the widgets in the presentation
by name. That way you can add behaviors to your application without depending
on scripting alone.
Package Listing
The API documentation covers the following Java packages:
- marimba.util
- This package contains generally useful utility classes.
- marimba.io
- This package contains extensions of the java.io classes. The streams
in this package are much more efficient than the standard I/O streams but
they are not thread-safe.
- marimba.gui
- This package is the basis for the Bongo GUI architecture. It contains
the base widget classes, extensions to the AWT, and classes that help you
build Bongo presentations. This package also contains all the standard
widget classes.
- marimba.text
- This package defines a multi-font and multi-line text editing widget.
- marimba.persist
- This package defines a set of classes which are used to persistify
user interface components and other data structures.
Important Classes
Here are direct links to the most important GUI classes:
- marimba.gui.Widget
- This is the base class for all widgets. It deals with all the details
of event handling, repainting, graphics, etc.
- marimba.gui.ContainerWidget
- This is the generic widget container class.
- marimba.gui.Presentation
- This is the top level widget that can be persistified to a file.
- marimba.gui.AWTWidget
- This is the base class for widgets which contain an AWT component.
- marimba.gui.PlayerPanel
- This AWT Panel let you quickly display a Presentation. This class takes
care of the double buffered graphics and widget event distribution.
- marimba.gui.PlayerFrame
- This is handy class if you want to show a presentation in its own window.
Other links
Also available are:
Note that the API documentation for the standard Java classes is NOT
included. This means that links to the these classes and packages may not
work.
Code Examples
Bongo comes with a number of simple examples.
- Example.java - An example
program which shows how to program the widgets directly from Java without
using Bongo.
- UserName.java - This
example program uses a presentation which was created using Bongo and shows
it in an AWT window. It then uses an event handler to intercept events
to add behavior to the widgets in the presentation.
- UserName2.java - A
variation of the previous example. This example uses 2 presentations and
displays them in different AWT panels.
- RoundButtonWidget.java
- An example of how to write your own widget from scratch.
- BinaryTreeNode.java
- An example of how to persistify a data structure.
Source Availability
The source to all widgets are included in the release they are located
in the src directory. They are included for your reference
only and should not be copied and/or modified.