xkbevd/printev.c

   1 /************************************************************
   2  Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc.
   3
   4  Permission to use, copy, modify, and distribute this
   5  software and its documentation for any purpose and without
   6  fee is hereby granted, provided that the above copyright
   7  notice appear in all copies and that both that copyright
   8  notice and this permission notice appear in supporting
   9  documentation, and that the name of Silicon Graphics not be
  10  used in advertising or publicity pertaining to distribution
  11  of the software without specific prior written permission.
  12  Silicon Graphics makes no representation about the suitability
  13  of this software for any purpose. It is provided "as is"
  14  without any express or implied warranty.
  15
  16  SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24
  25  ********************************************************/
  26
  27 #define DEBUG_VAR printevDebug
  28 #include "xkbevd.h"
  29 #include <X11/Xutil.h>
  30
  31 #define Yes     "yes"
  32 #define No      "no"
  33 #define Unknown "unknown"
  34 #define ynText(v)       ((v)?Yes:No)
  35
  36 static char *
  37 eventTypeToString(int evType)
  38 {
  39 static char name[20];
  40     switch (evType) {
  41         case KeyPress:  strcpy(name,"KeyPress"); break;
  42         case KeyRelease:strcpy(name,"KeyRelease"); break;
  43         default: strcpy(name,"unknown"); break;
  44     }
  45     return name;
  46 }
  47
  48 static void
  49 xkb_prologue (FILE *file, XkbEvent *ev, char *name)
  50 {
  51     XkbAnyEvent *e = &ev->any;
  52
  53     fprintf(file,"\n%s event, serial %ld, synthetic %s, device %d, time %ld,\n",
  54                 name, e->serial, ynText(e->send_event), e->device,e->time);
  55     return;
  56 }
  57
  58 static void
  59 do_XkbStateNotify(FILE *file, XkbEvent *xkbev)
  60 {
  61     XkbStateNotifyEvent *state= &xkbev->state;
  62
  63     if (state->keycode!=0)
  64          fprintf(file,"    keycode %d, eventType %s,\n",
  65                 state->keycode,eventTypeToString(state->event_type));
  66     else fprintf(file,"    request %d/%d,\n",state->req_minor,state->req_minor);
  67     fprintf(file,"    group= %d%s, base= %d%s, latched= %d%s, locked= %d%s,\n",
  68                 state->group, (state->changed&XkbGroupStateMask?"*":""),
  69                 state->base_group,(state->changed&XkbGroupBaseMask?"*":""),
  70                 state->latched_group,(state->changed&XkbGroupLatchMask?"*":""),
  71                 state->locked_group,(state->changed&XkbGroupLockMask?"*":""));
  72     fprintf(file,
  73     "    mods= 0x%02x%s, base= 0x%02x%s, latched= 0x%02x%s, locked= 0x%02x%s\n",
  74                 state->mods, (state->changed&XkbModifierStateMask?"*":""),
  75                 state->base_mods,(state->changed&XkbModifierBaseMask?"*":""),
  76                state->latched_mods,(state->changed&XkbModifierLatchMask?"*":""),
  77                 state->locked_mods,(state->changed&XkbModifierLockMask?"*":""));
  78     fprintf(file,"    grab mods= 0x%02x%s, compat grab mods= 0x%02x%s\n",
  79                 state->grab_mods, (state->changed&XkbGrabModsMask?"*":""),
  80                 state->compat_grab_mods,
  81                         (state->changed&XkbCompatGrabModsMask?"*":""));
  82     fprintf(file,"    lookup mods= 0x%02x%s, compat lookup mods= 0x%02x%s\n",
  83                 state->lookup_mods, (state->changed&XkbLookupModsMask?"*":""),
  84                 state->compat_lookup_mods,
  85                         (state->changed&XkbCompatLookupModsMask?"*":""));
  86     fprintf(file,"    compatState = 0x%02x%s, ",
  87                 state->compat_state,(state->changed&XkbCompatStateMask?"*":""));
  88     fprintf(file,"ptr_buttons= 0x%04x%s\n",state->ptr_buttons,
  89                 (state->changed&XkbPointerButtonMask?"*":""));
  90     return;
  91 }
  92
  93 static void
  94 do_map_message(char *what, int first, int num, int eol)
  95 {
  96     if (num>1)
  97          printf("%ss %d..%d changed%s",what,first,first+num-1,(eol?"\n":""));
  98     else printf("%s %d changed%s",what,first,(eol?"\n":""));
  99 }
 100
 101 static void
 102 do_XkbMapNotify(FILE *file,XkbEvent *xkbev)
 103 {
 104     XkbMapNotifyEvent *map = &xkbev->map;
 105     if (map->changed&XkbKeyTypesMask) {
 106         do_map_message("key type",map->first_type,map->num_types,0);
 107     }
 108     if (map->changed&XkbKeySymsMask) {
 109         do_map_message("symbols for key",map->first_key_sym,map->num_key_syms,
 110                                                 1);
 111     }
 112     if (map->changed&XkbKeyActionsMask) {
 113         do_map_message("acts for key",map->first_key_act,
 114                                                 map->num_key_acts,1);
 115     }
 116     if (map->changed&XkbKeyBehaviorsMask) {
 117         do_map_message("behavior for key",map->first_key_behavior,
 118                                                 map->num_key_behaviors,1);
 119     }
 120     if (map->changed&XkbVirtualModsMask) {
 121         fprintf(file,"    virtual modifiers changed (0x%04x)\n",map->vmods);
 122     }
 123     if (map->changed&XkbExplicitComponentsMask) {
 124         do_map_message("explicit components for key",map->first_key_explicit,
 125                                                 map->num_key_explicit,1);
 126     }
 127     if (map->changed&XkbModifierMapMask) {
 128         do_map_message("modifier map for key",map->first_modmap_key,
 129                                                 map->num_modmap_keys,1);
 130     }
 131     return;
 132 }
 133
 134 static void
 135 do_XkbControlsNotify(FILE *file, XkbEvent *xkbev)
 136 {
 137     XkbControlsNotifyEvent *ctrls = &xkbev->ctrls;
 138     fprintf(file,"    changed= 0x%x, enabled= 0x%x, enabledChanges= 0x%x\n",
 139                         ctrls->changed_ctrls,ctrls->enabled_ctrls,
 140                         ctrls->enabled_ctrl_changes);
 141     fprintf(file,"    num_groups= %d\n",ctrls->num_groups);
 142     if (ctrls->keycode!=0)
 143          fprintf(file,"    keycode %d, eventType %s,",
 144                 ctrls->keycode,eventTypeToString(ctrls->event_type));
 145     else fprintf(file,"    request %d/%d%s\n",ctrls->req_major,ctrls->req_minor,
 146                         (ctrls->req_major!=xkbOpcode?" (NON-XKB)":""));
 147     return;
 148 }
 149
 150 static void
 151 do_XkbIndicatorNotify(FILE *file, XkbEvent *xkbev)
 152 {
 153     XkbIndicatorNotifyEvent *leds = &xkbev->indicators;
 154     if (leds->xkb_type==XkbIndicatorStateNotify)
 155          fprintf(file,"    state changes= 0x%08x, new state= 0x%08x\n",
 156                                         leds->changed,leds->state);
 157     else fprintf(file,"    map changes= 0x%08x, state= 0x%08x\n",
 158                                         leds->changed,leds->state);
 159     return;
 160 }
 161
 162 static void
 163 do_XkbBellNotify(FILE *file, XkbEvent *xkbev)
 164 {
 165     XkbBellNotifyEvent *bell = &xkbev->bell;
 166     fprintf(file,"    bell class= %d, id= %d\n",bell->bell_class,bell->bell_id);
 167     fprintf(file,"    percent= %d, pitch= %d, duration= %d",
 168                                 bell->percent,bell->pitch,bell->duration);
 169     if (bell->name!=None) {
 170          char *name = XGetAtomName (dpy, bell->name);
 171          fprintf(file,"\n    name= \"%s\"\n",(name?name:""));
 172          if (name)
 173             XFree(name);
 174     }
 175     else fprintf(file,", no name\n");
 176     fprintf(file,"    window= 0x%x, %sevent_only\n",(unsigned int)bell->window,
 177                                                 (bell->event_only?"":"!"));
 178     return;
 179 }
 180
 181 static void
 182 do_XkbAccessXNotify(FILE *file, XkbEvent *xkbev)
 183 {
 184     XkbAccessXNotifyEvent *sk = &xkbev->accessx;
 185     char *detail;
 186     switch (sk->detail) {
 187         case XkbAXN_SKPress:  detail= "skpress"; break;
 188         case XkbAXN_SKAccept: detail= "skaccept"; break;
 189         case XkbAXN_SKReject: detail= "skreject"; break;
 190         case XkbAXN_SKRelease: detail= "skrelease"; break;
 191         case XkbAXN_BKAccept: detail= "bkaccept"; break;
 192         case XkbAXN_BKReject: detail= "bkreject"; break;
 193         case XkbAXN_AXKWarning: detail= "warning"; break;
 194         default: {
 195             static char buf[20];
 196             sprintf(buf,"unknown(%d)",sk->detail);
 197             detail= buf;
 198             break;
 199         }
 200     }
 201     fprintf(file,
 202         "    keycode= %d,detail= %s,slow keys delay= %d,debounce delay= %d\n",
 203                         sk->keycode,detail,sk->sk_delay,sk->debounce_delay);
 204     return;
 205 }
 206
 207 static void
 208 do_XkbNamesNotify(FILE *file, XkbEvent *xkbev)
 209 {
 210     XkbNamesNotifyEvent *names = &xkbev->names;
 211
 212     if (names->changed&
 213                 (XkbKeycodesNameMask|XkbGeometryNameMask|XkbSymbolsNameMask)) {
 214         int needComma= 0;
 215         fprintf(file,"    ");
 216         if (names->changed&XkbKeycodesNameMask) {
 217             fprintf(file,"keycodes");
 218             needComma++;
 219         }
 220         if (names->changed&XkbGeometryNameMask) {
 221             fprintf(file,"%sgeometry",(needComma?", ":""));
 222             needComma++;
 223         }
 224         if (names->changed&XkbSymbolsNameMask) {
 225             fprintf(file,"%ssymbols",(needComma?", ":""));
 226             needComma++;
 227         }
 228         if (names->changed&XkbPhysSymbolsNameMask) {
 229             fprintf(file,"%sphysical symbols",(needComma?", ":""));
 230             needComma++;
 231         }
 232         fprintf(file," name%s changed\n",(needComma>1?"s":""));
 233     }
 234     if (names->changed&XkbKeyTypeNamesMask) {
 235         do_map_message("key type name",names->first_type,names->num_types,1);
 236     }
 237     if (names->changed&XkbKTLevelNamesMask) {
 238         do_map_message("level names for key type",
 239                                         names->first_lvl,names->num_lvls,1);
 240     }
 241     if (names->changed&XkbIndicatorNamesMask) {
 242         fprintf(file,"    names of indicators in 0x%08x changed\n",
 243                                                 names->changed_indicators);
 244     }
 245     if (names->changed&XkbVirtualModNamesMask) {
 246         fprintf(file,"    names of virtual modifiers in 0x%04x changed\n",
 247                                                 names->changed_vmods);
 248     }
 249     if (names->changed&XkbGroupNamesMask) {
 250         fprintf(file,"    names of groups in 0x%x changed\n",
 251                                                 names->changed_groups);
 252     }
 253     if (names->changed&XkbKeyNamesMask) {
 254         do_map_message("names for key",names->first_key,names->num_keys,1);
 255     }
 256     if (names->changed&XkbKeyAliasesMask) {
 257         fprintf(file,"key aliases changed (%d aliases total)\n",
 258                                         names->num_aliases);
 259     }
 260     if (names->changed&XkbRGNamesMask) {
 261         fprintf(file,"radio group names changed (%d radio groups total)\n",
 262                                         names->num_radio_groups);
 263     }
 264     return;
 265 }
 266
 267 static void
 268 do_XkbCompatMapNotify(FILE *file, XkbEvent *xkbev)
 269 {
 270     XkbCompatMapNotifyEvent *map = &xkbev->compat;
 271
 272     if (map->changed_groups)
 273         fprintf(file,"    compat maps for groups in 0x%02x changed\n",
 274                                                 map->changed_groups);
 275     if (map->num_si>0) {
 276         fprintf(file,"    symbol interpretations %d..%d (of %d) changed\n",
 277                                 map->first_si,map->first_si+map->num_si-1,
 278                                                         map->num_total_si);
 279     }
 280     else fprintf(file,"   keyboard has %d symbol interpretations\n",
 281                                                         map->num_total_si);
 282     return;
 283 }
 284
 285 static void
 286 do_XkbActionMessage(FILE *file, XkbEvent *xkbev)
 287 {
 288     XkbActionMessageEvent *msg= &xkbev->message;
 289     fprintf(file,"    message: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 290                                         msg->message[0],msg->message[1],
 291                                         msg->message[2],msg->message[3],
 292                                         msg->message[4],msg->message[5]);
 293     fprintf(file,"    key %d, event: %s,  follows: %s\n",msg->keycode,
 294                                      (msg->press?"press":"release"),
 295                                      (msg->key_event_follows?"yes":"no"));
 296     return;
 297 }
 298
 299 static void
 300 do_XkbNewKeyboardNotify(FILE *file, XkbEvent *xkbev)
 301 {
 302     XkbNewKeyboardNotifyEvent *nk= &xkbev->new_kbd;
 303     fprintf(file,"    new device: %d min_keycode: %d, max_keycode %d\n",
 304                                 nk->device,nk->min_key_code,nk->max_key_code);
 305     fprintf(file,"    old device: %d min_keycode: %d, max_keycode %d\n",
 306                                 nk->old_device,
 307                                 nk->old_min_key_code,nk->old_max_key_code);
 308     return;
 309 }
 310
 311 static void
 312 do_XkbExtensionDeviceNotify(FILE *file, XkbEvent *xkbev)
 313 {
 314     XkbExtensionDeviceNotifyEvent *edn= &xkbev->device;
 315     fprintf(file,"    device= %d, class= %d, id= %d\n",edn->device,
 316                                                 edn->led_class,edn->led_id);
 317     fprintf(file,"    reason= 0x%0x\n",edn->reason);
 318     fprintf(file,"    supported= 0x%0x, unsupported= 0x%0x\n",edn->supported,
 319                                                         edn->unsupported);
 320     fprintf(file,"    first button= %d, num buttons= %d\n",edn->first_btn,
 321                                                         edn->num_btns);
 322     fprintf(file,"    leds defined= 0x%08x, led state= 0x%08x\n",
 323                                         edn->leds_defined,edn->led_state);
 324     return;
 325 }
 326
 327 #ifdef notyet
 328 static  char keyState[XkbMaxLegalKeyCode];
 329
 330 static void
 331 do_KeyEvent(XkbEvent *eventp, int compose, int repeat)
 332 {
 333     XKeyEvent *e = &eventp->core.xkey;
 334     KeySym ks;
 335     char *ksname,*kname;
 336     int nbytes;
 337     char str[256+1];
 338     static XComposeStatus status;
 339
 340     nbytes = XLookupString (e, str, 256, &ks, (compose?&status:NULL));
 341     if (ks == NoSymbol)
 342         ksname = "NoSymbol";
 343     else if (!(ksname = XKeysymToString (ks)))
 344         ksname = "(no name)";
 345     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
 346             e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
 347
 348     if (xkb && xkb->names && xkb->names->keys)
 349          kname= XkbKeyNameText(xkb->names->keys[e->keycode].name,XkbMessage);
 350     else kname= "<???""?>";     /* XXX break trigraph */
 351
 352     printf ("    state 0x%x, group= %d, key %s (keycode %u, keysym 0x%x, %s)\n",
 353                 e->state&0x1FFF, (e->state>>13)&0x7, kname,
 354                 e->keycode, (unsigned int)ks, ksname);
 355     printf ("    same_screen %s, autorepeat %s,\n",ynText(e->same_screen),
 356                         (detectableRepeat ? ynText(repeat) : "UNKNOWN"));
 357     if (nbytes < 0) nbytes = 0;
 358     if (nbytes > 256) nbytes = 256;
 359     str[nbytes] = '\0';
 360     printf ("    XLookupString gives %d characters:  \"%s\"\n", nbytes, str);
 361
 362     return;
 363 }
 364
 365 static void
 366 do_KeyPress(XkbEvent *eventp)
 367 {
 368 int     repeat;
 369
 370     repeat= keyState[eventp->core.xkey.keycode]!=0;
 371     keyState[eventp->core.xkey.keycode]= 1;
 372     do_KeyEvent (eventp, 1,repeat);
 373     return;
 374 }
 375
 376 static void
 377 do_KeyRelease(XkbEvent *eventp)
 378 {
 379     keyState[eventp->core.xkey.keycode]= 0;
 380     do_KeyEvent (eventp,0,False);
 381     return;
 382 }
 383
 384 static void
 385 do_ButtonPress(XkbEvent *eventp)
 386 {
 387     XButtonEvent *e = &eventp->core.xbutton;
 388
 389     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
 390             e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
 391     printf ("    state 0x%x, group= %d, button %u, same_screen %s\n",
 392             e->state&0x1FFF, (e->state>>13)&0x7, e->button,
 393             ynText(e->same_screen));
 394
 395     return;
 396 }
 397
 398 static void
 399 do_ButtonRelease(XkbEvent *eventp)
 400 {
 401     do_ButtonPress (eventp);            /* since it has the same info */
 402     return;
 403 }
 404
 405 static void
 406 do_MotionNotify(XkbEvent *eventp)
 407 {
 408     XMotionEvent *e = &eventp->core.xmotion;
 409
 410     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
 411             e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
 412     printf ("    state 0x%x, group= %d, is_hint %u, same_screen %s\n",
 413             e->state&0x1FFF, (e->state>>13)&0x7, e->is_hint,
 414             ynText(e->same_screen));
 415
 416     return;
 417 }
 418
 419 static void
 420 do_EnterNotify(XkbEvent *eventp)
 421 {
 422     XCrossingEvent *e = &eventp->core.xcrossing;
 423     char *mode, *detail;
 424     char dmode[10], ddetail[10];
 425
 426     switch (e->mode) {
 427       case NotifyNormal:  mode = "NotifyNormal"; break;
 428       case NotifyGrab:  mode = "NotifyGrab"; break;
 429       case NotifyUngrab:  mode = "NotifyUngrab"; break;
 430       case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
 431       default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
 432     }
 433
 434     switch (e->detail) {
 435       case NotifyAncestor:  detail = "NotifyAncestor"; break;
 436       case NotifyVirtual:  detail = "NotifyVirtual"; break;
 437       case NotifyInferior:  detail = "NotifyInferior"; break;
 438       case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
 439       case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
 440       case NotifyPointer:  detail = "NotifyPointer"; break;
 441       case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
 442       case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
 443       default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
 444     }
 445
 446     printf ("    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
 447             e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
 448     printf ("    mode %s, detail %s, same_screen %s,\n",
 449             mode, detail, ynText(e->same_screen));
 450     printf ("    focus %s, state %u, group= %d\n", ynText(e->focus),
 451             e->state&0x1FFF, (e->state>>13)&7 );
 452
 453     return;
 454 }
 455
 456 static void
 457 do_LeaveNotify(XkbEvent *eventp)
 458 {
 459     do_EnterNotify (eventp);            /* since it has same information */
 460     return;
 461 }
 462
 463 static void
 464 do_KeymapNotify(XkbEvent *eventp)
 465 {
 466     XKeymapEvent *e = &eventp->core.xkeymap;
 467     int i;
 468
 469     printf ("    keys:  ");
 470     for (i = 0; i < 32; i++) {
 471         if (i == 16) printf ("\n           ");
 472         printf ("%-3u ", (unsigned int) e->key_vector[i]);
 473     }
 474     printf ("\n");
 475     return;
 476 }
 477
 478 static void
 479 do_ClientMessage(XkbEvent *eventp)
 480 {
 481     XClientMessageEvent *e = &eventp->core.xclient;
 482     char *mname = XGetAtomName (dpy, e->message_type);
 483
 484     printf ("    message_type 0x%lx (%s), format %d\n",
 485             e->message_type, mname ? mname : Unknown, e->format);
 486
 487     if (mname) XFree (mname);
 488     return;
 489 }
 490
 491 static void
 492 do_MappingNotify(XkbEvent *eventp)
 493 {
 494     XMappingEvent *e = &eventp->core.xmapping;
 495     char *r;
 496     char rdummy[10];
 497
 498     switch (e->request) {
 499       case MappingModifier:  r = "MappingModifier"; break;
 500       case MappingKeyboard:  r = "MappingKeyboard"; break;
 501       case MappingPointer:  r = "MappingPointer"; break;
 502       default:  r = rdummy; sprintf (rdummy, "%d", e->request); break;
 503     }
 504
 505     printf ("    request %s, first_keycode %d, count %d\n",
 506             r, e->first_keycode, e->count);
 507     XRefreshKeyboardMapping(e);
 508     return;
 509 }
 510
 511
 512 static void
 513 set_sizehints(XSizeHints *hintp, int min_width, int min_height,
 514               int defwidth, int defheight, int defx, int defy, char *geom)
 515 {
 516     int geom_result;
 517
 518     /* set the size hints, algorithm from xlib xbiff */
 519
 520     hintp->width = hintp->min_width = min_width;
 521     hintp->height = hintp->min_height = min_height;
 522     hintp->flags = PMinSize;
 523     hintp->x = hintp->y = 0;
 524     geom_result = NoValue;
 525     if (geom != NULL) {
 526         geom_result = XParseGeometry (geom, &hintp->x, &hintp->y,
 527                                       (unsigned int *)&hintp->width,
 528                                       (unsigned int *)&hintp->height);
 529         if ((geom_result & WidthValue) && (geom_result & HeightValue)) {
 530 #define max(a,b) ((a) > (b) ? (a) : (b))
 531             hintp->width = max (hintp->width, hintp->min_width);
 532             hintp->height = max (hintp->height, hintp->min_height);
 533             hintp->flags |= USSize;
 534         }
 535         if ((geom_result & XValue) && (geom_result & YValue)) {
 536             hintp->flags += USPosition;
 537         }
 538     }
 539     if (!(hintp->flags & USSize)) {
 540         hintp->width = defwidth;
 541         hintp->height = defheight;
 542         hintp->flags |= PSize;
 543     }
 544 /*
 545     if (!(hintp->flags & USPosition)) {
 546         hintp->x = defx;
 547         hintp->y = defy;
 548         hintp->flags |= PPosition;
 549     }
 550  */
 551     if (geom_result & XNegative) {
 552         hintp->x = DisplayWidth (dpy, DefaultScreen (dpy)) + hintp->x -
 553                     hintp->width;
 554     }
 555     if (geom_result & YNegative) {
 556         hintp->y = DisplayHeight (dpy, DefaultScreen (dpy)) + hintp->y -
 557                     hintp->height;
 558     }
 559     return;
 560 }
 561 #endif
 562
 563 void
 564 PrintXkbEvent(FILE *file, XkbEvent *ev)
 565 {
 566     if (ev->type==xkbEventCode) {
 567         switch (ev->any.xkb_type) {
 568             case XkbStateNotify:
 569                 xkb_prologue(file, ev, "XkbStateNotify" );
 570                 do_XkbStateNotify(file,ev);
 571                 break;
 572             case XkbMapNotify:
 573                 xkb_prologue(file, ev, "XkbMapNotify" );
 574                 do_XkbMapNotify(file,ev);
 575                 break;
 576             case XkbControlsNotify:
 577                 xkb_prologue(file, ev, "XkbControlsNotify" );
 578                 do_XkbControlsNotify(file,ev);
 579                 break;
 580             case XkbIndicatorMapNotify:
 581                 xkb_prologue(file, ev, "XkbIndicatorMapNotify" );
 582                 do_XkbIndicatorNotify(file,ev);
 583                 break;
 584             case XkbIndicatorStateNotify:
 585                 xkb_prologue(file, ev, "XkbIndicatorStateNotify" );
 586                 do_XkbIndicatorNotify(file,ev);
 587                 break;
 588             case XkbBellNotify:
 589                 xkb_prologue(file, ev, "XkbBellNotify" );
 590                 do_XkbBellNotify(file,ev);
 591                 break;
 592             case XkbAccessXNotify:
 593                 xkb_prologue(file, ev, "XkbAccessXNotify" );
 594                 do_XkbAccessXNotify(file,ev);
 595                 break;
 596             case XkbNamesNotify:
 597                 xkb_prologue(file, ev, "XkbNamesNotify" );
 598                 do_XkbNamesNotify(file,ev);
 599                 break;
 600             case XkbCompatMapNotify:
 601                 xkb_prologue(file, ev, "XkbCompatMapNotify" );
 602                 do_XkbCompatMapNotify(file,ev);
 603                 break;
 604             case XkbActionMessage:
 605                 xkb_prologue(file, ev, "XkbActionMessage" );
 606                 do_XkbActionMessage(file,ev);
 607                 break;
 608             case XkbNewKeyboardNotify:
 609                 xkb_prologue(file, ev, "XkbNewKeyboard" );
 610                 do_XkbNewKeyboardNotify(file,ev);
 611                 break;
 612             case XkbExtensionDeviceNotify:
 613                 xkb_prologue(file, ev, "XkbExtensionDeviceNotify" );
 614                 do_XkbExtensionDeviceNotify(file,ev);
 615                 break;
 616             default:
 617                 xkb_prologue(file, ev, "XKB_UNKNOWN!!!" );
 618                 break;
 619         }
 620     }
 621     return;
 622 }