common/xdbg_evlog_core.c

   1 /**************************************************************************
   2
   3 xdbg
   4
   5 Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
   6
   7 Contact: Boram Park <boram1288.park@samsung.com>
   8          Sangjin LEE <lsj119@samsung.com>
   9
  10 Permission is hereby granted, free of charge, to any person obtaining a
  11 copy of this software and associated documentation files (the
  12 "Software"), to deal in the Software without restriction, including
  13 without limitation the rights to use, copy, modify, merge, publish,
  14 distribute, sub license, and/or sell copies of the Software, and to
  15 permit persons to whom the Software is furnished to do so, subject to
  16 the following conditions:
  17
  18 The above copyright notice and this permission notice (including the
  19 next paragraph) shall be included in all copies or substantial portions
  20 of the Software.
  21
  22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  25 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  26 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30 **************************************************************************/
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"
  34 #endif
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <strings.h>
  39 #include <sys/types.h>
  40 #include <sys/fcntl.h>
  41 #include <unistd.h>
  42 #include <stdarg.h>
  43 #include <fcntl.h>
  44 #include <unistd.h>
  45
  46 #include <dix.h>
  47 #define XREGISTRY
  48 #include <registry.h>
  49 #include <xace.h>
  50 #include <xacestr.h>
  51 #include <X11/Xatom.h>
  52 #include <X11/Xlib.h>
  53 #include <windowstr.h>
  54 #include <X11/Xproto.h>
  55 #include <X11/extensions/XI2proto.h>
  56
  57 #include "xdbg_types.h"
  58 #include "xdbg_evlog_core.h"
  59 #include "xdbg_evlog.h"
  60
  61
  62 static char*
  63 _getWindowAttributeMask (CARD32 mask, char *reply, int *len)
  64 {
  65     int i;
  66     int init = 0;
  67
  68     for (i = 0 ; i < sizeof(mask) * 4 ; i++)
  69     {
  70         if(mask & (1 << i))
  71         {
  72             if (init)
  73                 REPLY(" ");
  74             else
  75                 init = 1;
  76
  77             switch (1 << i)
  78             {
  79                 case CWBackPixmap: REPLY("CWBackPixmap"); break;
  80                 case CWBackPixel: REPLY("CWBackPixel"); break;
  81                 case CWBorderPixmap: REPLY("CWBorderPixmap"); break;
  82                 case CWBorderPixel: REPLY("CWBorderPixel"); break;
  83                 case CWBitGravity: REPLY("CWBitGravity"); break;
  84                 case CWWinGravity: REPLY("CWWinGravity"); break;
  85                 case CWBackingStore: REPLY("CWBackingStore"); break;
  86                 case CWBackingPlanes: REPLY("CWBackingPlanes"); break;
  87                 case CWBackingPixel: REPLY("CWBackingPixel"); break;
  88                 case CWOverrideRedirect: REPLY("CWOverrideRedirect"); break;
  89                 case CWSaveUnder: REPLY("CWSaveUnder"); break;
  90                 case CWEventMask: REPLY("CWEventMask"); break;
  91                 case CWDontPropagate: REPLY("CWDontPropagate"); break;
  92                 case CWColormap: REPLY("CWColormap"); break;
  93                 case CWCursor: REPLY("CWCursor"); break;
  94             }
  95         }
  96     }
  97
  98     return reply;
  99 }
 100
 101 #define GET_INT16(m, f) \
 102         if (m & mask) \
 103           { \
 104              f = (INT16) *pVlist;\
 105             pVlist++; \
 106          }
 107 #define GET_CARD16(m, f) \
 108         if (m & mask) \
 109          { \
 110             f = (CARD16) *pVlist;\
 111             pVlist++;\
 112          }
 113
 114 #define GET_CARD8(m, f) \
 115         if (m & mask) \
 116          { \
 117             f = (CARD8) *pVlist;\
 118             pVlist++;\
 119          }
 120
 121 static char*
 122 _getConfigureWindowMask (CARD16 mask, char *reply, int *len, XID *vlist)
 123 {
 124     int i;
 125     int init = 0;
 126     short x=0, y=0;
 127     unsigned short w=0, h=0;
 128     XID *pVlist;
 129
 130     if(vlist)
 131     {
 132         pVlist = vlist;
 133
 134         if ((mask & (CWX | CWY)) && (!(mask & (CWHeight | CWWidth)))) {
 135             GET_INT16(CWX, x);
 136             GET_INT16(CWY, y);
 137         }
 138         /* or should be resized */
 139         else if (mask & (CWX | CWY | CWWidth | CWHeight)) {
 140             GET_INT16(CWX, x);
 141             GET_INT16(CWY, y);
 142             GET_CARD16(CWWidth, w);
 143             GET_CARD16(CWHeight, h);
 144         }
 145     }
 146
 147     for (i = 0 ; i < sizeof(mask) * 4 ; i++)
 148     {
 149         if(mask & (1 << i))
 150         {
 151             if (init)
 152                 REPLY(" ");
 153             else
 154                 init = 1;
 155
 156             if (vlist)
 157             {
 158                 switch (1 << i)
 159                 {
 160                     case CWX: REPLY("CWX:%d",x); break;
 161                     case CWY: REPLY("CWY:%d",y); break;
 162                     case CWWidth: REPLY("CWWidth:%d",w); break;
 163                     case CWHeight: REPLY("CWHeight:%d",h); break;
 164                     case CWBorderWidth: REPLY("CWBorderWidth"); break;
 165                     case CWSibling: REPLY("CWSibling"); break;
 166                     case CWStackMode: REPLY("CWStackMode"); break;
 167                 }
 168             }
 169             else
 170             {
 171                 switch (1 << i)
 172                 {
 173                     case CWX: REPLY("CWX"); break;
 174                     case CWY: REPLY("CWY"); break;
 175                     case CWWidth: REPLY("CWWidth"); break;
 176                     case CWHeight: REPLY("CWHeight"); break;
 177                     case CWBorderWidth: REPLY("CWBorderWidth"); break;
 178                     case CWSibling: REPLY("CWSibling"); break;
 179                     case CWStackMode: REPLY("CWStackMode"); break;
 180                 }
 181             }
 182         }
 183     }
 184
 185     return reply;
 186 }
 187
 188 static char*
 189 _getKeyMask (CARD16 mask, char *reply, int *len)
 190 {
 191     int i;
 192     int init = 0;
 193
 194     for (i = 0 ; i < sizeof(mask) * 4 ; i++)
 195     {
 196         if(mask & (1 << i))
 197         {
 198             if (init)
 199                 REPLY(" ");
 200             else
 201                 init = 1;
 202
 203             switch (1 << i)
 204             {
 205                 case ShiftMask: REPLY("ShiftMask"); break;
 206                 case LockMask: REPLY("LockMask"); break;
 207                 case ControlMask: REPLY("ControlMask"); break;
 208                 case Mod1Mask: REPLY("Mod1Mask"); break;
 209                 case Mod2Mask: REPLY("Mod2Mask"); break;
 210                 case Mod3Mask: REPLY("Mod3Mask"); break;
 211                 case Mod4Mask: REPLY("Mod4Mask"); break;
 212                 case Mod5Mask: REPLY("Mod5Mask"); break;
 213                 case Button1Mask: REPLY("Button1Mask"); break;
 214                 case Button2Mask: REPLY("Button2Mask"); break;
 215                 case Button3Mask: REPLY("Button3Mask"); break;
 216                 case Button4Mask: REPLY("Button4Mask"); break;
 217                 case Button5Mask: REPLY("Button5Mask"); break;
 218                 case AnyModifier: REPLY("AnyModifier"); break;
 219             }
 220         }
 221     }
 222
 223     return reply;
 224 }
 225
 226 static char*
 227 _getEventMask (CARD32 mask, char *reply, int *len)
 228 {
 229     int i;
 230     int init = 0;
 231
 232     for (i = 0 ; i < sizeof(mask) * 4 ; i++)
 233     {
 234         if(mask & (1 << i))
 235         {
 236             if (init)
 237                 REPLY(" ");
 238             else
 239                 init = 1;
 240
 241             switch (1 << i)
 242             {
 243                 case NoEventMask: REPLY("NoEventMask"); break;
 244                 case KeyPressMask: REPLY("KeyPressMask"); break;
 245                 case KeyReleaseMask: REPLY("KeyReleaseMask"); break;
 246                 case ButtonPressMask: REPLY("ButtonPressMask"); break;
 247                 case ButtonReleaseMask: REPLY("ButtonReleaseMask"); break;
 248                 case EnterWindowMask: REPLY("EnterWindowMask"); break;
 249                 case LeaveWindowMask: REPLY("LeaveWindowMask"); break;
 250                 case PointerMotionMask: REPLY("PointerMotionMask"); break;
 251                 case PointerMotionHintMask: REPLY("PointerMotionHintMask"); break;
 252                 case Button1MotionMask: REPLY("Button1MotionMask"); break;
 253                 case Button2MotionMask: REPLY("Button2MotionMask"); break;
 254                 case Button3MotionMask: REPLY("Button3MotionMask"); break;
 255                 case Button4MotionMask: REPLY("Button4MotionMask"); break;
 256                 case Button5MotionMask: REPLY("Button5MotionMask"); break;
 257                 case ButtonMotionMask: REPLY("ButtonMotionMask"); break;
 258                 case KeymapStateMask: REPLY("KeymapStateMask"); break;
 259                 case ExposureMask: REPLY("ExposureMask"); break;
 260                 case VisibilityChangeMask: REPLY("VisibilityChangeMask"); break;
 261                 case StructureNotifyMask: REPLY("StructureNotifyMask"); break;
 262                 case ResizeRedirectMask: REPLY("ResizeRedirectMask"); break;
 263                 case SubstructureNotifyMask: REPLY("SubstructureNotifyMask"); break;
 264                 case SubstructureRedirectMask: REPLY("SubstructureRedirectMask"); break;
 265                 case FocusChangeMask: REPLY("FocusChangeMask"); break;
 266                 case PropertyChangeMask: REPLY("PropertyChangeMask"); break;
 267                 case ColormapChangeMask: REPLY("ColormapChangeMask"); break;
 268                 case OwnerGrabButtonMask: REPLY("OwnerGrabButtonMask"); break;
 269             }
 270         }
 271     }
 272
 273     return reply;
 274 }
 275
 276 char * xDbgEvlogRequestCore (EvlogInfo *evinfo, int detail_level, char *reply, int *len)
 277 {
 278     xReq *req = evinfo->req.ptr;
 279
 280     switch (req->reqType)
 281     {
 282     case X_CreateWindow:
 283         {
 284             xCreateWindowReq *stuff = (xCreateWindowReq *)req;
 285
 286             REPLY (": Window(0x%lx) Parent(0x%lx) size(%dx%d) boaderWid(%d) coordinate(%d,%d)",
 287                 stuff->wid,
 288                 stuff->parent,
 289                 stuff->width,
 290                 stuff->height,
 291                 stuff->borderWidth,
 292                 stuff->x,
 293                 stuff->y);
 294
 295             if (detail_level >= EVLOG_PRINT_DETAIL)
 296             {
 297                 const char *visual, *class;
 298                 char dvisual[10], dclass[10];
 299
 300                 switch (stuff->visual)
 301                 {
 302                     case CopyFromParent:  visual = "CopyFromParent"; break;
 303                     default:  visual = dvisual; snprintf (dvisual, 10, "0x%lx", stuff->visual); break;
 304                 }
 305
 306                 switch (stuff->class)
 307                 {
 308                     case CopyFromParent:  class = "CopyFromParent"; break;
 309                     case InputOutput:  class = "InputOutput"; break;
 310                     case InputOnly:  class = "InputOnly"; break;
 311                     default:  class = dclass; snprintf (dclass, 10, "0x%x", stuff->class); break;
 312                 }
 313
 314                 REPLY ("\n");
 315                 REPLY ("%67s depth(%d) visual_ID(%s) class(%s)\n",
 316                     " ",
 317                     stuff->depth,
 318                     visual,
 319                     class);
 320
 321     \r           REPLY ("%67s mask", " ");
 322     \r           REPLY ("(");
 323                 reply = _getWindowAttributeMask(stuff->mask, reply, len);
 324     \r           REPLY (")");
 325             }
 326
 327             return reply;
 328         }
 329
 330     case X_ChangeWindowAttributes:
 331         {
 332             xChangeWindowAttributesReq *stuff = (xChangeWindowAttributesReq *)req;
 333             REPLY (": XID(0x%lx)",
 334                 stuff->window);
 335
 336             if (detail_level >= EVLOG_PRINT_DETAIL)
 337             {
 338     \r           REPLY (" value_mask");
 339     \r           REPLY ("(");
 340                 reply = _getWindowAttributeMask(stuff->valueMask, reply, len);
 341     \r           REPLY (")");
 342             }
 343
 344             return reply;
 345         }
 346
 347     case X_ChangeSaveSet:
 348         {
 349             xChangeSaveSetReq *stuff = (xChangeSaveSetReq *)req;
 350
 351             REPLY (": XID(0x%lx)",
 352                 stuff->window);
 353
 354             if (detail_level >= EVLOG_PRINT_DETAIL)
 355             {
 356                 const char *mode;
 357                 char dmode[10];
 358
 359                 switch (stuff->mode)
 360                 {
 361                     case SetModeInsert:  mode = "SetModeInsert"; break;
 362                     case SetModeDelete:  mode = "SetModeDelete"; break;
 363                     default:  mode = dmode; snprintf (dmode, 10, "%d", stuff->mode); break;
 364                 }
 365
 366                 REPLY (" mode(%s)",
 367                     mode);
 368             }
 369
 370             return reply;
 371         }
 372
 373     case X_ReparentWindow:
 374         {
 375             xReparentWindowReq *stuff = (xReparentWindowReq *)req;
 376             REPLY (": Window(0x%lx) Parent(0x%lx) coord(%d,%d)",
 377                 stuff->window,
 378                 stuff->parent,
 379                 stuff->x,
 380                 stuff->y);
 381
 382             return reply;
 383         }
 384
 385     case X_ConfigureWindow:
 386         {
 387             xConfigureWindowReq *stuff = (xConfigureWindowReq *)req;
 388             REPLY (": XID(0x%lx)",
 389                 stuff->window);
 390
 391             if (detail_level >= EVLOG_PRINT_DETAIL)
 392             {
 393                 REPLY (" mask");
 394                 REPLY ("(");
 395                 reply = _getConfigureWindowMask(stuff->mask, reply, len, (XID *)&stuff[1]);
 396                 REPLY (")");
 397             }
 398
 399             return reply;
 400         }
 401
 402     case X_CirculateWindow:
 403         {
 404             xCirculateWindowReq *stuff = (xCirculateWindowReq *)req;
 405
 406             REPLY (": XID(0x%lx)",
 407                 stuff->window);
 408
 409             if (detail_level >= EVLOG_PRINT_DETAIL)
 410             {
 411                 const char *direction;
 412                 char ddirection[10];
 413
 414                 switch (stuff->direction)
 415                 {
 416                     case RaiseLowest:  direction = "RaiseLowest"; break;
 417                     case LowerHighest:  direction = "LowerHighest"; break;
 418                     default:  direction = ddirection; snprintf (ddirection, 10, "%d", stuff->direction); break;
 419                 }
 420
 421                 REPLY (" direction(%s)",
 422                     direction);
 423             }
 424
 425             return reply;
 426         }
 427
 428     case X_ChangeProperty:
 429         {
 430             xChangePropertyReq *stuff = (xChangePropertyReq *)req;
 431
 432             REPLY (": XID(0x%lx)",
 433                 stuff->window);
 434
 435             REPLY (" Property");
 436             reply = xDbgGetAtom(stuff->property, evinfo, reply, len);
 437
 438             REPLY (" Type");
 439             reply = xDbgGetAtom(stuff->type, evinfo, reply, len);
 440
 441             if (detail_level >= EVLOG_PRINT_DETAIL)
 442             {
 443                 const char *mode;
 444                 char dmode[10];
 445
 446                 switch (stuff->mode)
 447                 {
 448                     case PropModeReplace:  mode = "PropModeReplace"; break;
 449                     case PropModePrepend:  mode = "PropModePrepend"; break;
 450                     case PropModeAppend:  mode = "PropModeAppend"; break;
 451                     default:  mode = dmode; snprintf (dmode, 10, "%d", stuff->mode); break;
 452                 }
 453
 454                 REPLY ("\n");
 455                 REPLY ("%67s mode(%s) format(%d) nUnits(%ld)",
 456                     " ",
 457                     mode,
 458                     stuff->format,
 459                     stuff->nUnits);
 460             }
 461
 462             return reply;
 463         }
 464
 465     case X_DeleteProperty:
 466         {
 467             xDeletePropertyReq *stuff = (xDeletePropertyReq *)req;
 468             REPLY (": XID(0x%lx)",
 469                 stuff->window);
 470
 471             REPLY (" Property");
 472             reply = xDbgGetAtom(stuff->property, evinfo, reply, len);
 473
 474             return reply;
 475         }
 476
 477     case X_GetProperty:
 478         {
 479             xGetPropertyReq *stuff = (xGetPropertyReq *)req;
 480
 481             REPLY (": XID(0x%lx)",
 482                 stuff->window);
 483
 484             REPLY (" Property");
 485             reply = xDbgGetAtom(stuff->property, evinfo, reply, len);
 486             REPLY (" Type");
 487             reply = xDbgGetAtom(stuff->type, evinfo, reply, len);
 488
 489             if (detail_level >= EVLOG_PRINT_DETAIL)
 490             {
 491                 REPLY ("\n");
 492                 REPLY ("%67s delete(%s) longOffset(%ld) longLength(%ld)",
 493                     " ",
 494                     stuff->delete ? "YES" : "NO",
 495                     stuff->longOffset,
 496                     stuff->longLength);
 497             }
 498
 499             return reply;
 500         }
 501
 502     case X_SetSelectionOwner:
 503         {
 504             xSetSelectionOwnerReq *stuff = (xSetSelectionOwnerReq *)req;
 505             REPLY (": XID(0x%lx)",
 506                 stuff->window);
 507
 508             REPLY (" Selection");
 509             reply = xDbgGetAtom(stuff->selection, evinfo, reply, len);
 510
 511             if (detail_level >= EVLOG_PRINT_DETAIL)
 512             {
 513                 REPLY (" time(%lums)",
 514                     stuff->time);
 515             }
 516
 517             return reply;
 518         }
 519
 520     case X_ConvertSelection:
 521         {
 522             xConvertSelectionReq *stuff = (xConvertSelectionReq *)req;
 523             REPLY (": XID(0x%lx)",
 524                 stuff->requestor);
 525
 526             REPLY (" Selection");
 527             reply = xDbgGetAtom(stuff->selection, evinfo, reply, len);
 528             REPLY (" Target");
 529             reply = xDbgGetAtom(stuff->target, evinfo, reply, len);
 530             REPLY (" Property");
 531             reply = xDbgGetAtom(stuff->property, evinfo, reply, len);
 532
 533             if (detail_level >= EVLOG_PRINT_DETAIL)
 534             {
 535                 REPLY (" time(%lums)",
 536                     stuff->time);
 537             }
 538
 539             return reply;
 540         }
 541
 542     case X_SendEvent:
 543         {
 544             xSendEventReq *stuff = (xSendEventReq *)req;
 545             REPLY (": XID(0x%lx)",
 546                 stuff->destination);
 547
 548             if (detail_level >= EVLOG_PRINT_DETAIL)
 549             {
 550                 REPLY (" propagate(%s)",
 551                     stuff->propagate ? "YES" : "NO");
 552
 553                 REPLY (" event_mask");
 554                 REPLY ("(");
 555                 reply = _getEventMask(stuff->eventMask, reply, len);
 556                 REPLY (")");
 557             }
 558
 559             return reply;
 560         }
 561
 562     case X_GrabPointer:
 563         {
 564             xGrabPointerReq *stuff = (xGrabPointerReq *)req;
 565
 566             REPLY (": XID(0x%lx) ConfineTo(0x%lx) Cursor(0x%lx)",
 567                 stuff->grabWindow,
 568                 stuff->confineTo,
 569                 stuff->cursor);
 570
 571             if (detail_level >= EVLOG_PRINT_DETAIL)
 572             {
 573                 const char *pointer_mode, *keyboard_mode;
 574                 char dpointer_mode[10], dkeyboard_mode[10];
 575
 576                 switch (stuff->pointerMode)
 577                 {
 578                     case GrabModeSync:  pointer_mode = "GrabModeSync"; break;
 579                     case GrabModeAsync:  pointer_mode = "GrabModeAsync"; break;
 580                     default:  pointer_mode = dpointer_mode; snprintf (dpointer_mode, 10, "%d", stuff->pointerMode); break;
 581                 }
 582
 583                 switch (stuff->keyboardMode)
 584                 {
 585                     case GrabModeSync:  keyboard_mode = "GrabModeSync"; break;
 586                     case GrabModeAsync:  keyboard_mode = "GrabModeAsync"; break;
 587                     default:  keyboard_mode = dkeyboard_mode; snprintf (dkeyboard_mode, 10, "%d", stuff->keyboardMode); break;
 588                 }
 589
 590                 REPLY (" pointer_mode(%s) keyboard_mode(%s) time(%lums)\n",
 591                     pointer_mode,
 592                     keyboard_mode,
 593                     stuff->time);
 594
 595                 REPLY (" event_mask");
 596                 REPLY ("(");
 597                 reply = _getEventMask(stuff->eventMask, reply, len);
 598                 REPLY (")");
 599             }
 600
 601             return reply;
 602         }
 603
 604     case X_GrabButton:
 605         {
 606             xGrabButtonReq *stuff = (xGrabButtonReq *)req;
 607
 608             REPLY (": XID(0x%lx) ConfineTo(0x%lx) Cursor(0x%lx)",
 609                 stuff->grabWindow,
 610                 stuff->confineTo,
 611                 stuff->cursor);
 612
 613             if (detail_level >= EVLOG_PRINT_DETAIL)
 614             {
 615                 const char *pointer_mode, *keyboard_mode, *button;
 616                 char dpointer_mode[10], dkeyboard_mode[10], dbutton[10];
 617
 618                 switch (stuff->pointerMode)
 619                 {
 620                     case GrabModeSync:  pointer_mode = "GrabModeSync"; break;
 621                     case GrabModeAsync:  pointer_mode = "GrabModeAsync"; break;
 622                     default:  pointer_mode = dpointer_mode; snprintf (dpointer_mode, 10, "%d", stuff->pointerMode); break;
 623                 }
 624
 625                 switch (stuff->keyboardMode)
 626                 {
 627                     case GrabModeSync:  keyboard_mode = "GrabModeSync"; break;
 628                     case GrabModeAsync:  keyboard_mode = "GrabModeAsync"; break;
 629                     default:  keyboard_mode = dkeyboard_mode; snprintf (dkeyboard_mode, 10, "%d", stuff->keyboardMode); break;
 630                 }
 631
 632                 switch (stuff->button)
 633                 {
 634                     case Button1:  button = "Button1"; break;
 635                     case Button2:  button = "Button2"; break;
 636                     case Button3:  button = "Button3"; break;
 637                     case Button4:  button = "Button4"; break;
 638                     case Button5:  button = "Button5"; break;
 639                     default:  button = dbutton; snprintf (dbutton, 10, "%d", stuff->button); break;
 640                 }
 641
 642                 REPLY ("\n");
 643                 REPLY ("%67s event_mask(0x%x) pointer_mode(%s) keyboard_mode(%s) button(%s)",
 644                     " ",
 645                     stuff->eventMask,
 646                     pointer_mode,
 647                     keyboard_mode,
 648                     button);
 649
 650                 REPLY (" modifiers");
 651                 REPLY ("(");
 652                 reply = _getKeyMask(stuff->modifiers, reply, len);
 653                 REPLY (")");
 654             }
 655
 656             return reply;
 657         }
 658
 659     case X_UngrabButton:
 660         {
 661             xUngrabButtonReq *stuff = (xUngrabButtonReq *)req;
 662             REPLY (": XID(0x%lx)",
 663                 stuff->grabWindow);
 664
 665             if (detail_level >= EVLOG_PRINT_DETAIL)
 666             {
 667                 REPLY (" modifiers");
 668                 REPLY ("(");
 669                 reply = _getKeyMask(stuff->modifiers, reply, len);
 670                 REPLY (")");
 671             }
 672
 673             return reply;
 674         }
 675
 676     case X_ChangeActivePointerGrab:
 677         {
 678             xChangeActivePointerGrabReq *stuff = (xChangeActivePointerGrabReq *)req;
 679             REPLY (": Cursor(0x%lx)",
 680                 stuff->cursor);
 681
 682             if (detail_level >= EVLOG_PRINT_DETAIL)
 683             {
 684                 REPLY (" time(%lums)",
 685                     stuff->time);
 686
 687                 REPLY (" event_mask");
 688                 REPLY ("(");
 689                 reply = _getEventMask(stuff->eventMask, reply, len);
 690                 REPLY (")");
 691             }
 692
 693             return reply;
 694         }
 695
 696     case X_GrabKeyboard:
 697         {
 698             xGrabKeyboardReq *stuff = (xGrabKeyboardReq *)req;
 699
 700             REPLY (": XID(0x%lx)",
 701                 stuff->grabWindow);
 702
 703             if (detail_level >= EVLOG_PRINT_DETAIL)
 704             {
 705                 const char *pointer_mode, *keyboard_mode;
 706                 char dpointer_mode[10], dkeyboard_mode[10];
 707
 708                 switch (stuff->pointerMode)
 709                 {
 710                     case GrabModeSync:  pointer_mode = "GrabModeSync"; break;
 711                     case GrabModeAsync:  pointer_mode = "GrabModeAsync"; break;
 712                     default:  pointer_mode = dpointer_mode; snprintf (dpointer_mode, 10, "%d", stuff->pointerMode); break;
 713                 }
 714
 715                 switch (stuff->keyboardMode)
 716                 {
 717                     case GrabModeSync:  keyboard_mode = "GrabModeSync"; break;
 718                     case GrabModeAsync:  keyboard_mode = "GrabModeAsync"; break;
 719                     default:  keyboard_mode = dkeyboard_mode; snprintf (dkeyboard_mode, 10, "%d", stuff->keyboardMode); break;
 720                 }
 721
 722                 REPLY (" owner_events(%s) pointer_mode(%s) keyboard_mode(%s)",
 723                     stuff->ownerEvents ? "YES" : "NO",
 724                     pointer_mode,
 725                     keyboard_mode);
 726             }
 727
 728             return reply;
 729         }
 730
 731     case X_GrabKey:
 732         {
 733             xGrabKeyReq *stuff = (xGrabKeyReq *)req;
 734
 735             REPLY (": XID(0x%lx)",
 736                 stuff->grabWindow);
 737
 738             if (detail_level >= EVLOG_PRINT_DETAIL)
 739             {
 740                 const char *pointer_mode, *keyboard_mode;
 741                 char dpointer_mode[10], dkeyboard_mode[10];
 742
 743                 switch (stuff->pointerMode)
 744                 {
 745                     case GrabModeSync:  pointer_mode = "GrabModeSync"; break;
 746                     case GrabModeAsync:  pointer_mode = "GrabModeAsync"; break;
 747                     default:  pointer_mode = dpointer_mode; snprintf (dpointer_mode, 10, "%d", stuff->pointerMode); break;
 748                 }
 749
 750                 switch (stuff->keyboardMode)
 751                 {
 752                     case GrabModeSync:  keyboard_mode = "GrabModeSync"; break;
 753                     case GrabModeAsync:  keyboard_mode = "GrabModeAsync"; break;
 754                     default:  keyboard_mode = dkeyboard_mode; snprintf (dkeyboard_mode, 10, "%d", stuff->keyboardMode); break;
 755                 }
 756
 757                 REPLY (" key(%d) pointer_mode(%s) keyboard_mode(%s)\n",
 758                     stuff->key,
 759                     pointer_mode,
 760                     keyboard_mode);
 761
 762                 REPLY (" modifiers");
 763                 REPLY ("(");
 764                 reply = _getKeyMask(stuff->modifiers, reply, len);
 765                 REPLY (")");
 766             }
 767
 768             return reply;
 769         }
 770
 771     case X_UngrabKey:
 772         {
 773             xUngrabKeyReq *stuff = (xUngrabKeyReq *)req;
 774             REPLY (": XID(0x%lx)",
 775                 stuff->grabWindow);
 776
 777             if (detail_level >= EVLOG_PRINT_DETAIL)
 778             {
 779                 REPLY (" key(%d)",
 780                     stuff->key);
 781
 782                 REPLY (" modifiers");
 783                 REPLY ("(");
 784                 reply = _getKeyMask(stuff->modifiers, reply, len);
 785                 REPLY (")");
 786             }
 787
 788             return reply;
 789         }
 790
 791     case X_SetInputFocus:
 792         {
 793             xSetInputFocusReq *stuff = (xSetInputFocusReq *)req;
 794             REPLY (": XID(0x%lx)",
 795                 stuff->focus);
 796
 797             if (detail_level >= EVLOG_PRINT_DETAIL)
 798             {
 799                 REPLY (" reverTo(%d) time(%lums)",
 800                     stuff->revertTo,
 801                     stuff->time);
 802             }
 803
 804             return reply;
 805         }
 806
 807     case X_CreatePixmap:
 808         {
 809             xCreatePixmapReq *stuff = (xCreatePixmapReq *)req;
 810             REPLY (": Pixmap(0x%lx) Drawable(0x%lx) size(%dx%d)",
 811                 stuff->pid,
 812                 stuff->drawable,
 813                 stuff->width,
 814                 stuff->height);
 815
 816             if (detail_level >= EVLOG_PRINT_DETAIL)
 817             {
 818                 REPLY (" depth(%d)",
 819                     stuff->depth);
 820             }
 821
 822             return reply;
 823         }
 824
 825     case X_ClearArea:
 826         {
 827             xClearAreaReq *stuff = (xClearAreaReq *)req;
 828             REPLY (": XID(0x%lx) area(%d,%d %dx%d)",
 829                 stuff->window,
 830                 stuff->x,
 831                 stuff->y,
 832                 stuff->width,
 833                 stuff->height);
 834
 835             if (detail_level >= EVLOG_PRINT_DETAIL)
 836             {
 837                 REPLY (" exposures(%s)",
 838                     stuff->exposures ? "YES" : "NO");
 839             }
 840
 841         \r   return reply;
 842         }
 843
 844     case X_CopyArea:
 845         {
 846             xCopyAreaReq *stuff = (xCopyAreaReq *)req;
 847             REPLY (": srcXID(0x%lx) dstXID(0x%lx) gc(0x%lx) size(%dx%d) src(%d,%d) dst(%d,%d)",
 848                 stuff->srcDrawable,
 849                 stuff->dstDrawable,
 850                 stuff->gc,
 851                 stuff->width,
 852                 stuff->height,
 853                 stuff->srcX,
 854                 stuff->srcY,
 855                 stuff->dstX,
 856                 stuff->dstY);
 857
 858             return reply;
 859         }
 860
 861     case X_CopyPlane:
 862         {
 863             xCopyPlaneReq *stuff = (xCopyPlaneReq *)req;
 864             REPLY (": srcXID(0x%lx) dstXID(0x%lx) gc(0x%lx) size(%dx%d) src(%d,%d) dst(%d,%d)",
 865                 stuff->srcDrawable,
 866                 stuff->dstDrawable,
 867                 stuff->gc,
 868                 stuff->width,
 869                 stuff->height,
 870                 stuff->srcX,
 871                 stuff->srcY,
 872                 stuff->dstX,
 873                 stuff->dstY);
 874
 875             if (detail_level >= EVLOG_PRINT_DETAIL)
 876             {
 877                 REPLY (" bit_plane(0x%lx)",
 878                     stuff->bitPlane);
 879             }
 880
 881             return reply;
 882         }
 883
 884     case X_PolyPoint:
 885         {
 886             xPolyPointReq *stuff = (xPolyPointReq *)req;
 887             REPLY (": XID(0x%lx) gc(0x%lx)",
 888                 stuff->drawable,
 889                 stuff->gc);
 890
 891             if (detail_level >= EVLOG_PRINT_DETAIL)
 892             {
 893                 const char *coord_mode;
 894                 char dcoord_mode[10];
 895
 896                 switch (stuff->coordMode)
 897                 {
 898                     case CoordModeOrigin:  coord_mode = "CoordModeOrigin"; break;
 899                     case CoordModePrevious:  coord_mode = "CoordModePrevious"; break;
 900                     default:  coord_mode = dcoord_mode; snprintf (dcoord_mode, 10, "%d", stuff->coordMode); break;
 901                 }
 902
 903                 REPLY (" coord_mode(%s)",
 904                     coord_mode);
 905             }
 906
 907             return reply;
 908         }
 909
 910     case X_PolyLine:
 911         {
 912             xPolyLineReq *stuff = (xPolyLineReq *)req;
 913             REPLY (": XID(0x%lx gc(0x%lx)",
 914                 stuff->drawable,
 915                 stuff->gc);
 916
 917             if (detail_level >= EVLOG_PRINT_DETAIL)
 918             {
 919                 const char *coord_mode;
 920                 char dcoord_mode[10];
 921
 922                 switch (stuff->coordMode)
 923                 {
 924                     case CoordModeOrigin:  coord_mode = "CoordModeOrigin"; break;
 925                     case CoordModePrevious:  coord_mode = "CoordModePrevious"; break;
 926                     default:  coord_mode = dcoord_mode; snprintf (dcoord_mode, 10, "%d", stuff->coordMode); break;
 927                 }
 928
 929                 REPLY (" coord_mode(%s)",
 930                     coord_mode);
 931             }
 932
 933             return reply;
 934         }
 935
 936     case X_PolySegment:
 937         {
 938             xPolySegmentReq *stuff = (xPolySegmentReq *)req;
 939             REPLY (": XID(0x%lx) gc(0x%lx)",
 940                 stuff->drawable,
 941                 stuff->gc);
 942
 943             return reply;
 944         }
 945
 946     case X_PolyRectangle:
 947         {
 948             xPolyRectangleReq *stuff = (xPolyRectangleReq *)req;
 949             REPLY (": XID(0x%lx) gc(0x%lx)",
 950                 stuff->drawable,
 951                 stuff->gc);
 952
 953             return reply;
 954         }
 955
 956     case X_PolyArc:
 957         {
 958             xPolyArcReq *stuff = (xPolyArcReq *)req;
 959             REPLY (": XID(0x%lx) gc(0x%lx)",
 960                 stuff->drawable,
 961                 stuff->gc);
 962
 963             return reply;
 964         }
 965
 966     case X_FillPoly:
 967         {
 968             xFillPolyReq *stuff = (xFillPolyReq *)req;
 969             REPLY (": XID(0x%lx) gc(0x%lx)",
 970                 stuff->drawable,
 971                 stuff->gc);
 972
 973             if (detail_level >= EVLOG_PRINT_DETAIL)
 974             {
 975                 const char *shape, *coord_mode;
 976                 char dshape[10], dcoord_mode[10];
 977
 978                 switch (stuff->shape)
 979                 {
 980                     case Complex:  shape = "Complex"; break;
 981                     case Nonconvex:  shape = "Nonconvex"; break;
 982                     case Convex:  shape = "Convex"; break;
 983                     default:  shape = dshape; snprintf (dshape, 10, "%d", stuff->shape); break;
 984                 }
 985
 986                 switch (stuff->coordMode)
 987                 {
 988                     case CoordModeOrigin:  coord_mode = "CoordModeOrigin"; break;
 989                     case CoordModePrevious:  coord_mode = "CoordModePrevious"; break;
 990                     default:  coord_mode = dcoord_mode; snprintf (dcoord_mode, 10, "%d", stuff->coordMode); break;
 991                 }
 992
 993                 REPLY (" shape(%s) coord_mode(%s)",
 994                     shape,
 995                     coord_mode);
 996             }
 997
 998             return reply;
 999         }
1000
1001     case X_PolyFillRectangle:
1002         {
1003             xPolyFillRectangleReq *stuff = (xPolyFillRectangleReq *)req;
1004             REPLY (": XID(0x%lx) gc(0x%lx)",
1005                 stuff->drawable,
1006                 stuff->gc);
1007
1008             return reply;
1009         }
1010
1011     case X_PolyFillArc:
1012         {
1013             xPolyFillArcReq *stuff = (xPolyFillArcReq *)req;
1014             REPLY (": XID(0x%lx) gc(0x%lx)",
1015                 stuff->drawable,
1016                 stuff->gc);
1017
1018             return reply;
1019         }
1020
1021     case X_PutImage:
1022         {
1023             xPutImageReq *stuff = (xPutImageReq *)req;
1024             REPLY (": XID(0x%lx) gc(0x%lx) size(%dx%d) dst(%d,%d)",
1025                 stuff->drawable,
1026                 stuff->gc,
1027                 stuff->width,
1028                 stuff->height,
1029                 stuff->dstX,
1030                 stuff->dstY);
1031
1032             if (detail_level >= EVLOG_PRINT_DETAIL)
1033             {
1034                 const char *format;
1035                 char dformat[10];
1036
1037                 switch (stuff->format)
1038                 {
1039                     case XYBitmap:  format = "XYBitmap"; break;
1040                     case XYPixmap:  format = "XYPixmap"; break;
1041                     case ZPixmap:  format = "ZPixmap"; break;
1042                     default:  format = dformat; snprintf (dformat, 10, "%d", stuff->format); break;
1043                 }
1044
1045                 REPLY (" format(%s) depth(%d)",
1046                     format,
1047                     stuff->depth);
1048             }
1049
1050             return reply;
1051         }
1052
1053     case X_GetImage:
1054         {
1055             xGetImageReq *stuff = (xGetImageReq *)req;
1056             REPLY (": XID(0x%lx) size(%dx%d) dst(%d,%d)",
1057                 stuff->drawable,
1058                 stuff->width,
1059                 stuff->height,
1060                 stuff->x,
1061                 stuff->y);
1062
1063             if (detail_level >= EVLOG_PRINT_DETAIL)
1064             {
1065                 const char *format;
1066                 char dformat[10];
1067
1068                 switch (stuff->format)
1069                 {
1070                     case XYBitmap:  format = "XYBitmap"; break;
1071                     case XYPixmap:  format = "XYPixmap"; break;
1072                     case ZPixmap:  format = "ZPixmap"; break;
1073                     default:  format = dformat; snprintf (dformat, 10, "%d", stuff->format); break;
1074                 }
1075
1076                 REPLY (" format(%s) plane_mask(0x%lx)",
1077                     format,
1078                     stuff->planeMask);
1079             }
1080
1081             return reply;
1082         }
1083
1084     case X_PolyText8:
1085         {
1086             xPolyText8Req *stuff = (xPolyText8Req *)req;
1087             REPLY (": XID(0x%lx) gc(0x%lx) coord(%d,%d)",
1088                 stuff->drawable,
1089                 stuff->gc,
1090                 stuff->x,
1091                 stuff->y);
1092
1093             return reply;
1094         }
1095
1096     case X_PolyText16:
1097         {
1098             xPolyText16Req *stuff = (xPolyText16Req *)req;
1099             REPLY (": XID(0x%lx) gc(0x%lx) coord(%d,%d)",
1100                 stuff->drawable,
1101                 stuff->gc,
1102                 stuff->x,
1103                 stuff->y);
1104
1105             return reply;
1106         }
1107
1108     case X_ImageText8:
1109         {
1110             xImageText8Req *stuff = (xImageText8Req *)req;
1111             REPLY (": XID(0x%lx) gc(0x%lx) coord(%d,%d)",
1112                 stuff->drawable,
1113                 stuff->gc,
1114                 stuff->x,
1115                 stuff->y);
1116
1117             if (detail_level >= EVLOG_PRINT_DETAIL)
1118             {
1119                 REPLY (" nchars(%d)",
1120                     stuff->nChars);
1121             }
1122
1123             return reply;
1124         }
1125
1126     case X_ImageText16:
1127         {
1128             xImageText16Req *stuff = (xImageText16Req *)req;
1129             REPLY (": XID(0x%lx) gc(0x%lx) coord(%d,%d)",
1130                 stuff->drawable,
1131                 stuff->gc,
1132                 stuff->x,
1133                 stuff->y);
1134
1135             if (detail_level >= EVLOG_PRINT_DETAIL)
1136             {
1137                 REPLY (" nchars(%d)",
1138                     stuff->nChars);
1139             }
1140
1141             return reply;
1142         }
1143
1144     case X_ChangeKeyboardMapping:
1145         {
1146             xChangeKeyboardMappingReq *stuff = (xChangeKeyboardMappingReq *)req;
1147             REPLY (": first_key_code(%d) key_syms_per_key_code(%d)",
1148                 stuff->firstKeyCode,
1149                 stuff->keySymsPerKeyCode);
1150
1151             if (detail_level >= EVLOG_PRINT_DETAIL)
1152             {
1153                 REPLY (" key_codes(%d)",
1154                     stuff->keyCodes);
1155             }
1156
1157             return reply;
1158         }
1159
1160     case X_GetKeyboardMapping:
1161         {
1162             xGetKeyboardMappingReq *stuff = (xGetKeyboardMappingReq *)req;
1163             REPLY (": first_key_code(%d)",
1164                 stuff->firstKeyCode);
1165
1166             if (detail_level >= EVLOG_PRINT_DETAIL)
1167             {
1168                 REPLY (" count(%d)",
1169                     stuff->count);
1170             }
1171
1172             return reply;
1173         }
1174
1175     case X_ChangePointerControl:
1176         {
1177             xChangePointerControlReq *stuff = (xChangePointerControlReq *)req;
1178             REPLY (": accelNum(%d) accelDenum(%d) threshold(%d)",
1179                 stuff->accelNum,
1180                 stuff->accelDenum,
1181                 stuff->threshold);
1182
1183             if (detail_level >= EVLOG_PRINT_DETAIL)
1184             {
1185                 REPLY (" do_accel(%s) do_thresh(%s)",
1186                     stuff->doAccel ? "YES" : "NO",
1187                     stuff->doThresh ? "YES" : "NO");
1188             }
1189
1190             return reply;
1191         }
1192
1193     case X_SetPointerMapping:
1194         {
1195             xSetPointerMappingReq *stuff = (xSetPointerMappingReq *)req;
1196
1197             if (detail_level >= EVLOG_PRINT_DETAIL)
1198             {
1199                 REPLY (": Elts(%d)",
1200                     stuff->nElts);
1201             }
1202
1203             return reply;
1204         }
1205
1206     case X_SetModifierMapping:
1207         {
1208             xSetModifierMappingReq *stuff =(xSetModifierMappingReq *)req;
1209             REPLY (": num_key_per_modifier(%d)",
1210                 stuff->numKeyPerModifier);
1211
1212             return reply;
1213         }
1214
1215     case X_ListProperties:
1216     case X_DestroyWindow:
1217     case X_DestroySubwindows:
1218     case X_MapWindow:
1219     case X_MapSubwindows:
1220     case X_UnmapWindow:
1221     case X_UnmapSubwindows:
1222     case X_GetGeometry:
1223     case X_QueryTree:
1224     case X_UngrabPointer:
1225     case X_UngrabKeyboard:
1226     case X_FreePixmap:
1227     case X_KillClient:
1228         {
1229             xResourceReq *stuff = (xResourceReq *)req;
1230             REPLY (": XID(0x%lx)",
1231                 stuff->id);
1232
1233             return reply;
1234         }
1235
1236     default:
1237             break;
1238     }
1239
1240     return reply;
1241 }
1242
1243 char * xDbgEvlogEventCore (EvlogInfo *evinfo, int detail_level, char *reply, int *len)
1244 {
1245     xEvent *evt = evinfo->evt.ptr;
1246
1247     switch (evt->u.u.type & 0x7F)
1248     {
1249     case KeyPress:
1250     case KeyRelease:
1251     case ButtonPress:
1252     case ButtonRelease:
1253     case MotionNotify:
1254         {
1255             REPLY (": Root(0x%lx %d,%d) Event(0x%lx %d,%d) Child(0x%lx)",
1256                 evt->u.keyButtonPointer.root,
1257                 evt->u.keyButtonPointer.rootX,
1258                 evt->u.keyButtonPointer.rootY,
1259                 evt->u.keyButtonPointer.event,
1260                 evt->u.keyButtonPointer.eventX,
1261                 evt->u.keyButtonPointer.eventY,
1262                 evt->u.keyButtonPointer.child);
1263
1264             if (detail_level >= EVLOG_PRINT_DETAIL)
1265             {
1266                 REPLY ("\n");
1267                 REPLY ("%67s state(0x%x) same_screen(%s)",
1268                     " ",
1269                     evt->u.keyButtonPointer.state,
1270                     evt->u.keyButtonPointer.sameScreen ? "YES" : "NO");
1271             }
1272
1273             return reply;
1274         }
1275
1276     case EnterNotify:
1277     case LeaveNotify:
1278         {
1279             REPLY (": Root(0x%lx %d,%d) Event(0x%lx %d,%d) Child(0x%lx)",
1280                 evt->u.enterLeave.root,
1281                 evt->u.enterLeave.rootX,
1282                 evt->u.enterLeave.rootY,
1283                 evt->u.enterLeave.event,
1284                 evt->u.enterLeave.eventX,
1285                 evt->u.enterLeave.eventY,
1286                 evt->u.enterLeave.child);
1287
1288             if (detail_level >= EVLOG_PRINT_DETAIL)
1289             {
1290                 REPLY ("\n");
1291                 REPLY ("%67s time(%lums) state(0x%x) same_screen(%s) focus(%s)",
1292                     " ",
1293                     evt->u.enterLeave.time,
1294                     evt->u.enterLeave.state,
1295                     evt->u.enterLeave.flags & ELFlagSameScreen ? "YES" : "NO",
1296                     evt->u.enterLeave.flags & ELFlagFocus ? "YES" : "NO");
1297             }
1298
1299             return reply;
1300         }
1301
1302     case FocusIn:
1303     case FocusOut:
1304     case KeymapNotify:
1305         {
1306             REPLY (": XID(0x%lx)",
1307                 evt->u.focus.window);
1308
1309             if (detail_level >= EVLOG_PRINT_DETAIL)
1310             {
1311                 const char* mode;
1312                 char dmode[10];
1313
1314                 switch (evt->u.focus.mode)
1315                 {
1316                     case NotifyNormal:  mode = "NotifyNormal"; break;
1317                     case NotifyGrab:  mode = "NotifyGrab"; break;
1318                     case NotifyUngrab:  mode = "NotifyUngrab"; break;
1319                     case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
1320                     default:  mode = dmode, snprintf (dmode, 10, "%u", evt->u.focus.mode); break;
1321                 }
1322
1323                 REPLY (" mode(%s)",
1324                     mode);
1325             }
1326
1327             return reply;
1328         }
1329
1330     case Expose:
1331         {
1332             REPLY (": XID(0x%lx) size(%dx%d) coord(%d,%d)",
1333                 evt->u.expose.window,
1334                 evt->u.expose.width,
1335                 evt->u.expose.height,
1336                 evt->u.expose.x,
1337                 evt->u.expose.y);
1338
1339             if (detail_level >= EVLOG_PRINT_DETAIL)
1340             {
1341                 REPLY (" count(%d)",
1342                     evt->u.expose.count);
1343             }
1344
1345             return reply;
1346         }
1347
1348     case GraphicsExpose:
1349         {
1350             REPLY (": XID(0x%lx) size(%dx%d) coord(%d,%d)",
1351                 evt->u.graphicsExposure.drawable,
1352                 evt->u.graphicsExposure.width,
1353                 evt->u.graphicsExposure.height,
1354                 evt->u.graphicsExposure.x,
1355                 evt->u.graphicsExposure.y);
1356
1357             if (detail_level >= EVLOG_PRINT_DETAIL)
1358             {
1359                 const char *major;
1360                 char dmajor[10];
1361
1362                 switch (evt->u.graphicsExposure.majorEvent)
1363                 {
1364                     case X_CopyArea:  major = "CopyArea";  break;
1365                     case X_CopyPlane:  major = "CopyPlane";  break;
1366                     default: major = dmajor; snprintf (dmajor, 10, "%d", evt->u.graphicsExposure.majorEvent); break;
1367                 }
1368
1369                 REPLY (" major_event(%s) minor_event(%d) count(%d)",
1370                     major,
1371                     evt->u.graphicsExposure.minorEvent,
1372                     evt->u.graphicsExposure.count);
1373             }
1374
1375             return reply;
1376         }
1377
1378     case NoExpose:
1379         {
1380             REPLY (": XID(0x%lx)",
1381                 evt->u.noExposure.drawable);
1382
1383             if (detail_level >= EVLOG_PRINT_DETAIL)
1384             {
1385                 const char *major;
1386                 char dmajor[10];
1387
1388                 switch (evt->u.noExposure.majorEvent)
1389                 {
1390                     case X_CopyArea:  major = "CopyArea";  break;
1391                     case X_CopyPlane:  major = "CopyPlane";  break;
1392                     default:  major = dmajor; snprintf (dmajor, 10, "%d", evt->u.noExposure.majorEvent); break;
1393                 }
1394
1395                 REPLY (" major_event(%s) minor_event(%d)",
1396                     major,
1397                     evt->u.noExposure.minorEvent);
1398             }
1399
1400             return reply;
1401         }
1402
1403     case VisibilityNotify:
1404         {
1405             REPLY (": XID(0x%lx)",
1406                 evt->u.visibility.window);
1407
1408             if (detail_level >= EVLOG_PRINT_DETAIL)
1409             {
1410                 const char *state;
1411                 char dstate[10];
1412
1413                 switch (evt->u.visibility.state)
1414                 {
1415                     case VisibilityUnobscured:  state = "VisibilityUnobscured"; break;
1416                     case VisibilityPartiallyObscured:  state = "VisibilityPartiallyObscured"; break;
1417                     case VisibilityFullyObscured:  state = "VisibilityFullyObscured"; break;
1418                     default:  state = dstate; snprintf (dstate, 10, "%d", evt->u.visibility.state); break;
1419                 }
1420
1421                 REPLY (" state(%s)",
1422                     state);
1423             }
1424
1425             return reply;
1426         }
1427
1428     case CreateNotify:
1429         {
1430             REPLY (": Window(0x%lx) Parent(0x%lx) size(%dx%d) coord(%d,%d) borderWidth(%d)",
1431                 evt->u.createNotify.window,
1432                 evt->u.createNotify.parent,
1433                 evt->u.createNotify.width,
1434                 evt->u.createNotify.height,
1435                 evt->u.createNotify.x,
1436                 evt->u.createNotify.y,
1437                 evt->u.createNotify.borderWidth);
1438
1439             if (detail_level >= EVLOG_PRINT_DETAIL)
1440             {
1441                 REPLY (" override(%s)",
1442                     evt->u.createNotify.override ? "YES" : "NO");
1443             }
1444
1445             return reply;
1446         }
1447
1448     case DestroyNotify:
1449         {
1450             REPLY (": Window(0x%lx) Event(0x%lx)",
1451                 evt->u.destroyNotify.window,
1452                 evt->u.destroyNotify.event);
1453
1454             return reply;
1455                 }
1456
1457     case UnmapNotify:
1458         {
1459             REPLY (": Window(0x%lx) Event(0x%lx)",
1460                 evt->u.unmapNotify.window,
1461                 evt->u.unmapNotify.event);
1462
1463             if (detail_level >= EVLOG_PRINT_DETAIL)
1464             {
1465                 REPLY (" from_Configure(%s)",
1466                     evt->u.unmapNotify.fromConfigure ? "YES" : "NO");
1467             }
1468
1469             return reply;
1470         }
1471
1472     case MapNotify:
1473         {
1474             REPLY (": Window(0x%lx) Event(0x%lx)",
1475                 evt->u.mapNotify.window,
1476                 evt->u.mapNotify.event);
1477
1478             if (detail_level >= EVLOG_PRINT_DETAIL)
1479             {
1480                 REPLY (" override(%s)",
1481                     evt->u.mapNotify.override ? "YES" : "NO");
1482             }
1483
1484             return reply;
1485         }
1486
1487     case MapRequest:
1488         {
1489             REPLY (": Window(0x%lx) Parent(0x%lx)",
1490                 evt->u.mapRequest.window,
1491                 evt->u.mapRequest.parent);
1492
1493             return reply;
1494         }
1495
1496     case ReparentNotify:
1497         {
1498             REPLY (": Window(0x%lx) Event(0x%lx) Parent(0x%lx) coord(%d,%d)",
1499                 evt->u.reparent.window,
1500                 evt->u.reparent.event,
1501                 evt->u.reparent.parent,
1502                 evt->u.reparent.x,
1503                 evt->u.reparent.y);
1504
1505             if (detail_level >= EVLOG_PRINT_DETAIL)
1506             {
1507                 REPLY (" override(%s)",
1508                     evt->u.reparent.override ? "YES" : "NO");
1509             }
1510
1511             return reply;
1512         }
1513
1514     case ConfigureNotify:
1515         {
1516             REPLY (": Window(0x%lx) Event(0x%lx) AboveSibling(0x%lx) size(%dx%d) coord(%d,%d) borderWidth(%d)",
1517                 evt->u.configureNotify.window,
1518                 evt->u.configureNotify.event,
1519                 evt->u.configureNotify.aboveSibling,
1520                 evt->u.configureNotify.width,
1521                 evt->u.configureNotify.height,
1522                 evt->u.configureNotify.x,
1523                 evt->u.configureNotify.y,
1524                 evt->u.configureNotify.borderWidth);
1525
1526             if (detail_level >= EVLOG_PRINT_DETAIL)
1527             {
1528                 REPLY (" override(%s)",
1529                     evt->u.configureNotify.override ? "YES" : "NO");
1530             }
1531
1532             return reply;
1533         }
1534
1535     case ConfigureRequest:
1536         {
1537             REPLY (": Window(0x%lx) Parent(0x%lx) Sibling(0x%lx) size(%dx%d) coord(%d,%d) borderWidth(%d)",
1538                 evt->u.configureRequest.window,
1539                 evt->u.configureRequest.parent,
1540                 evt->u.configureRequest.sibling,
1541                 evt->u.configureRequest.width,
1542                 evt->u.configureRequest.height,
1543                 evt->u.configureRequest.x,
1544                 evt->u.configureRequest.y,
1545                 evt->u.configureRequest.borderWidth);
1546
1547             if (detail_level >= EVLOG_PRINT_DETAIL)
1548             {
1549                 REPLY ("\n");
1550                 REPLY ("%67s value_mask",
1551                     " ");
1552                 REPLY ("(");
1553                 reply = _getConfigureWindowMask(evt->u.configureRequest.valueMask, reply, len, NULL);
1554                 REPLY (")");
1555             }
1556
1557             return reply;
1558         }
1559
1560     case GravityNotify:
1561         {
1562             REPLY (": Window(0x%lx) Event(0x%lx) coord(%d,%d)",
1563                 evt->u.gravity.window,
1564                 evt->u.gravity.event,
1565                 evt->u.gravity.x,
1566                 evt->u.gravity.y);
1567
1568             return reply;
1569         }
1570
1571     case ResizeRequest:
1572         {
1573             REPLY (": Window(0x%lx) size(%dx%d)",
1574                 evt->u.resizeRequest.window,
1575                 evt->u.resizeRequest.width,
1576                 evt->u.resizeRequest.height);
1577
1578             return reply;
1579         }
1580
1581     case CirculateNotify:
1582     case CirculateRequest:
1583         {
1584             REPLY (": Window(0x%lx) Event(0x%lx) parent(0x%lx)",
1585                 evt->u.circulate.window,
1586                 evt->u.circulate.event,
1587                 evt->u.circulate.parent);
1588
1589             if (detail_level >= EVLOG_PRINT_DETAIL)
1590             {
1591                 const char *place;
1592                 char dplace[10];
1593
1594                 switch (evt->u.circulate.place)
1595                 {
1596                     case PlaceOnTop:  place = "PlaceOnTop"; break;
1597                     case PlaceOnBottom:  place = "PlaceOnBottom"; break;
1598                     default:  place = dplace; snprintf (dplace, 10, "%d", evt->u.circulate.place); break;
1599                 }
1600
1601                 REPLY (" place(%s)",
1602                     place);
1603             }
1604
1605             return reply;
1606         }
1607
1608     case PropertyNotify:
1609         {
1610             REPLY (": Window(0x%lx)",
1611                 evt->u.property.window);
1612
1613             REPLY (" Property");
1614             reply = xDbgGetAtom(evt->u.property.atom, evinfo, reply, len);
1615
1616             if (detail_level >= EVLOG_PRINT_DETAIL)
1617             {
1618                 const char *state;
1619                 char dstate[10];
1620
1621                 switch (evt->u.property.state)
1622                 {
1623                     case PropertyNewValue:  state = "PropertyNewValue"; break;
1624                     case PropertyDelete:  state = "PropertyDelete"; break;
1625                     default:  state = dstate; snprintf (dstate, 10, "%d", evt->u.property.state); break;
1626                 }
1627
1628                 REPLY ("\n");
1629                 REPLY ("%67s time(%lums) state(%s)",
1630                     " ",
1631                     evt->u.property.time,
1632                     state);
1633             }
1634
1635             return reply;
1636         }
1637
1638     case SelectionClear:
1639         {
1640             REPLY (": Window(0x%lx)",
1641                 evt->u.selectionClear.window);
1642
1643             REPLY (" Atom");
1644             reply = xDbgGetAtom(evt->u.selectionClear.atom, evinfo, reply, len);
1645
1646             if (detail_level >= EVLOG_PRINT_DETAIL)
1647             {
1648                 REPLY (" time(%lums)",
1649                     evt->u.selectionClear.time);
1650             }
1651
1652             return reply;
1653                 }
1654
1655     case SelectionRequest:
1656         {
1657             REPLY (": Owner(0x%lx) Requestor(0x%lx)",
1658                 evt->u.selectionRequest.owner,
1659                 evt->u.selectionRequest.requestor);
1660
1661             REPLY (" selection");
1662             reply = xDbgGetAtom(evt->u.selectionRequest.selection, evinfo, reply, len);
1663             REPLY (" Target");
1664             reply = xDbgGetAtom(evt->u.selectionRequest.target, evinfo, reply, len);
1665             REPLY (" Property");
1666             reply = xDbgGetAtom(evt->u.selectionRequest.property, evinfo, reply, len);
1667
1668             if (detail_level >= EVLOG_PRINT_DETAIL)
1669             {
1670                 REPLY (" time(%lums)",
1671                     evt->u.selectionRequest.time);
1672             }
1673
1674             return reply;
1675         }
1676
1677     case SelectionNotify:
1678         {
1679             REPLY (": Requestor(0x%lx)",
1680                 evt->u.selectionNotify.requestor);
1681
1682             REPLY (" selection");
1683             reply = xDbgGetAtom(evt->u.selectionNotify.selection, evinfo, reply, len);
1684             REPLY (" Target");
1685             reply = xDbgGetAtom(evt->u.selectionNotify.target, evinfo, reply, len);
1686             REPLY (" Property");
1687             reply = xDbgGetAtom(evt->u.selectionNotify.property, evinfo, reply, len);
1688
1689             if (detail_level >= EVLOG_PRINT_DETAIL)
1690             {
1691                 REPLY (" time(%lums)",
1692                     evt->u.selectionNotify.time);
1693             }
1694
1695             return reply;
1696         }
1697
1698     case ColormapNotify:
1699         {
1700             REPLY (": XID(0x%lx) Colormap(0x%lx)",
1701                 evt->u.colormap.window,
1702                 evt->u.colormap.colormap);
1703
1704             if (detail_level >= EVLOG_PRINT_DETAIL)
1705             {
1706                 const char *state;
1707                 char dstate[10];
1708
1709                 switch (evt->u.colormap.state)
1710                 {
1711                     case ColormapInstalled:  state = "ColormapInstalled"; break;
1712                     case ColormapUninstalled:  state = "ColormapUninstalled"; break;
1713                     default: state = dstate; snprintf (dstate, 10, "%d", evt->u.colormap.state); break;
1714                 }
1715
1716                 REPLY (" new(%s) state(%s)",
1717                     evt->u.colormap.new ? "YES" : "NO",
1718                     state);
1719             }
1720
1721             return reply;
1722         }
1723
1724     case ClientMessage:
1725         {
1726             REPLY (": XID(0x%lx)",
1727                 evt->u.clientMessage.window);
1728
1729             REPLY (" Type");
1730             reply = xDbgGetAtom(evt->u.clientMessage.u.b.type, evinfo, reply, len);
1731
1732             return reply;
1733                 }
1734
1735     case MappingNotify:
1736     case GenericEvent:
1737     default:
1738             break;
1739     }
1740
1741     return reply;
1742 }
1743
1744 char * xDbgEvlogReplyCore (EvlogInfo *evinfo, int detail_level, char *reply, int *len)
1745 {
1746     xGenericReply *rep = evinfo->rep.ptr;
1747
1748     switch (evinfo->rep.reqType)
1749     {
1750     case X_GetGeometry:
1751         {
1752             if (evinfo->rep.isStart)
1753             {
1754                 xGetGeometryReply *stuff = (xGetGeometryReply *)rep;
1755
1756                 REPLY (": XID(0x%lx) coord(%d,%d %dx%d) borderWidth(%d)",
1757                     stuff->root,
1758                     stuff->x,
1759                     stuff->y,
1760                     stuff->width,
1761                     stuff->height,
1762                     stuff->borderWidth);
1763             }
1764             else
1765             {
1766                 return reply;
1767             }
1768
1769             return reply;
1770         }
1771
1772     case X_QueryTree:
1773         {
1774             if (evinfo->rep.isStart)
1775             {
1776                 xQueryTreeReply *stuff = (xQueryTreeReply *)rep;
1777
1778                 REPLY (": XID(0x%lx) Parent(0x%lx) ChildrenNum(%d)",
1779                     stuff->root,
1780                     stuff->parent,
1781                     stuff->nChildren);
1782             }
1783             else
1784             {
1785                 Window *stuff = (Window *)rep;
1786                 int i;
1787
1788                 REPLY ("childIDs");
1789                 REPLY ("(");
1790                 for (i = 0 ; i < evinfo->rep.size / sizeof(Window) ; i++)
1791                 {
1792                     REPLY("0x%lx", stuff[i]);
1793                     if(i != evinfo->rep.size / sizeof(Window) - 1)
1794                         REPLY (", ");
1795                 }
1796                 REPLY (")");
1797             }
1798
1799             return reply;
1800         }
1801
1802     case X_GetProperty:
1803         {
1804             if (evinfo->rep.isStart)
1805             {
1806                 xGetPropertyReply *stuff = (xGetPropertyReply *)rep;
1807
1808                 REPLY (": PropertyType");
1809                 reply = xDbgGetAtom(stuff->propertyType, evinfo, reply, len);
1810
1811                 REPLY (" bytesAfter(0x%lx) format(%d) ItemNum(%ld)",
1812                     stuff->bytesAfter,
1813                     stuff->format,
1814                     stuff->nItems);
1815             }
1816             else
1817             {
1818                 return reply;
1819             }
1820
1821             return reply;
1822         }
1823
1824     case X_ListProperties:
1825         {
1826             if (evinfo->rep.isStart)
1827             {
1828                 xListPropertiesReply *stuff = (xListPropertiesReply *)rep;
1829
1830                 REPLY (" PropertieNum(%d)",
1831                     stuff->nProperties);
1832             }
1833             else
1834             {
1835                 Atom *stuff = (Atom *)rep;
1836                 int i;
1837
1838                 REPLY ("Properties");
1839                 REPLY ("(");
1840                 for (i = 0 ; i < evinfo->rep.size / sizeof(Atom) ; i ++)
1841                 {
1842                     reply = xDbgGetAtom(stuff[i], evinfo, reply, len);
1843                     if(i != evinfo->rep.size / sizeof(Atom) - 1)
1844                         REPLY (", ");
1845                 }
1846                 REPLY (")");
1847             }
1848
1849             return reply;
1850         }
1851
1852     case X_GetImage:
1853         {
1854             if (evinfo->rep.isStart)
1855             {
1856                 xGetImageReply *stuff = (xGetImageReply *)rep;
1857
1858                 REPLY (": XID(0x%lx)",
1859                     stuff->visual);
1860             }
1861             else
1862             {
1863                 return reply;
1864             }
1865
1866             return reply;
1867         }
1868
1869     case X_GetKeyboardControl:
1870         {
1871             if (evinfo->rep.isStart)
1872             {
1873                 xGetKeyboardControlReply *stuff = (xGetKeyboardControlReply *)rep;
1874
1875                 REPLY (": keyClickPercent(%d) bellPercent(%d), bellPitch(%d) bellDuration(%d)",
1876                     stuff->keyClickPercent,
1877                     stuff->bellPercent,
1878                     stuff->bellPitch,
1879                     stuff->bellDuration);
1880             }
1881             else
1882             {
1883                 return reply;
1884             }
1885
1886             return reply;
1887         }
1888
1889     case X_GetPointerControl:
1890         {
1891             if (evinfo->rep.isStart)
1892             {
1893                 xGetPointerControlReply *stuff = (xGetPointerControlReply *)rep;
1894
1895                 REPLY (": accelNumerator(%d) accelDenominator(%d), threshold(%d)",
1896                     stuff->accelNumerator,
1897                     stuff->accelDenominator,
1898                     stuff->threshold);
1899             }
1900             else
1901             {
1902                 return reply;
1903             }
1904
1905             return reply;
1906         }
1907
1908     default:
1909         break;
1910     }
1911
1912     return reply;
1913 }