path: root/printev.c

/************************************************************
 Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc.

 Permission to use, copy, modify, and distribute this
 software and its documentation for any purpose and without
 fee is hereby granted, provided that the above copyright
 notice appear in all copies and that both that copyright
 notice and this permission notice appear in supporting
 documentation, and that the name of Silicon Graphics not be
 used in advertising or publicity pertaining to distribution
 of the software without specific prior written permission.
 Silicon Graphics makes no representation about the suitability
 of this software for any purpose. It is provided "as is"
 without any express or implied warranty.

 SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
 SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
 GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
 THE USE OR PERFORMANCE OF THIS SOFTWARE.

 ********************************************************/

#define	DEBUG_VAR printevDebug
#include "xkbevd.h"
#include <X11/Xutil.h>

#define	Yes	"yes"
#define	No	"no"
#define	Unknown	"unknown"
#define	ynText(v)	((v)?Yes:No)

static char *
eventTypeToString(int evType)
{
static char name[20];
    switch (evType) {
	case KeyPress:	strcpy(name,"KeyPress"); break;
	case KeyRelease:strcpy(name,"KeyRelease"); break;
	default: strcpy(name,"unknown"); break;
    }
    return name;
}

static void
xkb_prologue (FILE *file, XkbEvent *ev, const char *name)
{
    XkbAnyEvent *e = &ev->any;

    fprintf(file,"\n%s event, serial %ld, synthetic %s, device %d, time %ld,\n",
	    	name, e->serial, ynText(e->send_event), e->device,e->time);
    return;
}

static void
do_XkbStateNotify(FILE *file, XkbEvent *xkbev)
{
    XkbStateNotifyEvent *state= &xkbev->state;

    if (state->keycode!=0)
	 fprintf(file,"    keycode %d, eventType %s,\n",
		state->keycode,eventTypeToString(state->event_type));
    else fprintf(file,"    request %d/%d,\n",state->req_minor,state->req_minor);
    fprintf(file,"    group= %d%s, base= %d%s, latched= %d%s, locked= %d%s,\n",
		state->group, (state->changed&XkbGroupStateMask?"*":""),
		state->base_group,(state->changed&XkbGroupBaseMask?"*":""),
		state->latched_group,(state->changed&XkbGroupLatchMask?"*":""),
		state->locked_group,(state->changed&XkbGroupLockMask?"*":""));
    fprintf(file,
    "    mods= 0x%02x%s, base= 0x%02x%s, latched= 0x%02x%s, locked= 0x%02x%s\n",
		state->mods, (state->changed&XkbModifierStateMask?"*":""),
		state->base_mods,(state->changed&XkbModifierBaseMask?"*":""),
	       state->latched_mods,(state->changed&XkbModifierLatchMask?"*":""),
		state->locked_mods,(state->changed&XkbModifierLockMask?"*":""));
    fprintf(file,"    grab mods= 0x%02x%s, compat grab mods= 0x%02x%s\n",
		state->grab_mods, (state->changed&XkbGrabModsMask?"*":""),
		state->compat_grab_mods,
			(state->changed&XkbCompatGrabModsMask?"*":""));
    fprintf(file,"    lookup mods= 0x%02x%s, compat lookup mods= 0x%02x%s\n",
		state->lookup_mods, (state->changed&XkbLookupModsMask?"*":""),
		state->compat_lookup_mods,
			(state->changed&XkbCompatLookupModsMask?"*":""));
    fprintf(file,"    compatState = 0x%02x%s, ",
		state->compat_state,(state->changed&XkbCompatStateMask?"*":""));
    fprintf(file,"ptr_buttons= 0x%04x%s\n",state->ptr_buttons,
                (state->changed&XkbPointerButtonMask?"*":""));
    return;
}

static void
do_map_message(const char *what, int first, int num, int eol)
{
    if (num>1)
	 printf("%ss %d..%d changed%s",what,first,first+num-1,(eol?"\n":""));
    else printf("%s %d changed%s",what,first,(eol?"\n":""));
}

static void
do_XkbMapNotify(FILE *file,XkbEvent *xkbev)
{
    XkbMapNotifyEvent *map = &xkbev->map;
    if (map->changed&XkbKeyTypesMask) {
	do_map_message("key type",map->first_type,map->num_types,0);
    }
    if (map->changed&XkbKeySymsMask) {
	do_map_message("symbols for key",map->first_key_sym,map->num_key_syms,
						1);
    }
    if (map->changed&XkbKeyActionsMask) {
	do_map_message("acts for key",map->first_key_act,
					 	map->num_key_acts,1);
    }
    if (map->changed&XkbKeyBehaviorsMask) {
	do_map_message("behavior for key",map->first_key_behavior,
						map->num_key_behaviors,1);
    }
    if (map->changed&XkbVirtualModsMask) {
	fprintf(file,"    virtual modifiers changed (0x%04x)\n",map->vmods);
    }
    if (map->changed&XkbExplicitComponentsMask) {
	do_map_message("explicit components for key",map->first_key_explicit,
						map->num_key_explicit,1);
    }
    if (map->changed&XkbModifierMapMask) {
	do_map_message("modifier map for key",map->first_modmap_key,
						map->num_modmap_keys,1);
    }
    return;
}

static void
do_XkbControlsNotify(FILE *file, XkbEvent *xkbev)
{
    XkbControlsNotifyEvent *ctrls = &xkbev->ctrls;
    fprintf(file,"    changed= 0x%x, enabled= 0x%x, enabledChanges= 0x%x\n",
			ctrls->changed_ctrls,ctrls->enabled_ctrls,
			ctrls->enabled_ctrl_changes);
    fprintf(file,"    num_groups= %d\n",ctrls->num_groups);
    if (ctrls->keycode!=0)
	 fprintf(file,"    keycode %d, eventType %s,",
		ctrls->keycode,eventTypeToString(ctrls->event_type));
    else fprintf(file,"    request %d/%d%s\n",ctrls->req_major,ctrls->req_minor,
			(ctrls->req_major!=xkbOpcode?" (NON-XKB)":""));
    return;
}

static void
do_XkbIndicatorNotify(FILE *file, XkbEvent *xkbev)
{
    XkbIndicatorNotifyEvent *leds = &xkbev->indicators;
    if (leds->xkb_type==XkbIndicatorStateNotify)
	 fprintf(file,"    state changes= 0x%08x, new state= 0x%08x\n",
					leds->changed,leds->state);
    else fprintf(file,"    map changes= 0x%08x, state= 0x%08x\n",
					leds->changed,leds->state);
    return;
}

static void
do_XkbBellNotify(FILE *file, XkbEvent *xkbev)
{
    XkbBellNotifyEvent *bell = &xkbev->bell;
    fprintf(file,"    bell class= %d, id= %d\n",bell->bell_class,bell->bell_id);
    fprintf(file,"    percent= %d, pitch= %d, duration= %d",
				bell->percent,bell->pitch,bell->duration);
    if (bell->name!=None) {
	 char *name = XGetAtomName (dpy, bell->name);
	 fprintf(file,"\n    name= \"%s\"\n",(name?name:""));
	 if (name)
	    XFree(name);
    }
    else fprintf(file,", no name\n");
    fprintf(file,"    window= 0x%x, %sevent_only\n",(unsigned int)bell->window,
						(bell->event_only?"":"!"));
    return;
}

static void
do_XkbAccessXNotify(FILE *file, XkbEvent *xkbev)
{
    XkbAccessXNotifyEvent *sk = &xkbev->accessx;
    const char *detail;
    switch (sk->detail) {
	case XkbAXN_SKPress:  detail= "skpress"; break;
	case XkbAXN_SKAccept: detail= "skaccept"; break;
	case XkbAXN_SKReject: detail= "skreject"; break;
	case XkbAXN_SKRelease: detail= "skrelease"; break;
	case XkbAXN_BKAccept: detail= "bkaccept"; break;
	case XkbAXN_BKReject: detail= "bkreject"; break;
	case XkbAXN_AXKWarning: detail= "warning"; break;
	default: {
	    static char buf[20];
	    sprintf(buf,"unknown(%d)",sk->detail);
	    detail= buf;
	    break;
	}
    }
    fprintf(file,
	"    keycode= %d,detail= %s,slow keys delay= %d,debounce delay= %d\n",
			sk->keycode,detail,sk->sk_delay,sk->debounce_delay);
    return;
}

static void
do_XkbNamesNotify(FILE *file, XkbEvent *xkbev)
{
    XkbNamesNotifyEvent *names = &xkbev->names;

    if (names->changed&
		(XkbKeycodesNameMask|XkbGeometryNameMask|XkbSymbolsNameMask)) {
	int needComma= 0;
	fprintf(file,"    ");
	if (names->changed&XkbKeycodesNameMask) {
	    fprintf(file,"keycodes");
	    needComma++;
	}
	if (names->changed&XkbGeometryNameMask) {
	    fprintf(file,"%sgeometry",(needComma?", ":""));
	    needComma++;
	}
	if (names->changed&XkbSymbolsNameMask) {
	    fprintf(file,"%ssymbols",(needComma?", ":""));
	    needComma++;
	}
	if (names->changed&XkbPhysSymbolsNameMask) {
	    fprintf(file,"%sphysical symbols",(needComma?", ":""));
	    needComma++;
	}
	fprintf(file," name%s changed\n",(needComma>1?"s":""));
    }
    if (names->changed&XkbKeyTypeNamesMask) {
	do_map_message("key type name",names->first_type,names->num_types,1);
    }
    if (names->changed&XkbKTLevelNamesMask) {
	do_map_message("level names for key type",
					names->first_lvl,names->num_lvls,1);
    }
    if (names->changed&XkbIndicatorNamesMask) {
	fprintf(file,"    names of indicators in 0x%08x changed\n",
						names->changed_indicators);
    }
    if (names->changed&XkbVirtualModNamesMask) {
	fprintf(file,"    names of virtual modifiers in 0x%04x changed\n",
						names->changed_vmods);
    }
    if (names->changed&XkbGroupNamesMask) {
	fprintf(file,"    names of groups in 0x%x changed\n",
						names->changed_groups);
    }
    if (names->changed&XkbKeyNamesMask) {
	do_map_message("names for key",names->first_key,names->num_keys,1);
    }
    if (names->changed&XkbKeyAliasesMask) {
	fprintf(file,"key aliases changed (%d aliases total)\n",
					names->num_aliases);
    }
    if (names->changed&XkbRGNamesMask) {
	fprintf(file,"radio group names changed (%d radio groups total)\n",
					names->num_radio_groups);
    }
    return;
}

static void
do_XkbCompatMapNotify(FILE *file, XkbEvent *xkbev)
{
    XkbCompatMapNotifyEvent *map = &xkbev->compat;

    if (map->changed_groups)
	fprintf(file,"    compat maps for groups in 0x%02x changed\n",
						map->changed_groups);
    if (map->num_si>0) {
	fprintf(file,"    symbol interpretations %d..%d (of %d) changed\n",
				map->first_si,map->first_si+map->num_si-1,
							map->num_total_si);
    }
    else fprintf(file,"   keyboard has %d symbol interpretations\n",
							map->num_total_si);
    return;
}

static void
do_XkbActionMessage(FILE *file, XkbEvent *xkbev)
{
    XkbActionMessageEvent *msg= &xkbev->message;
    fprintf(file,"    message: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
					msg->message[0],msg->message[1],
					msg->message[2],msg->message[3],
					msg->message[4],msg->message[5]);
    fprintf(file,"    key %d, event: %s,  follows: %s\n",msg->keycode,
				     (msg->press?"press":"release"),
				     (msg->key_event_follows?"yes":"no"));
    return;
}

static void
do_XkbNewKeyboardNotify(FILE *file, XkbEvent *xkbev)
{
    XkbNewKeyboardNotifyEvent *nk= &xkbev->new_kbd;
    fprintf(file,"    new device: %d min_keycode: %d, max_keycode %d\n",
				nk->device,nk->min_key_code,nk->max_key_code);
    fprintf(file,"    old device: %d min_keycode: %d, max_keycode %d\n",
				nk->old_device,
				nk->old_min_key_code,nk->old_max_key_code);
    return;
}

static void
do_XkbExtensionDeviceNotify(FILE *file, XkbEvent *xkbev)
{
    XkbExtensionDeviceNotifyEvent *edn= &xkbev->device;
    fprintf(file,"    device= %d, class= %d, id= %d\n",edn->device,
						edn->led_class,edn->led_id);
    fprintf(file,"    reason= 0x%0x\n",edn->reason);
    fprintf(file,"    supported= 0x%0x, unsupported= 0x%0x\n",edn->supported,
							edn->unsupported);
    fprintf(file,"    first button= %d, num buttons= %d\n",edn->first_btn,
							edn->num_btns);
    fprintf(file,"    leds defined= 0x%08x, led state= 0x%08x\n",
					edn->leds_defined,edn->led_state);
    return;
}

#ifdef notyet
static	char keyState[XkbMaxLegalKeyCode];

static void
do_KeyEvent(XkbEvent *eventp, int compose, int repeat)
{
    XKeyEvent *e = &eventp->core.xkey;
    KeySym ks;
    char *ksname,*kname;
    int nbytes;
    char str[256+1];
    static XComposeStatus status;

    nbytes = XLookupString (e, str, 256, &ks, (compose?&status:NULL));
    if (ks == NoSymbol)
	ksname = "NoSymbol";
    else if (!(ksname = XKeysymToString (ks)))
	ksname = "(no name)";
    printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);

    if (xkb && xkb->names && xkb->names->keys)
	 kname= XkbKeyNameText(xkb->names->keys[e->keycode].name,XkbMessage);
    else kname= "<???""?>";	/* XXX break trigraph */

    printf ("    state 0x%x, group= %d, key %s (keycode %u, keysym 0x%x, %s)\n",
	    	e->state&0x1FFF, (e->state>>13)&0x7, kname,
		e->keycode, (unsigned int)ks, ksname);
    printf ("    same_screen %s, autorepeat %s,\n",ynText(e->same_screen),
			(detectableRepeat ? ynText(repeat) : "UNKNOWN"));
    if (nbytes < 0) nbytes = 0;
    if (nbytes > 256) nbytes = 256;
    str[nbytes] = '\0';
    printf ("    XLookupString gives %d characters:  \"%s\"\n", nbytes, str);

    return;
}

static void
do_KeyPress(XkbEvent *eventp)
{
int	repeat;

    repeat= keyState[eventp->core.xkey.keycode]!=0;
    keyState[eventp->core.xkey.keycode]= 1;
    do_KeyEvent (eventp, 1,repeat);
    return;
}

static void
do_KeyRelease(XkbEvent *eventp)
{
    keyState[eventp->core.xkey.keycode]= 0;
    do_KeyEvent (eventp,0,False);
    return;
}

static void
do_ButtonPress(XkbEvent *eventp)
{
    XButtonEvent *e = &eventp->core.xbutton;

    printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
    printf ("    state 0x%x, group= %d, button %u, same_screen %s\n",
	    e->state&0x1FFF, (e->state>>13)&0x7, e->button,
	    ynText(e->same_screen));

    return;
}

static void
do_ButtonRelease(XkbEvent *eventp)
{
    do_ButtonPress (eventp);		/* since it has the same info */
    return;
}

static void
do_MotionNotify(XkbEvent *eventp)
{
    XMotionEvent *e = &eventp->core.xmotion;

    printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
    printf ("    state 0x%x, group= %d, is_hint %u, same_screen %s\n",
	    e->state&0x1FFF, (e->state>>13)&0x7, e->is_hint,
	    ynText(e->same_screen));

    return;
}

static void
do_EnterNotify(XkbEvent *eventp)
{
    XCrossingEvent *e = &eventp->core.xcrossing;
    char *mode, *detail;
    char dmode[10], ddetail[10];

    switch (e->mode) {
      case NotifyNormal:  mode = "NotifyNormal"; break;
      case NotifyGrab:  mode = "NotifyGrab"; break;
      case NotifyUngrab:  mode = "NotifyUngrab"; break;
      case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
      default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
    }

    switch (e->detail) {
      case NotifyAncestor:  detail = "NotifyAncestor"; break;
      case NotifyVirtual:  detail = "NotifyVirtual"; break;
      case NotifyInferior:  detail = "NotifyInferior"; break;
      case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
      case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
      case NotifyPointer:  detail = "NotifyPointer"; break;
      case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
      case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
      default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
    }

    printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
    printf ("    mode %s, detail %s, same_screen %s,\n",
	    mode, detail, ynText(e->same_screen));
    printf ("    focus %s, state %u, group= %d\n", ynText(e->focus),
	    e->state&0x1FFF, (e->state>>13)&7 );

    return;
}

static void
do_LeaveNotify(XkbEvent *eventp)
{
    do_EnterNotify (eventp);		/* since it has same information */
    return;
}

static void
do_KeymapNotify(XkbEvent *eventp)
{
    XKeymapEvent *e = &eventp->core.xkeymap;
    int i;

    printf ("    keys:  ");
    for (i = 0; i < 32; i++) {
	if (i == 16) printf ("\n           ");
	printf ("%-3u ", (unsigned int) e->key_vector[i]);
    }
    printf ("\n");
    return;
}

static void
do_ClientMessage(XkbEvent *eventp)
{
    XClientMessageEvent *e = &eventp->core.xclient;
    char *mname = XGetAtomName (dpy, e->message_type);

    printf ("    message_type 0x%lx (%s), format %d\n",
	    e->message_type, mname ? mname : Unknown, e->format);

    if (mname) XFree (mname);
    return;
}

static void
do_MappingNotify(XkbEvent *eventp)
{
    XMappingEvent *e = &eventp->core.xmapping;
    char *r;
    char rdummy[10];

    switch (e->request) {
      case MappingModifier:  r = "MappingModifier"; break;
      case MappingKeyboard:  r = "MappingKeyboard"; break;
      case MappingPointer:  r = "MappingPointer"; break;
      default:  r = rdummy; sprintf (rdummy, "%d", e->request); break;
    }

    printf ("    request %s, first_keycode %d, count %d\n",
	    r, e->first_keycode, e->count);
    XRefreshKeyboardMapping(e);
    return;
}


static void
set_sizehints(XSizeHints *hintp, int min_width, int min_height,
	      int defwidth, int defheight, int defx, int defy, char *geom)
{
    int geom_result;

    /* set the size hints, algorithm from xlib xbiff */

    hintp->width = hintp->min_width = min_width;
    hintp->height = hintp->min_height = min_height;
    hintp->flags = PMinSize;
    hintp->x = hintp->y = 0;
    geom_result = NoValue;
    if (geom != NULL) {
        geom_result = XParseGeometry (geom, &hintp->x, &hintp->y,
				      (unsigned int *)&hintp->width,
				      (unsigned int *)&hintp->height);
	if ((geom_result & WidthValue) && (geom_result & HeightValue)) {
#define max(a,b) ((a) > (b) ? (a) : (b))
	    hintp->width = max (hintp->width, hintp->min_width);
	    hintp->height = max (hintp->height, hintp->min_height);
	    hintp->flags |= USSize;
	}
	if ((geom_result & XValue) && (geom_result & YValue)) {
	    hintp->flags += USPosition;
	}
    }
    if (!(hintp->flags & USSize)) {
	hintp->width = defwidth;
	hintp->height = defheight;
	hintp->flags |= PSize;
    }
/*
    if (!(hintp->flags & USPosition)) {
	hintp->x = defx;
	hintp->y = defy;
	hintp->flags |= PPosition;
    }
 */
    if (geom_result & XNegative) {
	hintp->x = DisplayWidth (dpy, DefaultScreen (dpy)) + hintp->x -
		    hintp->width;
    }
    if (geom_result & YNegative) {
	hintp->y = DisplayHeight (dpy, DefaultScreen (dpy)) + hintp->y -
		    hintp->height;
    }
    return;
}
#endif

void
PrintXkbEvent(FILE *file, XkbEvent *ev)
{
    if (ev->type==xkbEventCode) {
	switch (ev->any.xkb_type) {
	    case XkbStateNotify:
		xkb_prologue(file, ev, "XkbStateNotify" );
		do_XkbStateNotify(file,ev);
		break;
	    case XkbMapNotify:
		xkb_prologue(file, ev, "XkbMapNotify" );
		do_XkbMapNotify(file,ev);
		break;
	    case XkbControlsNotify:
		xkb_prologue(file, ev, "XkbControlsNotify" );
		do_XkbControlsNotify(file,ev);
		break;
	    case XkbIndicatorMapNotify:
		xkb_prologue(file, ev, "XkbIndicatorMapNotify" );
		do_XkbIndicatorNotify(file,ev);
		break;
	    case XkbIndicatorStateNotify:
		xkb_prologue(file, ev, "XkbIndicatorStateNotify" );
		do_XkbIndicatorNotify(file,ev);
		break;
	    case XkbBellNotify:
		xkb_prologue(file, ev, "XkbBellNotify" );
		do_XkbBellNotify(file,ev);
		break;
	    case XkbAccessXNotify:
		xkb_prologue(file, ev, "XkbAccessXNotify" );
		do_XkbAccessXNotify(file,ev);
		break;
	    case XkbNamesNotify:
		xkb_prologue(file, ev, "XkbNamesNotify" );
		do_XkbNamesNotify(file,ev);
		break;
	    case XkbCompatMapNotify:
		xkb_prologue(file, ev, "XkbCompatMapNotify" );
		do_XkbCompatMapNotify(file,ev);
		break;
	    case XkbActionMessage:
		xkb_prologue(file, ev, "XkbActionMessage" );
		do_XkbActionMessage(file,ev);
		break;
	    case XkbNewKeyboardNotify:
		xkb_prologue(file, ev, "XkbNewKeyboard" );
		do_XkbNewKeyboardNotify(file,ev);
		break;
	    case XkbExtensionDeviceNotify:
		xkb_prologue(file, ev, "XkbExtensionDeviceNotify" );
		do_XkbExtensionDeviceNotify(file,ev);
		break;
	    default:
		xkb_prologue(file, ev, "XKB_UNKNOWN!!!" );
		break;
	}
    }
    return;
}