There are several possible models for multi-window applications in Xt. One approach is to create a single top-level window used as the main window of the application. All other windows are then popup shells whose parent is the main window. Another approach is to create a single shell that never appears on the screen. All other windows are then popup children of the main shell. In this model, all top-level windows are treated equally, as siblings. One window may logically be the top-level window of the application, but as far as Xt is concerned, all windows are equal.

ViewKit follows the second model. The VkApp class, described in Chapter 3, “The ViewKit Application Class,” creates a single widget that serves as the parent of all top-level windows created by the program. The VkApp base widget does not appear on the screen.

All top-level windows in a ViewKit application must be instances of VkSimpleWindow, VkWindow, or a subclass of one of these classes. The VkSimpleWindow class supports a top-level window that does not include a menu bar. The VkWindow class, derived from VkSimpleWindow, adds support for a menu bar along the top of the window. You must create a separate instance of VkSimpleWindow, VkWindow, or a subclass of one of these classes for each top-level window in your application.

Instantiating a VkSimpleWindow or VkWindow object creates a popup shell as a child of the invisible shell created by your application's instance of VkApp. VkSimpleWindow and VkWindow also create a XmMainWindow widget as a child of the popup shell. You define the contents of a window by creating a widget or ViewKit component to use as the work area (or view) for the XmMainWindow widget. In most cases, you will create several widgets and/or ViewKit components as children of a container widget and then assign that container widget as the view of the XmMainWindow widget. “Creating the Window Interface” describes how to assign a view to a window. Figure 4-2 shows an example of a widget hierarchy for the top-level windows of a simple ViewKit application with two top-level windows.

Figure 4-2. Widget Hierarchy of Top-Level Windows in ViewKit Applications

In most cases, directly instantiating a VkSimpleWindow or VkWindow object is not appropriate.^[5] In addition to the widgets and components composing the window's interface, most windows require other data and support functions. In accordance with good object-oriented programming style, the functions and data associated with a window should be contained within that window's class. Therefore, the best practice to follow when creating a ViewKit application is to create a separate subclass for each window in your application. You can derive these subclasses from VkWindow for those windows that require menu bars, and from VkSimpleWindow for those windows that do not. “Deriving Window Subclasses” describes in detail the process of deriving window subclasses.

In addition to creating shell and XmMainWindow widgets, the VkSimpleWindow and VkWindow classes set up various properties on the shell window and provide simple hooks for window manager interactions. “Window Manager Interface” discusses the built-in window manager support.

The VkSimpleWindow and VkWindow classes provide simple functions to raise, lower, iconify, and open windows, as described in “Manipulating Windows”. The classes also provide several convenience functions for determining a window's state (for example, whether it is visible, iconified, and so on) and for retrieving other window information. These access functions are described in “Window Data Access Functions”.

The VkSimpleWindow and VkWindow classes also register their windows with the application's VkApp instance to support application-wide services such as setting the cursor for all of an application's windows, entering busy states, and manipulating all windows in an application. Chapter 3, “The ViewKit Application Class,” describes how to use these application-wide services.

The preferred method of defining the contents of a window is to create the interface in the constructor of a VkSimpleWindow or VkWindow subclass. In this case, you simply create the widgets and components that you want to appear in your window in your subclass constructor. Remember that each window can have only one direct child widget as a view, so in most cases you must create a container widget and then create all other widgets and components as descendents of this direct child. Manage all widgets except the container widget, which you should leave unmanaged.

The parent widget of your view's top-level widget or component must be the window's XmMainWindow widget. You can retrieve this widget by calling the mainWindowWidget() function inherited from VkSimpleWindow. “Window Data Access Functions” discusses the mainWindowWidget() function.

---

Note: The _baseWidget data member for VkSimpleWindow and derived classes is the window's popup shell widget. Do not assign any other widget to this data member in a derived class.

---

After creating your interface, call addView():

void addView(Widget w)
void addView(VkComponent *component)

addView() accepts as an argument either a widget or a pointer to a component, which addView() installs as the view for the window.

---

Note: Some Motif functions such as XmCreateScrolledText(3Xm) create a ScrolledWindow widget and a child widget, and then return the ID of the child widget. As a convenience for using these functions, addView() can automatically determine the correct parent widget if you provide the child widget ID instead of the ScrolledWindow ID.

---

Example 4-1 shows a simple example that defines ScaleWindow, which creates a window with a RowColumn widget containing three Scale widgets. Because ScaleWindow is derived from VkSimpleWindow, it does not support a menu bar. If you required a menu bar, you would instead derive this class from VkWindow.

Note that ScaleWindow includes default resources for the Scale widget labels. This encapsulation technique is a good object-oriented practice to follow when creating reusable components in ViewKit. For example, if you were to extend this class by adding callback functions to the Scale widgets, you should make the callback functions members of the ScaleWindow class.

///////////////////////////
// ScaleWindow.h
///////////////////////////
 
#include <Vk/VkSimpleWindow.h>
 
class ScaleWindow: public VkSimpleWindow {
 
  public:
    ScaleWindow (const char *);
    ~ScaleWindow();
    virtual const char* className();
 
  private:
    static String _defaultResources[];
};
 
///////////////////////////
// ScaleWindow.c++
///////////////////////////
 
#include "ScaleWindow.h"
#include <Xm/RowColumn.h>
#include <Xm/Scale.h>
 
String ScaleWindow::_defaultResources[] = {
    "*dayScale.titleString:    Days",
    "*weekScale.titleString:   Weeks",
    "*monthScale.titleString:  Months",
    NULL };
 
ScaleWindow::ScaleWindow (const char *name) : VkSimpleWindow (name)
{
    setDefaultResources(mainWindowWidget(), _defaultResources);
    
    Widget scales = XtCreateWidget("scales", xmRowColumnWidgetClass,
                                   mainWindowWidget(), NULL, 0);
    
    Widget dayScale = XtCreateManagedWidget("dayScale", xmScaleWidgetClass,
                                            scales, NULL, 0);
    XtVaSetValues(dayScale,
                  XmNorientation, XmHORIZONTAL,
                  XmNminimum, 1,
                  XmNmaximum, 7,
                  XmNvalue, 1,
                  XmNshowValue, TRUE,
                  NULL);
 
    Widget weekScale = XtCreateManagedWidget("weekScale", xmScaleWidgetClass,
                                             scales, NULL, 0);
    XtVaSetValues(weekScale,
                  XmNorientation, XmHORIZONTAL,
                  XmNminimum, 1,
                  XmNmaximum, 52,
                  XmNvalue, 1,
                  XmNshowValue, TRUE,
                  NULL);
    Widget monthScale = XtCreateManagedWidget("monthScale", xmScaleWidgetClass,
                                              scales, NULL, 0);
    XtVaSetValues(monthScale,
                  XmNorientation, XmHORIZONTAL,
                  XmNminimum, 1,
                  XmNmaximum, 12,
                  XmNvalue, 1,
                  XmNshowValue, TRUE,
                  NULL);
 
    addView(scales);    
}
 
ScaleWindow::~ScaleWindow()
{
    // Empty
}
 
const char* ScaleWindow::className()
{
    return "ScaleWindow";
}
 
///////////////////////////
// scaleApp.c++
///////////////////////////
 
#include "ScaleWindow.h"
#include <Vk/VkApp.h>
 
void main ( int argc, char **argv )
{
    VkApp *scaleApp = new VkApp("ScaleApp", &argc, argv);
    ScaleWindow *scaleWin = new ScaleWindow("scaleWin");
 
    scaleWin->show();
    scaleApp->run();
}

Running the scaleApp program shown above displays a ScaleWindow, as shown in Figure 4-3.

Figure 4-3. Simple Example of a VkSimpleWindow Subclass

You can also create components and add them just as you would widgets. The constructor shown in Example 4-2 creates a VkRadioBox(3x) component and installs several items.

///////////////////////////
// RadioWindow.h
///////////////////////////
 
#include <Vk/VkSimpleWindow.h>
 
class RadioWindow: public VkSimpleWindow {
 
  public:
    RadioWindow (const char *);
    ~RadioWindow();
    virtual const char* className();
  private:
    static String _defaultResources[];
};
///////////////////////////
// RadioWindow.c++
///////////////////////////
 
#include "RadioWindow.h"
#include <Vk/VkRadioBox.h>
 
String RadioWindow::_defaultResources[] = {
    "*color*label*labelString:  Color",
    "*red.labelString:    Red",
    "*green.labelString:  Green",
    "*blue.labelString:   Blue",
    NULL };
 
RadioWindow::RadioWindow (const char *name) : VkSimpleWindow (name)
{
    setDefaultResources(mainWindowWidget(), _defaultResources);
    
    VkRadioBox *rb = new VkRadioBox( "color", mainWindowWidget() );
 
    rb->addItem("red");
    rb->addItem("green");
    rb->addItem("blue");
 
    addView(rb);
}
RadioWindow::~RadioWindow()
{
    // Empty
}
 
const char* RadioWindow::className()
{
    return "RadioWindow";
}
 
 
///////////////////////////
// radioApp.c++
///////////////////////////
 
#include <Vk/VkApp.h>
#include "RadioWindow.h"
 
void main ( int argc, char **argv )
{
    VkApp *radioApp = new VkApp("RadioApp", &argc, argv);
    RadioWindow *radioWin = new RadioWindow("radioWin");
 
    radioWin->show();
    radioApp->run();
}

Running the radioApp program shown above displays a RadioWindow, as shown in Figure 4-4.

Figure 4-4. Using a Component as a Window's View

When you create your window interface in your window constructor using addView(), all setup overhead occurs when the window is instantiated. Additionally, your program allocates memory for all of the widgets created. Occasionally, you might need to instantiate a window so that your application can access some of its public functions, but not display it. If the window interface is large or complex, the time and memory consumed to create the interface is unnecessary if the user might not display it.

The ViewKit window classes provide a mechanism for delaying the creation of a window's interface until the window needs to be displayed. Rather than including the interface code in the window constructor, you can include the code in the definition of the protected virtual member function setUpInterface().

When you call show() to display a window, show() checks to see whether you have already added a view to the window (for example, in the window's constructor). If not, show() calls setUpInterface() to create the window's interface.

Using this approach, you do not allocate memory for the window interface until your application actually displays the window for the first time—and you never allocate the memory if your application never displays the window. Additionally, this approach reduces your application's startup time. The trade-off is that the first time you display this window, the response time might be slow because your application must create the interface before displaying the window.

The syntax of setUpInterface() is as follows:

virtual Widget setUpInterface(Widget parent)

show() passes the main window widget to setUpInterface() for you to use as the parent of the window's widget hierarchy. You must return a widget to be added as a view. Do not call addView() from within setUpInterface().

---

Note: Some Motif functions such as XmCreateScrolledText(3Xm) create a ScrolledWindow widget and a child widget, and then return the ID of the child widget. As a convenience for using these functions, setUpInterface() can automatically determine the correct parent widget if you provide the child widget ID instead of the ScrolledWindow ID.

---

Example 4-3 shows the RadioWindow example from Example 4-2 rewritten to use setUpInterface() instead of addView() in the constructor.

///////////////////////////
// RadioWindow2.h
///////////////////////////
 
#include <Vk/VkSimpleWindow.h>
 
class RadioWindow: public VkSimpleWindow {
 
  public:
    RadioWindow (const char *);
    ~RadioWindow();
    virtual const char* className();
 
  protected:
    Widget setUpInterface(Widget);
 
  private:
    static String _defaultResources[];
};
 
 
///////////////////////////
// RadioWindow2.c++
///////////////////////////
 
#include "RadioWindow2.h"
#include <Vk/VkRadioBox.h>
 
String RadioWindow::_defaultResources[] = {
    "*color*label*labelString:  Color",
    "*red.labelString:    Red",
    "*green.labelString:  Green",
    "*blue.labelString:   Blue",
    NULL };
 
RadioWindow::RadioWindow (const char *name) : VkSimpleWindow (name)
{
    // Empty
}
RadioWindow::~RadioWindow()
{
    // Empty
}
 
const char* RadioWindow::className()
{
    return "RadioWindow";
}
 
Widget RadioWindow::setUpInterface (Widget parent)
{
    setDefaultResources(mainWindowWidget(), _defaultResources);
    
    VkRadioBox *rb = new VkRadioBox( "color", parent );
 
    rb->addItem("red");
    rb->addItem("green");
    rb->addItem("blue");
 
    return(*rb);
}

Note that this example uses the Widget operator defined by VkComponent to return the VkRadioBox's base widget in setUpInterface(). (See “VkComponent Access Functions” for information on the Widget operator.) If you prefer, you could explicitly call baseWidget():

return( rb->baseWidget() );

There are exceptional cases for which you may choose to directly instantiate a VkSimpleWindow or VkWindow object and use addView() to associate a view with the window. For example, if you have a complex, self-contained component and need a window simply to display the component, you might find this method acceptable. Example 4-4 shows a simple example of adding a component to a direct instantation of the VkSimpleWindow class.

VkSimpleWindow *roloWindow = VkSimpleWindow("roloWindow");
Rolodex *rolodex = Rolodex( "rolodex", roloWindow->mainWindowWidget() );
roloWindow->addView(rolodex);

In most cases, you should not use this technique because most windows require data and support functions that should be encapsulated by the window class to follow proper object-oriented programming style.

Occasionally, you might want to replace the view of an existing window. To do so, you must first remove the current view using the removeView() function:

void removeView()

You should not call this function unless you have previously added a view to this window. removeView() does not destroy the view; if you no longer need the view, you should destroy it.

After removing a view, you can add another view using addView().

The VkSimpleWindow and VkWindow classes provide easy-to-use functions to set your application's window and icon titles.

The setTitle() function sets the title of a window:

void setTitle(const char *newTitle)

The string is treated first as a resource name that setTitle() looks up relative to the window. If the resource exists, its value is used as the window title. If the resource does not exist, or if the string contains spaces or newline characters, setTitle() uses the string itself as the window title. This allows applications to change a window title dynamically without hard-coding the exact title names in the application code. Example 4-5 shows an example of setting a window title using a resource value.

You can retrieve the current window title using getTitle():

const char *getTitle()

The setIconName() function sets the title of a window's icon:

void setIconName(const char *newTitle)

The string is treated first as a resource name that setIconName() looks up relative to the window. If the resource exists, its value is used as the window's icon title. If the resource does not exist, or if the string contains spaces or newline characters, setIconName() uses the string itself as the icon title. This allows applications to dynamically change a window's icon title without hard-coding the exact title names in the application code. Example 4-5 shows an example of setting a window's icon title using a resource value.

class MainWindow : public VkSimpleWindow {
 
  public:
    MainWindow (const char *);
    // ...
 
  private:
    static String _defaultResources[];
    // ...
};
 
String _defaultResources[] = {
    "*winTitle:    Foobar Main Window",
    "*iconTitle:   Foobar",
    NULL
};
 
MainWindow::MainWindow(const char *name) : VkSimpleWindow(name)
{
    setDefaultResources(mainWindowWidget(), _defaultResources);
 
    setTitle("winTitle");
    setIconName("iconTitle");
 
    // ...
}

The window class constructors automatically set up various window properties and shell resources when you create a window. The window classes also provide some hooks to allow you to set your own properties or change the window manager message handling in a derived class.

Because the first window you create is by default the main window, the window class constructors also set some shell resources on the popup shell widget of that window. The constructors obtain the geometry of the invisible application shell created by VkApp and assign that geometry to the window's popup shell widget. The constructors also set the XmNargc and XmNargv resources on the popup shell to the values of VkApp::argc() and VkApp::argv(), respectively. (“Application Data Access Functions” describes VkApp::argc() and VkApp::argv().)

For all windows, the window class constructors register a callback function to handle WM_DELETE_WINDOW messages from the window manager. This callback function calls handleWmDeleteMessage():

virtual void handleWmDeleteMessage()

By default, handleWmDeleteMessage() calls the window's okToQuit() function. If okToQuit() returns TRUE, then handleWmDeleteMessage() deletes the window. You can override handleWmDeleteMessage() to change how your window handles a WM_DELETE_WINDOW message. In most cases, you should simply perform any additional actions that you desire and then call the base class's handleWmDeleteMessage() function.

The window class constructors also register a callback function to handle WM_QUIT_APP messages from the window manager. This callback function calls handleWmQuitMessage():

virtual void handleWmQuitMessage()

By default, handleWmQuitMessage() calls the application's quitYourself() function to quit the application. You can override handleWmQuitMessage() to change how your windows handles a WM_QUIT_APP message. In most cases, you should simply
perform any additional actions that you desire and then call the base class's handleWmQuitMessage() function to exit your application.

If you want to set any additional properties on a window, you can override setUpWindowProperties():

virtual void setUpWindowProperties()

setUpWindowProperties() is called after realizing a window's popup shell widget but before mapping it. Subclasses that wish to store other properties on windows can override this function and perform additional actions. If you override this function, you should set all desired properties and then call the base class's setUpWindowProperties() function.

Note that you should use setUpWindowProperties() to set window properties instead of VkComponent::afterRealizeHook() as described in “Displaying and Hiding Components”. The difference between the two is that setUpWindowProperties() is guaranteed to be called before the window manager is notified of the window's existence. Because of race conditions, this might not be true of afterRealizeHook().

You can also change the value of the window manager class hint stored on a window using setClassHint():

void setClassHint(const char *className)

setClassHint() sets the class resource element of the XA_WM_CLASS property stored on this window to the string you pass as an argument.

In addition to those functions described in previous sections, the ViewKit window classes provide a number of virtual functions and data members that you can access from window subclasses. These functions and data allow you to

virtual Boolean okToQuit()

virtual void stateChanged(IconState newState)

virtual void afterRealizeHook()

virtual void handleRawEvent(XEvent *event)

Widget _mainWindowWidget

The following is a summary of guidelines for creating subclasses of the ViewKit window classes:

The program in Example 4-6 creates ColorWindow, a VkSimpleWindow subclass that implements a simple utility for determining the results of mixing primary ink colors when printing. The user can use toggles to select any of the three primary colors—cyan, magenta, and yellow—and the window reports the resulting color.

Figure 4-5 shows the widget hierarchy of the ColorWindow subclass. The VkSimpleWindow constructor creates the window's popup shell and XmMainWindow widget. The ColorWindow constructor creates a Form widget to serve as the window's view. The constructor adds a VkCheckBox component as a child of the Form to provide the toggle buttons. The constructor then adds a Frame widget as a child of the Form widget, and creates two Label gadgets as children of the Frame: one to serve as a title, and one to report the resulting color. The constructor manages all of these widgets except for the top-level Form widget. (The constructor manages the VkCheckBox component by calling its show() member function.)

Figure 4-5. Widget Hierarchy of ColorWindow Subclass

This example illustrates a number of object-oriented techniques that you should follow when programming in ViewKit. Note that all data and utility functions used by the window are declared as members of the ColorWindow class. Also note that ColorWindow uses resources to set all the text that it displays. It includes a set of default values, but you can override these values in a resource file (for example, to provide German-language equivalents for all the strings).

///////////////////////////
// ColorWindow.h
///////////////////////////
 
#include <Vk/VkSimpleWindow.h>
#include <Vk/VkCheckBox.h>
 
class ColorWindow: public VkSimpleWindow {
 
  public:
    ColorWindow (const char *);
    ~ColorWindow();
    virtual const char* className();
 
  private:
    void displayColor(char *);
    void colorChanged(VkCallbackObject *, void *, void *);
    static String _defaultResources[]; // Default resource values
    static String _colors[];           // Array of possible resulting colors
    Widget _resultColor;               // Label to display resulting color
    VkCheckBox *_primaries;            // Checkbox for setting colors
    int _colorStatus;                  // Bit-wise color status variable
                                       //     Bit 0: Cyan
                                       //     Bit 1: Magenta
                                       //     Bit 2: Yellow
                                       //   Also used as index into _colors[]
};
 
 
///////////////////////////
// ColorWindow.c++
///////////////////////////
 
#include "ColorWindow.h"
#include <Xm/RowColumn.h>
#include <Xm/Form.h>
#include <Xm/Frame.h>
#include <Xm/LabelG.h>
#include <Vk/VkCheckBox.h>
#include <Vk/VkResource.h>
// Default ColorWindow class resource values.
 
String ColorWindow::_defaultResources[] = {
    "*windowTitle:                  Color Mixer",
    "*iconTitle:                    Color Mixer",
    "*primaries*label*labelString:  Primary Colors",
    "*cyan.labelString:             Cyan",
    "*magenta.labelString:          Magenta",
    "*yellow.labelString:           Yellow",
    "*resultLabel.labelString:      Resulting Color",
    "*cyan:                         Cyan",
    "*magenta:                      Magenta",
    "*yellow:                       Yellow",
    "*blue:                         Blue",
    "*red:                          Red",
    "*green:                        Green",
    "*white:                        White",
    "*black:                        Black",
    NULL };
 
// Set _colors array to correspond to color values indicated by the
// bits in the _colorStatus variable.
 
String ColorWindow::_colors[] = {
    "white",
    "cyan",
    "magenta",
    "blue",
    "yellow",
    "green",
    "red",
    "black" };
 
ColorWindow::ColorWindow (const char *name) : VkSimpleWindow (name)
{
    Arg args[5];
    int n;
 
    // Set default resources for the window.
 
    setDefaultResources(mainWindowWidget(), _defaultResources);
 
    // Create a Form widget to use as the window's view.
 
    Widget _form = XmCreateForm(mainWindowWidget(), "form", NULL, 0);
 
    // Create a VkCheckBox object to allow users to select primary colors.
    // Add toggle buttons and set their intial values to FALSE (unselected).
    // The labels for the checkbox frame and the toggle buttons are set
    // by the resouce database.
    
    _primaries = new VkCheckBox( "primaries", _form );
    _primaries->addItem("cyan", FALSE);
    _primaries->addItem("magenta", FALSE);
    _primaries->addItem("yellow", FALSE);
    _primaries->addCallback(VkCheckBox::itemChangedCallback, this,
                            (VkCallbackMethod) &ColorWindow::colorChanged);
    _primaries->show();
    
    // Set constraint resources on checkbox's base widget.
    
    n = 0;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
    XtSetValues(_primaries->baseWidget(), args, n);
 
    // Create a frame to display the name of the resulting blended color.
 
    n = 0;
    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNleftWidget, _primaries->baseWidget()); n++;
    Widget _result = XmCreateFrame(_form, "result", args, n);
    XtManageChild(_result);
    
    // Create a frame title label.  The label text is set by the resource
    // database.
    
    n = 0;
    XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
    Widget _resultLabel = XmCreateLabelGadget( _result, "resultLabel", args, n);
 
    // Create the label to display the blended color name.
    
    _resultColor = XmCreateLabelGadget( _result, "resultColor", NULL, 0);
    
    // Set intial value of _colorStatus and label string to white (all off).
    
    _colorStatus = 0;
    displayColor(_colors[_colorStatus]);
    
    XtManageChild(_resultLabel);
    XtManageChild(_resultColor);
 
    // Add the top-level Form widget as the window's view.
 
    addView(_form);
    
    // Set the window title and the icon title.
    
    setTitle("windowTitle");
    setIconName("iconTitle");
}
ColorWindow::~ColorWindow()
{
    // Empty
}
 
const char* ColorWindow::className()
{
    return "ColorWindow";
}
 
// Given a color name, update the label to display the color
 
void ColorWindow::displayColor(char *newColor)
{
    Arg args[2];
    int n;
 
    // Common resource trick in ViewKit applications.
    // Given a string, check the resource database for a corresponding
    // value.  If none exists, use the string as the value.
 
    char *_colorName = (char *) VkGetResource(_baseWidget, newColor, "Color",
                                              XmRString, newColor);
 
    // Update the label
 
    XmString _label = XmStringCreateSimple(_colorName);
    n = 0;
    XtSetArg(args[n], XmNlabelString, _label); n++;
    XtSetValues(_resultColor, args, n);
    XmStringFree(_label);
}
 
// When the user changes the value of one of the toggles, update the
// display to show the new blended color.
 
/* ARGSUSED */
void ColorWindow::colorChanged(VkCallbackObject *obj, void *, void *callData)
{
    int index = (int) (prtdiff_t)callData;
    
    // Update color status based on toggle value.  Set or rest the
    // status bit corresponding to the respective toggle.
 
    if (_primaries->getValue(index))
        _colorStatus |= 1<<index;
    else
        _colorStatus &= ~(1<<index);
 
    // Update the display to show the new blended color, using
    // _colorStatus as an index.
 
    displayColor(_colors[_colorStatus]);
}
 
///////////////////////////
// colors.c++
///////////////////////////
 
#include <Vk/VkApp.h>
#include "ColorWindow.h"
 
void main ( int argc, char **argv )
{
    VkApp *colorApp = new VkApp("ColorApp", &argc, argv);
    ColorWindow *colorWin = new ColorWindow("colorWin");
    colorWin->show();
    colorApp->run();
}

Figure 4-6 shows the ColorWindow window displayed by the colors program.

Figure 4-6. ColorWindow Window Subclass