Conference bulova::decw_jan-89_to_nov-90

#include <decw$include/decwdwtwidgetprog.h>
#include <decw$include/xatom.h>
#include <decw$include/keysym.h>
#include <decw$include/keysymdef.h>
#include <stdio.h>

enum {
   MDL_VK_RETURN, MDL_VK_LEFT, MDL_VK_RIGHT, MDL_VK_BACK, MDL_VK_HOME,
   MDL_VK_END, MDL_VK_DOWN, MDL_VK_UP, MDL_VK_PRIOR, MDL_VK_NEXT
};

enum {
   MDL_WM_CHAR, MDL_WM_KEYDOWN
};


#define MAX_BOUND_STR_LEN 256

Widget top;

static int controlKeyDown;
static int altKeyDown;

static void KeyHandler();
static void ExposeHandler();

void
QuitProc(widget, tag, data)
Widget widget;
Opaque tag;
DwtAnyCallbackStruct *data;
{
   printf("QUIT\n");
}

main(argc, argv)
int argc;
char **argv;
{
   
   Widget mainWindow, workArea, menubar, menu, pull, button;
   Window topWindow;
   Arg args[10];
   int i;
   static DwtCallback quitCallback[] = {
      {QuitProc, NULL,},
      {NULL, NULL}
   };

   top = XtInitialize("", "", NULL, 0, &argc, argv);

   mainWindow = DwtMainWindow(top, "", 0, 0, 0, 0);
   if (argc > 1) {
      i = 0;
      XtSetArg(args[i], DwtNacceptFocus, TRUE);       ++i;
      XtSetValues(mainWindow, args, i);
   }
   XtManageChild(mainWindow);

   menubar = DwtMenuBar(mainWindow, "", NULL, NULL);
   XtManageChild(menubar);

   menu = DwtMenu(menubar, "", 0, 0, DwtMenuPulldown,
                  DwtOrientationVertical, NULL, NULL, NULL);

   i = 0;
   XtSetArg(args[i], DwtNactivateCallback, quitCallback);            ++i;
   XtSetArg(args[i], DwtNlabel, DwtLatin1String("Quit"));            ++i;
   XtSetArg(args[i], DwtNacceleratorText, DwtLatin1String("ALT/Q")); ++i;
   XtSetArg(args[i], DwtNbuttonAccelerator, "Alt<KeyPress>q:");      ++i;
   button = DwtPushButtonCreate(menu, "", args, i);
   XtManageChild(button);
   pull = DwtPullDownMenuEntry(menubar, "", 0, 0,
                               DwtLatin1String("File"),
                               menu, NULL, NULL);
   XtManageChild(pull);
                                   
   i = 0;
   XtSetArg(args[i], DwtNwidth, 200);              ++i;
   XtSetArg(args[i], DwtNheight, 200);             ++i;
   if (argc == 1) {
      XtSetArg(args[i], DwtNacceptFocus, TRUE);    ++i;
   }
   workArea = DwtDialogBoxCreate(mainWindow, "", args, i);
   XtAddEventHandler(workArea, KeyPressMask | KeyReleaseMask,
                     FALSE, KeyHandler, NULL);
   XtAddEventHandler(workArea, ExposureMask,
                     FALSE, ExposeHandler, NULL);
   XtManageChild(workArea);

   XtRealizeWidget(top);

   topWindow = XtWindow(top);

   /* install the keyboard accelerators */
   XtInstallAllAccelerators((argc > 1) ? mainWindow : workArea, mainWindow);

   XtMainLoop();
}

static void
KeyHandler(workArea, window, event)
Widget workArea;
caddr_t window;
XEvent *event;
{
   int count, controlKey, altKey, i, c, keyCode;
   char string[MAX_BOUND_STR_LEN];
   KeySym keysym;
   XComposeStatus compose;

   count = XLookupString(&event->xkey, string, MAX_BOUND_STR_LEN,
                         &keysym, &compose);
   controlKey = (keysym == XK_Control_L || keysym == XK_Control_R);
   altKey = (keysym == XK_Alt_L || keysym == XK_Alt_R);
   if (event->xkey.type == KeyRelease) {
      if (controlKey) controlKeyDown = FALSE;
      if (altKey) altKeyDown = FALSE;
   } else {
      if (controlKey) controlKeyDown = TRUE;
      if (altKey) altKeyDown = TRUE;
      if (count > 0) {
         for (i = 0; i < count; ++i) {
            c = string[i];
            if (isprint(c)) {
               MDLSendMessage(window, MDL_WM_CHAR, c, 0L);
            } else if (c == toascii(XK_Return)) {
               MDLSendMessage(window, MDL_WM_KEYDOWN, MDL_VK_RETURN, 0L);
            } else if (c == toascii(XK_Delete)) {
               MDLSendMessage(window, MDL_WM_KEYDOWN, MDL_VK_BACK, 0L);
            }
         }
      } else {
         switch (keysym) {
            case XK_Left:
               keyCode = MDL_VK_LEFT;
               break;
            case XK_Right:
               keyCode = MDL_VK_RIGHT;
               break;
            case XK_Up:
               keyCode = MDL_VK_UP;
               break;
            case XK_Down:
               keyCode = MDL_VK_DOWN;
               break;
            case XK_F12:
               keyCode = (event->xkey.state & ShiftMask) ?
                         MDL_VK_END : MDL_VK_HOME;
               break;
            case XK_Prior:
               keyCode = MDL_VK_PRIOR;
               break;
            case XK_Next:
               keyCode = MDL_VK_NEXT;
               break;
            default:
               keyCode = -1;
               break;
         }
         if (keyCode >= 0) MDLSendMessage(window, MDL_WM_KEYDOWN, keyCode, 0L);
      }
   }
}


long
MDLSendMessage(mw, messageCode, wParam, lParam)
caddr_t mw;
int messageCode, wParam;
long lParam;
{
   printf("MDLSendMessage called");
   if (messageCode == MDL_WM_CHAR) printf(": %c", wParam);
   printf("\n");
}


static void
ExposeHandler(workArea, window, event)
Widget workArea;
caddr_t window;
XEvent *event;
{

   XSetInputFocus(XtDisplay(workArea), XtWindow(workArea),
                  RevertToPointerRoot, CurrentTime);

}