HomeDigital EditionSys-Con RadioSearch Java Cd
Advanced Java AWT Book Reviews/Excerpts Client Server Corba Editorials Embedded Java Enterprise Java IDE's Industry Watch Integration Interviews Java Applet Java & Databases Java & Web Services Java Fundamentals Java Native Interface Java Servlets Java Beans J2ME Libraries .NET Object Orientation Observations/IMHO Product Reviews Scalability & Performance Security Server Side Source Code Straight Talking Swing Threads Using Java with others Wireless XML
 

So you've got a nice Java application in the works. Your team has toiled for weeks to get it just right. Finally, the magic moment arrives. The development team has a meeting, and every part of the code is humming perfectly, doing just what you intended it to do. Now comes that final step, when the code is brought together into one big application. There's just one last detail - it's time to make the program "user friendly," which usually means, among other things, adding a GUI (graphical user interface) so the end users don't have to be programmers or rocket scientists to use it.

Although there are many products on the market that can do this, you, like your end users, want something powerful, yet easy to use. After all, you just spent all that time and effort climbing up the development mountain, so why not take an easy road down?

If this sounds like your situation, I recommend you take a look at StudioJ by Rogue Wave Software. StudioJ is a very fine set of development tools that will add the needed interfaces to your application with a minimum of cost and effort.

System Requirements and Installation
StudioJ will run on any JDK 1.1x-enabled system. (It was recently announced that Rogue Wave products with JDK 1.2 support will be available in the first quarter of 1999.) If you want to use StudioJ with Java-Beans, you must also use an Integrated Development Environment (IDE) that supports JavaBeans.

I installed StudioJ over the JDK 1.1.7 by running the class file named "setup.class" from the CD-ROM. An installation program initiated, and setup was a no-brainer from there.

After installation, I soon discovered that StudioJ isn't one, but four powerful development tools packaged together in one suite. These components are available separately, as well. Let's take a quick look at each of these libraries and how the developer can benefit from them.

Quickly Create Buttons, Bars and Panels with Blend.J
There's no doubt about it, end users are unlike developers in one important aspect: they don't like to type at command prompts! Any application that attempts this is doomed to failure, therefore, it's necessary to add GUI components that are familiar and easy to use. The most common of these are buttons and "click here" bars. Blend.J contains classes for over thirty different widgets, starting with the familiar bars and radio buttons, and ranging to some pretty tricked-out interface components. Some of them include:

  • ToolBar - Provides your users with an easy shortcut to the most commonly used menu items. Images that were created in other development environments can be reused by incorporating them into the toolbar. The ToolBar class is a simple java.awt.Panel with added border functionality. The image objects can be displayed with the use of any layout manager.
  • ComboBox - A one-line editor with an associated dropdown panel that enables the user to click on the item of choice. This also includes a calendar and a calculator.
  • GroupBox - Groups components together in a field with a decorative border. With groupbox, it's possible to re-position the text to any part of the field.
  • DateTimeField - Enables the use of a local-aware time or date field. This can be configured in any practical way.
  • CellGrid - A quick way to create spreadsheet-like tables to display and manage data.
  • Animation - Enables the easy creation and display of a looped set of images at a specified rate.
  • ImageButto - A set of classes that lets you create buttons that display graphic images instead of ordinary text. When used with the Animation class, you can display an animation loop on the button rather than a static image.
  • ProgressBar - Shows the progress of lengthy operations in bar graph format. This is most useful for use with printing or downloading. At a glance, the user can tell how much longer the operation will take, or if the system has locked up.

Figure 1
Figure 1:  Simple buttons and bars like these can be
easily added with BlendJ

Emphasize the Meaning of Data with Chart.J
Whether it's a comparative study of touchdowns scored by different teams, or how the annual departmental budget will be spent, nothing seems to drive home the meaning of data like good charts. Chart.J includes a set of Java packages and Beans that enable you to use dynamic and customizable charts in your application. You may choose from built-in chart types or a set of charting primitives that enable the creation of your own specialized chart types. Here are a few of the listed features of Chart.J:

  • JavaBeans version of all charts - Chart.J features JavaBeans components for each chart type and many chart parts. Chart.J can be used in a Beans builder, and therefore charts can be included in the application without writing code.
  • Easy to use - When not using a Beans builder, the set methods provided in the Chart class and Style Customizers give total control of the appearance of charts with only a few lines of code.
  • A wide range of standard chart types - These include line charts, multi-row, multi-column and stacked bar charts, pie charts, multi-row and stacked area charts. These can be displayed in either two or three-dimensional versions.
  • Chart overlays - Sometimes it's necessary to combine two or more charts to show how different sets of values relate to each other. Chart.J includes two prebuilt overlay charts to suit this purpose.
  • Fast and easy customization of appearance - Chart.J supports a wide range of properties that control a chart's visual properties. These can be set in a Beans builder or through set methods.

Figure 2
Figure 2:  With ChartJ, complicated charts are no longer a big task

Interface with Databases by Using DBTools.J
One of the most challenging aspects of programming is creating an application that must interface with a database. The long hours of fist pounding and head scratching can now be eliminated by the use of DBTools.J, a high-level Java API for interfacing with relational databases. DBTools.J doesn't use SQL statements, but classes that encapsulate database elements such as tables and stored procedures, or operations such as select and insert. Some of the features that make your database interfacing tasks easier are:

  • Connection pool management - Rather than manipulate connections, you can create pools of connections, get these connections from the pool and return them when you're finished. This can greatly simplify the connection management in a multithreaded application.
  • Error checking control - Various types of runtime error detection can be turned on and off. For example, during development, checking can be left on for debugging purposes. Once finished, this can be turned off to optimize performance.
  • Thread safety - Shared classes are multithread safe.
  • Extensibility - All core abstractions can be extended through inheritance. This allows customization to meet future application requirements.
  • Portable SQL - High-level abstractions are transparently converted to the SQL dialect used by the server in which they are executed.
  • True Cursor objects - The DBTools.J Cursor class takes on the functionality of a cursor, thus hiding the underlying implementation details.
Bring Those Dull Grids to Life Using Grid.J
The use of grids is vital in presenting data to end-users. A colorful, animated or interactive grid will not only emphasize the data presented, but will enhance your end-user's experience as well. Grid.J provides an easy way to create such grids.

This includes full formula support to turn a grid into a fully functioning spreadsheet, utilizing automatic reference updates and circular dependency checks. Some of the more noteworthy features include:

  • Java Beans support
  • Printing support
  • JDBC support for database connectivity
  • Formula support
  • Grid can be made to act as a tree
  • Support for the merging of cells
  • Transparent background supported
  • The browsing of external data with one virtual override
  • Smooth tracking of row and column size
  • A wide variety of controls for use as cells in the grid
  • Row and column headers can act as pushbuttons
  • The embedding of custom controls
  • Undo and redo support for grid operations
  • Object-oriented architecture
One such use for Grid.J that comes to mind would be the creation of an interactive spreadsheet that can be threaded through to DBTools.J for a user-friendly database interface.

Perhaps you need a few simple navigational buttons to guide your end users through an application. Maybe you just want to use some interactive charts to demonstrate next year's projections. You may be unlucky enough to have been charged with the task of setting up a very complicated database interface, using spreadsheet-type input. No matter what your GUI needs, StudioJ will be right for you. I found it to be easy to install, easy to use and best of all, you don't need a supercharged system to run it. Pound for pound, buck for buck, this set of powerful development tools is hard to beat.

About the Author
Edward Zebrowski is a technical writer based in the Orlando, Florida, area. Ed runs his own Web development company, ZebraWeb, and can be reached on the net at [email protected]

 

All Rights Reserved
Copyright ©  2004 SYS-CON Media, Inc.
  E-mail: [email protected]

Java and Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. SYS-CON Publications, Inc. is independent of Sun Microsystems, Inc.