curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/gl/pdcgetsc.c

@@ -0,0 +1,30 @@
+/* PDCurses */
+
+#include "pdcgl.h"
+
+/* get the cursor size/shape */
+
+int PDC_get_cursor_mode(void)
+{
+    PDC_LOG(("PDC_get_cursor_mode() - called\n"));
+
+    return 0;
+}
+
+/* return number of screen rows */
+
+int PDC_get_rows(void)
+{
+    PDC_LOG(("PDC_get_rows() - called\n"));
+
+    return pdc_sheight / pdc_fheight;
+}
+
+/* return width of screen/viewport */
+
+int PDC_get_columns(void)
+{
+    PDC_LOG(("PDC_get_columns() - called\n"));
+
+    return pdc_swidth / pdc_fwidth;
+}

data/vendor/PDCursesMod/gl/pdcgl.h

@@ -0,0 +1,51 @@
+/* PDCurses */
+
+#if defined( PDC_FORCE_UTF8) && !defined( PDC_WIDE)
+   #define PDC_WIDE
+#endif
+
+#include <SDL.h>
+#include <SDL_ttf.h>
+#if SDL_TTF_VERSION_ATLEAST(2,0,18)
+/* SDL_ttf 2.0.18 introduced the the functions we use for rendering
+   individual characters beyond the BMP. */
+#define PDC_SDL_SUPPLEMENTARY_PLANES_SUPPORT 1
+#endif
+
+#define PDC_GL_RESIZE_NORMAL 0        /* Actually adds more characters. */
+#define PDC_GL_RESIZE_STRETCH 1       /* Stretches the contents to fill the
+                                         whole screen. */
+#define PDC_GL_RESIZE_SCALE 2         /* Same as above, but preserves aspect
+                                         ratio. */
+#define PDC_GL_RESIZE_INTEGER 3       /* Resizes in integer steps. */
+
+#define PDC_GL_INTERPOLATE_NEAREST 0  /* Nearest-neighbor interpolation for
+                                         text. */
+#define PDC_GL_INTERPOLATE_BILINEAR 1 /* Bilinear interpolation for text. */
+
+#include <curspriv.h>
+
+PDCEX  TTF_Font *pdc_ttffont;
+PDCEX  int pdc_font_size;
+PDCEX  int pdc_resize_mode;        /* PDC_GL_RESIZE_NORMAL by default */
+PDCEX  int pdc_interpolation_mode; /* PDC_GL_INTERPOLATE_BILINEAR by default */
+PDCEX  SDL_Window *pdc_window;
+PDCEX  SDL_Surface *pdc_icon;
+PDCEX  int pdc_sheight, pdc_swidth;
+
+extern Uint32 *pdc_glyph_cache[4];
+extern int pdc_glyph_cache_size[4];
+extern int pdc_glyph_row_capacity, pdc_glyph_col_capacity;
+extern int pdc_glyph_cache_w, pdc_glyph_cache_h;
+extern int* pdc_glyph_start_col;
+
+extern unsigned pdc_color_buffer, pdc_glyph_buffer;
+extern unsigned pdc_background_shader_program, pdc_foreground_shader_program;
+extern unsigned pdc_font_texture, pdc_render_target_texture;
+extern unsigned pdc_tex_fbo;
+
+extern int pdc_fheight, pdc_fwidth;  /* font height and width */
+extern int pdc_fthick;               /* thickness for highlights and
+                                        rendered ACS glyphs */
+extern void PDC_pump_and_peep(void);
+extern SDL_Rect PDC_get_viewport(void);

data/vendor/PDCursesMod/gl/pdckbd.c

@@ -0,0 +1,548 @@
+/* PDCurses */
+
+#include "pdcgl.h"
+
+#include <ctype.h>
+#include <string.h>
+
+static SDL_Event event;
+static SDL_Keycode oldkey;
+static MOUSE_STATUS old_mouse_status;
+
+static const struct
+{
+    SDL_Keycode keycode;
+    bool numkeypad;
+    unsigned short normal;
+    unsigned short shifted;
+    unsigned short control;
+    unsigned short alt;
+} key_table[] =
+{
+/* keycode      keypad  normal       shifted       control      alt*/
+ {SDLK_LEFT,    FALSE,  KEY_LEFT,    KEY_SLEFT,    CTL_LEFT,    ALT_LEFT},
+ {SDLK_RIGHT,   FALSE,  KEY_RIGHT,   KEY_SRIGHT,   CTL_RIGHT,   ALT_RIGHT},
+ {SDLK_UP,      FALSE,  KEY_UP,      KEY_SUP,      CTL_UP,      ALT_UP},
+ {SDLK_DOWN,    FALSE,  KEY_DOWN,    KEY_SDOWN,    CTL_DOWN,    ALT_DOWN},
+ {SDLK_HOME,    FALSE,  KEY_HOME,    KEY_SHOME,    CTL_HOME,    ALT_HOME},
+ {SDLK_END,     FALSE,  KEY_END,     KEY_SEND,     CTL_END,     ALT_END},
+ {SDLK_PAGEUP,  FALSE,  KEY_PPAGE,   KEY_SPREVIOUS,CTL_PGUP,    ALT_PGUP},
+ {SDLK_PAGEDOWN,FALSE,  KEY_NPAGE,   KEY_SNEXT,    CTL_PGDN,    ALT_PGDN},
+ {SDLK_INSERT,  FALSE,  KEY_IC,      KEY_SIC,      CTL_INS,     ALT_INS},
+ {SDLK_DELETE,  FALSE,  KEY_DC,      KEY_SDC,      CTL_DEL,     ALT_DEL},
+ {SDLK_F1,      FALSE,  KEY_F(1),    KEY_F(13),    KEY_F(25),   KEY_F(37)},
+ {SDLK_F2,      FALSE,  KEY_F(2),    KEY_F(14),    KEY_F(26),   KEY_F(38)},
+ {SDLK_F3,      FALSE,  KEY_F(3),    KEY_F(15),    KEY_F(27),   KEY_F(39)},
+ {SDLK_F4,      FALSE,  KEY_F(4),    KEY_F(16),    KEY_F(28),   KEY_F(40)},
+ {SDLK_F5,      FALSE,  KEY_F(5),    KEY_F(17),    KEY_F(29),   KEY_F(41)},
+ {SDLK_F6,      FALSE,  KEY_F(6),    KEY_F(18),    KEY_F(30),   KEY_F(42)},
+ {SDLK_F7,      FALSE,  KEY_F(7),    KEY_F(19),    KEY_F(31),   KEY_F(43)},
+ {SDLK_F8,      FALSE,  KEY_F(8),    KEY_F(20),    KEY_F(32),   KEY_F(44)},
+ {SDLK_F9,      FALSE,  KEY_F(9),    KEY_F(21),    KEY_F(33),   KEY_F(45)},
+ {SDLK_F10,     FALSE,  KEY_F(10),   KEY_F(22),    KEY_F(34),   KEY_F(46)},
+ {SDLK_F11,     FALSE,  KEY_F(11),   KEY_F(23),    KEY_F(35),   KEY_F(47)},
+ {SDLK_F12,     FALSE,  KEY_F(12),   KEY_F(24),    KEY_F(36),   KEY_F(48)},
+ {SDLK_F13,     FALSE,  KEY_F(13),   KEY_F(25),    KEY_F(37),   KEY_F(49)},
+ {SDLK_F14,     FALSE,  KEY_F(14),   KEY_F(26),    KEY_F(38),   KEY_F(50)},
+ {SDLK_F15,     FALSE,  KEY_F(15),   KEY_F(27),    KEY_F(39),   KEY_F(51)},
+ {SDLK_BACKSPACE,FALSE, 0x08,        0x08,         CTL_BKSP,    ALT_BKSP},
+ {SDLK_TAB,     FALSE,  0x09,        KEY_BTAB,     CTL_TAB,     ALT_TAB},
+ {SDLK_PRINTSCREEN,FALSE,KEY_PRINT,  KEY_SPRINT,   KEY_PRINT,   KEY_PRINT},
+ {SDLK_PAUSE,   FALSE,  KEY_SUSPEND, KEY_SSUSPEND, KEY_SUSPEND, KEY_SUSPEND},
+ {SDLK_CLEAR,   FALSE,  KEY_CLEAR,   KEY_CLEAR,    KEY_CLEAR,   KEY_CLEAR},
+ {SDLK_HELP,    FALSE,  KEY_HELP,    KEY_SHELP,    KEY_LHELP,   KEY_HELP},
+ {SDLK_MENU,    FALSE,  KEY_OPTIONS, KEY_SOPTIONS, KEY_OPTIONS, KEY_OPTIONS},
+ {SDLK_ESCAPE,  FALSE,  0x1B,        0x1B,         0x1B,        ALT_ESC},
+ {SDLK_KP_ENTER,TRUE,   PADENTER,    PADENTER,     CTL_PADENTER,ALT_PADENTER},
+ {SDLK_KP_PLUS, TRUE,   PADPLUS,     '+',          CTL_PADPLUS, ALT_PADPLUS},
+ {SDLK_KP_MINUS,TRUE,   PADMINUS,    '-',          CTL_PADMINUS,ALT_PADMINUS},
+ {SDLK_KP_MULTIPLY,TRUE,PADSTAR,     '*',          CTL_PADSTAR, ALT_PADSTAR},
+ {SDLK_KP_DIVIDE,TRUE,  PADSLASH,    '/',          CTL_PADSLASH,ALT_PADSLASH},
+ {SDLK_KP_PERIOD,TRUE,  PADSTOP,     '.',          CTL_PADSTOP, ALT_PADSTOP},
+ {SDLK_KP_0,    TRUE,   PAD0,        '0',          CTL_PAD0,    ALT_PAD0},
+ {SDLK_KP_1,    TRUE,   KEY_C1,      '1',          CTL_PAD1,    ALT_PAD1},
+ {SDLK_KP_2,    TRUE,   KEY_C2,      '2',          CTL_PAD2,    ALT_PAD2},
+ {SDLK_KP_3,    TRUE,   KEY_C3,      '3',          CTL_PAD3,    ALT_PAD3},
+ {SDLK_KP_4,    TRUE,   KEY_B1,      '4',          CTL_PAD4,    ALT_PAD4},
+ {SDLK_KP_5,    TRUE,   KEY_B2,      '5',          CTL_PAD5,    ALT_PAD5},
+ {SDLK_KP_6,    TRUE,   KEY_B3,      '6',          CTL_PAD6,    ALT_PAD6},
+ {SDLK_KP_7,    TRUE,   KEY_A1,      '7',          CTL_PAD7,    ALT_PAD7},
+ {SDLK_KP_8,    TRUE,   KEY_A2,      '8',          CTL_PAD8,    ALT_PAD8},
+ {SDLK_KP_9,    TRUE,   KEY_A3,      '9',          CTL_PAD9,    ALT_PAD9},
+ {SDLK_VOLUMEUP,  FALSE, KEY_VOLUME_UP, KEY_VOLUME_UP, KEY_VOLUME_UP, KEY_VOLUME_UP},
+ {SDLK_VOLUMEDOWN,  FALSE, KEY_VOLUME_DOWN, KEY_VOLUME_DOWN, KEY_VOLUME_DOWN, KEY_VOLUME_DOWN},
+ {SDLK_MUTE, FALSE, KEY_VOLUME_MUTE, KEY_VOLUME_MUTE, KEY_VOLUME_MUTE, KEY_VOLUME_MUTE},
+ {SDLK_AGAIN, FALSE, KEY_REDO, KEY_REDO, KEY_REDO, KEY_REDO },
+ {SDLK_SCROLLLOCK, FALSE, KEY_SCROLLLOCK, KEY_SCROLLLOCK, KEY_SCROLLLOCK, KEY_SCROLLLOCK },
+ {SDLK_UNDO, FALSE, KEY_UNDO, KEY_UNDO, KEY_UNDO, KEY_UNDO },
+ {SDLK_AUDIONEXT, FALSE, KEY_NEXT_TRACK, KEY_NEXT_TRACK, KEY_NEXT_TRACK, KEY_NEXT_TRACK },
+ {SDLK_AUDIOPREV, FALSE, KEY_PREV_TRACK, KEY_PREV_TRACK, KEY_PREV_TRACK, KEY_PREV_TRACK },
+ {SDLK_AUDIOSTOP, FALSE, KEY_MEDIA_STOP, KEY_MEDIA_STOP, KEY_MEDIA_STOP, KEY_MEDIA_STOP },
+ {SDLK_AUDIOPLAY, FALSE, KEY_PLAY_PAUSE, KEY_PLAY_PAUSE, KEY_PLAY_PAUSE, KEY_PLAY_PAUSE },
+ {0,            0,      0,           0,            0,           0}
+};
+
+void PDC_set_keyboard_binary(bool on)
+{
+    INTENTIONALLY_UNUSED_PARAMETER( on);
+    PDC_LOG(("PDC_set_keyboard_binary() - called\n"));
+}
+
+/* check if a key or mouse event is waiting */
+
+static int _stored_key;
+static Uint32 _stored_timestamp;
+
+bool PDC_check_key(void)
+{
+    bool haveevent;
+
+    if( _stored_key && SDL_GetTicks( ) > _stored_timestamp + 2)
+        return( TRUE);
+    PDC_pump_and_peep();
+
+    /* SDL_TEXTINPUT can return multiple chars from the IME which we
+       should handle before polling for additional events. */
+
+    if (event.type == SDL_TEXTINPUT && event.text.text[0])
+        haveevent = TRUE;
+    else
+        haveevent = (bool)SDL_PollEvent(&event);
+
+    return haveevent;
+}
+
+#ifdef PDC_WIDE
+static int _utf8_to_unicode(char *chstr, size_t *b)
+{
+    int i, bytes, unicode;
+    unsigned char byte = chstr[0];
+
+    if (byte > 0xf0)
+    {
+        bytes = 4;
+        unicode = byte & 0x7;
+    }
+    else if (byte > 0xe0)
+    {
+        bytes = 3;
+        unicode = byte & 0xf;
+    }
+    else if (byte > 0xc0)
+    {
+        bytes = 2;
+        unicode = byte & 0x1f;
+    }
+    else if (byte > 0x80) {
+        /* starts with a continuation byte; invalid character */
+        return -1;
+    }
+    else
+    {
+        bytes = 1;
+        unicode = byte;
+    }
+
+    for (i = 1; i < bytes; i++)
+        unicode = (unicode << 6) + (chstr[i] & 0x3f);
+
+    *b = bytes;
+    return unicode;
+}
+#endif
+
+/* Handle ALT and CTRL sequences */
+static int _handle_alt_keys(int key)
+{
+    if (key > 0x7f)
+        return key;
+
+    if (SP->key_modifiers & PDC_KEY_MODIFIER_CONTROL)
+    {
+        if (key >= 'A' && key <= 'Z') key -= 64;
+        if (key >= 'a' && key <= 'z') key -= 96;
+        if( key == 3 && !SP->raw_inp)
+            exit( 0);
+    }
+    else if (SP->key_modifiers & PDC_KEY_MODIFIER_ALT)
+    {
+        if (key >= 'A' && key <= 'Z')
+            key += ALT_A - 'A';
+        else if (key >= 'a' && key <= 'z')
+            key += ALT_A - 'a';
+        else if (key >= '0' && key <= '9')
+            key += ALT_0 - '0';
+    }
+
+    return key;
+}
+
+static int _process_key_event(void)
+{
+    int i, key = 0;
+    static int _key_already_handled = 0;
+#ifdef PDC_WIDE
+    size_t bytes;
+#endif
+
+    if (event.type == SDL_KEYUP)
+    {
+        switch (event.key.keysym.sym)
+        {
+            case SDLK_LCTRL:
+            case SDLK_RCTRL:
+                SP->key_modifiers &= ~PDC_KEY_MODIFIER_CONTROL;
+                break;
+            case SDLK_LALT:
+            case SDLK_RALT:
+                SP->key_modifiers &= ~PDC_KEY_MODIFIER_ALT;
+                break;
+            case SDLK_LSHIFT:
+            case SDLK_RSHIFT:
+                SP->key_modifiers &= ~PDC_KEY_MODIFIER_SHIFT;
+                break;
+        }
+
+        if (!(SDL_GetModState() & KMOD_NUM))
+            SP->key_modifiers &= ~PDC_KEY_MODIFIER_NUMLOCK;
+
+        if (SP->return_key_modifiers && event.key.keysym.sym == oldkey)
+        {
+            switch (event.key.keysym.sym)
+            {
+            case SDLK_RSHIFT:
+                return KEY_SHIFT_R;
+            case SDLK_LSHIFT:
+                return KEY_SHIFT_L;
+            case SDLK_RCTRL:
+                return KEY_CONTROL_R;
+            case SDLK_LCTRL:
+                return KEY_CONTROL_L;
+            case SDLK_RALT:
+                return KEY_ALT_R;
+            case SDLK_LALT:
+                return KEY_ALT_L;
+            default:
+                break;
+            }
+        }
+
+        return -1;
+    }
+    else if (event.type == SDL_TEXTINPUT)
+    {
+        int rval;
+
+#ifdef PDC_WIDE
+        if ((key = _utf8_to_unicode(event.text.text, &bytes)) == -1)
+        {
+            event.text.text[0] = '\0';
+        }
+        else
+        {
+            memmove(event.text.text, event.text.text + bytes,
+                    strlen(event.text.text) - bytes + 1);
+        }
+        rval = _handle_alt_keys(key);
+#else
+        key = (unsigned char)event.text.text[0];
+        memmove(event.text.text, event.text.text + 1,
+                strlen(event.text.text));
+        rval = (key > 0x7f ? -1 : _handle_alt_keys(key));
+#endif
+        if( rval > 0 && strchr( "/+*-", rval))            /* may actually be */
+        {                           /* PADSLASH, PADPLUS, etc.  Wait 2 ms to */
+            _stored_key = rval;     /* see if a PADx keystroke is coming in. */
+            _stored_timestamp = event.text.timestamp;
+            rval = -1;
+        }
+        _key_already_handled = rval;
+        return( rval);
+    }
+
+    oldkey = event.key.keysym.sym;
+    if (SDL_GetModState() & KMOD_NUM)
+        SP->key_modifiers |= PDC_KEY_MODIFIER_NUMLOCK;
+
+    switch (event.key.keysym.sym)
+    {
+        case SDLK_LCTRL:
+        case SDLK_RCTRL:
+            SP->key_modifiers |= PDC_KEY_MODIFIER_CONTROL;
+            break;
+        case SDLK_LALT:
+        case SDLK_RALT:
+            SP->key_modifiers |= PDC_KEY_MODIFIER_ALT;
+            break;
+        case SDLK_LSHIFT:
+        case SDLK_RSHIFT:
+            SP->key_modifiers |= PDC_KEY_MODIFIER_SHIFT;
+            break;
+        case SDLK_RETURN:
+            return 0x0d;
+        default:
+            key = event.key.keysym.sym;
+    }
+
+    for (i = 0; key_table[i].keycode; i++)
+    {
+        if (key_table[i].keycode == event.key.keysym.sym)
+        {
+            if ((event.key.keysym.mod & KMOD_SHIFT) ||
+                (key_table[i].numkeypad && (event.key.keysym.mod & KMOD_NUM)))
+            {
+                key = key_table[i].shifted;
+                if( (key >= '0' && key <= '9') || strchr( ".+-*/", key))
+                    key = -1;
+            }
+            else if (event.key.keysym.mod & KMOD_CTRL)
+            {
+                key = key_table[i].control;
+            }
+            else if (event.key.keysym.mod & KMOD_ALT)
+            {
+                key = key_table[i].alt;
+            }
+            else
+            {
+                /* To get here, we ignore all other modifiers */
+                key = key_table[i].normal;
+            }
+            _stored_key = 0;
+
+            return key;
+        }
+    }
+
+    /* SDL with TextInput ignores keys with CTRL */
+    if( key)
+        if( SP->key_modifiers & (PDC_KEY_MODIFIER_CONTROL | PDC_KEY_MODIFIER_ALT))
+        {
+            int rval = _handle_alt_keys( key);
+
+            if( rval == _key_already_handled)
+                rval = -1;         /* don't return this key twice */
+            return( rval);
+        }
+    return -1;
+}
+
+static int _process_mouse_event(void)
+{
+    SDL_Keymod keymods;
+    short shift_flags = 0;
+    int wheel_x = 0, wheel_y = 0;
+    int mouse_x = 0, mouse_y = 0;
+    SDL_Rect viewport = PDC_get_viewport();
+
+    memset(&SP->mouse_status, 0, sizeof(MOUSE_STATUS));
+
+    keymods = SDL_GetModState();
+
+    if (keymods & KMOD_SHIFT)
+        shift_flags |= BUTTON_SHIFT;
+
+    if (keymods & KMOD_CTRL)
+        shift_flags |= BUTTON_CONTROL;
+
+    if (keymods & KMOD_ALT)
+        shift_flags |= BUTTON_ALT;
+
+    if (event.type == SDL_MOUSEWHEEL)
+    {
+        wheel_x = event.wheel.x;
+        wheel_y = event.wheel.y;
+        SDL_GetMouseState( &event.motion.x, &event.motion.y);
+    }
+
+    if(viewport.w == 0) viewport.w = 1;
+    if(viewport.h == 0) viewport.h = 1;
+    mouse_x = (event.motion.x-viewport.x) * SP->cols / viewport.w;
+    mouse_y = (event.motion.y-viewport.y) * SP->lines / viewport.h;
+    if(mouse_x < 0 || mouse_x >= COLS || mouse_y < 0 || mouse_y >= SP->lines)
+        return -1;
+
+    SP->mouse_status.x = mouse_x;
+    SP->mouse_status.y = mouse_y;
+
+    if (event.type == SDL_MOUSEMOTION)
+    {
+        int i;
+
+        if (!event.motion.state ||
+           (SP->mouse_status.x == old_mouse_status.x &&
+            SP->mouse_status.y == old_mouse_status.y))
+            return -1;
+
+        SP->mouse_status.changes = PDC_MOUSE_MOVED;
+
+        for (i = 0; i < 3; i++)
+        {
+            if (event.motion.state & SDL_BUTTON(i + 1))
+            {
+                SP->mouse_status.button[i] = BUTTON_MOVED | shift_flags;
+                SP->mouse_status.changes |= (1 << i);
+            }
+        }
+    }
+    else if (event.type == SDL_MOUSEWHEEL)
+    {
+        if (wheel_y > 0)
+            SP->mouse_status.changes = PDC_MOUSE_WHEEL_UP;
+        else if (wheel_y < 0)
+            SP->mouse_status.changes = PDC_MOUSE_WHEEL_DOWN;
+        else if (wheel_x > 0)
+            SP->mouse_status.changes = PDC_MOUSE_WHEEL_RIGHT;
+        else if (wheel_x < 0)
+            SP->mouse_status.changes = PDC_MOUSE_WHEEL_LEFT;
+        else
+            return -1;
+
+        return KEY_MOUSE;
+    }
+    else if(event.type == SDL_MOUSEBUTTONUP || event.type == SDL_MOUSEBUTTONDOWN)
+    {
+        short action = (event.type == SDL_MOUSEBUTTONDOWN) ?
+                       BUTTON_PRESSED : BUTTON_RELEASED;
+        Uint8 btn = event.button.button;
+
+        if (btn < 1 || btn > 3)
+            return -1;
+
+        /* check for a click -- a press followed immediately by a release */
+
+        if (action == BUTTON_PRESSED && SP->mouse_wait)
+        {
+            SDL_Event rel;
+
+            while (action != BUTTON_TRIPLE_CLICKED && SDL_WaitEventTimeout(&rel, SP->mouse_wait))
+            {
+                if (rel.type == SDL_MOUSEBUTTONUP && rel.button.button == btn)
+                {
+                    if (action == BUTTON_PRESSED)
+                        action = BUTTON_CLICKED;
+                    else if (action == BUTTON_CLICKED)
+                        action = BUTTON_DOUBLE_CLICKED;
+                    else if (action == BUTTON_DOUBLE_CLICKED)
+                        action = BUTTON_TRIPLE_CLICKED;
+                }
+                else if(rel.type != SDL_MOUSEBUTTONDOWN || rel.button.button != btn)
+                {
+                    SDL_PushEvent(&rel);
+                    break;
+                }
+            }
+        }
+
+        btn--;
+
+        SP->mouse_status.button[btn] = action | shift_flags;
+        SP->mouse_status.changes = (1 << btn);
+    }
+
+    old_mouse_status = SP->mouse_status;
+
+    return KEY_MOUSE;
+}
+
+/* return the next available key or mouse event */
+
+int PDC_get_key(void)
+{
+    if( _stored_key && SDL_GetTicks( ) > _stored_timestamp + 2)
+    {                        /*  One of +/-* was hit and not cancelled  */
+        const int key = _stored_key;   /* out within 2 ms by a PADPLUS, */
+                                    /* PADSLASH, PADMINUS,  or PADSTAR. */
+        _stored_key = 0;
+        return( key);
+    }
+
+    switch (event.type)
+    {
+    case SDL_QUIT:
+        if( !PDC_get_function_key( FUNCTION_KEY_SHUT_DOWN))
+        {
+            exit(1);
+        }
+        return PDC_get_function_key( FUNCTION_KEY_SHUT_DOWN);
+    case SDL_WINDOWEVENT:
+        if(
+            SDL_WINDOWEVENT_SIZE_CHANGED == event.window.event ||
+            SDL_WINDOWEVENT_RESIZED == event.window.event
+        ){
+
+            if(pdc_resize_mode == PDC_GL_RESIZE_NORMAL)
+            {
+                const int prev_rows = pdc_sheight / pdc_fheight;
+                const int prev_cols = pdc_swidth / pdc_fwidth;
+                bool size_actually_changed;
+
+                pdc_sheight = event.window.data2;
+                pdc_swidth = event.window.data1;
+                size_actually_changed = ( pdc_sheight / pdc_fheight != prev_rows ||
+                                          pdc_swidth / pdc_fwidth != prev_cols);
+                if( size_actually_changed && curscr)
+                {
+                    touchwin(curscr);
+                    wrefresh(curscr);
+                }
+                if( size_actually_changed && !SP->resized)
+                {
+                    SP->resized = TRUE;
+                    return KEY_RESIZE;
+                }
+            }
+            else
+            {
+                /* Other resize modes don't care about changing sheight or
+                 * swidth!
+                 */
+                PDC_doupdate();
+            }
+        }
+        break;
+    case SDL_MOUSEMOTION:
+        SDL_ShowCursor(SDL_ENABLE);
+               /* FALLTHRU */
+    case SDL_MOUSEBUTTONUP:
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEWHEEL:
+        oldkey = SDLK_SPACE;
+        return _process_mouse_event();
+    case SDL_KEYUP:
+    case SDL_KEYDOWN:
+    case SDL_TEXTINPUT:
+        PDC_mouse_set();
+        return _process_key_event();
+    }
+
+    return -1;
+}
+
+/* discard any pending keyboard or mouse input -- this is the core
+   routine for flushinp() */
+
+void PDC_flushinp(void)
+{
+    PDC_LOG(("PDC_flushinp() - called\n"));
+
+    while (PDC_check_key())
+        PDC_get_key();
+}
+
+bool PDC_has_mouse(void)
+{
+    return TRUE;
+}
+
+int PDC_mouse_set(void)
+{
+    SDL_ShowCursor(SP->_trap_mbe ? SDL_ENABLE : SDL_DISABLE);
+
+    return OK;
+}
+
+int PDC_modifiers_set(void)
+{
+    return OK;
+}