X11 发送错误的按键

Question

I am making a simple xlib wrapper for recreation, but I am having a problem with X11 since I activated WSL: At the start of some programs, it starts sending a specific key press event and when I press something it stops.

I tried looking at some documentation and even debug input files on /dev/, but seems that WSL don't have them, at least I didn't found.

My window_init():

    Display* display = XOpenDisplay(NULL);
    Window root = DefaultRootWindow(display);
    XSetWindowAttributes swa;
    swa.event_mask = ExposureMask | PointerMotionMask | KeyPressMask | KeyReleaseMask;
    Window window = XCreateWindow(display, root, 0, 0, w, h, 0, CopyFromParent, InputOutput, CopyFromParent, CWEv>
    XStoreName(display, window, name);
    XMapWindow(display, window);
    XFlush(display);

My window_update():

    XEvent event;
    while (XPending(display->display)) {
        char k;
        XNextEvent(display->display, &event);
        switch (event.type) {
            case KeyPress:
               k = XLookupKeysym(&event.xkey, 0)-XK_a;
               if(k >= 0 && k<= 26){
                  keys_down[k] = 1;
                  pressed[k] = 1;
               }
               break;
         }
    }

I still didn't handle the release events property, but at the start of the execution the program dispatches lots of keypresses events.

Answer 1

Here is a fully verified working example of the same:

// SPDX-License-Identifier: CC0-1.0
#include <stdlib.h>
#include <stdio.h>
#include <X11/Xlib.h>

int main(void)
{
    Display             *display;
    Window               root, window;
    XSetWindowAttributes attrs;
    XEvent               event;
    Atom                 close_window;

    display = XOpenDisplay(NULL);
    if (!display) {
        fprintf(stderr, "No display.\n");
        return EXIT_FAILURE;
    }

    root = DefaultRootWindow(display);

    attrs.event_mask = ExposureMask | PointerMotionMask | KeyPressMask | KeyReleaseMask;
    window = XCreateWindow(display, root,
                           100, 100, 320, 240,
                           0, CopyFromParent, InputOutput, CopyFromParent,
                           CWEventMask, &attrs);
    XStoreName(display, window, "Example Program");

    close_window = XInternAtom(display, "WM_DELETE_WINDOW", False);
    XSetWMProtocols(display, window, &close_window, 1);

    XMapWindow(display, window);
    XFlush(display);

    while (1) {
        XNextEvent(display, &event);
        if (event.type == ClientMessage && (Atom)(event.xclient.data.l[0]) == close_window)
            break;

        switch (event.type) {

        case MotionNotify:
            // It's just mouse motion events, so we won't mention those.
            break;

        case KeyPress:
            printf("KeyPress event: state = %u (", event.xkey.state);
            if (event.xkey.state & ShiftMask) printf(" Shift");
            if (event.xkey.state & LockMask) printf(" CapsLock");
            if (event.xkey.state & ControlMask) printf(" Control");
            if (event.xkey.state & Mod1Mask) printf(" Mod1");
            if (event.xkey.state & Mod2Mask) printf(" Mod2");
            if (event.xkey.state & Mod3Mask) printf(" Mod3");
            if (event.xkey.state & Mod4Mask) printf(" Mod4");
            if (event.xkey.state & Mod5Mask) printf(" Mod5");
            printf(" ), keycode = %u\n", event.xkey.keycode);
            break;

        case KeyRelease:
            printf("KeyRelease event: state = %u (", event.xkey.state);
            if (event.xkey.state & ShiftMask) printf(" Shift");
            if (event.xkey.state & LockMask) printf(" CapsLock");
            if (event.xkey.state & ControlMask) printf(" Control");
            if (event.xkey.state & Mod1Mask) printf(" Mod1");
            if (event.xkey.state & Mod2Mask) printf(" Mod2");
            if (event.xkey.state & Mod3Mask) printf(" Mod3");
            if (event.xkey.state & Mod4Mask) printf(" Mod4");
            if (event.xkey.state & Mod5Mask) printf(" Mod5");
            printf(" ), keycode = %u\n", event.xkey.keycode);
            break;

        case Expose:
            printf("Expose event: x=%d, y=%d, width=%d, height=%d, count=%d\n", event.xexpose.x, event.xexpose.y, event.xexpose.width, event.xexpose.height, event.xexpose.count);
            break;

        default:
            printf("Event type %d\n", event.type);
        }
        fflush(stdout);
    }

    XCloseDisplay(display);
    return EXIT_SUCCESS;
}

When compiling, link against the X11 library.

Since Expose is not implemented, it is normal and expected for the contents of the window to be garbage (solid color, copy of existing window data, or anything else; it varies depending on X server and window manager).

If you run the program from the command line in Linux, and you keep Enter pressed, the first KeyPress event you get is the first autorepeat event. You do sometimes get the KeyRelease event corresponding to the Enter key being released after the window has been mapped, but before any autorepeat events. The first described event is usually the Expose event,
Expose event: x=0, y=0, width=320, height=240, count=0
occasionally followed by the KeyRelease event corresponding to the Enter key,
KeyRelease event: state = 8192 ( ), keycode = 36
but one should ignore any KeyRelease events anyway that do not correspond to previous KeyPress event, so that shouldn't be an issue. (Shift is Shift , Lock is CapsLock (when on/enabled), Control is Ctrl , Mod1 is Alt , Mod5 AltGr , Mod4 ⊞ (Windows key).)

The close_window atom is used to handle the window close button. When the button is pressed, the window manager will send a ClientMessage event containing the same atom.

If you get any KeyPress events corresponding to keypresses that occurred prior to the start of the program, it is a bug in WSL that you need to report to Microsoft. (Only KeyRelease events corresponding to keys that are released after the program started, and autorepeat KeyPress events corresponding to keys that are being pressed down when the program starts and afterwards, are expected to occur.)

(Personally, instead of WSL, I would recommend running a real Linux installation in a virtual machine in Windows, unless you explicitly intend your programs to be run under WSL instead of actual Linux installations. There just seem to be too many bugs in WSL, in my opinion; plus one can snapshot and start and stop the virtual machine as needed. Others disagree, of course.)