diff options
Diffstat (limited to 'printev.c')
| -rw-r--r-- | printev.c | 656 |
1 files changed, 656 insertions, 0 deletions
diff --git a/printev.c b/printev.c new file mode 100644 index 0000000..c889af0 --- /dev/null +++ b/printev.c @@ -0,0 +1,656 @@ +/* $Xorg: printev.c,v 1.3 2000/08/17 19:54:49 cpqbld Exp $ */ +/************************************************************ + 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(evType) + 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, ev, name) + FILE * file; + XkbEvent * ev; + 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,xkbev) + 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(what,first,num,eol) + 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":"")); +} + +void +do_XkbMapNotify(file,xkbev) + 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; +} + +void +do_XkbControlsNotify(file,xkbev) + 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; +} + +void +do_XkbIndicatorNotify(file,xkbev) + 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; +} + +void +do_XkbBellNotify(file,xkbev) + 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",bell->window, + (bell->event_only?"":"!")); + return; +} + +void +do_XkbAccessXNotify(file,xkbev) + FILE * file; + XkbEvent *xkbev; +{ + XkbAccessXNotifyEvent *sk = &xkbev->accessx; + 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; +} + +do_XkbNamesNotify(file,xkbev) + 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; +} + +void +do_XkbCompatMapNotify(file,xkbev) + 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; +} + +void +do_XkbActionMessage(file,xkbev) + 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; +} + +void +do_XkbNewKeyboardNotify(file,xkbev) + 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; +} + +void +do_XkbExtensionDeviceNotify(file,xkbev) + 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; +} + +static char keyState[XkbMaxLegalKeyCode]; + +do_KeyEvent (eventp,compose,repeat) + XkbEvent *eventp; +{ + 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= "<????>"; + + 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, 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; +} + + +do_KeyPress (eventp) + XkbEvent *eventp; +{ +int repeat; + + repeat= keyState[eventp->core.xkey.keycode]!=0; + keyState[eventp->core.xkey.keycode]= 1; + do_KeyEvent (eventp, 1,repeat); + return; +} + +do_KeyRelease (eventp) + XkbEvent *eventp; +{ + keyState[eventp->core.xkey.keycode]= 0; + do_KeyEvent (eventp,0,False); + return; +} + +do_ButtonPress (eventp) + 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; +} + +do_ButtonRelease (eventp) + XkbEvent *eventp; +{ + do_ButtonPress (eventp); /* since it has the same info */ + return; +} + +do_MotionNotify (eventp) + 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; +} + +do_EnterNotify (eventp) + 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; +} + +do_LeaveNotify (eventp) + XkbEvent *eventp; +{ + do_EnterNotify (eventp); /* since it has same information */ + return; +} + +do_KeymapNotify (eventp) + 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; +} + +do_ClientMessage (eventp) + 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; +} + +do_MappingNotify (eventp) + 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; +} + + + +set_sizehints (hintp, min_width, min_height, + defwidth, defheight, defx, defy, geom) + XSizeHints *hintp; + int min_width, min_height, defwidth, defheight, defx, 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; +} + +Bool +PrintXkbEvent(file,ev) + 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; +} |