ryudo/showevent/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;
  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;

  sprintf(
    buffer,
    "%ld day%s %02ld:%02ld:%02ld.%03ld",
    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;
{
  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(valuemask) 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(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;
{
  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(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;
{
  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(ev) 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\")",
    ev->keycode,
    (unsigned)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", (unsigned)ev->window, sep);
  printf("root=0x%x%s", (unsigned)ev->root, sep);
  printf("subwindow=0x%x%s", (unsigned)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", (unsigned)ev->window, sep);
  printf("root=0x%x%s", (unsigned)ev->root, sep);
  printf("subwindow=0x%x%s", (unsigned)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", (unsigned)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", (unsigned)ev->window, sep);
  printf("root=0x%x%s", (unsigned)ev->root, sep);
  printf("subwindow=0x%x%s", (unsigned)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", (unsigned)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", (unsigned)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", (unsigned)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", (unsigned)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", (unsigned)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", (unsigned)ev->window, sep);
  printf("root=0x%x%s", (unsigned)ev->root, sep);
  printf("subwindow=0x%x%s", (unsigned)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", (unsigned)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", (unsigned)ev->window, sep);
  printf("width=%d height=%d\n", ev->width, ev->height);
}

static void
VerbCirculate(XCirculateEvent* ev) {
  printf("event=0x%x%s", (unsigned)ev->event, sep);
  printf("window=0x%x%s", (unsigned)ev->window, sep);
  printf("place=%s\n", Place(ev->place));
}

static void
VerbConfigure(XConfigureEvent* ev) {
  printf("event=0x%x%s", (unsigned)ev->event, sep);
  printf("window=0x%x%s", (unsigned)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", (unsigned)ev->parent, sep);
  printf("window=0x%x%s", (unsigned)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", (unsigned)ev->event, sep);
  printf("window=0x%x\n", (unsigned)ev->window);
}

static void
VerbGravity(XGravityEvent* ev) {
  printf("event=0x%x%s", (unsigned)ev->event, sep);
  printf("window=0x%x%s", (unsigned)ev->window, sep);
  printf("x=%d y=%d\n", ev->x, ev->y);
}

static void
VerbMap(XMapEvent* ev) {
  printf("event=0x%x%s", (unsigned)ev->event, sep);
  printf("window=0x%x%s", (unsigned)ev->window, sep);
  printf("override_redirect=%s\n", TorF(ev->override_redirect));
}

static void
VerbReparent(XReparentEvent* ev) {
  printf("event=0x%x%s", (unsigned)ev->event, sep);
  printf("window=0x%x%s", (unsigned)ev->window, sep);
  printf("parent=0x%x%s", (unsigned)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", (unsigned)ev->event, sep);
  printf("window=0x%x%s", (unsigned)ev->window, sep);
  printf("from_configure=%s\n", TorF(ev->from_configure));
}

static void
VerbCirculateRequest(XCirculateRequestEvent* ev) {
  printf("parent=0x%x%s", (unsigned)ev->parent, sep);
  printf("window=0x%x%s", (unsigned)ev->window, sep);
  printf("place=%s\n", Place(ev->place));
}

static void
VerbConfigureRequest(XConfigureRequestEvent* ev) {
  printf("parent=0x%x%s", (unsigned)ev->parent, sep);
  printf("window=0x%x%s", (unsigned)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", (unsigned)ev->parent, sep);
  printf("window=0x%x\n", (unsigned)ev->window);
}

static void
VerbClient(XClientMessageEvent* ev) {
  int i;

  printf("window=0x%x%s", (unsigned)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", (unsigned)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", (unsigned)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", (unsigned)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", (unsigned)ev->owner, sep);
  printf("requestor=0x%x%s", (unsigned)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", (unsigned)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");
  }
  return "???";
}

/******************************************************************************/
/**************** Print the values of all fields for any event ****************/
/******************************************************************************/

void
ShowEvent(XEvent* eev) {
  XAnyEvent* ev = (XAnyEvent*)eev;
  /* determine which field separator to use */
  if (use_separate_lines)
    sep = "\n";
  else
    sep = " ";

  printf("type=%s%s", GetType((XEvent*)ev), sep);
  printf("serial=%ld%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;
  }
}