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