---

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:

• Alphabetical index
• Class Hierarchy
• Package Listing

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.