| /* |
| * Original code posted to comp.sources.x |
| * Modifications by Russ Cox <rsc@swtch.com>. |
| */ |
| |
| /* |
| Path: uunet!wyse!mikew |
| From: mikew@wyse.wyse.com (Mike Wexler) |
| Newsgroups: comp.sources.x |
| Subject: v02i056: subroutine to print events in human readable form, Part01/01 |
| Message-ID: <1935@wyse.wyse.com> |
| Date: 22 Dec 88 19:28:25 GMT |
| Organization: Wyse Technology, San Jose |
| Lines: 1093 |
| Approved: mikew@wyse.com |
| |
| Submitted-by: richsun!darkstar!ken |
| Posting-number: Volume 2, Issue 56 |
| Archive-name: showevent/part01 |
| |
| |
| There are times during debugging when it would be real useful to be able to |
| print the fields of an event in a human readable form. Too many times I found |
| myself scrounging around in section 8 of the Xlib manual looking for the valid |
| fields for the events I wanted to see, then adding printf's to display the |
| numeric values of the fields, and then scanning through X.h trying to decode |
| the cryptic detail and state fields. After playing with xev, I decided to |
| write a couple of standard functions that I could keep in a library and call |
| on whenever I needed a little debugging verbosity. The first function, |
| GetType(), is useful for returning the string representation of the type of |
| an event. The second function, ShowEvent(), is used to display all the fields |
| of an event in a readable format. The functions are not complicated, in fact, |
| they are mind-numbingly boring - but that's just the point nobody wants to |
| spend the time writing functions like this, they just want to have them when |
| they need them. |
| |
| A simple, sample program is included which does little else but to demonstrate |
| the use of these two functions. These functions have saved me many an hour |
| during debugging and I hope you find some benefit to these. If you have any |
| comments, suggestions, improvements, or if you find any blithering errors you |
| can get it touch with me at the following location: |
| |
| ken@richsun.UUCP |
| */ |
| |
| #include <stdio.h> |
| #include <X11/Intrinsic.h> |
| #include <X11/Xproto.h> |
| #include "printevent.h" |
| |
| static char* sep = " "; |
| |
| /******************************************************************************/ |
| /**** Miscellaneous routines to convert values to their string equivalents ****/ |
| /******************************************************************************/ |
| |
| /* Returns the string equivalent of a boolean parameter */ |
| static char* |
| TorF(int bool) |
| { |
| switch (bool) { |
| case True: |
| return ("True"); |
| |
| case False: |
| return ("False"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a property notify state */ |
| static char* |
| PropertyState(int state) |
| { |
| switch (state) { |
| case PropertyNewValue: |
| return ("PropertyNewValue"); |
| |
| case PropertyDelete: |
| return ("PropertyDelete"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a visibility notify state */ |
| static char* |
| VisibilityState(int state) |
| { |
| switch (state) { |
| case VisibilityUnobscured: |
| return ("VisibilityUnobscured"); |
| |
| case VisibilityPartiallyObscured: |
| return ("VisibilityPartiallyObscured"); |
| |
| case VisibilityFullyObscured: |
| return ("VisibilityFullyObscured"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a timestamp */ |
| static char* |
| ServerTime(Time time) |
| { |
| unsigned long msec; |
| unsigned long sec; |
| unsigned long min; |
| unsigned long hr; |
| unsigned long day; |
| static char buffer[32]; |
| |
| msec = time % 1000; |
| time /= 1000; |
| sec = time % 60; |
| time /= 60; |
| min = time % 60; |
| time /= 60; |
| hr = time % 24; |
| time /= 24; |
| day = time; |
| |
| if(0) |
| sprintf(buffer, "%lu day%s %02lu:%02lu:%02lu.%03lu", |
| day, day == 1 ? "" : "(s)", hr, min, sec, msec); |
| |
| sprintf(buffer, "%lud%luh%lum%lu.%03lds", day, hr, min, sec, msec); |
| return (buffer); |
| } |
| |
| /* Simple structure to ease the interpretation of masks */ |
| typedef struct MaskType MaskType; |
| struct MaskType |
| { |
| unsigned int value; |
| char *string; |
| }; |
| |
| /* Returns the string equivalent of a mask of buttons and/or modifier keys */ |
| static char* |
| ButtonAndOrModifierState(unsigned int state) |
| { |
| static char buffer[256]; |
| static MaskType masks[] = { |
| {Button1Mask, "Button1Mask"}, |
| {Button2Mask, "Button2Mask"}, |
| {Button3Mask, "Button3Mask"}, |
| {Button4Mask, "Button4Mask"}, |
| {Button5Mask, "Button5Mask"}, |
| {ShiftMask, "ShiftMask"}, |
| {LockMask, "LockMask"}, |
| {ControlMask, "ControlMask"}, |
| {Mod1Mask, "Mod1Mask"}, |
| {Mod2Mask, "Mod2Mask"}, |
| {Mod3Mask, "Mod3Mask"}, |
| {Mod4Mask, "Mod4Mask"}, |
| {Mod5Mask, "Mod5Mask"}, |
| }; |
| int num_masks = sizeof(masks) / sizeof(MaskType); |
| int i; |
| Boolean first = True; |
| |
| buffer[0] = 0; |
| |
| for (i = 0; i < num_masks; i++) |
| if (state & masks[i].value) |
| if (first) { |
| first = False; |
| strcpy(buffer, masks[i].string); |
| } else { |
| strcat(buffer, " | "); |
| strcat(buffer, masks[i].string); |
| } |
| return (buffer); |
| } |
| |
| /* Returns the string equivalent of a mask of configure window values */ |
| static char* |
| ConfigureValueMask(unsigned int valuemask) |
| { |
| static char buffer[256]; |
| static MaskType masks[] = { |
| {CWX, "CWX"}, |
| {CWY, "CWY"}, |
| {CWWidth, "CWWidth"}, |
| {CWHeight, "CWHeight"}, |
| {CWBorderWidth, "CWBorderWidth"}, |
| {CWSibling, "CWSibling"}, |
| {CWStackMode, "CWStackMode"}, |
| }; |
| int num_masks = sizeof(masks) / sizeof(MaskType); |
| int i; |
| Boolean first = True; |
| |
| buffer[0] = 0; |
| |
| for (i = 0; i < num_masks; i++) |
| if (valuemask & masks[i].value) |
| if (first) { |
| first = False; |
| strcpy(buffer, masks[i].string); |
| } else { |
| strcat(buffer, " | "); |
| strcat(buffer, masks[i].string); |
| } |
| |
| return (buffer); |
| } |
| |
| /* Returns the string equivalent of a motion hint */ |
| static char* |
| IsHint(char is_hint) |
| { |
| switch (is_hint) { |
| case NotifyNormal: |
| return ("NotifyNormal"); |
| |
| case NotifyHint: |
| return ("NotifyHint"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of an id or the value "None" */ |
| static char* |
| MaybeNone(int value) |
| { |
| static char buffer[16]; |
| |
| if (value == None) |
| return ("None"); |
| else { |
| sprintf(buffer, "0x%x", value); |
| return (buffer); |
| } |
| } |
| |
| /* Returns the string equivalent of a colormap state */ |
| static char* |
| ColormapState(int state) |
| { |
| switch (state) { |
| case ColormapInstalled: |
| return ("ColormapInstalled"); |
| |
| case ColormapUninstalled: |
| return ("ColormapUninstalled"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a crossing detail */ |
| static char* |
| CrossingDetail(int detail) |
| { |
| switch (detail) { |
| case NotifyAncestor: |
| return ("NotifyAncestor"); |
| |
| case NotifyInferior: |
| return ("NotifyInferior"); |
| |
| case NotifyVirtual: |
| return ("NotifyVirtual"); |
| |
| case NotifyNonlinear: |
| return ("NotifyNonlinear"); |
| |
| case NotifyNonlinearVirtual: |
| return ("NotifyNonlinearVirtual"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a focus change detail */ |
| static char* |
| FocusChangeDetail(int detail) |
| { |
| switch (detail) { |
| case NotifyAncestor: |
| return ("NotifyAncestor"); |
| |
| case NotifyInferior: |
| return ("NotifyInferior"); |
| |
| case NotifyVirtual: |
| return ("NotifyVirtual"); |
| |
| case NotifyNonlinear: |
| return ("NotifyNonlinear"); |
| |
| case NotifyNonlinearVirtual: |
| return ("NotifyNonlinearVirtual"); |
| |
| case NotifyPointer: |
| return ("NotifyPointer"); |
| |
| case NotifyPointerRoot: |
| return ("NotifyPointerRoot"); |
| |
| case NotifyDetailNone: |
| return ("NotifyDetailNone"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a configure detail */ |
| static char* |
| ConfigureDetail(int detail) |
| { |
| switch (detail) { |
| case Above: |
| return ("Above"); |
| |
| case Below: |
| return ("Below"); |
| |
| case TopIf: |
| return ("TopIf"); |
| |
| case BottomIf: |
| return ("BottomIf"); |
| |
| case Opposite: |
| return ("Opposite"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a grab mode */ |
| static char* |
| GrabMode(int mode) |
| { |
| switch (mode) { |
| case NotifyNormal: |
| return ("NotifyNormal"); |
| |
| case NotifyGrab: |
| return ("NotifyGrab"); |
| |
| case NotifyUngrab: |
| return ("NotifyUngrab"); |
| |
| case NotifyWhileGrabbed: |
| return ("NotifyWhileGrabbed"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a mapping request */ |
| static char* |
| MappingRequest(int request) |
| { |
| switch (request) { |
| case MappingModifier: |
| return ("MappingModifier"); |
| |
| case MappingKeyboard: |
| return ("MappingKeyboard"); |
| |
| case MappingPointer: |
| return ("MappingPointer"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a stacking order place */ |
| static char* |
| Place(int place) |
| { |
| switch (place) { |
| case PlaceOnTop: |
| return ("PlaceOnTop"); |
| |
| case PlaceOnBottom: |
| return ("PlaceOnBottom"); |
| |
| default: |
| return ("?"); |
| } |
| } |
| |
| /* Returns the string equivalent of a major code */ |
| static char* |
| MajorCode(int code) |
| { |
| static char buffer[32]; |
| |
| switch (code) { |
| case X_CopyArea: |
| return ("X_CopyArea"); |
| |
| case X_CopyPlane: |
| return ("X_CopyPlane"); |
| |
| default: |
| sprintf(buffer, "0x%x", code); |
| return (buffer); |
| } |
| } |
| |
| /* Returns the string equivalent the keycode contained in the key event */ |
| static char* |
| Keycode(XKeyEvent *ev) |
| { |
| static char buffer[256]; |
| KeySym keysym_str; |
| char *keysym_name; |
| char string[256]; |
| |
| XLookupString(ev, string, 64, &keysym_str, NULL); |
| |
| if (keysym_str == NoSymbol) |
| keysym_name = "NoSymbol"; |
| else if (!(keysym_name = XKeysymToString(keysym_str))) |
| keysym_name = "(no name)"; |
| sprintf(buffer, "%u (keysym 0x%x \"%s\")", |
| (int)ev->keycode, (int)keysym_str, keysym_name); |
| return (buffer); |
| } |
| |
| /* Returns the string equivalent of an atom or "None"*/ |
| static char* |
| AtomName(Display *dpy, Atom atom) |
| { |
| static char buffer[256]; |
| char *atom_name; |
| |
| if (atom == None) |
| return ("None"); |
| |
| atom_name = XGetAtomName(dpy, atom); |
| strncpy(buffer, atom_name, 256); |
| XFree(atom_name); |
| return (buffer); |
| } |
| |
| /******************************************************************************/ |
| /**** Routines to print out readable values for the field of various events ***/ |
| /******************************************************************************/ |
| |
| static void |
| VerbMotion(XMotionEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("root=0x%x%s", (int)ev->root, sep); |
| printf("subwindow=0x%x%s", (int)ev->subwindow, sep); |
| printf("time=%s%s", ServerTime(ev->time), sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("x_root=%d y_root=%d%s", ev->x_root, ev->y_root, sep); |
| printf("state=%s%s", ButtonAndOrModifierState(ev->state), sep); |
| printf("is_hint=%s%s", IsHint(ev->is_hint), sep); |
| printf("same_screen=%s\n", TorF(ev->same_screen)); |
| } |
| |
| static void |
| VerbButton(XButtonEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("root=0x%x%s", (int)ev->root, sep); |
| printf("subwindow=0x%x%s", (int)ev->subwindow, sep); |
| printf("time=%s%s", ServerTime(ev->time), sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("x_root=%d y_root=%d%s", ev->x_root, ev->y_root, sep); |
| printf("state=%s%s", ButtonAndOrModifierState(ev->state), sep); |
| printf("button=%s%s", ButtonAndOrModifierState(ev->button), sep); |
| printf("same_screen=%s\n", TorF(ev->same_screen)); |
| } |
| |
| static void |
| VerbColormap(XColormapEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("colormap=%s%s", MaybeNone(ev->colormap), sep); |
| printf("new=%s%s", TorF(ev->new), sep); |
| printf("state=%s\n", ColormapState(ev->state)); |
| } |
| |
| static void |
| VerbCrossing(XCrossingEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("root=0x%x%s", (int)ev->root, sep); |
| printf("subwindow=0x%x%s", (int)ev->subwindow, sep); |
| printf("time=%s%s", ServerTime(ev->time), sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("x_root=%d y_root=%d%s", ev->x_root, ev->y_root, sep); |
| printf("mode=%s%s", GrabMode(ev->mode), sep); |
| printf("detail=%s%s", CrossingDetail(ev->detail), sep); |
| printf("same_screen=%s%s", TorF(ev->same_screen), sep); |
| printf("focus=%s%s", TorF(ev->focus), sep); |
| printf("state=%s\n", ButtonAndOrModifierState(ev->state)); |
| } |
| |
| static void |
| VerbExpose(XExposeEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("width=%d height=%d%s", ev->width, ev->height, sep); |
| printf("count=%d\n", ev->count); |
| } |
| |
| static void |
| VerbGraphicsExpose(XGraphicsExposeEvent *ev) |
| { |
| printf("drawable=0x%x%s", (int)ev->drawable, sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("width=%d height=%d%s", ev->width, ev->height, sep); |
| printf("major_code=%s%s", MajorCode(ev->major_code), sep); |
| printf("minor_code=%d\n", ev->minor_code); |
| } |
| |
| static void |
| VerbNoExpose(XNoExposeEvent *ev) |
| { |
| printf("drawable=0x%x%s", (int)ev->drawable, sep); |
| printf("major_code=%s%s", MajorCode(ev->major_code), sep); |
| printf("minor_code=%d\n", ev->minor_code); |
| } |
| |
| static void |
| VerbFocus(XFocusChangeEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("mode=%s%s", GrabMode(ev->mode), sep); |
| printf("detail=%s\n", FocusChangeDetail(ev->detail)); |
| } |
| |
| static void |
| VerbKeymap(XKeymapEvent *ev) |
| { |
| int i; |
| |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("key_vector="); |
| for (i = 0; i < 32; i++) |
| printf("%02x", ev->key_vector[i]); |
| printf("\n"); |
| } |
| |
| static void |
| VerbKey(XKeyEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("root=0x%x%s", (int)ev->root, sep); |
| if(ev->subwindow) |
| printf("subwindow=0x%x%s", (int)ev->subwindow, sep); |
| printf("time=%s%s", ServerTime(ev->time), sep); |
| printf("[%d,%d]%s", ev->x, ev->y, sep); |
| printf("root=[%d,%d]%s", ev->x_root, ev->y_root, sep); |
| if(ev->state) |
| printf("state=%s%s", ButtonAndOrModifierState(ev->state), sep); |
| printf("keycode=%s%s", Keycode(ev), sep); |
| if(!ev->same_screen) |
| printf("!same_screen", TorF(ev->same_screen)); |
| printf("\n"); |
| return; |
| |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("root=0x%x%s", (int)ev->root, sep); |
| printf("subwindow=0x%x%s", (int)ev->subwindow, sep); |
| printf("time=%s%s", ServerTime(ev->time), sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("x_root=%d y_root=%d%s", ev->x_root, ev->y_root, sep); |
| printf("state=%s%s", ButtonAndOrModifierState(ev->state), sep); |
| printf("keycode=%s%s", Keycode(ev), sep); |
| printf("same_screen=%s\n", TorF(ev->same_screen)); |
| } |
| |
| static void |
| VerbProperty(XPropertyEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("atom=%s%s", AtomName(ev->display, ev->atom), sep); |
| printf("time=%s%s", ServerTime(ev->time), sep); |
| printf("state=%s\n", PropertyState(ev->state)); |
| } |
| |
| static void |
| VerbResizeRequest(XResizeRequestEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("width=%d height=%d\n", ev->width, ev->height); |
| } |
| |
| static void |
| VerbCirculate(XCirculateEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("place=%s\n", Place(ev->place)); |
| } |
| |
| static void |
| VerbConfigure(XConfigureEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("width=%d height=%d%s", ev->width, ev->height, sep); |
| printf("border_width=%d%s", ev->border_width, sep); |
| printf("above=%s%s", MaybeNone(ev->above), sep); |
| printf("override_redirect=%s\n", TorF(ev->override_redirect)); |
| } |
| |
| static void |
| VerbCreateWindow(XCreateWindowEvent *ev) |
| { |
| printf("parent=0x%x%s", (int)ev->parent, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("width=%d height=%d%s", ev->width, ev->height, sep); |
| printf("border_width=%d%s", ev->border_width, sep); |
| printf("override_redirect=%s\n", TorF(ev->override_redirect)); |
| } |
| |
| static void |
| VerbDestroyWindow(XDestroyWindowEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x\n", (int)ev->window); |
| } |
| |
| static void |
| VerbGravity(XGravityEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("x=%d y=%d\n", ev->x, ev->y); |
| } |
| |
| static void |
| VerbMap(XMapEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("override_redirect=%s\n", TorF(ev->override_redirect)); |
| } |
| |
| static void |
| VerbReparent(XReparentEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("parent=0x%x%s", (int)ev->parent, sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("override_redirect=%s\n", TorF(ev->override_redirect)); |
| } |
| |
| static void |
| VerbUnmap(XUnmapEvent *ev) |
| { |
| printf("event=0x%x%s", (int)ev->event, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("from_configure=%s\n", TorF(ev->from_configure)); |
| } |
| |
| static void |
| VerbCirculateRequest(XCirculateRequestEvent *ev) |
| { |
| printf("parent=0x%x%s", (int)ev->parent, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("place=%s\n", Place(ev->place)); |
| } |
| |
| static void |
| VerbConfigureRequest(XConfigureRequestEvent *ev) |
| { |
| printf("parent=0x%x%s", (int)ev->parent, sep); |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("x=%d y=%d%s", ev->x, ev->y, sep); |
| printf("width=%d height=%d%s", ev->width, ev->height, sep); |
| printf("border_width=%d%s", ev->border_width, sep); |
| printf("above=%s%s", MaybeNone(ev->above), sep); |
| printf("detail=%s%s", ConfigureDetail(ev->detail), sep); |
| printf("value_mask=%s\n", ConfigureValueMask(ev->value_mask)); |
| } |
| |
| static void |
| VerbMapRequest(XMapRequestEvent *ev) |
| { |
| printf("parent=0x%x%s", (int)ev->parent, sep); |
| printf("window=0x%x\n", (int)ev->window); |
| } |
| |
| static void |
| VerbClient(XClientMessageEvent *ev) |
| { |
| int i; |
| |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("message_type=%s%s", AtomName(ev->display, ev->message_type), sep); |
| printf("format=%d\n", ev->format); |
| printf("data (shown as longs)="); |
| for (i = 0; i < 5; i++) |
| printf(" 0x%08lx", ev->data.l[i]); |
| printf("\n"); |
| } |
| |
| static void |
| VerbMapping(XMappingEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("request=%s%s", MappingRequest(ev->request), sep); |
| printf("first_keycode=0x%x%s", ev->first_keycode, sep); |
| printf("count=0x%x\n", ev->count); |
| } |
| |
| static void |
| VerbSelectionClear(XSelectionClearEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("selection=%s%s", AtomName(ev->display, ev->selection), sep); |
| printf("time=%s\n", ServerTime(ev->time)); |
| } |
| |
| static void |
| VerbSelection(XSelectionEvent *ev) |
| { |
| printf("requestor=0x%x%s", (int)ev->requestor, sep); |
| printf("selection=%s%s", AtomName(ev->display, ev->selection), sep); |
| printf("target=%s%s", AtomName(ev->display, ev->target), sep); |
| printf("property=%s%s", AtomName(ev->display, ev->property), sep); |
| printf("time=%s\n", ServerTime(ev->time)); |
| } |
| |
| static void |
| VerbSelectionRequest(XSelectionRequestEvent *ev) |
| { |
| printf("owner=0x%x%s", (int)ev->owner, sep); |
| printf("requestor=0x%x%s", (int)ev->requestor, sep); |
| printf("selection=%s%s", AtomName(ev->display, ev->selection), sep); |
| printf("target=%s%s", AtomName(ev->display, ev->target), sep); |
| printf("property=%s%s", AtomName(ev->display, ev->property), sep); |
| printf("time=%s\n", ServerTime(ev->time)); |
| } |
| |
| static void |
| VerbVisibility(XVisibilityEvent *ev) |
| { |
| printf("window=0x%x%s", (int)ev->window, sep); |
| printf("state=%s\n", VisibilityState(ev->state)); |
| } |
| |
| /******************************************************************************/ |
| /************ Return the string representation for type of an event ***********/ |
| /******************************************************************************/ |
| |
| char *eventtype(XEvent *ev) |
| { |
| static char buffer[20]; |
| |
| switch (ev->type) { |
| case KeyPress: |
| return ("KeyPress"); |
| case KeyRelease: |
| return ("KeyRelease"); |
| case ButtonPress: |
| return ("ButtonPress"); |
| case ButtonRelease: |
| return ("ButtonRelease"); |
| case MotionNotify: |
| return ("MotionNotify"); |
| case EnterNotify: |
| return ("EnterNotify"); |
| case LeaveNotify: |
| return ("LeaveNotify"); |
| case FocusIn: |
| return ("FocusIn"); |
| case FocusOut: |
| return ("FocusOut"); |
| case KeymapNotify: |
| return ("KeymapNotify"); |
| case Expose: |
| return ("Expose"); |
| case GraphicsExpose: |
| return ("GraphicsExpose"); |
| case NoExpose: |
| return ("NoExpose"); |
| case VisibilityNotify: |
| return ("VisibilityNotify"); |
| case CreateNotify: |
| return ("CreateNotify"); |
| case DestroyNotify: |
| return ("DestroyNotify"); |
| case UnmapNotify: |
| return ("UnmapNotify"); |
| case MapNotify: |
| return ("MapNotify"); |
| case MapRequest: |
| return ("MapRequest"); |
| case ReparentNotify: |
| return ("ReparentNotify"); |
| case ConfigureNotify: |
| return ("ConfigureNotify"); |
| case ConfigureRequest: |
| return ("ConfigureRequest"); |
| case GravityNotify: |
| return ("GravityNotify"); |
| case ResizeRequest: |
| return ("ResizeRequest"); |
| case CirculateNotify: |
| return ("CirculateNotify"); |
| case CirculateRequest: |
| return ("CirculateRequest"); |
| case PropertyNotify: |
| return ("PropertyNotify"); |
| case SelectionClear: |
| return ("SelectionClear"); |
| case SelectionRequest: |
| return ("SelectionRequest"); |
| case SelectionNotify: |
| return ("SelectionNotify"); |
| case ColormapNotify: |
| return ("ColormapNotify"); |
| case ClientMessage: |
| return ("ClientMessage"); |
| case MappingNotify: |
| return ("MappingNotify"); |
| } |
| sprintf(buffer, "%d", ev->type); |
| return buffer; |
| } |
| |
| /******************************************************************************/ |
| /**************** Print the values of all fields for any event ****************/ |
| /******************************************************************************/ |
| |
| void printevent(XEvent *e) |
| { |
| XAnyEvent *ev = (void*)e; |
| |
| printf("%3ld %-20s ", ev->serial, eventtype(e)); |
| if(ev->send_event) |
| printf("(sendevent) "); |
| if(0){ |
| printf("type=%s%s", eventtype(e), sep); |
| printf("serial=%lu%s", ev->serial, sep); |
| printf("send_event=%s%s", TorF(ev->send_event), sep); |
| printf("display=0x%p%s", ev->display, sep); |
| } |
| |
| switch (ev->type) { |
| case MotionNotify: |
| VerbMotion((void*)ev); |
| break; |
| |
| case ButtonPress: |
| case ButtonRelease: |
| VerbButton((void*)ev); |
| break; |
| |
| case ColormapNotify: |
| VerbColormap((void*)ev); |
| break; |
| |
| case EnterNotify: |
| case LeaveNotify: |
| VerbCrossing((void*)ev); |
| break; |
| |
| case Expose: |
| VerbExpose((void*)ev); |
| break; |
| |
| case GraphicsExpose: |
| VerbGraphicsExpose((void*)ev); |
| break; |
| |
| case NoExpose: |
| VerbNoExpose((void*)ev); |
| break; |
| |
| case FocusIn: |
| case FocusOut: |
| VerbFocus((void*)ev); |
| break; |
| |
| case KeymapNotify: |
| VerbKeymap((void*)ev); |
| break; |
| |
| case KeyPress: |
| case KeyRelease: |
| VerbKey((void*)ev); |
| break; |
| |
| case PropertyNotify: |
| VerbProperty((void*)ev); |
| break; |
| |
| case ResizeRequest: |
| VerbResizeRequest((void*)ev); |
| break; |
| |
| case CirculateNotify: |
| VerbCirculate((void*)ev); |
| break; |
| |
| case ConfigureNotify: |
| VerbConfigure((void*)ev); |
| break; |
| |
| case CreateNotify: |
| VerbCreateWindow((void*)ev); |
| break; |
| |
| case DestroyNotify: |
| VerbDestroyWindow((void*)ev); |
| break; |
| |
| case GravityNotify: |
| VerbGravity((void*)ev); |
| break; |
| |
| case MapNotify: |
| VerbMap((void*)ev); |
| break; |
| |
| case ReparentNotify: |
| VerbReparent((void*)ev); |
| break; |
| |
| case UnmapNotify: |
| VerbUnmap((void*)ev); |
| break; |
| |
| case CirculateRequest: |
| VerbCirculateRequest((void*)ev); |
| break; |
| |
| case ConfigureRequest: |
| VerbConfigureRequest((void*)ev); |
| break; |
| |
| case MapRequest: |
| VerbMapRequest((void*)ev); |
| break; |
| |
| case ClientMessage: |
| VerbClient((void*)ev); |
| break; |
| |
| case MappingNotify: |
| VerbMapping((void*)ev); |
| break; |
| |
| case SelectionClear: |
| VerbSelectionClear((void*)ev); |
| break; |
| |
| case SelectionNotify: |
| VerbSelection((void*)ev); |
| break; |
| |
| case SelectionRequest: |
| VerbSelectionRequest((void*)ev); |
| break; |
| |
| case VisibilityNotify: |
| VerbVisibility((void*)ev); |
| break; |
| } |
| } |
| |
