Contents
Chapter 1: Introduction
Chapter 2: The JBuilder environment
Working in the AppBrowser
Main menu
Toolbar
Project pane
Structure pane
Content pane
Message pane
Debugger
Status bars
Navigating and searching in the AppBrowser
Editor
Coding shortcuts
CodeInsight
Code templates
Working with the visual design tools
Customizing JBuilder's IDE
Browser options
File Types options
Run/Debug options
Customizing the editor
Editor options
Display options
Color options
CodeInsight options
Templates options
Java structure options
Using the object gallery
Using wizards to get a quick start
Creating JavaBeans the easy way
JBuilder menus
Chapter 3: Creating and managing projects
Creating a new project
Creating a new project with the Project wizard
Displaying project files
Saving projects
Opening an existing project
Creating a new Java source file
Managing projects
Adding to a project
Removing from a project
Deleting from a project
Opening a file outside of a project
Renaming projects and files
Working with multiple projects
Switching between projects
Saving multiple projects
Working with libraries
What is a library?
Adding and configuring libraries
Editing libraries
Display of library lists
Setting project properties
Setting the JDK
Configuring JDKs
Setting paths for required libraries
Packages
.java file location = Source Path + Package Path
.class file location = Out Path + Package Path
Using packages in JBuilder
Package naming guidelines
How JBuilder constructs paths
Source Path
Out Path
Class Path
Browse Path
Doc Path
Backup Path
Working Directory
Where are my files?
How JBuilder finds files when you "drill down"
How JBuilder finds files when you compile
How JBuilder finds class files when you run or debug
Chapter 4: Compiling Java programs
Smart Dependencies Checking
Types of compiling
The Make command
The Rebuild command
The Run command
Automatic source packages
Compiling a program
Syntax errors and error messages
Compile problems when opening projects
Checking for package/directory correspondence
Selectively compiling stable packages
Making stable packages
Setting compiler options
The scope of project-wide settings
Adding symbolic debug information
Setting the output path
Compiling from the command line
bmj
bcj
Building a project from the command line
Switching between the command line and IDE
Chapter 5: Running Java programs
Running .java files
Running applets
JBuilder's AppletTestbed
Running web files
Running projects
Setting runtime configurations
Using the command line to run and debug
Running from the command line
Debugging from the command line
Chapter 6: Debugging Java programs
Types of errors
Runtime errors
Logic errors
Overview of the debugging process
Compiling the project with symbolic debug information
Starting the debugger
Running under the debugger's control
Pausing program execution
Ending a debugging session
The debugger user interface
Debugging sessions
Debugger views
Debugger toolbar
Debugger shortcut keys
ExpressionInsight
Tool tips
Controlling program execution
Running and suspending your program
Resetting the program
The execution point
Managing threads
Moving through code
Running to a breakpoint
Running to the end of a method
Running to the cursor location
Viewing method calls
Locating a method call
Controlling which classes to trace into
Using breakpoints
Setting breakpoints
Setting breakpoint properties
Setting breakpoint actions
Creating conditional breakpoints
Disabling and enabling breakpoints
Deleting breakpoints
Locating line breakpoints
Examining program data values
How variables are displayed in the debugger
Changing data values
Watching expressions
Evaluating and modifying expressions
Customizing the debugger
Customizing the debugger display
Customizing debugger settings
Setting update intervals
Creating debugger configurations
Chapter 7: Designing a user interface
What are components?
Component categories
Which component should you use?
What are containers?
Windows and Panels
JBuilder's visual design tools
Requirements for a class to be visually designable
Laying out your UI
Basic design tasks
Starting your UI project using wizards
Opening the UI designer
Adding components to the UI container
Specifying a coding style for generated code
Selecting components in your UI
Adding components to nested containers
Moving and resizing components
Cutting, copying, and pasting components
Deleting components from your UI
Undo/Redo
Grouping components
Adding menus, dialogs, and database components
Adding additional containers to your project
Changing the look and feel of your UI
Serializing components in the UI designer
Fast track to serializing
Serializing a this
object
Using customizers in the UI designer
Keyboard shortcuts in the UI designer
Using the component tree
How the component tree is organized
Icons in the component tree
Changing a component name in the component tree
Using the Inspector
Overview of the Inspector
Opening the Inspector
Setting property values
Adding or Removing String values from ResourceBundle files
Setting the Property Exposure Level
Exposing a property as a class level variable
Testing the UI at runtime
Running and debugging in JBuilder
Managing the component palette
Adding a component to the component palette
Using the Bean Chooser button
Selecting an image for a component palette button
Removing a page or component from the component palette
Reorganizing the component palette
Chapter 8: Designing menus
Opening the menu designer
Menu terminology
Menu design tools
Creating a new menu
Adding menu items
Inserting and deleting menus and menu items
Inserting a separator
Specifying keyboard shortcuts
Disabling (dimming) menu items
Creating checkable menu items
Creating radio button menu items
Moving menu items
Creating submenus
Creating a new submenu
Moving existing menus to submenus
Attaching code to menu events
Example: Invoking a dialog box from a menu item
Creating a pop-up menu
Chapter 9: Handling events
Event handling code vs. initialization code
Attaching event-handling code to a component event
Shortcut for creating an event handler
Example: Display "Hello World!" when a button is pressed
Code that JBuilder generates to connect events
Understanding the EventAdapter and the EventListener classes
Choosing which style event handlers to use
Standard event adapters
Anonymous inner class adapters
Example event handler
Invoking a dialog box from a menu item
Deleting event handlers
Chapter 10: Using layout managers
About layout managers
Using null and XYLayout
Understanding layout properties
Understanding layout constraints
Examples of layout properties and constraints
Selecting a new layout for a container
Modifying layout properties
Modifying component layout constraints
Understanding sizing properties
Determining the size and location of your UI window at runtime
Sizing a window automatically with pack()
Calculating preferredSize for containers
Explicitly setting the size of a window using setSize()
Making the size of your UI portable to various platforms
Positioning a window on the screen
Placing the sizing and positioning method calls in your code
Adding custom layout managers
Layouts provided with JBuilder
XYLayout
null
BorderLayout
FlowLayout
VerticalFlowLayout
BoxLayout2
GridLayout
CardLayout
OverlayLayout2
GridBagLayout
PaneLayout
Prototyping your UI
Use XYLayout and null layout for prototyping
Design the big regions first
Save before experimenting
Using nested panels and layouts
Chapter 11: Working with applets
How do applets work?
The APPLET tag
Sample APPLET Tag
APPLET tag attributes
Common mistakes in the APPLET tag
Browser issues
Java Support
Getting the preferred browser to the end user
Supporting multiple browsers
Differences in Java implementation
Solutions to browser issues
Additional tips for making applets work
Security and the Security Manager
The sandbox
Applet restrictions
Solutions to security problems
Using third-party libraries
Testing applets
Basic testing steps
Testing in the browsers
Deployment
Chapter 12: Team development using JBuilder
Using the history view
Using version control
Definitions
Version control in the JBuilder IDE
Configuring the CVS connection
File-level Team menu commands
Project-level Team menu commands
CVS from the command line
Creating a CVS repository
Adding a directory
Adding several files to a directory
Removing a directory
Removing several files from a directory
Removing all the files from a directory
Getting command help in CVS
Chapter 13: Installing and configuring CVS
Configuring your computer for CVS
Configuring CVS in JBuilder
Chapter 14: Deploying Java programs
Introduction
About Java Archive Files (JAR)
About the manifest file
Overriding the default manifest file
Creating JAR files
Basic deployment strategies
Basic deployment steps
Using the JDK Java Archive Tool
Running a program from a JAR file
Viewing archive file contents
Updating the contents of a JAR file
Deployment issues
Is everything you need on the class path?
Does your program rely on JDK 1.1 or JDK 1.2/3 (Java 2) features?
Does the user already have Java libraries installed locally?
Is this an applet or an application?
Download time
Deployment quicksteps
Applications
Applets
JavaBeans
Deployment tips
Setting up your working environment
Internet deployment
Deploying distributed applications
Redistribution of classes supplied with JBuilder
Links to additional information
Using the Archive Builder
Starting the deployment process
Archive Builder Step 1
Archive Builder Step 2
Archive Builder Step 3
Archive Builder Step 4
Archive Builder Step 5
Archive Builder Step 6
Understanding the archive node
Viewing the archive and manifest
Resetting the archive node's properties
Chapter 15: Creating JavaBeans with BeansExpress
What is a JavaBean?
Why build JavaBeans?
Generating a bean class
Designing the user interface of your bean
Adding properties to your bean
Modifying a property
Removing a property
Adding bound and constrained properties
Creating a BeanInfo class
Specifying BeanInfo data for a property
Working with the BeanInfo designer
Modifying a BeanInfo class
Adding events to your bean
Firing events
Listening for events
Creating a custom event set
Creating a property editor
Creating a String List editor
Creating a String Tag List editor
Creating an Integer Tag List editor
Creating a custom component property editor
Adding support for serialization
Checking the validity of a JavaBean
Installing a bean on the component palette
Specifying a component image
Specifying a component palette page
Deploying beans
Chapter 16: Internationalizing programs with JBuilder
Internationalization terms and definitions
Internationalization features in JBuilder
A multilingual sample application
Eliminating hard-coded strings using the Resource Strings wizard
dbSwing internationalization features
Using JBuilder's locale-sensitive components
JBuilder components display any Unicode character
Internationalization features in the UI designer
Unicode in the IDE debugger
Specifying a native encoding for the compiler
Setting the encoding option
Native encodings supported
Adding and overriding encodings
More about native encodings
The 16-bit Unicode format
Unicode support using ASCII and '\u'
JBuilder around the world
Online internationalization support
Appendix A: Using the command-line tools
Setting the class path for command-line tools
Using the -classpath option
Setting the CLASSPATH environment variable for command-line tools
JBuilder command-line arguments
Accessing options
Syntax
Options
bcj command-line compiler
Syntax
Description
Options
Cross-compilation options
VM options
bmj command-line make
Syntax
Description
Options
Cross-compilation options
Specifiers for root classes
VM options
Appendix B: Error and warning messages
About error and warning messages
Syntax errors and error messages
Symbols in error and warning messages
Compiler errors and warnings
Runtime errors and warnings
Debugger messages
Error messages
© 1997, 2000 by INPRISE Corporation, Inc.
All Rights Reserved