The tools provided in the book work in JBuilder versions from 7 through 10, unless otherwise noted.
A compiled and ready-to-run version of each project is available with the code.
Part 1 - Introduction to the OpenTools API (Chapters 1 - 3)
Part 2 - The PrimeTime Core (Chapters 4 - 6)
Part 3 - The User Experience (Chapters 7 - 9)
Part 4 - The Browser (Chapters 10 - 14)
Part 5 - The Editors and Viewers (Chapters 15 - 22)
Part 6 - The Wizard Framework (Chapters 23 - 24)
Part 7 - The Processors (Chapters 25 - 26)
Part 8 - External Systems (Chapters 27 - 28)
Part 1 - Introduction to the OpenTools API
- JBuilder itself is a collection of OpenTools. Just about whatever you see
that JBuilder can do, you can also do through an OpenTool.
- How OpenTools are found and loaded into JBuilder. This chapter includes
a very basic OpenTool to demonstrate the basic loading techniques.
- A discussion on various approaches to debugging your OpenTool: from simple
debug output, to using JBuilder's own debugging abilities to run and examine
itself. A configuration file for debugging JBuilder is included here.
Back to the top
Part 2 - The PrimeTime Core
- The starting point for most OpenTools is the
PrimeTime class which
provides version information for the OpenTools API. Command-line tools let you respond
to additional options on the JBuilder startup command. The
example lets you generate Javadoc for your project from the command line.
- Interfacing with various implementations of persistent storage, the Virtual File System
provides access to the files that make up a project. The
demonstrates how you could save and retrieve your files across the Internet.
- Added functionality for different file types comes from the node type hierarchy
within JBuilder. From the generic
Node, through organizational and
information nodes, to those that represent real files. From Java source code,
to images, to JAR files, and deployment descriptors, each node type
identifies a particular format and defines what you can do with that file.
OTFileNode example singles out OpenTools manifest files,
distinguishing them from generic text files.
Back to the top
Part 3 - The User Experience
- Saving property settings between sessions is a critical part of the user experience.
Customizations are remembered and used again next time enabling the user to focus on
their development tasks. Properties appear in several different contexts: global settings
for the IDE, settings for a project or an individual node, and in memory collections.
Values may be easily updated through property pages associated with a set of properties.
XMLTools example uses global properties to remember
which XML validator and XSLT engine to use.
- Adding online help to your tool can make it more friendly, and more likely to be
accepted and used. You can also provide Javadoc for your tool so that users can enhance
or extend it. This documentation can be integrated into JBuilder's IDE so that it
appears on request for your classes.
- A large number of utility classes are included in JBuilder and are available for
your use. From UI components such as enhanced trees and tables, to information about
the JBuilder environment, to dealing with Zip files and file differences, there is
something of interest for everyone. The
UISample example demonstrates
most of the UI components and several of the non-visual ones as well.
Back to the top
Part 4 - The Browser
- The browser is the main window for JBuilder, although you many have several open at
one time. It coordinates the interactions of the other sections of the window: the menu
and toolbar, the Project, Content, Structure, Message, and Status Panes. The
BrowserNumber example keeps track of your
open browsers by adding a sequential number to the caption of each one.
- Actions form the basis for most interactions with the UI. They underlie the menus
and toolbars. They are linked to keystrokes in the editor. They invoke wizards to
generate new files or work with existing files. JBuilder defines a hierarchy of action
classes for the different situations, including the
manages a set of other actions. The
ActionSampler example places a new
entry on the Help menu and demonstrates several of the action types.
- The menus and toolbars in JBuilder are the starting point for many activities
within the IDE. They host collections of actions which then provide the appropriate
ToolBarManager example lets you redesign your main
toolbar completely. It uses global properties to retain the user's settings between sessions.
- Communicating with the user in a non-intrusive manner is the purpose of the Status
and Message Panes. The Status Pane appears along the base of the browser and displays
a single line of text, such as fly-over hints for buttons and menu items, or the
summarized results of a compilation. The
IconTips example uses the
Status Pane to explain those strange icons in the Structure Pane for Java code as you
hover over them. For more detailed information, or where the user may want to interact
with the data, you use the Message Pane. This panel above the Status Pane appears as necessary
and provides a series of tabs for different topics. The
ConsoleDisplay example is a
command-line tool that redirects standard output and/or error to a tab on the Message Pane.
- Files and other nodes that make up a project are shown in the Project Pane. They can
be organized into hierarchical groupings, and operated on by bringing up a context menu.
Selecting Properties from that menu displays a set of property pages applicable
to the selected nodes. Opening a file or node usually loads its contents into a viewer
within the Content Pane. This pane has a set of tabs across the top or right sides -
one for each open node. Along its base appear tabs corresponding to viewers for the
current node. The
XMLTools example adds several menu items to the context
menu for XML nodes, while the
TabProps example adds menu items to the
Content Pane popup menu to alter the location and appearance of its tabs.
Back to the top
Part 5 - The Editors and Viewers
- The editor is one of the key node viewers, allowing you to view and alter any text-based file.
It provides syntax-highlighting, line and gutter marking, and numerous options for configuring
its behavior. The
SyntaxChecker example from Steven Lee, monitors the Structure Tree
for Java code, and highlights the positions of errors in the code within the editor.
- Support for different languages and text file formats is provided by the
associated with the various node types. These use a
Scanner to identify the tokens that
make up that language, thus connecting to the syntax-highlighting feature. The
OTScanner examples illustrate these abilities for OpenTools manifest files.
- Linking keystrokes in the editor to actions within the IDE is the purpose of key bindings.
You can define an entire set of key bindings to emulate a particular environment, or you can
customize existing bindings to add your particular actions. The
from Matt Mower takes over the standard keystrokes for cut, copy, and paste, and redirects
them to its own set of multiple clipboard buffers.
- Additional functionality may be provided for specific file types, such as rendering HTML,
viewing images, or comparing text files. Viewers must interact with the Virtual File System
to synchronize themselves and the underlying file. The
operates on GIF image nodes and provides a basic image editor.
- The Structure Pane generally provides some sort of navigational view of the node
in the Content Pane. However, you can place whatever UI components you want here. The
GIFEditorStructure example displays a preview of the image for the
GIFEditor tool from the previous chapter. The
example lists the OpenTools categories found in the manifest file, and adds a
context menu that makes it easy to add new categories to it.
- The Component Modeling Tool (CMT) is a collection of classes and interfaces that
makes it easier to read and alter properties on components within a Java class.
It is used in the UI designer and layout assistants described below. The
CMTDump example displays basic CMT information about the current file.
- For Java source files, a Design viewer tab is added to the Content Pane. Here
you can visually design your class, from UI development to database interactions.
IBXDesigner example manages components from the InternetBeans
Express suite, displaying their relationships and HTML content.
- Layouts let you design your UI in a device-independent manner. However,
the basic layout implementations do not provide enough feedback information
for a visual design tool. Enter layout assistants that fill the void, acting
as the go-between for various layouts in the UI designer. The
BorderCornerLayoutAssistant example creates a new layout and
its assistant for an enhanced
Back to the top
Part 6 - The Wizard Framework
- Wizards are implemented as dialogs with one or more pages that lead you through a
repetitive or complex task. They come in two main types: those that generate new files
and typically reside in the Object Gallery, and those that operate on existing files
and reside on the Wizards menu. JBuilder provides a hosting environment for the pages,
making the job of writing a wizard that much easier. The
example creates a wizard that scans a project for classes that implement JSP custom
tag functionality, and constructs a taglib descriptor file from them.
- Many wizards either generate or parse Java code to provide their abilities.
To assist in this process, the Java Object Toolkit (JOT) is available. Starting
from a package, you can step down into files, classes within a file, methods and
fields in a class, and statements within a method. You can generate entire new
classes or make very precise modifications to existing code. The
example is a wizard that builds a new class implementing JSP custom tag functionality.
Back to the top
Part 7 - The Processors
- Transforming your source code and supporting files into a runnable application
is the purpose of the build processor within JBuilder. It lets you define tasks that
are executed as part of the build of a project, and provides many standard ones.
This subsystem underwent a major overhaul in JBuilder 7 to base it on the open source
Ant tool. The
BuildNumber example from Joi Ellis demonstrates how to
add a task to the build process - updating a build number file each time.
It has been updated to work with JBuilder 7 and up.
- Once the application is built and packaged up you need to be able to run and
debug it. The runtime processor supports this requirement. Multiple configurations
for running your project may be established, each with its own runtime environment.
JBuilder automatically provides support for standalone applications, for applets,
for servlets and JSPs, and for EJBs. The
OTRunner example adds an
appropriate environment for running OpenTools - namely a second JBuilder instance.
Back to the top
Part 8 - External Systems
- Version Control Systems (VCS) assist in the management of access to multiple
versions of a file, for maintaining historical versions of files, and for grouping
files versions that work together as an application. These are external, standalone
systems that can be used in a variety of programming environments. JBuilder provides
an API whereby these tools can be integrated into the IDE, allowing you to check
files in and out, to retrieve old versions and compare them, and to review the
status of all the files in a project. The
SourceSafeVCS example from
David Brouse demonstrates how this is used to interact with Visual SourceSafe.
- Another type of external system that JBuilder regularly interacts with is an
application server. Again an API exists so that JBuilder can communicate with
external servers and deploy applications to them, start and stop them, and even
debug them. The
JBossOpenTool example from Marcus Redeker provides
a connection to JBoss, an open source application server.
Back to the top
- Many OpenTools are available online from the repositories listed in this chapter.
Also described in the process of submitting an OpenTool to
CodeCentral, Borland's code repository.
- More and more classes within the OpenTools API are being documented as new JBuilder
versions are released. This chapter tracks the differences between the versions
with respect to documentation.
- Several help topics are already defined as constants if you wich to reuse them.
This chapter lists those that are available.
- The XMLTools OpenTool is partially described through the book where its
functionality demonstrates various aspects of the OpenTools API.
This chapter provides a wrap up of the tool.
Back to the top
Inside the JBuilder OpenTools API