Uint32 timestamp;
    Uint32 windowID;    /**< The window with keyboard focus, if any */
    Uint8 state;        /**< ::SDL_PRESSED or ::SDL_RELEASED */
    Uint8 repeat;       /**< Non-zero if this is a key repeat */
    Uint8 padding2;
    Uint8 padding3;
    SDL_Keysym keysym;  /**< The key that was pressed or released */
    Uint16 rate;        /**< Wayland: key repeat rate */
    Uint16 delay;       /**< Wayland: key repeat delay */
} SDL_KeyboardEvent;

#define SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)
/**
 *  \brief Keyboard text editing event structure (event.edit.*)
 */
typedef struct SDL_TextEditingEvent

                        break;
                    }

                    /* Probably keyboard */
                    scan_code = SDL_EVDEV_translate_keycode(events[i].code);
                    if (scan_code != SDL_SCANCODE_UNKNOWN) {
                        if (events[i].value == 0) {
                            SDL_SendKeyboardKey(SDL_RELEASED, scan_code, 0, 0);
                        } else if (events[i].value == 1 || events[i].value == 2 /* key repeated */) {
                            SDL_SendKeyboardKey(SDL_PRESSED, scan_code, 0, 0);
#ifdef SDL_INPUT_LINUXKD
                            SDL_EVDEV_do_text_input(events[i].code);
#endif /* SDL_INPUT_LINUXKD */
                        }
                    }
                    break;
                case EV_ABS:

{
    WINRT_ProcessCharacterReceivedEvent(args);
}

template <typename BackButtonEventArgs>
static void WINRT_OnBackButtonPressed(BackButtonEventArgs ^ args)
{
    SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_AC_BACK, 0, 0);
    SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_AC_BACK, 0, 0);

    if (SDL_GetHintBoolean(SDL_HINT_WINRT_HANDLE_BACK_BUTTON, SDL_FALSE)) {
        args->Handled = true;
    }
}

#if NTDDI_VERSION == NTDDI_WIN10

    SDL_Scancode scancode;

#ifdef DEBUG_KEYBOARD
    printf("Resetting keyboard\n");
#endif
    for (scancode = 0; scancode < SDL_NUM_SCANCODES; ++scancode) {
        if (keyboard->keystate[scancode] == SDL_PRESSED) {
            SDL_SendKeyboardKey(SDL_RELEASED, scancode, 0, 0);
        }
    }
}

void
SDL_GetDefaultKeymap(SDL_Keycode * keymap)
{

                video->StartTextInput(video);
            }
        }
    }
}

int
SDL_SendKeyboardKey(Uint8 state, SDL_Scancode scancode, Uint16 rate, Uint16 delay)
{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    int posted;
    SDL_Keymod modifier;
    SDL_Keycode keycode;
    Uint16 modstate;
    Uint32 type;

        event.key.type = type;
        event.key.state = state;
        event.key.repeat = repeat;
        event.key.keysym.scancode = scancode;
        event.key.keysym.sym = keycode;
        event.key.keysym.mod = modstate;
        event.key.windowID = keyboard->focus ? keyboard->focus->id : 0;
        event.key.rate = rate;
        event.key.delay = delay;
        posted = (SDL_PushEvent(&event) > 0);
    }
    return (posted);
}

int
SDL_SendKeyboardText(const char *text)

   VideoQuit()). */
extern void SDL_SetScancodeName(SDL_Scancode scancode, const char *name);

/* Set the keyboard focus window */
extern void SDL_SetKeyboardFocus(SDL_Window * window);

/* Send a keyboard key event */
extern int SDL_SendKeyboardKey(Uint8 state, SDL_Scancode scancode, Uint16 rate, Uint16 delay);

/* Send keyboard text input */
extern int SDL_SendKeyboardText(const char *text);

/* Send editing text for selected range from start to end */
extern int SDL_SendEditingText(const char *text, int start, int end);

        }

        /* Make sure this isn't a repeated event (key pressed and held) */
        if(state == SDL_PRESSED && BE_GetKeyState(scancode) == SDL_PRESSED) {
            return;
        }
        BE_SetKeyState(scancode, state);
        SDL_SendKeyboardKey(state, BE_GetScancodeFromBeKey(scancode), 0, 0);
        
        if (state == SDL_PRESSED && SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
            const int8 *keyUtf8;
            ssize_t count;
            if (msg->FindData("key-utf8", B_INT8_TYPE, (const void**)&keyUtf8, &count) == B_OK) {
                char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
                SDL_zero(text);

    }
    return scancode;
}

int
Android_OnKeyDown(int keycode)
{
    return SDL_SendKeyboardKey(SDL_PRESSED, TranslateKeycode(keycode), 0, 0);
}

int
Android_OnKeyUp(int keycode)
{
    return SDL_SendKeyboardKey(SDL_RELEASED, TranslateKeycode(keycode), 0, 0);
}

SDL_bool
Android_HasScreenKeyboardSupport(_THIS)
{
    return SDL_TRUE;
}

#include "../../events/scancodes_xfree86.h"

#include "SDL_DirectFB_events.h"

#if USE_MULTI_API
#define SDL_SendMouseMotion_ex(w, id, relative, x, y, p) SDL_SendMouseMotion(w, id, relative, x, y, p)
#define SDL_SendMouseButton_ex(w, id, state, button) SDL_SendMouseButton(w, id, state, button)
#define SDL_SendKeyboardKey_ex(id, state, scancode) SDL_SendKeyboardKey(id, state, scancode, 0, 0)
#define SDL_SendKeyboardText_ex(id, text) SDL_SendKeyboardText(id, text)
#else
#define SDL_SendMouseMotion_ex(w, id, relative, x, y, p) SDL_SendMouseMotion(w, id, relative, x, y)
#define SDL_SendMouseButton_ex(w, id, state, button) SDL_SendMouseButton(w, id, state, button)
#define SDL_SendKeyboardKey_ex(id, state, scancode) SDL_SendKeyboardKey(state, scancode, 0, 0)
#define SDL_SendKeyboardText_ex(id, text) SDL_SendKeyboardText(text)
#endif

typedef struct _cb_data cb_data;
struct _cb_data
{
    DFB_DeviceData *devdata;

                        scancode = SDL_SCANCODE_RALT;
                        break;
                    case SDL_SCANCODE_LGUI:
                        scancode = SDL_SCANCODE_RGUI;
                        break;
                }
            }
            SDL_SendKeyboardKey(eventType == EMSCRIPTEN_EVENT_KEYDOWN ? SDL_PRESSED : SDL_RELEASED, scancode, 0, 0);
        }
    }

    SDL_bool prevent_default = SDL_GetEventState(eventType == EMSCRIPTEN_EVENT_KEYDOWN ? SDL_KEYDOWN : SDL_KEYUP) == SDL_ENABLE;

    /* if TEXTINPUT events are enabled we can't prevent keydown or we won't get keypress
     * we need to ALWAYS prevent backspace and tab otherwise chrome takes action and does bad navigation UX

    if (action == mir_keyboard_action_up)
        key_state = SDL_RELEASED;

    if (event_scancode < SDL_arraysize(xfree86_scancode_table2))
        sdl_scancode = xfree86_scancode_table2[event_scancode];

    if (sdl_scancode != SDL_SCANCODE_UNKNOWN)
        SDL_SendKeyboardKey(key_state, sdl_scancode, 0, 0);

    if (key_state == SDL_PRESSED)
        HandleKeyText(key_code);
}

static void
HandleMouseButton(SDL_Window* sdl_window, Uint8 state, MirPointerEvent const* pointer)

                    case PP_INPUTEVENT_TYPE_TOUCHMOVE:
                    case PP_INPUTEVENT_TYPE_TOUCHEND:
                    case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
                        /* FIXME: Touch events */
                        break;
                      
                    case PP_INPUTEVENT_TYPE_KEYDOWN:
                        SDL_SendKeyboardKey(SDL_PRESSED, SDL_NACL_translate_keycode(driverdata->ppb_keyboard_input_event->GetKeyCode(event)), 0, 0);
                        break;
                        
                    case PP_INPUTEVENT_TYPE_KEYUP:
                        SDL_SendKeyboardKey(SDL_RELEASED, SDL_NACL_translate_keycode(driverdata->ppb_keyboard_input_event->GetKeyCode(event)), 0, 0);
                        break;
                        
                    case PP_INPUTEVENT_TYPE_CHAR:
                        var = driverdata->ppb_keyboard_input_event->GetCharacterText(event);
                        str = driverdata->ppb_var->VarToUtf8(var, &str_len);
                        /* str is not null terminated! */
                        if ( str_len >= SDL_arraysize(text) ) {

                /* out of date
                SDL_PrivateKeyboard((keys & keymap_psp[i].id) ?
                            SDL_PRESSED : SDL_RELEASED,
                            &sym);
        */
                SDL_SendKeyboardKey((keys & keymap_psp[i].id) ?
                                    SDL_PRESSED : SDL_RELEASED, SDL_GetScancodeFromKey(keymap_psp[i].sym), 0, 0);
            }
        }
    }

#ifdef PSPIRKEYB
    if (irkbd_ready) {
            unsigned char buffer[255];

                        raw = scanData->raw;
                        pressed = scanData->pressed;
                sym.scancode = raw;
                sym.sym = keymap[raw];
                /* not tested */
                /* SDL_PrivateKeyboard(pressed?SDL_PRESSED:SDL_RELEASED, &sym); */
                SDL_SendKeyboardKey((keys & keymap_psp[i].id) ?
                                    SDL_PRESSED : SDL_RELEASED, SDL_GetScancodeFromKey(keymap[raw]), 0, 0);

                }
            }
        }
    }
#endif
    sceKernelDelayThread(0);

    double dx_frac;
    double dy_frac;

    struct {
        struct xkb_keymap *keymap;
        struct xkb_state *state;
    } xkb;

#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
    Uint16 key_rate;
    Uint16 key_delay;
#endif
};

void
Wayland_PumpEvents(_THIS)
{
    SDL_VideoData *d = _this->driverdata;
    struct pollfd pfd[1];

    uint32_t scancode;
    char text[8];
    int size;

    if (key < SDL_arraysize(xfree86_scancode_table2)) {
        scancode = xfree86_scancode_table2[key];


        if (scancode != SDL_SCANCODE_UNKNOWN) {
            Uint16 rate = 0, delay = 0;

#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
            if (WAYLAND_xkb_keymap_key_repeats(input->xkb.keymap, key + 8)) {
                rate = input->key_rate;
                delay = input->key_delay;
            }
#endif
            SDL_SendKeyboardKey(state == WL_KEYBOARD_KEY_STATE_PRESSED ?
                                SDL_PRESSED : SDL_RELEASED, scancode, rate, delay);
        }
    }

    if (!window || window->keyboard_device != input || !input->xkb.state)
        return;

    // TODO can this happen?
    if (WAYLAND_xkb_state_key_get_syms(input->xkb.state, key + 8, &syms) != 1)

                          uint32_t group)
{
    struct SDL_WaylandInput *input = data;

    WAYLAND_xkb_state_update_mask(input->xkb.state, mods_depressed, mods_latched,
                          mods_locked, 0, 0, group);
}

#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
static void
keyboard_handle_repeat_info(void *data, struct wl_keyboard *keyboard,
                            int32_t rate, int32_t delay)
{
    struct SDL_WaylandInput *input = data;

    if (rate > 0 && rate <= 0xffff) {
        input->key_rate = rate;
    } else {
        input->key_rate = 0;
    }
    if (delay > 0 && delay <= 0xffff) {
        input->key_delay = delay;
    } else {
        input->key_delay = 0;
    }
}
#endif

static const struct wl_keyboard_listener keyboard_listener = {
    keyboard_handle_keymap,
    keyboard_handle_enter,
    keyboard_handle_leave,
    keyboard_handle_key,
    keyboard_handle_modifiers,
#ifdef WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION
    keyboard_handle_repeat_info,
#endif
};

static void
seat_handle_capabilities(void *data, struct wl_seat *seat,
                         enum wl_seat_capability caps)
{
    struct SDL_WaylandInput *input = data;

    if (input == NULL)
        return;

    input->display = d;
    input->seat = wl_registry_bind(d->registry, id, &wl_seat_interface, 1);
    input->sx_w = wl_fixed_from_int(0);
    input->sy_w = wl_fixed_from_int(0);
    /* preset to 25 chars/second, 660 ms repeat delay */
    input->key_rate = 25;
    input->key_delay = 660;
    d->input = input;
    
    if (d->data_device_manager != NULL) {
        data_device = SDL_calloc(1, sizeof *data_device);
        if (data_device == NULL) {
            return;
        }

SDL_WAYLAND_SYM(void, wl_cursor_theme_destroy, (struct wl_cursor_theme *))
SDL_WAYLAND_SYM(struct wl_cursor *, wl_cursor_theme_get_cursor, (struct wl_cursor_theme *, const char *))
SDL_WAYLAND_SYM(struct wl_buffer *, wl_cursor_image_get_buffer, (struct wl_cursor_image *))
SDL_WAYLAND_SYM(int, wl_cursor_frame, (struct wl_cursor *, uint32_t))

SDL_WAYLAND_MODULE(WAYLAND_XKB)
SDL_WAYLAND_SYM(int, xkb_state_key_get_syms, (struct xkb_state *, xkb_keycode_t, const xkb_keysym_t **))
SDL_WAYLAND_SYM(int, xkb_keymap_key_repeats, (struct xkb_keymap *, xkb_keycode_t))
SDL_WAYLAND_SYM(int, xkb_keysym_to_utf8, (xkb_keysym_t, char *, size_t) )
SDL_WAYLAND_SYM(struct xkb_keymap *, xkb_keymap_new_from_string, (struct xkb_context *, const char *, enum xkb_keymap_format, enum xkb_keymap_compile_flags))
SDL_WAYLAND_SYM(struct xkb_state *, xkb_state_new, (struct xkb_keymap *) )
SDL_WAYLAND_SYM(void, xkb_keymap_unref, (struct xkb_keymap *) )
SDL_WAYLAND_SYM(void, xkb_state_unref, (struct xkb_state *) )
SDL_WAYLAND_SYM(void, xkb_context_unref, (struct xkb_context *) )
SDL_WAYLAND_SYM(struct xkb_context *, xkb_context_new, (enum xkb_context_flags flags) )

                /* ALT+F4: Close window */
                if (code == SDL_SCANCODE_F4 && ShouldGenerateWindowCloseOnAltF4()) {
                    SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
                }
            }

            if (code != SDL_SCANCODE_UNKNOWN) {
                SDL_SendKeyboardKey(SDL_PRESSED, code, 0, 0);
            }
        }
 
        returnCode = 0;
        break;

    case WM_SYSKEYUP:
    case WM_KEYUP:
        {
            SDL_Scancode code = WindowsScanCodeToSDLScanCode(lParam, wParam);
            const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);

            if (code != SDL_SCANCODE_UNKNOWN) {
                if (code == SDL_SCANCODE_PRINTSCREEN &&
                    keyboardState[code] == SDL_RELEASED) {
                    SDL_SendKeyboardKey(SDL_PRESSED, code, 0, 0);
                }
                SDL_SendKeyboardKey(SDL_RELEASED, code, 0, 0);
            }
        }
        returnCode = 0;
        break;

    case WM_UNICHAR:
        if ( wParam == UNICODE_NOCHAR ) {

    /* Windows loses a shift KEYUP event when you have both pressed at once and let go of one.
       You won't get a KEYUP until both are released, and that keyup will only be for the second
       key you released. Take heroic measures and check the keystate as of the last handled event,
       and if we think a key is pressed when Windows doesn't, unstick it in SDL's state. */
    keystate = SDL_GetKeyboardState(NULL);
    if ((keystate[SDL_SCANCODE_LSHIFT] == SDL_PRESSED) && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT, 0, 0);
    }
    if ((keystate[SDL_SCANCODE_RSHIFT] == SDL_PRESSED) && !(GetKeyState(VK_RSHIFT) & 0x8000)) {
        SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RSHIFT, 0, 0);
    }
}

static int app_registered = 0;
LPTSTR SDL_Appname = NULL;
Uint32 SDL_Appstyle = 0;
HINSTANCE SDL_Instance = NULL;

        args->VirtualKey,
        sdlScancode,
        SDL_GetScancodeName(sdlScancode),
        keycode,
        SDL_GetKeyName(keycode));
    //args->Handled = true;
#endif
    SDL_SendKeyboardKey(SDL_PRESSED, sdlScancode, 0, 0);
}

void
WINRT_ProcessKeyUpEvent(Windows::UI::Core::KeyEventArgs ^args)
{
    SDL_Scancode sdlScancode = WINRT_TranslateKeycode((int)args->VirtualKey, args->KeyStatus.ScanCode);
#if 0

        args->VirtualKey,
        sdlScancode,
        SDL_GetScancodeName(sdlScancode),
        keycode,
        SDL_GetKeyName(keycode));
    //args->Handled = true;
#endif
    SDL_SendKeyboardKey(SDL_RELEASED, sdlScancode, 0, 0);
}

void
WINRT_ProcessCharacterReceivedEvent(Windows::UI::Core::CharacterReceivedEventArgs ^args)
{
    wchar_t src_ucs2[2];
    char dest_utf8[16];

    if (X11_XQueryPointer(display, DefaultRootWindow(display), &junk_window, &junk_window, &x, &y, &x, &y, &mask)) {
        SDL_ToggleModState(KMOD_CAPS, (mask & LockMask) != 0);
        SDL_ToggleModState(KMOD_NUM, (mask & X11_GetNumLockModifierMask(_this)) != 0);
    }

    for (keycode = 0; keycode < 256; ++keycode) {
        if (keys[keycode / 8] & (1 << (keycode % 8))) {
            SDL_SendKeyboardKey(SDL_PRESSED, viddata->key_layout[keycode], 0, 0);
        } else {
            SDL_SendKeyboardKey(SDL_RELEASED, viddata->key_layout[keycode], 0, 0);
        }
    }
}


static void
X11_DispatchFocusIn(_THIS, SDL_WindowData *data)

        if (orig_keycode) {
#if defined(HAVE_IBUS_IBUS_H) || defined(HAVE_FCITX_FRONTEND_H)
            SDL_Scancode scancode = videodata->key_layout[orig_keycode];
            videodata->filter_code = orig_keycode;
            videodata->filter_time = xevent.xkey.time;

            if (orig_event_type == KeyPress) {
                SDL_SendKeyboardKey(SDL_PRESSED, scancode, 0, 0);
            } else {
                SDL_SendKeyboardKey(SDL_RELEASED, scancode, 0, 0);
            }
#endif
        }
        return;
    }

    /* Send a SDL_SYSWMEVENT if the application wants them */

            if(SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE){
                handled_by_ime = SDL_IME_ProcessKeyEvent(keysym, keycode);
            }
#endif
            if (!handled_by_ime) {
                /* Don't send the key if it looks like a duplicate of a filtered key sent by an IME */
                if (xevent.xkey.keycode != videodata->filter_code || xevent.xkey.time != videodata->filter_time) {
                    SDL_SendKeyboardKey(SDL_PRESSED, videodata->key_layout[keycode], 0, 0);
                }
                if(*text) {
                    SDL_SendKeyboardText(text);
                }
            }

            X11_UpdateUserTime(data, xevent.xkey.time);

#ifdef DEBUG_XEVENTS
            printf("window %p: KeyRelease (X11 keycode = 0x%X)\n", data, xevent.xkey.keycode);
#endif
            if (X11_KeyRepeat(display, &xevent)) {
                /* We're about to get a repeated key down, ignore the key up */
                break;
            }
            SDL_SendKeyboardKey(SDL_RELEASED, videodata->key_layout[keycode], 0, 0);
        }
        break;

        /* Have we been iconified? */
    case UnmapNotify:{
#ifdef DEBUG_XEVENTS
            printf("window %p: UnmapNotify!\n", data);

    agg_custom_free = (void (*)(void *)) Tcl_Free;
#endif

    if (SdlTkX.arg_sdllog) {
	SDL_LogSetAllPriority(SdlTkX.arg_sdllog);
    }
#ifndef ANDROID
#ifdef linux
    /*
     * Wayland: if SDL_VIDEODRIVER is unset but WAYLAND_DISPLAY
     * is set, prefer the Wayland video driver.
     */
    if (getenv("SDL_VIDEODRIVER") == NULL) {
	char *p = getenv("WAYLAND_DISPLAY");

	if ((p != NULL) && p[0]) {
	    putenv("SDL_VIDEODRIVER=wayland");
	}
    }
#endif
retryInit:
#endif
    if (SDL_Init(initMask) < 0) {
#ifdef ANDROID
	__android_log_print(ANDROID_LOG_ERROR, "libtk",
			    "Couldn't initialize SDL: %s", SDL_GetError());
#else

    SDL_SetWindowMinimumSize(SdlTkX.sdlscreen, min_w, min_h);
#endif
    SDL_GetWindowSize(SdlTkX.sdlscreen, &width, &height);

    fmt = SDL_GetWindowPixelFormat(SdlTkX.sdlscreen);
    if (fmt == SDL_PIXELFORMAT_UNKNOWN) {
	/*
	 * This can happen with the Wayland video driver,
	 * thus try to go on with 24 bit RGB.
	 */
	fmt = SDL_PIXELFORMAT_RGB888;
    }
    pfmt = SDL_AllocFormat(fmt);

    SdlTkX.sdlsurf = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height,

static Tcl_ThreadCreateType
EventThread(ClientData clientData)
{
    SDL_Event sdl_event;
    XEvent event;
    SDL_TimerID timerId;
    int skipRefresh = 0, overrun, initSuccess;
#ifndef ANDROID
    /* Key repeat handling for Wayland. */
    SDL_Event key_event, txt_event;
    int key_rpt_state = 0, key_rpt_time;
    extern int SDL_SendKeyboardKey(Uint8 state, SDL_Scancode scancode,
				   Uint16 rate, Uint16 delay);
    extern int SDL_SendKeyboardText(const char *text);
#endif
    struct EventThreadStartup *evs = (struct EventThreadStartup *) clientData;

    EVLOG("EventThread start");
#ifdef ANDROID
    Android_JNI_SetupThread();
#endif
    SdlTkLock(NULL);

    SDL_RenderCopy(SdlTkX.sdlrend, SdlTkX.sdltex, NULL, NULL);
#endif
    SdlTkUnlock(NULL);

    timerId = SDL_AddTimer(1000 / SDLTK_FRAMERATE, TimerCallback,
			   (void *) &SdlTkX.time_count);
    EVLOG("EventThread enter loop");
    /*
     * Add all pending SDL events to the X event queues and
     * deal with screen refresh.
     */
    while (1) {
	_XSQEvent *qevent;

	/* Enable timer messages. */
	timer_enabled = !SdlTkX.in_background;
	if (!SDL_WaitEvent(&sdl_event)) {
	    break;

	    if (!skipRefresh) {
		SdlTkScreenRefresh();
	    }
	    overrun = (SdlTkX.time_count - sdl_event.user.code) > 0;
	    skipRefresh = !skipRefresh && overrun;
	    /* Mark event to be skipped in SdlTkTranslateEvent() */
	    sdl_event.type = SDL_USEREVENT + 0x1000;
#ifndef ANDROID
	    /* Key repeat handling for Wayland. */
	    if (key_rpt_state && (SdlTkX.time_count - key_rpt_time >= 0)) {
		if (key_event.key.rate) {
		    key_rpt_time = SdlTkX.time_count + 1000/key_event.key.rate;
		    if (key_rpt_state > 1) {
			SDL_SendKeyboardText(txt_event.text.text);
		    } else {
			SDL_SendKeyboardKey(SDL_PRESSED,
					    key_event.key.keysym.scancode,
					    key_event.key.rate, 0);
		    }
		} else {
		    key_rpt_state = 0;
		}
	    }
#endif
	}
#ifndef ANDROID
	/* Key repeat handling for Wayland. */
	if ((sdl_event.type == SDL_KEYDOWN) && sdl_event.key.rate &&
	    sdl_event.key.delay && !sdl_event.key.repeat) {
	    key_rpt_state = 1;
	    key_event = sdl_event;
	    key_rpt_time = SdlTkX.time_count + key_event.key.delay;
	    if (SDL_PeepEvents(&txt_event, 1, SDL_PEEKEVENT,
			       SDL_TEXTINPUT, SDL_TEXTINPUT) == 1) {
		key_rpt_state = 2;
	    }
	} else if (key_rpt_state && (sdl_event.type == SDL_KEYUP) &&
		   sdl_event.key.rate && sdl_event.key.delay &&
		   !sdl_event.key.repeat) {
	    key_rpt_state = 0;
	}
#endif
	if ((sdl_event.type == SDL_USEREVENT) &&
	    (sdl_event.user.data1 == HandlePanZoom) &&
	    (sdl_event.user.data2 != NULL)) {
	    HandlePanZoom((struct PanZoomRequest *) sdl_event.user.data2);
	    /* Mark event to be skipped in SdlTkTranslateEvent() */
	    sdl_event.type = SDL_USEREVENT + 0x1001;
	}

		Tcl_ConditionWait(&time_cond, &xlib_lock, NULL);
	    } while (wait_refr && (SdlTkX.frame_count == frame_count));
#else
	    Uint32 fmt = SDL_GetWindowPixelFormat(_w->gl_wind);

	    if (fmt == SDL_PIXELFORMAT_UNKNOWN) {
		/*
		 * This can happen with the Wayland video driver,
		 * thus try to go on with 24 bit RGB.
		 */
		fmt = SDL_PIXELFORMAT_RGB888;
	    }
	    if (SDL_RenderReadPixels(rend, NULL, fmt, surf->pixels,
				     surf->pitch) == 0) {
		_Pixmap p;

build-vanilla-generic.sh	vanilla{tclsh,wish} for generic linux (e.g. arm)

The undroidwish variant uses the SDL2 backend, the vanilla variant
the native one (i.e. X11 on Linux, Win32/GDI on Windows).

The experimental Wayland variant gets built with both an X11 and a Wayland
video driver. The former driver is the default. In order to run with the
Wayland driver, the environment must have the variable WAYLAND_DRIVER

to be defined or alternatively SDL_VIDEODRIVER set to "wayland".

The build is currently verified only on Fedora 25. The undroidwish root
window starts without decorations and can be moved and/or resized
(-sdlresizable required) with window manager hot keys (Alt-F7, Alt-F8).



Refer to the individual script for build requirements. The
general pattern for invocation is

  <full-name-of-script-within-AndroWish-source-tree> ?<action>?

where <action> (default is "build") carries out the following: