| 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 |
| |
| |
| |
| Following is a shar file of a debugging aid along with a sample program to |
| show how it is used. The README contains more details. |
| |
| Ken |
| |
| #! /bin/sh |
| # This is a shell archive, meaning: |
| # 1. Remove everything above the #! /bin/sh line. |
| # 2. Save the resulting text in a file. |
| # 3. Execute the file with /bin/sh (not csh) to create the files: |
| # Makefile |
| # README |
| # ShowEvent.c |
| # ShowEvent.man |
| # patchlevel.h |
| # sample.c |
| # This archive created: Thu Dec 22 12:13:46 1988 |
| export PATH; PATH=/bin:$PATH |
| if test -f 'Makefile' |
| then |
| echo shar: will not over-write existing file "'Makefile'" |
| else |
| cat << \SHAR_EOF > 'Makefile' |
| CFLAGS = -g |
| INCLUDE = -I/global/include |
| LFLAGS = -L/global/lib |
| OBJS = ShowEvent.o sample.o |
| LIBS = -lX11 |
| |
| all: sample |
| |
| .c.o: |
| $(CC) $(INCLUDE) $(CFLAGS) -c $< |
| |
| sample: $(OBJS) |
| $(CC) $(LFLAGS) $(OBJS) $(LIBS) -o sample |
| SHAR_EOF |
| fi # end of overwriting check |
| if test -f 'README' |
| then |
| echo shar: will not over-write existing file "'README'" |
| else |
| cat << \SHAR_EOF > 'README' |
| 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 |
| SHAR_EOF |
| fi # end of overwriting check |
| if test -f 'ShowEvent.c' |
| then |
| echo shar: will not over-write existing file "'ShowEvent.c'" |
| else |
| cat << \SHAR_EOF > 'ShowEvent.c' |
| #include <X11/Intrinsic.h> |
| #include <X11/Xproto.h> |
| |
| Boolean use_separate_lines = True; |
| static char *sep; |
| |
| /******************************************************************************/ |
| /**** Miscellaneous routines to convert values to their string equivalents ****/ |
| /******************************************************************************/ |
| |
| /* Returns the string equivalent of a boolean parameter */ |
| static char *TorF(bool) |
| 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(state) |
| 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(state) |
| 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 time; |
| { |
| unsigned long msec; |
| unsigned long sec; |
| unsigned long min; |
| unsigned long hr; |
| unsigned long day; |
| 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; |
| |
| sprintf(buffer, "%d day%s %02d:%02d:%02d.%03d", |
| day, day == 1 ? "" : "(s)", hr, min, sec, msec); |
| return (buffer); |
| } |
| |
| /* Simple structure to ease the interpretation of masks */ |
| typedef struct _MaskType { |
| unsigned int value; |
| char *string; |
| } MaskType; |
| |
| /* Returns the string equivalent of a mask of buttons and/or modifier keys */ |
| static char *ButtonAndOrModifierState(state) |
| unsigned int state; |
| { |
| 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] = NULL; |
| |
| 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(valuemask) |
| unsigned int valuemask; |
| { |
| 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] = NULL; |
| |
| 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(is_hint) |
| 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(value) |
| int value; |
| { |
| 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(state) |
| 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(detail) |
| 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(detail) |
| 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(detail) |
| 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(mode) |
| 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(request) |
| 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(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(code) |
| int code; |
| { |
| 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(ev) |
| XKeyEvent *ev; |
| { |
| 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\")", |
| ev->keycode, keysym_str, keysym_name); |
| return (buffer); |
| } |
| |
| /* Returns the string equivalent of an atom or "None"*/ |
| static char *AtomName(dpy, atom) |
| Display *dpy; |
| Atom atom; |
| { |
| 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(ev) |
| XMotionEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("root=0x%x%s", ev->root, sep); |
| printf("subwindow=0x%x%s", 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(ev) |
| XButtonEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("root=0x%x%s", ev->root, sep); |
| printf("subwindow=0x%x%s", 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(ev) |
| XColormapEvent *ev; |
| { |
| printf("window=0x%x%s", 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(ev) |
| XCrossingEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("root=0x%x%s", ev->root, sep); |
| printf("subwindow=0x%x%s", 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(ev) |
| XExposeEvent *ev; |
| { |
| printf("window=0x%x%s", 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(ev) |
| XGraphicsExposeEvent *ev; |
| { |
| printf("drawable=0x%x%s", 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(ev) |
| XNoExposeEvent *ev; |
| { |
| printf("drawable=0x%x%s", ev->drawable, sep); |
| printf("major_code=%s%s", MajorCode(ev->major_code), sep); |
| printf("minor_code=%d\n", ev->minor_code); |
| } |
| |
| static void VerbFocus(ev) |
| XFocusChangeEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("mode=%s%s", GrabMode(ev->mode), sep); |
| printf("detail=%s\n", FocusChangeDetail(ev->detail)); |
| } |
| |
| static void VerbKeymap(ev) |
| XKeymapEvent *ev; |
| { |
| int i; |
| |
| printf("window=0x%x%s", ev->window, sep); |
| printf("key_vector="); |
| for (i = 0; i < 32; i++) |
| printf("%02x", ev->key_vector[i]); |
| printf("\n"); |
| } |
| |
| static void VerbKey(ev) |
| XKeyEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("root=0x%x%s", ev->root, sep); |
| printf("subwindow=0x%x%s", 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(ev) |
| XPropertyEvent *ev; |
| { |
| printf("window=0x%x%s", 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(ev) |
| XResizeRequestEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("width=%d height=%d\n", ev->width, ev->height); |
| } |
| |
| static void VerbCirculate(ev) |
| XCirculateEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x%s", ev->window, sep); |
| printf("place=%s\n", Place(ev->place)); |
| } |
| |
| static void VerbConfigure(ev) |
| XConfigureEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x%s", 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(ev) |
| XCreateWindowEvent *ev; |
| { |
| printf("parent=0x%x%s", ev->parent, sep); |
| printf("window=0x%x%s", 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(ev) |
| XDestroyWindowEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x\n", ev->window); |
| } |
| |
| static void VerbGravity(ev) |
| XGravityEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x%s", ev->window, sep); |
| printf("x=%d y=%d\n", ev->x, ev->y); |
| } |
| |
| static void VerbMap(ev) |
| XMapEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x%s", ev->window, sep); |
| printf("override_redirect=%s\n", TorF(ev->override_redirect)); |
| } |
| |
| static void VerbReparent(ev) |
| XReparentEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x%s", ev->window, sep); |
| printf("parent=0x%x%s", 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(ev) |
| XUnmapEvent *ev; |
| { |
| printf("event=0x%x%s", ev->event, sep); |
| printf("window=0x%x%s", ev->window, sep); |
| printf("from_configure=%s\n", TorF(ev->from_configure)); |
| } |
| |
| static void VerbCirculateRequest(ev) |
| XCirculateRequestEvent *ev; |
| { |
| printf("parent=0x%x%s", ev->parent, sep); |
| printf("window=0x%x%s", ev->window, sep); |
| printf("place=%s\n", Place(ev->place)); |
| } |
| |
| static void VerbConfigureRequest(ev) |
| XConfigureRequestEvent *ev; |
| { |
| printf("parent=0x%x%s", ev->parent, sep); |
| printf("window=0x%x%s", 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=0x%x%s", ConfigureDetail(ev->detail), sep); |
| printf("value_mask=%s\n", ConfigureValueMask(ev->value_mask)); |
| } |
| |
| static void VerbMapRequest(ev) |
| XMapRequestEvent *ev; |
| { |
| printf("parent=0x%x%s", ev->parent, sep); |
| printf("window=0x%x\n", ev->window); |
| } |
| |
| static void VerbClient(ev) |
| XClientMessageEvent *ev; |
| { |
| int i; |
| |
| printf("window=0x%x%s", 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%08x", ev->data.l[i]); |
| printf("\n"); |
| } |
| |
| static void VerbMapping(ev) |
| XMappingEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("request=0x%x%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(ev) |
| XSelectionClearEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("selection=%s%s", AtomName(ev->display, ev->selection), sep); |
| printf("time=%s\n", ServerTime(ev->time)); |
| } |
| |
| static void VerbSelection(ev) |
| XSelectionEvent *ev; |
| { |
| printf("requestor=0x%x%s", 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(ev) |
| XSelectionRequestEvent *ev; |
| { |
| printf("owner=0x%x%s", ev->owner, sep); |
| printf("requestor=0x%x%s", 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(ev) |
| XVisibilityEvent *ev; |
| { |
| printf("window=0x%x%s", ev->window, sep); |
| printf("state=%s\n", VisibilityState(ev->state)); |
| } |
| |
| /******************************************************************************/ |
| /************ Return the string representation for type of an event ***********/ |
| /******************************************************************************/ |
| |
| char *GetType(ev) |
| XEvent *ev; |
| { |
| 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"); |
| } |
| } |
| |
| /******************************************************************************/ |
| /**************** Print the values of all fields for any event ****************/ |
| /******************************************************************************/ |
| |
| void ShowEvent(ev) |
| XAnyEvent *ev; |
| { |
| /* determine which field separator to use */ |
| if (use_separate_lines) |
| sep = "\n"; |
| else |
| sep = " "; |
| |
| printf("type=%s%s", GetType(ev), sep); |
| printf("serial=%d%s", ev->serial, sep); |
| printf("send_event=%s%s", TorF(ev->send_event), sep); |
| printf("display=0x%x%s", ev->display, sep); |
| |
| switch (ev->type) { |
| case MotionNotify: |
| VerbMotion(ev); |
| break; |
| |
| case ButtonPress: |
| case ButtonRelease: |
| VerbButton(ev); |
| break; |
| |
| case ColormapNotify: |
| VerbColormap(ev); |
| break; |
| |
| case EnterNotify: |
| case LeaveNotify: |
| VerbCrossing(ev); |
| break; |
| |
| case Expose: |
| VerbExpose(ev); |
| break; |
| |
| case GraphicsExpose: |
| VerbGraphicsExpose(ev); |
| break; |
| |
| case NoExpose: |
| VerbNoExpose(ev); |
| break; |
| |
| case FocusIn: |
| case FocusOut: |
| VerbFocus(ev); |
| break; |
| |
| case KeymapNotify: |
| VerbKeymap(ev); |
| break; |
| |
| case KeyPress: |
| case KeyRelease: |
| VerbKey(ev); |
| break; |
| |
| case PropertyNotify: |
| VerbProperty(ev); |
| break; |
| |
| case ResizeRequest: |
| VerbResizeRequest(ev); |
| break; |
| |
| case CirculateNotify: |
| VerbCirculate(ev); |
| break; |
| |
| case ConfigureNotify: |
| VerbConfigure(ev); |
| break; |
| |
| case CreateNotify: |
| VerbCreateWindow(ev); |
| break; |
| |
| case DestroyNotify: |
| VerbDestroyWindow(ev); |
| break; |
| |
| case GravityNotify: |
| VerbGravity(ev); |
| break; |
| |
| case MapNotify: |
| VerbMap(ev); |
| break; |
| |
| case ReparentNotify: |
| VerbReparent(ev); |
| break; |
| |
| case UnmapNotify: |
| VerbUnmap(ev); |
| break; |
| |
| case CirculateRequest: |
| VerbCirculateRequest(ev); |
| break; |
| |
| case ConfigureRequest: |
| VerbConfigureRequest(ev); |
| break; |
| |
| case MapRequest: |
| VerbMapRequest(ev); |
| break; |
| |
| case ClientMessage: |
| VerbClient(ev); |
| break; |
| |
| case MappingNotify: |
| VerbMapping(ev); |
| break; |
| |
| case SelectionClear: |
| VerbSelectionClear(ev); |
| break; |
| |
| case SelectionNotify: |
| VerbSelection(ev); |
| break; |
| |
| case SelectionRequest: |
| VerbSelectionRequest(ev); |
| break; |
| |
| case VisibilityNotify: |
| VerbVisibility(ev); |
| break; |
| |
| } |
| } |
| SHAR_EOF |
| fi # end of overwriting check |
| if test -f 'ShowEvent.man' |
| then |
| echo shar: will not over-write existing file "'ShowEvent.man'" |
| else |
| cat << \SHAR_EOF > 'ShowEvent.man' |
| .TH ShowEvent 3X11 "December 1988" |
| .SH NAME |
| .B ShowEvent \- display the fields of an event |
| .br |
| .B GetType - get a string representation of an event type |
| |
| .SH SYNOPSIS |
| .B void ShowEvent(event) |
| .br |
| .B XEvent *event; |
| .PP |
| .B char *GetType(event) |
| .br |
| .B XEvent *event; |
| |
| .SH DESCRIPTION |
| ShowEvent displays the fields of the specified event in a readable form. |
| .PP |
| GetType returns the string representation of the specified event type. |
| |
| SHAR_EOF |
| fi # end of overwriting check |
| if test -f 'patchlevel.h' |
| then |
| echo shar: will not over-write existing file "'patchlevel.h'" |
| else |
| cat << \SHAR_EOF > 'patchlevel.h' |
| #define PATCHLEVEL 0 |
| SHAR_EOF |
| fi # end of overwriting check |
| if test -f 'sample.c' |
| then |
| echo shar: will not over-write existing file "'sample.c'" |
| else |
| cat << \SHAR_EOF > 'sample.c' |
| #include <X11/Intrinsic.h> |
| |
| /* |
| * Disclaimer: No I don't actually code like this but this is a simple, |
| * "Quick-n-Dirty", plain, vanilla, "No ups, No extras" piece of code. |
| */ |
| |
| main(argc, argv) |
| int argc; |
| char **argv; |
| { |
| Display *dpy; |
| int screen; |
| Window window; |
| XEvent event; |
| extern Boolean use_separate_lines; |
| |
| if (!(dpy = XOpenDisplay(""))) { |
| printf("Failed to open display...\n"); |
| exit(1); |
| } |
| screen = DefaultScreen(dpy); |
| |
| window = XCreateSimpleWindow(dpy, RootWindow(dpy, screen), 100, 100, |
| 300, 200, 2, BlackPixel(dpy, screen), WhitePixel(dpy, screen)); |
| |
| XSelectInput(dpy, window, KeyPressMask | KeyReleaseMask | ButtonPressMask | |
| ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | |
| PointerMotionMask | PointerMotionHintMask | Button1MotionMask | |
| Button2MotionMask | Button3MotionMask | Button4MotionMask | |
| Button5MotionMask | ButtonMotionMask | KeymapStateMask | |
| ExposureMask | VisibilityChangeMask | StructureNotifyMask | |
| SubstructureNotifyMask | SubstructureRedirectMask | FocusChangeMask | |
| PropertyChangeMask | ColormapChangeMask | OwnerGrabButtonMask); |
| |
| XMapWindow(dpy, window); |
| |
| /* set this to false to make ShowEvent take up less vertival space */ |
| use_separate_lines = True; |
| |
| while (1) { |
| XNextEvent(dpy, &event); |
| printf("Detail of %s event:\n", GetType(&event)); |
| ShowEvent(&event); |
| printf("\n\n"); |
| } |
| } |
| |
| SHAR_EOF |
| fi # end of overwriting check |
| # End of shell archive |
| exit 0 |
| -- |
| Mike Wexler(wyse!mikew) Phone: (408)433-1000 x1330 |
| Moderator of comp.sources.x |