C Programming

The D-Flat++ class library is well underway. Its design is largely influenced by my experiences with D-Flat. DF++ will support my original requirements better than D-Flat does, because it will be less, not more, and it will be in C++. The goals that launched D-Flat were for a DOS-based, text-mode CUA library in C to support some applications that I was developing. The library grew with features as I learned more about CUA and as readers responded. But when I look at my D-Flat applications, I realize that I never used many of its features. The example Memopad application uses more D-Flat features than any of my real applications. I wondered why, and I concluded: A 25x80 text-mode screen does not support full-blown CUA all that well. For example, why have a multiple-document interface with minimized windows on a text-mode screen? What good are simulated icons on such paltry screen real estate?

CUA is a moving target. IBM has modified their standard reference document at least once. I get e-mail messages that complain that D-Flat doesn't work exactly like this or that "CUA-compliant" program. Every program has its own interpretation. IBM's standard reference document is unambiguous, but no one seems to be reading it. Microsoft is redefining the standard with minor changes--improvements, actually--to the Windows 3.1 interface. Their version will, no doubt, prevail.

What are our requirements? If we need a full-blown C++ CUA package, we have several avenues. Microsoft's and Borland's application-frameworks packages are C++ classes that hook into the Windows API. Borland's Turbo Vision is a full-featured C++ class library that implements CUA in DOS text-mode. What do we need from D-Flat++ that we can't get elsewhere? We need a simple class library that implements the minimum features necessary to launch a single-user, single-document application. The CUA part will support menus, dialog boxes, and the usual controls.

This month we will look at the design of the D-Flat++ desktop and its input/output devices and discuss some DF++ concepts in general terms.

DF++ is an object-oriented design. An application will operate from within a global object called the "desktop." The DeskTop class contains one application-window object and the device objects--the mouse, keyboard, screen, cursor, speaker, and clock objects. The application program does not declare most of these objects. There is already a DeskTop object named desktop when the program starts up, and it already has all the devices except for the mouse if no mouse driver is installed. The application program does declare the application window, which automatically associates itself with the global desktop object.

A DF++ program will define its application by defining menus and dialog boxes and deriving a custom application window class from the base Application class. DF++ adopts the event-driven, message-based model of D-Flat, but uses the features of C++ to manage the messages. The application program sets up the application window and lets the desktop object collect events and dispatch messages. The difference is that the messages are class member functions that belong to the various window classes. The oblique SendMessage processing of D-Flat is unnecessary in DF++.

The application calls the desktop's DispatchEvents function to start event and message processing. That function then calls the DispatchEvents functions of the sysmouse, syskeyboard, and sysclock objects. Those functions poll their respective devices and call the appropriate member function of the window that should get the message. The device object determines which window that should be. Keyboard messages go to the window that has captured the focus, if any. Otherwise they go either to the window that has the focus or to the application window. In all cases, the messages are sent as calls to the window's member function through one of the pointers in the desktop object. Mouse messages go to the window where the mouse is pointing unless a window has captured the mouse, in which case, the capturing window gets the message, regardless of where the mouse cursor points.

When a window object gets a message, it can do one of four things. First, the window object can process the message and return. Second, it can decide that it has no interest in the message but that some base class somewhere up the class hierarchy to which the window class belongs should process the message. Third, the window object can do a combination of the first two. Finally, it can intercept and reject the message, deciding that neither it nor its base classes should process the message.

  Void EditBox::Keyboard(int key)

       {
          switch (key)   {
            case F1:
                 // --- process the F1 key
                 // ...
                 break;
            case F2:
                 // --- pass the F2 key up the hierarchy
                 TextBox::Keyboard(key);
                 break;
            case F3:
                 // --- process the F3 key
                 // ...
                 // --- pass the F3 key up the hierarchy
                 TextBox::Keyboard(key);
                 break;
            case F4:
                 // --- intercept and reject the F4 key
                 break;
            default:
                 break;
            }
       {

Window objects can send messages to other window objects or to themselves. Menus pop down because of messages between windows, and application's processes get called by menu-selection messages. Later columns will describe these processes in detail. The concept of sending messages is not new to C++ programmers nor to programmers in Windows-like, event-driven environments. This project uses C++ messages to implement event-driven messages. So far in my development, the DF++ programs are simpler and more expressive than the D-Flat programs, no doubt because of the natural fit of C++ messages and event-driven user-interface messages.

Mike Hall is a gentleman bartender in my hometown, and we have spent a lot of time together. Mike's current station is in a small lounge in a beachside resort hotel owned by some folks in England. They installed a homegrown point-of-sale system with terminals throughout the hotel. Its user interface is remarkable, to say the least. Their own programmer contrived it and steadfastly insists that the interface is so closely and tightly intertwined with the rest of the program that it cannot be modified. It takes Mike about 12 keystrokes on a custom array of plastic-covered function keys to ring up the sale of a beer. Every transaction returns to the top-level menu, and he has to start from the top no matter what. Often the printer goes off into the weeds and forgets what font it should use. A receipt can take a minute to print because the THANK YOU is printed in dot-matrix graphics letters a foot high. The program crashes a lot and forgets the cumulated total on a guest check, so Mike has to post it all over again. They told Mike that the system is their check-and-balance to match inventory with sales and control what the industry calls "shrinkage"--another word for employee theft. Mike told them that if they'd turn off the computer, give him a cigar box to put the cash in, and let the employees steal $1000.00 a month, they'd be money ahead.

<a name="029b_000a">

// ---------- desktop.h
#ifndef DESKTOP_H
#define DESKTOP_H

#include "screen.h"
#include "cursor.h"
#include "keyboard.h"
#include "mouse.h"
#include "speaker.h"
#include "clock.h"

class DFWindow;

class DeskTop {
    DFWindow *apwnd;        // application window
    DFWindow *infocus;      // current window with the focus
    DFWindow *firstcapture; // first window to capture the focus
    DFWindow *focuscapture; // current window with captured focus
    // ------- the desktop devices
    Screen   sysscreen;     // the system screen
    Mouse    sysmouse;      // the system mouse
    Keyboard syskeyboard;   // the system keyboard
    Cursor   syscursor;     // the system cursor
    Clock    sysclock;      // the system clock
    Speaker  sysspeaker;    // the system speaker
public:
    DeskTop();
    ~DeskTop();
    DFWindow *ApplWnd() { return apwnd; }
    void SetApplication(DFWindow *ApWnd) { apwnd = ApWnd; }
    Bool DispatchEvents();
    DFWindow *InFocus()      { return infocus; }
    DFWindow *FocusCapture() { return focuscapture; }
    DFWindow *FirstCapture() { return firstcapture; }
    void SetFocus(DFWindow *wnd) { infocus = wnd; }
    void SetFocusCapture(DFWindow *wnd) { focuscapture = wnd; }
    void SetFirstCapture(DFWindow *wnd) { firstcapture = wnd; }
    // ------- the desktop devices
    Mouse&    mouse()       { return sysmouse;    }
    Screen&   screen()      { return sysscreen;   }
    Keyboard& keyboard()    { return syskeyboard; }
    Cursor&   cursor()      { return syscursor;   }
    Clock&    clock()       { return sysclock;    }
    Speaker&  speaker()     { return sysspeaker;  }
};
extern DeskTop desktop;

#endif



<a name="029b_000b">
<a name="029b_000c">

<a name="029b_000c">

// ----------- screen.h
#ifndef SCREEN_H
#define SCREEN_H

#include <dos.h>
#include "dflatdef.h"
#include "rectangl.h"

class Screen    {
    unsigned address;
    unsigned mode;
    unsigned page;
    unsigned height;
    unsigned width;
    union REGS regs;
    // ---- compute video offset address
    unsigned vad(int x, int y) { return y * (width*2) + x*2; }
public:
    Screen();
    unsigned Height() { return height; }
    unsigned Width()  { return width; }
    unsigned Page()   { return page; }
    Bool isEGA();
    Bool isVGA();
    Bool isMono() { return (Bool) (mode == 7); }
    Bool isText() { return (Bool) (mode < 4);  }
    void Scroll(Rect &rc, int d, int fg, int bg);
    unsigned int GetVideoChar(int x, int y);
    void PutVideoChar(int x, int y, unsigned int c);
    void WriteVideoString(char *s,int x,int y,int fg,int bg);
    void SwapBuffer(Rect &rc, char *bf,
        Bool Hiding, Bool HasShadow, Bool isFrame);
    void GetBuffer(Rect &rc, char *bf);
    void PutBuffer(Rect &rc, char *bf);
};
const int VIDEO = 0x10;
inline int clr(int fg, int bg)
{
    return fg | (bg << 4);
}
#endif





<a name="029b_000d">
<a name="029b_000e">

<a name="029b_000e">

// ---------- mouse.h
#ifndef MOUSE_H
#define MOUSE_H

#include <dos.h>
#include "dfwindow.h"
#include "timer.h"

class Mouse    {
    Bool installed;      // True = mouse is installed
    char *statebuffer;   // mouse state buffer
    Timer doubletimer;   // mouse double-click timer
    Timer delaytimer;    // mouse typematic click timer
    int prevx;           // previous mouse x coordinate
    int prevy;           // previous mouse y coordinate
    int clickx;          // click x position
    int clicky;          // click y position
    int releasex;        // release x position
    int releasey;        // release y position
    union REGS regs;
    DFWindow *MouseWindow(int mx, int my);
    void CallMouse(int m1,int m2=0,int m3=0,int m4=0,unsigned es=0);
    void DispatchRelease();
    void DispatchMove();
    void DispatchLeftButton();
public:
    Mouse();
    ~Mouse();
    Bool Installed() { return installed; }
    void GetPosition(int &x, int &y); // get mouse position
    void SetPosition(int x, int y);   // set mouse position
    Bool Moved();           // True if mouse has moved
    void Show();            // show the mouse cursor
    void Hide();            // hide the mouse cursor
    Bool LeftButton();     // True if left button is pressed
    Bool ButtonReleased(); // True if button was released
    void SetTravel(int minx, int maxx, int miny, int maxy);
    void DispatchEvent();
};
const int MOUSE          = 0x33;  // mouse interrupt vector
// -------- mouse commands
const int RESETMOUSE     =  0;
const int SHOWMOUSE      =  1;
const int HIDEMOUSE      =  2;
const int READMOUSE      =  3;
const int SETPOSITION    =  4;
const int BUTTONRELEASED =  6;
const int XLIMIT         =  7;
const int YLIMIT         =  8;
const int BUFFSIZE       = 21;
const int SAVESTATE      = 22;
const int RESTORESTATE   = 23;
// -------- timer delays for mouse repeat, double clicks
const int DELAYTICKS     =  1;
const int FIRSTDELAY     =  7;
const int DOUBLETICKS    =  5;

#endif




<a name="029b_000f">
<a name="029b_0010">

<a name="029b_0010">

// ------------- cursor.h
#ifndef CURSOR_H
#define CURSOR_H

// ------- video BIOS (0x10) functions
const int SETCURSORTYPE = 1;
const int SETCURSOR     = 2;
const int READCURSOR    = 3;
const int HIDECURSOR    = 0x20;

const int MAXSAVES = 50;  // depth of cursor save/restore stack
class Cursor {
    // --- cursor save/restore stack
    int cursorpos[MAXSAVES];
    int cursorshape[MAXSAVES];
    int cs;             // count of cursor saves in effect
    union REGS regs;
    void Cursor::GetCursor();
public:
    Cursor();
    ~Cursor();
    void SetPosition(int x, int y);
    void GetPosition(int &x, int &y);
    void SetType(unsigned t);
    void normalcursor() { SetType(0x0607); }
    void Hide();
    void Show();
    void Save();
    void Restore();
    void SwapStack();
};
inline void swap(int a, int b)
{
    int x = a;
    a = b;
    b = x;
}
#endif




<a name="029b_0011">
<a name="029b_0012">

<a name="029b_0012">

// ------------ keyboard.h
#ifndef KEYBOARD_H
#define KEYBOARD_H

#include <dos.h>
#include "dflatdef.h"

class Keyboard    {
    union REGS regs;
    int shift;
public:
    Keyboard() { shift = GetShift(); }
    Bool ShiftChanged();
    int ShiftState() { return shift = GetShift(); }
    int AltConvert(int);
    int GetKey();
    int GetShift();
    Bool KeyHit();
    void clearBIOSbuffer();
    void DispatchEvent();
};
const int KEYBOARDVECT = 9;
const int KEYBOARDPORT = 0x60;

inline void Keyboard::clearBIOSbuffer()
{
    *(int far *)(MK_FP(0x40,0x1a)) =
    *(int far *)(MK_FP(0x40,0x1c));
}
// ----- keyboard BIOS (0x16) functions
const int KEYBRD = 0x16;
const int READKB = 0;
const int KBSTAT = 1;

const int ZEROFLAG = 0x40;
const int OFFSET = 0x1000;

const int RUBOUT = 8;
const int BELL   = 7;
const int ESC    = 27;
const unsigned F1          = (187+OFFSET);
const unsigned F8          = (194+OFFSET);
const unsigned SHIFT_F8    = (219+OFFSET);
const unsigned F10         = (196+OFFSET);
const unsigned HOME        = (199+OFFSET);
const unsigned UP          = (200+OFFSET);
const unsigned PGUP        = (201+OFFSET);
const unsigned BS          = (203+OFFSET);
const unsigned FWD         = (205+OFFSET);
const unsigned END         = (207+OFFSET);
const unsigned DN          = (208+OFFSET);
const unsigned PGDN        = (209+OFFSET);
const unsigned INS         = (210+OFFSET);
const unsigned DEL         = (211+OFFSET);
const unsigned CTRL_HOME   = (247+OFFSET);
const unsigned CTRL_PGUP   = (132+OFFSET);
const unsigned CTRL_BS     = (243+OFFSET);
const unsigned CTRL_FIVE   = (143+OFFSET);
const unsigned CTRL_FWD    = (244+OFFSET);
const unsigned CTRL_END    = (245+OFFSET);
const unsigned CTRL_PGDN   = (246+OFFSET);
const unsigned SHIFT_HT    = (143+OFFSET);
const unsigned ALT_A       = (158+OFFSET);
const unsigned ALT_B       = (176+OFFSET);
const unsigned ALT_C       = (174+OFFSET);
const unsigned ALT_D       = (160+OFFSET);
const unsigned ALT_E       = (146+OFFSET);
const unsigned ALT_F       = (161+OFFSET);
const unsigned ALT_G       = (162+OFFSET);
const unsigned ALT_H       = (163+OFFSET);
const unsigned ALT_I       = (151+OFFSET);
const unsigned ALT_J       = (164+OFFSET);
const unsigned ALT_K       = (165+OFFSET);
const unsigned ALT_L       = (166+OFFSET);
const unsigned ALT_M       = (178+OFFSET);
const unsigned ALT_N       = (177+OFFSET);
const unsigned ALT_O       = (152+OFFSET);
const unsigned ALT_P       = (153+OFFSET);
const unsigned ALT_Q       = (144+OFFSET);
const unsigned ALT_R       = (147+OFFSET);
const unsigned ALT_S       = (159+OFFSET);
const unsigned ALT_T       = (148+OFFSET);
const unsigned ALT_U       = (150+OFFSET);
const unsigned ALT_V       = (175+OFFSET);
const unsigned ALT_W       = (145+OFFSET);
const unsigned ALT_X       = (173+OFFSET);
const unsigned ALT_Y       = (149+OFFSET);
const unsigned ALT_Z       = (172+OFFSET);
const unsigned ALT_1      = (0xf8+OFFSET);
const unsigned ALT_2      = (0xf9+OFFSET);
const unsigned ALT_3      = (0xfa+OFFSET);
const unsigned ALT_4      = (0xfb+OFFSET);
const unsigned ALT_5      = (0xfc+OFFSET);
const unsigned ALT_6      = (0xfd+OFFSET);
const unsigned ALT_7      = (0xfe+OFFSET);
const unsigned ALT_8      = (0xff+OFFSET);
const unsigned ALT_9      = (0x80+OFFSET);
const unsigned ALT_0      = (0x81+OFFSET);
const unsigned ALT_HYPHEN = (130+OFFSET);
const unsigned CTRL_F4    = (225+OFFSET);
const unsigned ALT_F4     = (235+OFFSET);
const unsigned ALT_F6     = (237+OFFSET);

enum {CTRL_A=1,CTRL_B,CTRL_C,CTRL_D,CTRL_E,CTRL_F,CTRL_G,CTRL_H,
        CTRL_I,CTRL_J,CTRL_K,CTRL_L,CTRL_M,CTRL_N,CTRL_O,CTRL_P,
        CTRL_Q,CTRL_R,CTRL_S,CTRL_T,CTRL_U,CTRL_V,CTRL_W,CTRL_X,
        CTRL_Y,CTRL_Z };
// ------- BIOS shift key mask values
const int RIGHTSHIFT = 0x01;
const int LEFTSHIFT  = 0x02;
const int CTRLKEY    = 0x04;
const int ALTKEY     = 0x08;
const int SCROLLLOCK = 0x10;
const int NUMLOCK    = 0x20;
const int CAPSLOCK   = 0x40;
const int INSERTKEY  = 0x80;

#endif



<a name="029b_0013">
<a name="029b_0014">

<a name="029b_0014">

// --------- speaker.h
#ifndef SPEAKER_H
#define SPEAKER_H

class Speaker    {
    void Wait(int n);
public:
    void Beep();
};
const int FREQUENCY = 100;
const long COUNT = 1193280L / FREQUENCY;

#endif




<a name="029b_0015">
<a name="029b_0029"><a name="029b_0016">

<a name="029b_0016">

// --------- clock.h
#ifndef CLOCK_H
#define CLOCK_H

#include "timer.h"

class Clock    {
    Timer clocktimer;
public:
    Clock();
    void DispatchEvent();
};
#endif

Copyright © 1992, Dr. Dobb's Journal