The next chapter covers using assembly language routines to access hardware and begins with a discussion of interfacing assembly language routines with C++. Short, but clear, explanations of function and variable naming, parameter passing and return values are presented with assembly language fragments as examples. The examples are based on Zortech C++ v1.0 so the specifics may differ for v2.0

The majority of the chapter consists of an assembly language listing of low-level video routines to handle saving and displaying rectangular regions of text on the screen, drawing boxes, setting attributes, setting the video mode and a single low-level routine to read characters from the keyboard.

Chapter three begins a series of chapters with listings of C/C++ code used to build a user interface. Though entitled "The C++ Input/Output Functions", the chapter contains no C++ functions. The second listing, lowlevel.cpp, contains C functions which generally call the PC-BIOS to handle cursor movement, shape, setting video attributes, etc. There are also a couple of functions used to print a character, with or without an attribute. Another function prints a string centered on a particular column. The listing is given the .cpp suffix only because it includes the windows.hpp header file, which does contain declarations of C++ objects.

Chapter four covers pointing devices, discussing the Microsoft mouse services and how to access them. Appendix C contains a more complete description of the services. A short listing implements a polling interface to the mouse driver. A second listing generalizes this interface into a C++ class called pointer. Though it would be easy to derive additional pointer devices like trackballs and digitizers, the book never uses the pointer class again. The menu functions, discussed below, use the mouse functions to access the driver directly.

Chapter five fleshes out a C++ window class. A window's private data consists of location information, cursor position within the window, an attribute, a border type (single or double), and a scroll bar type. Several other private methods do coordinate adjustments. Public methods open, close and draw the window, set the cursor position within the window or return its position, clear all or part of the window, draw horizontal and vertical scroll bars, scroll the window contents, and print text within the window.

Chapter six presents three types of menu objects: popups, pulldowns and dialogs. In my opinion, this chapter is an example of how not to create C++ objects. Though the menu objects are related and have many similarities, they are implemented as separate, unrelated classes. A more object-oriented approach might have derived these specialized menu classes from a more general, parent menu class, which might have descended from the window class.

The author also seems to implement the menu classes inconsistently. The only private data associated with the popup and dialog classes are their positions and a flag. The selection text for the menu items is stored elsewhere and only associated with the object at the time a menu must draw itself. This seems to violate good data encapsulation guidelines.

Chapter seven presents data entry in plain C. The field types supported include date, dollars, long integers, telephone numbers, Social Security numbers and general strings.

The author seems to miss another opportunity to use features of C++. He could have used the C++ class inheritance mechanism to build a hierarchy of data entry field types. The string field might have been the parent class. The long integer field could have descended from the string field. Fields for dates, dollars, Social Security and telephone numbers could have been written as descendants of the long integer field class. Such a class heirarchy would also make adding new field types easier.

The final chapter presents a ledger program that exploits some of the features of the user interface library. I am not an expert in accounting, but the program seems quite usable. The interface functions which handle windows, menus, and input/output appear to work quite well in this application.

The third appendix references the services available from a Microsoft compatible mouse driver. I found this appendix interesting, but of little use. The descriptions were very brief, containing little explanation of why a particular service might be useful.

The final, small appendix describes how to compile the interface functions, put them in a library, and compile and link the sample ledger program. Instructions are provided for Zortech and Guidelines C++. No specific version numbers are given, but I presume the author used Zortech C++ v1.0.

The C++ code in the book will not compile and link without errors using Zortech C++ v2.0. These problems are not the fault of the code, but are due to the differences between C++ 1.0 and C++ 2.0. Several errors are due to missing function prototypes and can be fixed simply by including the appropriate header files.

I ran into problems when trying to compile the sample ledger program. It uses the standard C library functions bsearch and qsort, which require pointers to functions as arguments. Both functions take a pointer to a function which takes two pointer arguments, compares the two things pointed at, and returns an int. Both qsort and bsearch expect a pointer to a C function. Since pointers to C functions are not type compatible with pointers to C++ functions, you must change the comparison function in the ledger program to something like:

extern "C" {
   int compare(const void *, const void *);
}

Related problems occur during linkage. You must declare the prototypes for the assembly language functions in windows.hpp as having normal C linkage. You can place an extern statement similar to the one above in the header file. Finally, the assembly language functions call two functions in mouse.cpp. The mouse functions must be declared as having standard C linkage and recompiled.

Once these changes are made, the interface library functions and example program compile and link without error. The program then runs fine.

There is nothing wrong functionally with the code presented in the book. I found only one error, in the way the right arrow key is handled by the dialog class. While the code shows good function, it does not demonstrate particularly good C++ style.

If you need user interface routines to handle simple text windows and menus, consider Mr. Goodman's other book containing routines written in C. (It's even a couple of bucks cheaper.) If you already have similar routines written in C, this book is not going to be much of an improvement. If you are interested in how you might use C++ and object-oriented programming to build a flexible user interface library, wait for something else.

User Interfaces In C ++ And Object-Oriented Programming
Mark Goodwin
MIS Press 1989
$26.95 book only,
$53.95 book and disk; 394 pages.