home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / gnu / djgpp / contrib / dvx / demos / xev / xev.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-15  |  26.0 KB  |  927 lines
  1. /*
  2.  * xev - event diagnostics
  3.  *
  4.  * $XConsortium: xev.c,v 1.10 89/12/12 14:50:23 rws Exp $
  5.  *
  6.  * Copyright 1988 Massachusetts Institute of Technology
  7.  *
  8.  * Permission to use, copy, modify, and distribute this software and its
  9.  * documentation for any purpose and without fee is hereby granted, provided
  10.  * that the above copyright notice appear in all copies and that both that
  11.  * copyright notice and this permission notice appear in supporting
  12.  * documentation, and that the name of M.I.T. not be used in advertising or
  13.  * publicity pertaining to distribution of the software without specific,
  14.  * written prior permission.  M.I.T. makes no representations about the
  15.  * suitability of this software for any purpose.  It is provided "as is"
  16.  * without express or implied warranty.
  17.  *
  18.  * Author:  Jim Fulton, MIT X Consortium
  19.  */
  20.  
  21. #if defined (PROTO) || defined(PROTO1) /* JDC 91/04/22 */
  22. #define NeedFunctionPrototypes 0
  23. #define NeedFunctionPtrPrototypes 1
  24. #include "xev.fd1"
  25. #endif
  26.  
  27. #if PROTO
  28. #include "xev.fd2"
  29. #endif
  30.  
  31. #include <stdio.h>
  32. #include <X11/Xos.h>
  33. #include <X11/Xlib.h>
  34. #include <X11/Xutil.h>
  35. #include <X11/Xproto.h>
  36. #include <ctype.h>
  37.  
  38. #define INNER_WINDOW_WIDTH 50
  39. #define INNER_WINDOW_HEIGHT 50
  40. #define INNER_WINDOW_BORDER 4
  41. #define INNER_WINDOW_X 10
  42. #define INNER_WINDOW_Y 10
  43. #define OUTER_WINDOW_MIN_WIDTH (INNER_WINDOW_WIDTH + \
  44.                 2 * (INNER_WINDOW_BORDER + INNER_WINDOW_X))
  45. #define OUTER_WINDOW_MIN_HEIGHT (INNER_WINDOW_HEIGHT + \
  46.                 2 * (INNER_WINDOW_BORDER + INNER_WINDOW_Y))
  47. #define OUTER_WINDOW_DEF_WIDTH (OUTER_WINDOW_MIN_WIDTH + 100)
  48. #define OUTER_WINDOW_DEF_HEIGHT (OUTER_WINDOW_MIN_HEIGHT + 100)
  49. #define OUTER_WINDOW_DEF_X 100
  50. #define OUTER_WINDOW_DEF_Y 100
  51.                 
  52.  
  53. typedef unsigned long Pixel;
  54.  
  55. char *Yes = "YES";
  56. char *No = "NO";
  57. char *Unknown = "unknown";
  58.  
  59. char *ProgramName;
  60. Display *dpy;
  61. int screen;
  62.  
  63. usage ()
  64. {
  65.     static char *msg[] = {
  66. "    -display displayname                X server to contact",
  67. "    -geometry geom                      size and location of window",
  68. "    -bw pixels                          border width in pixels",
  69. "    -bs {NotUseful,WhenMapped,Always}   backingstore attribute",
  70. "    -s                                  set save-unders attribute",
  71. "",
  72. NULL};
  73.     char **cpp;
  74.  
  75.     fprintf (stderr, "usage:  %s [-options ...]\n", ProgramName);
  76.     fprintf (stderr, "where options include:\n");
  77.  
  78.     for (cpp = msg; *cpp; cpp++) {
  79.     fprintf (stderr, "%s\n", *cpp);
  80.     }
  81.  
  82.     exit (1);
  83. }
  84.  
  85. static int parse_backing_store (s)
  86.     char *s;
  87. {
  88.     int len = strlen (s);
  89.     char *cp;
  90.  
  91.     for (cp = s; *cp; cp++) {
  92.     if (isascii (*cp) && isupper (*cp)) *cp = tolower (*cp);
  93.     }
  94.  
  95.     if (strncmp (s, "notuseful", len) == 0) return (NotUseful);
  96.     if (strncmp (s, "whenmapped", len) == 0) return (WhenMapped);
  97.     if (strncmp (s, "always", len) == 0) return (Always);
  98.  
  99.     usage ();
  100. }
  101.  
  102. main (argc, argv)
  103.     int argc;
  104.     char **argv;
  105. {
  106.     char *displayname = NULL;
  107.     char *geom = NULL;
  108.     int i;
  109.     XSizeHints hints;
  110.     int borderwidth = 2;
  111.     Window w, subw;
  112.     XSetWindowAttributes attr;
  113.     unsigned long mask = 0L;
  114.     int done;
  115.  
  116.     ProgramName = argv[0];
  117.     for (i = 1; i < argc; i++) {
  118.     char *arg = argv[i];
  119.  
  120.     if (arg[0] == '-') {
  121.         switch (arg[1]) {
  122.           case 'd':            /* -display host:dpy */
  123.         if (++i >= argc) usage ();
  124.         displayname = argv[i];
  125.         continue;
  126.           case 'g':            /* -geometry geom */
  127.         if (++i >= argc) usage ();
  128.         geom = argv[i];
  129.         continue;
  130.           case 'b':
  131.         switch (arg[2]) {
  132.           case 'w':        /* -bw pixels */
  133.             if (++i >= argc) usage ();
  134.             borderwidth = atoi (argv[i]);
  135.             continue;
  136.           case 's':        /* -bs type */
  137.             if (++i >= argc) usage ();
  138.             attr.backing_store = parse_backing_store (argv[i]);
  139.             mask |= CWBackingStore;
  140.             continue;
  141.           default:
  142.             usage ();
  143.         }
  144.           case 's':            /* -s */
  145.         attr.save_under = True;
  146.         mask |= CWSaveUnder;
  147.         continue;
  148.           default:
  149.         usage ();
  150.         }                /* end switch on - */
  151.     } else 
  152.       usage ();
  153.     }                    /* end for over argc */
  154.  
  155.     dpy = XOpenDisplay (displayname);
  156.     if (!dpy) {
  157.     fprintf (stderr, "%s:  unable to open display '%s'\n",
  158.          ProgramName, XDisplayName (displayname));
  159.     exit (1);
  160.     }
  161.  
  162.     set_sizehints (&hints, OUTER_WINDOW_MIN_WIDTH, OUTER_WINDOW_MIN_HEIGHT,
  163.            OUTER_WINDOW_DEF_WIDTH, OUTER_WINDOW_DEF_HEIGHT, 
  164.            OUTER_WINDOW_DEF_X, OUTER_WINDOW_DEF_Y, geom);
  165.  
  166.     screen = DefaultScreen (dpy);
  167.  
  168.     attr.background_pixel = BlackPixel (dpy, screen);
  169.     attr.border_pixel = WhitePixel (dpy, screen);
  170.     /* select for all events */
  171.     attr.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |
  172.                ButtonReleaseMask | EnterWindowMask |
  173.                LeaveWindowMask | PointerMotionMask | 
  174.                PointerMotionHintMask | Button1MotionMask |
  175.                Button2MotionMask | Button3MotionMask |
  176.                Button4MotionMask | Button5MotionMask |
  177.                ButtonMotionMask | KeymapStateMask |
  178.                ExposureMask | VisibilityChangeMask | 
  179.                StructureNotifyMask | /* ResizeRedirectMask | */
  180.                SubstructureNotifyMask | SubstructureRedirectMask |
  181.                FocusChangeMask | PropertyChangeMask |
  182.                ColormapChangeMask | OwnerGrabButtonMask;
  183.     mask |= (CWBackPixel | CWBorderPixel | CWEventMask);
  184.  
  185.     w = XCreateWindow (dpy, RootWindow (dpy, screen), hints.x, hints.y,
  186.                hints.width, hints.height, borderwidth, 0, InputOutput,
  187.                (Visual *)CopyFromParent,
  188.                mask, &attr);
  189.  
  190.     XSetStandardProperties (dpy, w, "Event Tester", NULL, (Pixmap) 0,
  191.                 argv, argc, &hints);
  192.  
  193.     subw = XCreateSimpleWindow (dpy, w, INNER_WINDOW_X, INNER_WINDOW_Y,
  194.                 INNER_WINDOW_WIDTH, INNER_WINDOW_HEIGHT,
  195.                 INNER_WINDOW_BORDER,
  196.                 attr.border_pixel, attr.background_pixel);
  197.  
  198.     XMapWindow (dpy, subw);        /* map before w so that it appears */
  199.     XMapWindow (dpy, w);
  200.  
  201.     printf ("Outer window is 0x%lx, inner window is 0x%lx\n", w, subw);
  202.  
  203.     for (done = 0; !done; ) {
  204.     XEvent event;
  205.  
  206.     XNextEvent (dpy, &event);
  207.  
  208.     switch (event.type) {
  209.       case KeyPress:
  210.         prologue (&event, "KeyPress");
  211.         do_KeyPress (&event);
  212.         break;
  213.       case KeyRelease:
  214.         prologue (&event, "KeyRelease");
  215.         do_KeyRelease (&event);
  216.         break;
  217.       case ButtonPress:
  218.         prologue (&event, "ButtonPress");
  219.         do_ButtonPress (&event);
  220.         break;
  221.       case ButtonRelease:
  222.         prologue (&event, "ButtonRelease");
  223.         do_ButtonRelease (&event);
  224.         break;
  225.       case MotionNotify:
  226.         prologue (&event, "MotionNotify");
  227.         do_MotionNotify (&event);
  228.         break;
  229.       case EnterNotify:
  230.         prologue (&event, "EnterNotify");
  231.         do_EnterNotify (&event);
  232.         break;
  233.       case LeaveNotify:
  234.         prologue (&event, "LeaveNotify");
  235.         do_LeaveNotify (&event);
  236.         break;
  237.       case FocusIn:
  238.         prologue (&event, "FocusIn");
  239.         do_FocusIn (&event);
  240.         break;
  241.       case FocusOut:
  242.         prologue (&event, "FocusOut");
  243.         do_FocusOut (&event);
  244.         break;
  245.       case KeymapNotify:
  246.         prologue (&event, "KeymapNotify");
  247.         do_KeymapNotify (&event);
  248.         break;
  249.       case Expose:
  250.         prologue (&event, "Expose");
  251.         do_Expose (&event);
  252.         break;
  253.       case GraphicsExpose:
  254.         prologue (&event, "GraphicsExpose");
  255.         do_GraphicsExpose (&event);
  256.         break;
  257.       case NoExpose:
  258.         prologue (&event, "NoExpose");
  259.         do_NoExpose (&event);
  260.         break;
  261.       case VisibilityNotify:
  262.         prologue (&event, "VisibilityNotify");
  263.         do_VisibilityNotify (&event);
  264.         break;
  265.       case CreateNotify:
  266.         prologue (&event, "CreateNotify");
  267.         do_CreateNotify (&event);
  268.         break;
  269.       case DestroyNotify:
  270.         prologue (&event, "DestroyNotify");
  271.         do_DestroyNotify (&event);
  272.         break;
  273.       case UnmapNotify:
  274.         prologue (&event, "UnmapNotify");
  275.         do_UnmapNotify (&event);
  276.         break;
  277.       case MapNotify:
  278.         prologue (&event, "MapNotify");
  279.         do_MapNotify (&event);
  280.         break;
  281.       case MapRequest:
  282.         prologue (&event, "MapRequest");
  283.         do_MapRequest (&event);
  284.         break;
  285.       case ReparentNotify:
  286.         prologue (&event, "ReparentNotify");
  287.         do_ReparentNotify (&event);
  288.         break;
  289.       case ConfigureNotify:
  290.         prologue (&event, "ConfigureNotify");
  291.         do_ConfigureNotify (&event);
  292.         break;
  293.       case ConfigureRequest:
  294.         prologue (&event, "ConfigureRequest");
  295.         do_ConfigureRequest (&event);
  296.         break;
  297.       case GravityNotify:
  298.         prologue (&event, "GravityNotify");
  299.         do_GravityNotify (&event);
  300.         break;
  301.       case ResizeRequest:
  302.         prologue (&event, "ResizeRequest");
  303.         do_ResizeRequest (&event);
  304.         break;
  305.       case CirculateNotify:
  306.         prologue (&event, "CirculateNotify");
  307.         do_CirculateNotify (&event);
  308.         break;
  309.       case CirculateRequest:
  310.         prologue (&event, "CirculateRequest");
  311.         do_CirculateRequest (&event);
  312.         break;
  313.       case PropertyNotify:
  314.         prologue (&event, "PropertyNotify");
  315.         do_PropertyNotify (&event);
  316.         break;
  317.       case SelectionClear:
  318.         prologue (&event, "SelectionClear");
  319.         do_SelectionClear (&event);
  320.         break;
  321.       case SelectionRequest:
  322.         prologue (&event, "SelectionRequest");
  323.         do_SelectionRequest (&event);
  324.         break;
  325.       case SelectionNotify:
  326.         prologue (&event, "SelectionNotify");
  327.         do_SelectionNotify (&event);
  328.         break;
  329.       case ColormapNotify:
  330.         prologue (&event, "ColormapNotify");
  331.         do_ColormapNotify (&event);
  332.         break;
  333.       case ClientMessage:
  334.         prologue (&event, "ClientMessage");
  335.         do_ClientMessage (&event);
  336.         break;
  337.       case MappingNotify:
  338.         prologue (&event, "MappingNotify");
  339.         do_MappingNotify (&event);
  340.         break;
  341.       default:
  342.         printf ("Unknown event type %d\n", event.type);
  343.         break;
  344.     }
  345.     }
  346.  
  347.     XCloseDisplay (dpy);
  348.     exit (0);
  349. }
  350.  
  351. prologue (eventp, event_name)
  352.     XEvent *eventp;
  353.     char *event_name;
  354. {
  355.     XAnyEvent *e = (XAnyEvent *) eventp;
  356.  
  357.     printf ("\n%s event, serial %ld, synthetic %s, window 0x%lx,\n",
  358.         event_name, e->serial, e->send_event ? Yes : No, e->window);
  359.     return;
  360. }
  361.  
  362.  
  363. do_KeyPress (eventp)
  364.     XEvent *eventp;
  365. {
  366.     XKeyEvent *e = (XKeyEvent *) eventp;
  367.     KeySym ks;
  368.     char *ksname;
  369.     int nbytes;
  370.     char str[256+1];
  371.  
  372.     nbytes = XLookupString (e, str, 256, &ks, NULL);
  373.     if (ks == NoSymbol)
  374.     ksname = "NoSymbol";
  375.     else if (!(ksname = XKeysymToString (ks)))
  376.     ksname = "(no name)";
  377.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  378.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  379. #if 0 /* POHC 90/10/09 */
  380.     printf ("    state 0x%x, keycode %u (keysym 0x%x, %s), same_screen %s,\n",
  381.         e->state, e->keycode, ks, ksname, e->same_screen ? Yes : No);
  382. #else
  383.     printf ("    state 0x%x, keycode %u (keysym 0x%x, ", e->state, e->keycode, ks);
  384.     printf (ksname);
  385.     printf ("), same_screen %s,\n", e->same_screen ? Yes : No);
  386. #endif
  387.     if (nbytes < 0) nbytes = 0;
  388.     if (nbytes > 256) nbytes = 256;
  389.     str[nbytes] = '\0';
  390.     printf ("    XLookupString gives %d characters:  \"%s\"\n", nbytes, str);
  391.  
  392.     return;
  393. }
  394.  
  395. do_KeyRelease (eventp)
  396.     XEvent *eventp;
  397. {
  398.     do_KeyPress (eventp);        /* since it has the same info */
  399.     return;
  400. }
  401.  
  402. do_ButtonPress (eventp)
  403.     XEvent *eventp;
  404. {
  405.     XButtonEvent *e = (XButtonEvent *) eventp;
  406.  
  407.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  408.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  409.     printf ("    state 0x%x, button %u, same_screen %s\n",
  410.         e->state, e->button, e->same_screen ? Yes : No);
  411.  
  412.     return;
  413. }
  414.  
  415. do_ButtonRelease (eventp)
  416.     XEvent *eventp;
  417. {
  418.     do_ButtonPress (eventp);        /* since it has the same info */
  419.     return;
  420. }
  421.  
  422. do_MotionNotify (eventp)
  423.     XEvent *eventp;
  424. {
  425.     XMotionEvent *e = (XMotionEvent *) eventp;
  426.  
  427.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  428.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  429.     printf ("    state 0x%x, is_hint %u, same_screen %s\n",
  430.         e->state, e->is_hint, e->same_screen ? Yes : No);
  431.  
  432.     return;
  433. }
  434.  
  435. do_EnterNotify (eventp)
  436.     XEvent *eventp;
  437. {
  438.     XCrossingEvent *e = (XCrossingEvent *) eventp;
  439.     char *mode, *detail;
  440.     char dmode[10], ddetail[10];
  441.  
  442.     switch (e->mode) {
  443.       case NotifyNormal:  mode = "NotifyNormal"; break;
  444.       case NotifyGrab:  mode = "NotifyGrab"; break;
  445.       case NotifyUngrab:  mode = "NotifyUngrab"; break;
  446.       case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
  447.       default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
  448.     }
  449.  
  450.     switch (e->detail) {
  451.       case NotifyAncestor:  detail = "NotifyAncestor"; break;
  452.       case NotifyVirtual:  detail = "NotifyVirtual"; break;
  453.       case NotifyInferior:  detail = "NotifyInferior"; break;
  454.       case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
  455.       case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
  456.       case NotifyPointer:  detail = "NotifyPointer"; break;
  457.       case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
  458.       case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
  459.       default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
  460.     }
  461.  
  462.     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
  463.         e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
  464.     printf ("    mode %s, detail %s, same_screen %s,\n",
  465.         mode, detail, e->same_screen ? Yes : No);
  466.     printf ("    focus %s, state %u\n", e->focus ? Yes : No, e->state);
  467.  
  468.     return;
  469. }
  470.  
  471. do_LeaveNotify (eventp)
  472.     XEvent *eventp;
  473. {
  474.     do_EnterNotify (eventp);        /* since it has same information */
  475.     return;
  476. }
  477.  
  478. do_FocusIn (eventp)
  479.     XEvent *eventp;
  480. {
  481.     XFocusChangeEvent *e = (XFocusChangeEvent *) eventp;
  482.     char *mode, *detail;
  483.     char dmode[10], ddetail[10];
  484.  
  485.     switch (e->mode) {
  486.       case NotifyNormal:  mode = "NotifyNormal"; break;
  487.       case NotifyGrab:  mode = "NotifyGrab"; break;
  488.       case NotifyUngrab:  mode = "NotifyUngrab"; break;
  489.       case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
  490.       default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
  491.     }
  492.  
  493.     switch (e->detail) {
  494.       case NotifyAncestor:  detail = "NotifyAncestor"; break;
  495.       case NotifyVirtual:  detail = "NotifyVirtual"; break;
  496.       case NotifyInferior:  detail = "NotifyInferior"; break;
  497.       case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
  498.       case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
  499.       case NotifyPointer:  detail = "NotifyPointer"; break;
  500.       case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
  501.       case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
  502.       default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
  503.     }
  504.  
  505.     printf ("    mode %s, detail %s\n", mode, detail);
  506.     return;
  507. }
  508.  
  509. do_FocusOut (eventp)
  510.     XEvent *eventp;
  511. {
  512.     do_FocusIn (eventp);        /* since it has same information */
  513.     return;
  514. }
  515.  
  516. do_KeymapNotify (eventp)
  517.     XEvent *eventp;
  518. {
  519.     XKeymapEvent *e = (XKeymapEvent *) eventp;
  520.     int i;
  521.  
  522.     printf ("    keys:  ");
  523.     for (i = 0; i < 32; i++) {
  524.     if (i == 16) printf ("\n           ");
  525.     printf ("%-3u ", (unsigned int) e->key_vector[i]);
  526.     }
  527.     printf ("\n");
  528.     return;
  529. }
  530.  
  531. do_Expose (eventp)
  532.     XEvent *eventp;
  533. {
  534.     XExposeEvent *e = (XExposeEvent *) eventp;
  535.  
  536.     printf ("    (%d,%d), width %d, height %d, count %d\n",
  537.         e->x, e->y, e->width, e->height, e->count);
  538.     return;
  539. }
  540.  
  541. do_GraphicsExpose (eventp)
  542.     XEvent *eventp;
  543. {
  544.     XGraphicsExposeEvent *e = (XGraphicsExposeEvent *) eventp;
  545.     char *m;
  546.     char mdummy[10];
  547.  
  548.     switch (e->major_code) {
  549.       case X_CopyArea:  m = "CopyArea";  break;
  550.       case X_CopyPlane:  m = "CopyPlane";  break;
  551.       default:  m = mdummy; sprintf (mdummy, "%d", e->major_code); break;
  552.     }
  553.  
  554.     printf ("    (%d,%d), width %d, height %d, count %d,\n",
  555.         e->x, e->y, e->width, e->height, e->count);
  556.     printf ("    major %s, minor %d\n", m, e->minor_code);
  557.     return;
  558. }
  559.  
  560. do_NoExpose (eventp)
  561.     XEvent *eventp;
  562. {
  563.     XNoExposeEvent *e = (XNoExposeEvent *) eventp;
  564.     char *m;
  565.     char mdummy[10];
  566.  
  567.     switch (e->major_code) {
  568.       case X_CopyArea:  m = "CopyArea";  break;
  569.       case X_CopyPlane:  m = "CopyPlane";  break;
  570.       default:  m = mdummy; sprintf (mdummy, "%d", e->major_code); break;
  571.     }
  572.  
  573.     printf ("    major %s, minor %d\n", m, e->minor_code);
  574.     return;
  575. }
  576.  
  577. do_VisibilityNotify (eventp)
  578.     XEvent *eventp;
  579. {
  580.     XVisibilityEvent *e = (XVisibilityEvent *) eventp;
  581.     char *v;
  582.     char vdummy[10];
  583.  
  584.     switch (e->state) {
  585.       case VisibilityUnobscured:  v = "VisibilityUnobscured"; break;
  586.       case VisibilityPartiallyObscured:  v = "VisibilityPartiallyObscured"; break;
  587.       case VisibilityFullyObscured:  v = "VisibilityFullyObscured"; break;
  588.       default:  v = vdummy; sprintf (vdummy, "%d", e->state); break;
  589.     }
  590.  
  591.     printf ("    state %s\n", v);
  592.     return;
  593. }
  594.  
  595. do_CreateNotify (eventp)
  596.     XEvent *eventp;
  597. {
  598.     XCreateWindowEvent *e = (XCreateWindowEvent *) eventp;
  599.  
  600.     printf ("    parent 0x%lx, window 0x%lx, (%d,%d), width %d, height %d\n",
  601.         e->parent, e->window, e->x, e->y, e->width, e->height);
  602.     printf ("border_width %d, override %s\n",
  603.         e->border_width, e->override_redirect ? Yes : No);
  604.     return;
  605. }
  606.  
  607. do_DestroyNotify (eventp)
  608.     XEvent *eventp;
  609. {
  610.     XDestroyWindowEvent *e = (XDestroyWindowEvent *) eventp;
  611.  
  612.     printf ("    event 0x%lx, window 0x%lx\n", e->event, e->window);
  613.     return;
  614. }
  615.  
  616. do_UnmapNotify (eventp)
  617.     XEvent *eventp;
  618. {
  619.     XUnmapEvent *e = (XUnmapEvent *) eventp;
  620.  
  621.     printf ("    event 0x%lx, window 0x%lx, from_configure %s\n",
  622.         e->event, e->window, e->from_configure ? Yes : No);
  623.     return;
  624. }
  625.  
  626. do_MapNotify (eventp)
  627.     XEvent *eventp;
  628. {
  629.     XMapEvent *e = (XMapEvent *) eventp;
  630.  
  631.     printf ("    event 0x%lx, window 0x%lx, override %s\n",
  632.         e->event, e->window, e->override_redirect ? Yes : No);
  633.     return;
  634. }
  635.  
  636. do_MapRequest (eventp)
  637.     XEvent *eventp;
  638. {
  639.     XMapRequestEvent *e = (XMapRequestEvent *) eventp;
  640.  
  641.     printf ("    parent 0x%lx, window 0x%lx\n", e->parent, e->window);
  642.     return;
  643. }
  644.  
  645. do_ReparentNotify (eventp)
  646.     XEvent *eventp;
  647. {
  648.     XReparentEvent *e = (XReparentEvent *) eventp;
  649.  
  650.     printf ("    event 0x%lx, window 0x%lx, parent 0x%lx,\n",
  651.         e->event, e->window, e->parent);
  652.     printf ("    (%d,%d), override %s\n", e->x, e->y, 
  653.         e->override_redirect ? Yes : No);
  654.     return;
  655. }
  656.  
  657. do_ConfigureNotify (eventp)
  658.     XEvent *eventp;
  659. {
  660.     XConfigureEvent *e = (XConfigureEvent *) eventp;
  661.  
  662.     printf ("    event 0x%lx, window 0x%lx, (%d,%d), width %d, height %d,\n",
  663.         e->event, e->window, e->x, e->y, e->width, e->height);
  664.     printf ("    border_width %d, above 0x%lx, override %s\n",
  665.         e->border_width, e->above, e->override_redirect ? Yes : No);
  666.     return;
  667. }
  668.  
  669. do_ConfigureRequest (eventp)
  670.     XEvent *eventp;
  671. {
  672.     XConfigureRequestEvent *e = (XConfigureRequestEvent *) eventp;
  673.     char *detail;
  674.     char ddummy[10];
  675.  
  676.     switch (e->detail) {
  677.       case Above:  detail = "Above";  break;
  678.       case Below:  detail = "Below";  break;
  679.       case TopIf:  detail = "TopIf";  break;
  680.       case BottomIf:  detail = "BottomIf"; break;
  681.       case Opposite:  detail = "Opposite"; break;
  682.       default:  detail = ddummy; sprintf (ddummy, "%d", e->detail); break;
  683.     }
  684.  
  685.     printf ("    parent 0x%lx, window 0x%lx, (%d,%d), width %d, height %d,\n",
  686.         e->parent, e->window, e->x, e->y, e->width, e->height);
  687.     printf ("    border_width %d, above 0x%lx, detail %s, value 0x%lx\n",
  688.         e->border_width, e->above, detail, e->value_mask);
  689.     return;
  690. }
  691.  
  692. do_GravityNotify (eventp)
  693.     XEvent *eventp;
  694. {
  695.     XGravityEvent *e = (XGravityEvent *) eventp;
  696.  
  697.     printf ("    event 0x%lx, window 0x%lx, (%d,%d)\n",
  698.         e->event, e->window, e->x, e->y);
  699.     return;
  700. }
  701.  
  702. do_ResizeRequest (eventp)
  703.     XEvent *eventp;
  704. {
  705.     XResizeRequestEvent *e = (XResizeRequestEvent *) eventp;
  706.  
  707.     printf ("    width %d, height %d\n", e->width, e->height);
  708.     return;
  709. }
  710.  
  711. do_CirculateNotify (eventp)
  712.     XEvent *eventp;
  713. {
  714.     XCirculateEvent *e = (XCirculateEvent *) eventp;
  715.     char *p;
  716.     char pdummy[10];
  717.  
  718.     switch (e->place) {
  719.       case PlaceOnTop:  p = "PlaceOnTop"; break;
  720.       case PlaceOnBottom:  p = "PlaceOnBottom"; break;
  721.       default:  p = pdummy; sprintf (pdummy, "%d", e->place); break;
  722.     }
  723.  
  724.     printf ("    event 0x%lx, window 0x%lx, place %s\n",
  725.         e->event, e->window, p);
  726.     return;
  727. }
  728.  
  729. do_CirculateRequest (eventp)
  730.     XEvent *eventp;
  731. {
  732.     XCirculateRequestEvent *e = (XCirculateRequestEvent *) eventp;
  733.     char *p;
  734.     char pdummy[10];
  735.  
  736.     switch (e->place) {
  737.       case PlaceOnTop:  p = "PlaceOnTop"; break;
  738.       case PlaceOnBottom:  p = "PlaceOnBottom"; break;
  739.       default:  p = pdummy; sprintf (pdummy, "%d", e->place); break;
  740.     }
  741.  
  742.     printf ("    parent 0x%lx, window 0x%lx, place %s\n",
  743.         e->parent, e->window, p);
  744.     return;
  745. }
  746.  
  747. do_PropertyNotify (eventp)
  748.     XEvent *eventp;
  749. {
  750.     XPropertyEvent *e = (XPropertyEvent *) eventp;
  751.     char *aname = XGetAtomName (dpy, e->atom);
  752.     char *s;
  753.     char sdummy[10];
  754.  
  755.     switch (e->state) {
  756.       case PropertyNewValue:  s = "PropertyNewValue"; break;
  757.       case PropertyDelete:  s = "PropertyDelete"; break;
  758.       default:  s = sdummy; sprintf (sdummy, "%d", e->state); break;
  759.     }
  760.  
  761.     printf ("    atom 0x%lx (%s), time %lu, state %s\n",
  762.        e->atom, aname ? aname : Unknown, e->time,  s);
  763.  
  764.     if (aname) XFree (aname);
  765.     return;
  766. }
  767.  
  768. do_SelectionClear (eventp)
  769.     XEvent *eventp;
  770. {
  771.     XSelectionClearEvent *e = (XSelectionClearEvent *) eventp;
  772.     char *sname = XGetAtomName (dpy, e->selection);
  773.  
  774.     printf ("    selection 0x%lx (%s), time %lu\n",
  775.         e->selection, sname ? sname : Unknown, e->time);
  776.  
  777.     if (sname) XFree (sname);
  778.     return;
  779. }
  780.  
  781. do_SelectionRequest (eventp)
  782.     XEvent *eventp;
  783. {
  784.     XSelectionRequestEvent *e = (XSelectionRequestEvent *) eventp;
  785.     char *sname = XGetAtomName (dpy, e->selection);
  786.     char *tname = XGetAtomName (dpy, e->target);
  787.     char *pname = XGetAtomName (dpy, e->property);
  788.  
  789.     printf ("    owner 0x%lx, requestor 0x%lx, selection 0x%lx (%s),\n",
  790.         e->owner, e->requestor, e->selection, sname ? sname : Unknown);
  791.     printf ("    target 0x%lx (%s), property 0x%lx (%s), time %lu\n",
  792.         e->target, tname ? tname : Unknown, e->property,
  793.         pname ? pname : Unknown, e->time);
  794.  
  795.     if (sname) XFree (sname);
  796.     if (tname) XFree (tname);
  797.     if (pname) XFree (pname);
  798.  
  799.     return;
  800. }
  801.  
  802. do_SelectionNotify (eventp)
  803.     XEvent *eventp;
  804. {
  805.     XSelectionEvent *e = (XSelectionEvent *) eventp;
  806.     char *sname = XGetAtomName (dpy, e->selection);
  807.     char *tname = XGetAtomName (dpy, e->target);
  808.     char *pname = XGetAtomName (dpy, e->property);
  809.  
  810.     printf ("    selection 0x%lx (%s), target 0x%lx (%s),\n",
  811.         e->selection, sname ? sname : Unknown, e->target,
  812.         tname ? tname : Unknown);
  813.     printf ("    property 0x%lx (%s), time %lu\n",
  814.         e->property, pname ? pname : Unknown, e->time);
  815.  
  816.     if (sname) XFree (sname);
  817.     if (tname) XFree (tname);
  818.     if (pname) XFree (pname);
  819.  
  820.     return;
  821. }
  822.  
  823. do_ColormapNotify (eventp)
  824.     XEvent *eventp;
  825. {
  826.     XColormapEvent *e = (XColormapEvent *) eventp;
  827.     char *s;
  828.     char sdummy[10];
  829.  
  830.     switch (e->state) {
  831.       case ColormapInstalled:  s = "ColormapInstalled"; break;
  832.       case ColormapUninstalled:  s = "ColormapUninstalled"; break;
  833.       default:  s = sdummy; sprintf (sdummy, "%d", e->state); break;
  834.     }
  835.  
  836.     printf ("    colormap 0x%lx, new %s, state %s\n",
  837.         e->colormap, e->new ? Yes : No, s);
  838.     return;
  839. }
  840.  
  841. do_ClientMessage (eventp)
  842.     XEvent *eventp;
  843. {
  844.     XClientMessageEvent *e = (XClientMessageEvent *) eventp;
  845.     char *mname = XGetAtomName (dpy, e->message_type);
  846.  
  847.     printf ("    message_type 0x%lx (%s), format %d\n",
  848.         e->message_type, mname ? mname : Unknown, e->format);
  849.  
  850.     if (mname) XFree (mname);
  851.     return;
  852. }
  853.  
  854. do_MappingNotify (eventp)
  855.     XEvent *eventp;
  856. {
  857.     XMappingEvent *e = (XMappingEvent *) eventp;
  858.     char *r;
  859.     char rdummy[10];
  860.  
  861.     switch (e->request) {
  862.       case MappingModifier:  r = "MappingModifier"; break;
  863.       case MappingKeyboard:  r = "MappingKeyboard"; break;
  864.       case MappingPointer:  r = "MappingPointer"; break;
  865.       default:  r = rdummy; sprintf (rdummy, "%d", e->request); break;
  866.     }
  867.  
  868.     printf ("    request %s, first_keycode %d, count %d\n",
  869.         r, e->first_keycode, e->count);
  870.     return;
  871. }
  872.  
  873.  
  874.  
  875. set_sizehints (hintp, min_width, min_height,
  876.            defwidth, defheight, defx, defy, geom)
  877.     XSizeHints *hintp;
  878.     int min_width, min_height, defwidth, defheight, defx, defy;
  879.     char *geom;
  880. {
  881.     int geom_result;
  882.  
  883.     /* set the size hints, algorithm from xlib xbiff */
  884.  
  885.     hintp->width = hintp->min_width = min_width;
  886.     hintp->height = hintp->min_height = min_height;
  887.     hintp->flags = PMinSize;
  888.     hintp->x = hintp->y = 0;
  889.     geom_result = NoValue;
  890.     if (geom != NULL) {
  891.         geom_result = XParseGeometry (geom, &hintp->x, &hintp->y,
  892.                       (unsigned int *)&hintp->width,
  893.                       (unsigned int *)&hintp->height);
  894.     if ((geom_result & WidthValue) && (geom_result & HeightValue)) {
  895. #define max(a,b) ((a) > (b) ? (a) : (b))
  896.         hintp->width = max (hintp->width, hintp->min_width);
  897.         hintp->height = max (hintp->height, hintp->min_height);
  898.         hintp->flags |= USSize;
  899.     }
  900.     if ((geom_result & XValue) && (geom_result & YValue)) {
  901.         hintp->flags += USPosition;
  902.     }
  903.     }
  904.     if (!(hintp->flags & USSize)) {
  905.     hintp->width = defwidth;
  906.     hintp->height = defheight;
  907.     hintp->flags |= PSize;
  908.     }
  909. /*
  910.     if (!(hintp->flags & USPosition)) {
  911.     hintp->x = defx;
  912.     hintp->y = defy;
  913.     hintp->flags |= PPosition;
  914.     }
  915.  */
  916.     if (geom_result & XNegative) {
  917.     hintp->x = DisplayWidth (dpy, DefaultScreen (dpy)) + hintp->x -
  918.             hintp->width;
  919.     }
  920.     if (geom_result & YNegative) {
  921.     hintp->y = DisplayHeight (dpy, DefaultScreen (dpy)) + hintp->y -
  922.             hintp->height;
  923.     }
  924.     return;
  925. }
  926.  
  927.