ViewKit provides a small set of classes that are either essential for all applications or provide fundamental support for all other classes. The most basic of these classes is the VkComponent class, which defines the basic structure of all user interface components. All user interface classes are derived from VkComponent.

The framework classes also include support for features needed by nearly all applications, including application management and X server setup, top-level windows, menus, and dialog management. All classes are designed to implement as many typical features as possible. For example: all top-level windows and dialogs handle the window manager quit/close protocol; dialogs are cached to balance memory use and display speed; the menu system goes beyond simply constructing menus to support dynamically adding, removing, and replacing items, and more.

The classes that make up the framework of ViewKit are closely integrated and work together to support essential features required by most applications as automatically as possible. Among the basic services supported by the core ViewKit framework are single and multi-level undo; interruptible tasks; and an application-level callback mechanism that allows C++ classes to dynamically register member functions to be invoked by other C++ classes.

In addition to the basic user interface support provided by the core framework classes, ViewKit provides an assortment of ready-to-use interface components. Examples of these components are a graph viewer/editor, an input field that supports name expansion, and an outliner component for displaying and manipulating hierarchical information.

You are encouraged to use the architecture of ViewKit to create new components and extend existing components. Creating reusable, high-level components promotes consistency throughout a set of applications by providing elements that users can learn once and then easily recognize in multiple applications.

ViewKit provides various utility functions and classes for your convenience. These utilities include simple functions that make it easier to load resources (including automatic type conversion), classes that support the use of icons, and other miscellaneous utilities.

To compile and link with the ViewKit libraries, you must install a C++ compiler and a Motif development environment (either 1.2 or 2.1), along with the ViewKit development option subsystems. Consult the ViewKit Release Notes for a complete list of subsystems that you must install on your system to compile and link ViewKit programs.

---

Note: See “Required Packages (ViewKit 2.1 Addendum)” in Appendix B for ViewKit 2.1 subsystems.

---

The ViewKit development option contains the following subsystems:

The ViewKit_dev.sw.base subsystem installs the following libraries:

The ViewKit_dev.sw.debug subsystem installs the following libraries:

All ViewKit header files appear in /usr/include/Vk. In most cases, the header file for a given class is the class name followed by.h. For example, the header file for the VkWindow class is <Vk/VkWindow.h>. Some minor classes are grouped together into single header files. For example, the header file for the VkMenu class automatically includes the header information for every type of menu supported by ViewKit. These cases are noted in the text where appropriate.

You need to include Motif header files for only those Motif widgets that you explicitly use in a ViewKit program. ViewKit automatically includes any X or Motif header files required by ViewKit components that you use in your program.

You must link all ViewKit programs with the ViewKit library, libvk, and the Motif and X libraries. If you use an external help system with your application, you should link with the appropriate help library. (See Chapter 11, “Using a Help System With ViewKit” for more information.)

For example, to compile a file hello.c++ to produce the executable hello, enter

CC -o hello hello.c++ -lvk -lXm -lXt -lX11 

If you are debugging a program, you might find it useful to compile your program with the debug libraries, which contain additional symbol table information.

Applications based on ViewKit must obey certain organizational conventions. To see how this organization works, consider Example 1-1, a simple ViewKit application that displays the label “hello” in a window.

#include <Vk/VkApp.h>
#include <Vk/VkSimpleWindow.h>
#include <Xm/Label.h>
 
// Define a top-level window class
 
class HelloWindow: public VkSimpleWindow {
 
  public:
    HelloWindow (const char *name);
    ~HelloWindow();
    virtual const char* className();
};
 
// Construct a single rooted widget tree, and designate the
// root of the tree as the window's view.  This example is very
// simple, just creating a single XmLabel widget to display the
// string "hello".
 
HelloWindow::HelloWindow (const char *name) : VkSimpleWindow (name)
{
    Widget label =  XmCreateLabel (mainWindowWidget(), "hello",
                                   NULL, 0);
    addView(label);
}
 
const char* HelloWindow::className()
{
    return "HelloWindow";  // Identify this class
}
 
HelloWindow::~HelloWindow()
{
    // Empty
}
 
 
// Main driver. Just instantiate a VkApp and a top-level window,
// "show" the window and then "run" the application.
 
void main ( int argc, char **argv )
{
    VkApp        *app = new VkApp("Hello", &argc, argv);
    HelloWindow  *win = new HelloWindow("hello");
 
    win->show();
    app->run();
}

To build this example, simply compile the file hello.c++ and link with the ViewKit library, and the Motif and X libraries:

CC -o hello hello.c++ -lvk -lXm -lXt -lX11 

Running the hello program displays a window that says “hello,” as shown in Figure 1-1.

Figure 1-1. Result of Running hello

This example uses two classes: the VkApp class and an application-defined class, HelloWindow. The HelloWindow class is derived from the ViewKit VkSimpleWindow class.

First look at main(). All ViewKit applications start by creating an instance of VkApp. The arguments to this constructor specify the Xt-style class of the application, a pointer to argc, and the argv array. Instantiating a VkApp object opens a connection to the X server and initializes many other services needed by typical applications. VkApp is described in detail in Chapter 3, “The ViewKit Application Class.” Next, the hello.c++ program instantiates a HelloWindow object that serves as the application's top-level window. The constructor for this class requires only a name for the window. Finally, the application concludes by calling the HelloWindow object's show() function and the VkApp object's run() function. The run() method never returns. The bodies of most ViewKit programs are similar to this short example.

Now look at the HelloWindow class. ViewKit encourages you to create classes to represent all major elements of the user interface. In this simple example, the only major user interface component is a top-level window that contains a label widget. ViewKit provides a class, VkSimpleWindow, that supports many features common to all top-level windows and that works closely with the VkApp class to implement various ViewKit features. To use the VkSimpleWindow class, you derive a new subclass and create a single-rooted widget tree that the window displays as its view. ViewKit applications do not have to create shell widgets directly.

The hello.c++ example is so simple that the HelloWindow class creates only a single XmLabel widget. The XmLabel widget is created in the constructor and then designated as the window's view. More complex classes might create a manager widget and create other widgets as children, or might instantiate other objects, as well. Chapter 4, “ViewKit Windows,” describes how to create windows using ViewKit.

The className() member function is supported, by convention, by all ViewKit classes. This function is used by several ViewKit facilities and is discussed in “VkComponent Access Functions”.

The ViewKit_dev.sw.demo subsystem installs in the /usr/share/src/ViewKit directory several demonstration programs that illustrate different features of ViewKit. A few of the highlights include: