Netscape IFC in a Nutshell is written by Dan Petrich and David Flanangan. In the Nutshell tradition, it is not too big or intimidating. The cover graphic will surely lead IFC geeks to refer to it as ``the fish book''. It weighs in at around 350 pages, approximately 140 pages of which are the quick reference section. This same reference information is available in HTML format from Netscape. I think it is helpful to complement on-line documentation with a compact hard copy reference, and I'm sure we all agree that making notes in the margin of an HTML page can be a bit difficult.
The book is far more than an API reference. It takes you through the IFC classes in a logical and matter-of-fact manner. Numerous examples cover most of the important aspects of the IFC. The examples are typically small but effective. They are well focused on the topics at hand and help immensely with understanding. The book does not include a CD-ROM, which is too bad as it would make a nice addition to the book. As an alternative, O'Reilly and Associates could have provided space on their web site for on-line examples and running applets. Unfortunately, they didn't do that either, so be prepared to type in each example and code fragment by hand.
The authors begin with a high-level introduction to the IFC. They discuss its capabilities including the sophisticated GUI widgets, persistence mechanism and the visual construction tool Constructor. If you are not sure what the IFC is all about or if it's right for you, this section is very helpful.
The next topic is an introduction to the most basic class in the IFC, the Application Class. As an IFC user, I have noticed that the IFC often departs from traditional Java vernacular. The Application class is one example of many you will come across. Seasoned Java developers typically understand application to mean a stand-alone Java program, and applet to mean a restricted Java program that runs in a browser. Forget all that when using the IFC. Every running IFC program, be it stand-alone or applet, is an application. Don't worry though; it's all explained very simply in this chapter using the power of the venerable Hello World program.
Having straightened out what an application is, the book takes you through a good explanation of the IFC's View classes. View classes in the IFC are akin to the Container classes in standard Java, but with differences in both architecture and capabilities. The authors devote three chapters to a discussion of these classes. They make good use of examples to show you many of the important features, from tiling a bitmap on the background to drawing.
Users interact with GUIs using a mouse and keyboard. In Java, these devices make themselves known by generating events. The mechanism by which these events are made available to your program is known as the event model. The Java standard event model has evolved over its short lifetime. It began as an inheritance-based model, eventually maturing to the more powerful delegation-based model used today. The IFC uses a hybrid model. The chapter on mouse and keyboard events covers the inheritance-based model. The chapter on targets covers the IFCs implementation of delegation-style event handling. The details of using each type of event are discussed in reasonable detail. Numerous examples show how to code your own event processing. However, I felt that the authors should have contrasted the two styles better. In addition, it would be helpful if they offered some guidelines on when to use each model.
The book moves on to cover each widget in considerable detail. Remember that the IFC provides a replacement for every standard widget, so even items as simple as a push-button or text field have a new API. These chapters really drive home the power of these IFC widgets, making the traditional widgets from Sun look absolutely bland.
I found their treatment of scrolling particularly useful. The IFC provides a framework to support scrolling of text and graphics. While very powerful, understanding the details can be daunting. The authors present scrolling clearly and offer good illustrative examples. With the details in this chapter, you will be able to add scrolling to any application with ease.
Another excellent section is the one on layout managers. Layout managers are classes that help View classes decide upon the size and position of the widgets they contain. The IFC includes a powerful new layout manager, the PackLayout. The book covers this complex layout manager in excellent detail. Outside of this book, there is virtually no useful documentation on the true behavior of the pack layout.
Anyone who has ever written an applet that displays images will eventually reach the conclusion ``why don't they handle all of this mess for me?'' Netscape's engineers felt the same way, and they did something about it. In the chapters on images and animation, you will learn how simply your application can read and display image files (both GIFs and JPEGs). Creating animation is a simple matter as well. The book explains how the IFC handles threading, sequencing and double buffering. If you are interested in images and animation, these chapters will get you going quickly and painlessly.
In the Advanced Topics section, the authors cover the details of the TextView class, archives, and the free GUI builder Constructor.
The authors rightly spend a considerable amount of time discussing the TextView class. They show how to use TextView to display HTML documents, handle hyperlinks, open a mini editor and more. With all this versatility from a single component, it is a comfort to have clear explanations and examples to lead you.
The authors next discuss archives. Archives provide object persistence. Every class in the IFC can be archived to disk so that it can outlive the process that created it. The authors detail how to use IFC archives to read and write objects in a number of situations. They also discuss how to archive existing IFC classes and explain how to archive classes that you have created.
Finally, you will learn how to use Netscape Constructor. Unlike the rest of the IFC, Constructor is an application not a component. Perhaps this is why the chapter is so skimpy. Considering this chapter is in the ``Advanced Topics'' section, I would have expected more detailed information. Nonetheless, the chapter does provide some good information on few aspects of the elusive Constructor.
The GUIs that are created using the IFC are truly a pleasure to behold. The widgets, in stark contrast to their plain Java brethren, have a polished look and feel. Some of the components, such as TextView, are so powerful that they could be marketed on their own. Learning such a comprehensive class library can be downright scary. Netscape IFC in a Nutshell provides numerous easy to follow examples, detailed explanations and a quick reference guide.
Eventually, the IFC will be subsumed by the Java Foundation Classes (JFC), a joint venture between Sun and Netscape. But if you want beautiful user interfaces today, the IFC is the way to go, and Netscape IFC in a Nutshell is a great way to get you there.