AFC and JFC

The first set of interface classes for Java, the Abstract Window Toolkit (AWT), has actually been part of the Java Development Kit almost since its inception. The JDK 1.0 contained the AWT and was officially released in January of 1996. To put this in perspective, Java itself was announced in May of 1995, seven months earlier.
The AWT, however, suffered and still suffers from a number of technical problems primarily driven by the fact that it is not totally written in Java. In some cases, the AWT relies on peer classes that are, by definition, platform specific. If you create an AWT button on a Windows platform, a native Windows button will be created in a peer class. If the same program runs on a UNIX machine, a Motif (UNIX user-interface) button will be created in a peer class instead.
Since the AWT relied upon peer classes and native code that were platform specific, it had (and still has) many technical problems with platform specific bugs. It also was very hard to maintain and extend. A developer working on a Windows or Macintosh platform could find a bug in a user-interface object which would not exist on the Sun platform. Developers would need to test their programs on each platform to ensure user-interface consistency and quality. Peer classes also make the interface hard to extend. To add a new interface object for Java, you would need to determine the appropriate native objects to use on each platform and then create peer classes for the native objects on each different platform.
Many developers quickly ran into the limitations of the AWT classes in early 1996. One such group of developers particularly relevant to the advancement of Java user-interface tools worked at a small startup company called Netcode. They created a set of interface classes designed to offer more functionality than the AWT and to fix the most basic problems caused by the AWT's native code and peer classes.
Netcode's classes were written in pure Java and only used the most basic peer classes in the AWT: Window, Graphics, Font and Event classes. Their classes would basically create a single AWT window and offered methods that allowed you to add buttons, text fields and other items to the window. Their classes also performed all the management of drawing and dealing with user-input. This made their classes extremely portable and easily extensible since they did not rely on many platform specific classes. When you wanted to add new features to a button, for example, you could simply write code in Java to do it, instead of having to deal with platform-specific peer classes. Netscape liked Netcode's classes and purchased the company in March of 1996. Netscape then released these classes as the Netscape IFC (Internet Foundation Classes).
Sun and Netscape continued to refine and improve the AWT and the IFC, respectively. Then, in October of 1996, Sun released the JavaBeans API that defined a new standard API for Java components. Since Netscape IFC and Sun's AWT were both written prior to the JavaBeans API, both needed some major work to conform to the new specification.
Many other companies were also developing interface objects at this time, filling in the areas where the AWT and IFC lagged. One such company, Microline Software, was extremely successful in selling an interface toolkit containing tables, trees and other advanced components for the AWT and IFC.
It looked like the world was headed toward two diverging standards for user-interfaces in early 1997, but then on April 2nd came a flurry of announcements from the major industry players. On the same day, Netscape, Sun and Microsoft announced new foundation classes for creating user-interfaces in Java. Netscape and Sun (Javasoft) announced the JFC (Java Foundation Classes) and Microsoft, until now quietly watching from the sidelines, announced the Microsoft Application Foundation Classes (AFC).
Unlike the AWT and the IFC, the AFC and JFC are each a complete set of foundation classes. Both contain all the basic user-interface components users have come to expect in modern applications including multi-column lists, trees and tabs. They also both offer a 2D graphic API with advanced drawing support.
The announcements left a lot of developers wondering what to do for user-interface development. Now, instead of two major sets of foundation classes (the AWT and IFC) to choose from, there were four. However at this stage, the JFC and AFC were just announcements, with neither scheduled to release for months. So, most developers continued to sit on the sidelines until the newly announced foundation classes shipped and continued to work with both the AWT and IFC until late 1997.
On October 7, 1997 Microsoft released the SDK 2.0 for Java which included the Microsoft AFC. Like Netscape IFC, the AFC is written entirely in Java without the use of peer classes. Also like the IFC, it does rely on the AWT for its basic functions. For example, it creates windows and receives events using some of the AWT's basic classes. This allows it to run anywhere these basic AWT classes are available, including in Netscape Navigator and with Sun's JDK for UNIX.
There are actually two versions of the AFC. One works with Microsoft's Java Virtual Machine that comes as part of Microsoft Internet Explorer and JDK 1.1 and another that works with the JDK 1.02. The AFC is optimized to work with Microsoft's implementation of Java and should provide higher performance and less system resource use with Microsoft's own Java implementation.

Additional Resources:

Threads
Table of Contents
Congratulations

Graphics & Media Lab. >> Áèáëèîòåêà | Êóðñû | Ãðàôèêîí

Hosted by Graphics & Media Lab
http://graphics.cs.msu.su

mailto: Laboratory