curses 1.3.0 → 1.4.2

data/vendor/PDCurses/os2/pdcclip.c

@@ -0,0 +1,188 @@
+/* Public Domain Curses */
+
+#include "pdcos2.h"
+
+/*man-start**************************************************************
+
+clipboard
+---------
+
+### Synopsis
+
+    int PDC_getclipboard(char **contents, long *length);
+    int PDC_setclipboard(const char *contents, long length);
+    int PDC_freeclipboard(char *contents);
+    int PDC_clearclipboard(void);
+
+### Description
+
+   PDC_getclipboard() gets the textual contents of the system's
+   clipboard. This function returns the contents of the clipboard
+   in the contents argument. It is the responsibilitiy of the
+   caller to free the memory returned, via PDC_freeclipboard().
+   The length of the clipboard contents is returned in the length
+   argument.
+
+   PDC_setclipboard copies the supplied text into the system's
+   clipboard, emptying the clipboard prior to the copy.
+
+   PDC_clearclipboard() clears the internal clipboard.
+
+### Return Values
+
+    indicator of success/failure of call.
+    PDC_CLIP_SUCCESS        the call was successful
+    PDC_CLIP_MEMORY_ERROR   unable to allocate sufficient memory for
+                            the clipboard contents
+    PDC_CLIP_EMPTY          the clipboard contains no text
+    PDC_CLIP_ACCESS_ERROR   no clipboard support
+
+### Portability
+                             X/Open    BSD    SYS V
+    PDC_getclipboard            -       -       -
+    PDC_setclipboard            -       -       -
+    PDC_freeclipboard           -       -       -
+    PDC_clearclipboard          -       -       -
+
+**man-end****************************************************************/
+
+int PDC_getclipboard(char **contents, long *length)
+{
+#ifndef EMXVIDEO
+    HMQ hmq;
+    HAB hab;
+    PTIB ptib;
+    PPIB ppib;
+    ULONG ulRet;
+    long len;
+    int rc;
+#endif
+    PDC_LOG(("PDC_getclipboard() - called\n"));
+
+#ifndef EMXVIDEO
+    DosGetInfoBlocks(&ptib, &ppib);
+    ppib->pib_ultype = 3;
+    hab = WinInitialize(0);
+    hmq = WinCreateMsgQueue(hab, 0);
+
+    if (!WinOpenClipbrd(hab))
+    {
+        WinDestroyMsgQueue(hmq);
+        WinTerminate(hab);
+        return PDC_CLIP_ACCESS_ERROR;
+    }
+
+    rc = PDC_CLIP_EMPTY;
+
+    ulRet = WinQueryClipbrdData(hab, CF_TEXT);
+
+    if (ulRet)
+    {
+        len = strlen((char *)ulRet);
+        *contents = malloc(len + 1);
+
+        if (!*contents)
+            rc = PDC_CLIP_MEMORY_ERROR;
+        else
+        {
+            strcpy((char *)*contents, (char *)ulRet);
+            *length = len;
+            rc = PDC_CLIP_SUCCESS;
+        }
+    }
+
+    WinCloseClipbrd(hab);
+    WinDestroyMsgQueue(hmq);
+    WinTerminate(hab);
+
+    return rc;
+#else
+    return PDC_CLIP_ACCESS_ERROR;
+#endif
+}
+
+int PDC_setclipboard(const char *contents, long length)
+{
+#ifndef EMXVIDEO
+    HAB hab;
+    PTIB ptib;
+    PPIB ppib;
+    ULONG ulRC;
+    PSZ szTextOut = NULL;
+    int rc;
+#endif
+    PDC_LOG(("PDC_setclipboard() - called\n"));
+
+#ifndef EMXVIDEO
+    DosGetInfoBlocks(&ptib, &ppib);
+    ppib->pib_ultype = 3;
+    hab = WinInitialize(0);
+
+    if (!WinOpenClipbrd(hab))
+    {
+        WinTerminate(hab);
+        return PDC_CLIP_ACCESS_ERROR;
+    }
+
+    rc = PDC_CLIP_MEMORY_ERROR;
+
+    ulRC = DosAllocSharedMem((PVOID)&szTextOut, NULL, length + 1,
+                             PAG_WRITE | PAG_COMMIT | OBJ_GIVEABLE);
+
+    if (ulRC == 0)
+    {
+        strcpy(szTextOut, contents);
+        WinEmptyClipbrd(hab);
+
+        if (WinSetClipbrdData(hab, (ULONG)szTextOut, CF_TEXT, CFI_POINTER))
+            rc = PDC_CLIP_SUCCESS;
+        else
+        {
+            DosFreeMem(szTextOut);
+            rc = PDC_CLIP_ACCESS_ERROR;
+        }
+    }
+
+    WinCloseClipbrd(hab);
+    WinTerminate(hab);
+
+    return rc;
+#else
+    return PDC_CLIP_ACCESS_ERROR;
+#endif
+}
+
+int PDC_freeclipboard(char *contents)
+{
+    PDC_LOG(("PDC_freeclipboard() - called\n"));
+
+    if (contents)
+        free(contents);
+
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_clearclipboard(void)
+{
+#ifndef EMXVIDEO
+    HAB hab;
+    PTIB ptib;
+    PPIB ppib;
+#endif
+    PDC_LOG(("PDC_clearclipboard() - called\n"));
+
+#ifndef EMXVIDEO
+    DosGetInfoBlocks(&ptib, &ppib);
+    ppib->pib_ultype = 3;
+    hab = WinInitialize(0);
+
+    WinEmptyClipbrd(hab);
+
+    WinCloseClipbrd(hab);
+    WinTerminate(hab);
+
+    return PDC_CLIP_SUCCESS;
+#else
+    return PDC_CLIP_ACCESS_ERROR;
+#endif
+}

data/vendor/PDCurses/os2/pdcdisp.c

@@ -0,0 +1,93 @@
+/* Public Domain Curses */
+
+#include "pdcos2.h"
+
+/* ACS definitions originally by jshumate@wrdis01.robins.af.mil -- these 
+   match code page 437 and compatible pages (CP850, CP852, etc.) */
+
+#ifdef CHTYPE_LONG
+
+# define A(x) ((chtype)x | A_ALTCHARSET)
+
+chtype acs_map[128] =
+{
+    A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9),
+    A(10), A(11), A(12), A(13), A(14), A(15), A(16), A(17), A(18),
+    A(19), A(20), A(21), A(22), A(23), A(24), A(25), A(26), A(27),
+    A(28), A(29), A(30), A(31), ' ', '!', '"', '#', '$', '%', '&',
+    '\'', '(', ')', '*',
+
+    A(0x1a), A(0x1b), A(0x18), A(0x19),
+
+    '/',
+
+    0xdb,
+
+    '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=',
+    '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+    'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+    'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
+
+    A(0x04), 0xb1,
+
+    'b', 'c', 'd', 'e',
+
+    0xf8, 0xf1, 0xb0, A(0x0f), 0xd9, 0xbf, 0xda, 0xc0, 0xc5, 0x2d,
+    0x2d, 0xc4, 0x2d, 0x5f, 0xc3, 0xb4, 0xc1, 0xc2, 0xb3, 0xf3,
+    0xf2, 0xe3, 0xd8, 0x9c, 0xf9,
+
+    A(127)
+};
+
+# undef A
+
+#endif
+
+/* position hardware cursor at (y, x) */
+
+void PDC_gotoyx(int row, int col)
+{
+    PDC_LOG(("PDC_gotoyx() - called: row %d col %d\n", row, col));
+
+#ifdef EMXVIDEO
+    v_gotoxy(col, row);
+#else
+    VioSetCurPos(row, col, 0);
+#endif
+}
+
+/* update the given physical line to look like the corresponding line in
+   curscr */
+
+void PDC_transform_line(int lineno, int x, int len, const chtype *srcp)
+{
+    /* this should be enough for the maximum width of a screen. */
+
+    struct {unsigned char text, attr;} temp_line[256];
+    int j;
+
+    PDC_LOG(("PDC_transform_line() - called: line %d\n", lineno));
+
+    /* replace the attribute part of the chtype with the 
+       actual color value for each chtype in the line */
+
+    for (j = 0; j < len; j++)
+    {
+        chtype ch = srcp[j];
+
+        temp_line[j].attr = pdc_atrtab[ch >> PDC_ATTR_SHIFT];
+
+#ifdef CHTYPE_LONG
+        if (ch & A_ALTCHARSET && !(ch & 0xff80))
+            ch = acs_map[ch & 0x7f];
+#endif
+        temp_line[j].text = ch & 0xff;
+    }
+
+#ifdef EMXVIDEO
+    v_putline((char *)temp_line, x, lineno, len);
+#else
+    VioWrtCellStr((PCH)temp_line, (USHORT)(len * sizeof(unsigned short)),
+                  (USHORT)lineno, (USHORT)x, 0);
+#endif
+}

data/vendor/PDCurses/os2/pdcgetsc.c

@@ -0,0 +1,89 @@
+/* Public Domain Curses */
+
+#include "pdcos2.h"
+
+/* return width of screen/viewport */
+
+int PDC_get_columns(void)
+{
+#ifdef EMXVIDEO
+    int rows = 0;
+#else
+    VIOMODEINFO modeInfo = {0};
+#endif
+    int cols = 0;
+    const char *env_cols;
+
+    PDC_LOG(("PDC_get_columns() - called\n"));
+
+#ifdef EMXVIDEO
+    v_dimen(&cols, &rows);
+#else
+    modeInfo.cb = sizeof(modeInfo);
+    VioGetMode(&modeInfo, 0);
+    cols = modeInfo.col;
+#endif
+    env_cols = getenv("COLS");
+
+    if (env_cols)
+        cols = min(atoi(env_cols), cols);
+
+    PDC_LOG(("PDC_get_columns() - returned: cols %d\n", cols));
+
+    return cols;
+}
+
+/* get the cursor size/shape */
+
+int PDC_get_cursor_mode(void)
+{
+#ifdef EMXVIDEO
+    int curstart = 0, curend = 0;
+#else
+    VIOCURSORINFO cursorInfo;
+#endif
+    PDC_LOG(("PDC_get_cursor_mode() - called\n"));
+
+#ifdef EMXVIDEO
+    v_getctype(&curstart, &curend);
+    return (curstart << 8) | curend;
+#else
+    VioGetCurType (&cursorInfo, 0);
+
+    return (cursorInfo.yStart << 8) | cursorInfo.cEnd;
+#endif
+}
+
+/* return number of screen rows */
+
+int PDC_get_rows(void)
+{
+#ifdef EMXVIDEO
+    int cols = 0;
+#else
+    VIOMODEINFO modeInfo = {0};
+#endif
+    int rows = 0;
+    const char *env_rows;
+
+    PDC_LOG(("PDC_get_rows() - called\n"));
+
+    /* use the value from LINES environment variable, if set. MH 10-Jun-92 */
+    /* and use the minimum of LINES and *ROWS.                MH 18-Jun-92 */
+
+#ifdef EMXVIDEO
+    v_dimen(&cols, &rows);
+#else
+    modeInfo.cb = sizeof(modeInfo);
+    VioGetMode(&modeInfo, 0);
+    rows = modeInfo.row;
+#endif
+    env_rows = getenv("LINES");
+
+    if (env_rows)
+        rows = min(atoi(env_rows), rows);
+
+    PDC_LOG(("PDC_get_rows() - returned: rows %d\n", rows));
+
+    return rows;
+}

data/vendor/PDCurses/os2/pdckbd.c

@@ -0,0 +1,521 @@
+/* Public Domain Curses */
+
+#if defined(__EMX__) || defined(__WATCOMC__) || defined(__IBMC__) || \
+defined(__TURBOC__)
+# define HAVE_SIGNAL
+# include <signal.h>
+#endif
+
+#include "pdcos2.h"
+
+/*man-start**************************************************************
+
+pdckbd
+------
+
+### Synopsis
+
+    unsigned long PDC_get_input_fd(void);
+
+### Description
+
+   PDC_get_input_fd() returns the file descriptor that PDCurses
+   reads its input from. It can be used for select().
+
+### Portability
+                             X/Open    BSD    SYS V
+    PDC_get_input_fd            -       -       -
+
+**man-end****************************************************************/
+
+#ifdef EMXVIDEO
+# include <termios.h>
+static int tahead = -1;
+#else
+static KBDINFO kbdinfo;     /* default keyboard mode */
+static HMOU mouse_handle = 0;
+static MOUSE_STATUS old_mouse_status;
+static USHORT old_shift = 0;
+static bool key_pressed = FALSE;
+static int mouse_events = 0;
+#endif
+
+/************************************************************************
+ *    Table for key code translation of function keys in keypad mode    *
+ *    These values are for strict IBM keyboard compatibles only         *
+ ************************************************************************/
+
+static short key_table[] =
+{
+    -1,             ALT_ESC,        -1,             0,
+    -1,             -1,             -1,             -1,
+    -1,             -1,             -1,             -1,
+    -1,             -1,             ALT_BKSP,       KEY_BTAB,
+    ALT_Q,          ALT_W,          ALT_E,          ALT_R,
+    ALT_T,          ALT_Y,          ALT_U,          ALT_I,
+    ALT_O,          ALT_P,          ALT_LBRACKET,   ALT_RBRACKET,
+    ALT_ENTER,      -1,             ALT_A,          ALT_S,
+    ALT_D,          ALT_F,          ALT_G,          ALT_H,
+    ALT_J,          ALT_K,          ALT_L,          ALT_SEMICOLON,
+    ALT_FQUOTE,     ALT_BQUOTE,     -1,             ALT_BSLASH,
+    ALT_Z,          ALT_X,          ALT_C,          ALT_V,
+    ALT_B,          ALT_N,          ALT_M,          ALT_COMMA,
+    ALT_STOP,       ALT_FSLASH,     -1,             ALT_PADSTAR,
+    -1,             -1,             -1,             KEY_F(1),
+    KEY_F(2),       KEY_F(3),       KEY_F(4),       KEY_F(5),
+    KEY_F(6),       KEY_F(7),       KEY_F(8),       KEY_F(9),
+    KEY_F(10),      -1,             -1,             KEY_HOME,
+    KEY_UP,         KEY_PPAGE,      ALT_PADMINUS,   KEY_LEFT,
+    KEY_B2,         KEY_RIGHT,      ALT_PADPLUS,    KEY_END,
+    KEY_DOWN,       KEY_NPAGE,      KEY_IC,         KEY_DC,
+    KEY_F(13),      KEY_F(14),      KEY_F(15),      KEY_F(16),
+    KEY_F(17),      KEY_F(18),      KEY_F(19),      KEY_F(20),
+    KEY_F(21),      KEY_F(22),      KEY_F(25),      KEY_F(26),
+    KEY_F(27),      KEY_F(28),      KEY_F(29),      KEY_F(30),
+    KEY_F(31),      KEY_F(32),      KEY_F(33),      KEY_F(34),
+    KEY_F(37),      KEY_F(38),      KEY_F(39),      KEY_F(40),
+    KEY_F(41),      KEY_F(42),      KEY_F(43),      KEY_F(44),
+    KEY_F(45),      KEY_F(46),      -1,             CTL_LEFT,
+    CTL_RIGHT,      CTL_END,        CTL_PGDN,       CTL_HOME,
+    ALT_1,          ALT_2,          ALT_3,          ALT_4,
+    ALT_5,          ALT_6,          ALT_7,          ALT_8,
+    ALT_9,          ALT_0,          ALT_MINUS,      ALT_EQUAL,
+    CTL_PGUP,       KEY_F(11),      KEY_F(12),      KEY_F(23),
+    KEY_F(24),      KEY_F(35),      KEY_F(36),      KEY_F(47),
+    KEY_F(48),      CTL_UP,         CTL_PADMINUS,   CTL_PADCENTER,
+    CTL_PADPLUS,    CTL_DOWN,       CTL_INS,        CTL_DEL,
+    CTL_TAB,        CTL_PADSLASH,   CTL_PADSTAR,    ALT_HOME,
+    ALT_UP,         ALT_PGUP,       -1,             ALT_LEFT,
+    -1,             ALT_RIGHT,      -1,             ALT_END,
+    ALT_DOWN,       ALT_PGDN,       ALT_INS,        ALT_DEL,
+    ALT_PADSLASH,   ALT_TAB,        ALT_PADENTER,   -1
+};
+
+unsigned long pdc_key_modifiers = 0L;
+
+unsigned long PDC_get_input_fd(void)
+{
+    PDC_LOG(("PDC_get_input_fd() - called\n"));
+
+    return (unsigned long)fileno(stdin);
+}
+
+#ifndef EMXVIDEO
+
+void PDC_get_keyboard_info(void)
+{
+    kbdinfo.cb = sizeof(kbdinfo);
+    KbdGetStatus(&kbdinfo, 0);
+}
+
+void PDC_set_keyboard_default(void)
+{
+    KbdSetStatus(&kbdinfo, 0);
+}
+
+#endif /* ifndef EMXVIDEO */
+
+void PDC_set_keyboard_binary(bool on)
+{
+    PDC_LOG(("PDC_set_keyboard_binary() - called\n"));
+
+#ifndef EMXVIDEO
+    if (on)
+    {
+        kbdinfo.fsMask &= ~(KEYBOARD_ASCII_MODE);
+        kbdinfo.fsMask |= KEYBOARD_BINARY_MODE;
+    }
+    else
+    {
+        kbdinfo.fsMask &= ~(KEYBOARD_BINARY_MODE);
+        kbdinfo.fsMask |= KEYBOARD_ASCII_MODE;
+    }
+
+    KbdSetStatus(&kbdinfo, 0);
+#endif
+
+#ifdef HAVE_SIGNAL
+    signal(SIGBREAK, on ? SIG_IGN : SIG_DFL);
+#endif
+}
+
+/* check if a key or mouse event is waiting */
+
+bool PDC_check_key(void)
+{
+#if !defined(_MSC_VER) && !defined(EMXVIDEO)
+    KBDKEYINFO keyInfo = {0};
+#endif
+
+#ifdef EMXVIDEO
+    if (tahead == -1)       /* Nothing typed yet */
+    {                    
+        tahead = _read_kbd(0, 0, 0);
+
+        /* Read additional */
+
+        if (tahead == 0)    
+            tahead = _read_kbd(0, 1, 0) << 8;
+    }
+
+    return (tahead != -1);
+#else
+# ifndef _MSC_VER
+
+    KbdGetStatus(&kbdinfo, 0);
+
+    if (mouse_handle)
+    {
+        MOUQUEINFO queue;
+
+        MouGetNumQueEl(&queue, mouse_handle);
+        mouse_events = queue.cEvents;
+
+        if (mouse_events)
+            return TRUE;
+    }
+
+    if (old_shift && !kbdinfo.fsState)  /* modifier released */
+    {
+        if (!key_pressed && SP->return_key_modifiers)
+            return TRUE;
+    }
+    else if (!old_shift && kbdinfo.fsState) /* modifier pressed */
+        key_pressed = FALSE;
+
+    old_shift = kbdinfo.fsState;
+
+    KbdPeek(&keyInfo, 0);   /* peek at keyboard  */
+    return (keyInfo.fbStatus != 0);
+# else
+    return kbhit();
+# endif
+#endif
+}         
+
+#ifndef EMXVIDEO
+
+static int _process_mouse_events(void)
+{
+    MOUEVENTINFO event;
+    static const USHORT button_mask[] = {6, 96, 24},
+                        move_mask[] = {2, 32, 8},
+                        press_mask[] = {4, 64, 16};
+    USHORT count = 1;
+    short shift_flags = 0;
+    int i;
+
+    MouReadEventQue(&event, &count, mouse_handle);
+    mouse_events--;
+
+    for (i = 0; i < 3; i++)
+    {
+        pdc_mouse_status.button[i] =
+            ((event.fs & move_mask[i]) ? BUTTON_MOVED : 0) |
+            ((event.fs & press_mask[i]) ? BUTTON_PRESSED : 0);
+
+        /* PRESS events are sometimes mistakenly reported as MOVE 
+           events. A MOVE should always follow a PRESS, so treat a MOVE 
+           immediately after a RELEASE as a PRESS. */
+
+        if ((pdc_mouse_status.button[i] == BUTTON_MOVED) &&
+            (old_mouse_status.button[i] == BUTTON_RELEASED))
+        {
+            pdc_mouse_status.button[i] = BUTTON_PRESSED;
+        }
+
+        if (pdc_mouse_status.button[i] == BUTTON_PRESSED && SP->mouse_wait)
+        {
+            /* Check for a click -- a PRESS followed immediately by a 
+               release */
+
+            if (!mouse_events)
+            {
+                MOUQUEINFO queue;
+
+                napms(SP->mouse_wait);
+
+                MouGetNumQueEl(&queue, mouse_handle);
+                mouse_events = queue.cEvents;
+            }
+
+            if (mouse_events)
+            {
+                MouReadEventQue(&event, &count, mouse_handle);
+
+                if (!(event.fs & button_mask[i]))
+                    pdc_mouse_status.button[i] = BUTTON_CLICKED;
+            }
+        }
+    }
+
+    pdc_mouse_status.x = event.col;
+    pdc_mouse_status.y = event.row;
+
+    pdc_mouse_status.changes = 0;
+
+    for (i = 0; i < 3; i++)
+    {
+        if (old_mouse_status.button[i] != pdc_mouse_status.button[i])
+            pdc_mouse_status.changes |= (1 << i);
+
+        if (pdc_mouse_status.button[i] == BUTTON_MOVED)
+        {
+            /* Discard non-moved "moves" */
+
+            if (pdc_mouse_status.x == old_mouse_status.x &&
+                pdc_mouse_status.y == old_mouse_status.y)
+                return -1;
+
+            /* Motion events always flag the button as changed */
+
+            pdc_mouse_status.changes |= (1 << i);
+            pdc_mouse_status.changes |= PDC_MOUSE_MOVED;
+            break;
+        }
+    }
+
+    old_mouse_status = pdc_mouse_status;
+
+    /* Treat click events as release events for comparison purposes */
+
+    for (i = 0; i < 3; i++)
+    {
+        if (old_mouse_status.button[i] == BUTTON_CLICKED)
+            old_mouse_status.button[i] = BUTTON_RELEASED;
+    }
+
+    /* Check for SHIFT/CONTROL/ALT */
+
+    if (kbdinfo.fsState & KBDSTF_ALT)
+        shift_flags |= BUTTON_ALT;
+
+    if (kbdinfo.fsState & KBDSTF_CONTROL)
+        shift_flags |= BUTTON_CONTROL;
+
+    if (kbdinfo.fsState & (KBDSTF_LEFTSHIFT|KBDSTF_RIGHTSHIFT))
+        shift_flags |= BUTTON_SHIFT;
+
+    if (shift_flags)
+    {
+        for (i = 0; i < 3; i++)
+        {
+            if (pdc_mouse_status.changes & (1 << i))
+                pdc_mouse_status.button[i] |= shift_flags;
+        }
+    }
+
+    old_shift = kbdinfo.fsState;
+    key_pressed = TRUE;
+
+    SP->key_code = TRUE;
+    return KEY_MOUSE;
+}
+
+#endif
+
+/* return the next available key or mouse event */
+
+int PDC_get_key(void)
+{
+    int key, scan;
+#ifndef EMXVIDEO
+    KBDKEYINFO keyInfo = {0};
+#endif
+
+#ifdef EMXVIDEO
+    if (tahead == -1)
+    {
+        tahead = _read_kbd(0, 1, 0);
+
+        /* Read additional */
+
+        if (tahead == 0)
+            tahead = _read_kbd(0, 1, 0) << 8;
+    }
+
+    key = tahead & 0xff;
+    scan = tahead >> 8;
+    pdc_key_modifiers = 0L;
+
+    tahead = -1;
+#else
+    pdc_key_modifiers = 0L;
+
+    if (mouse_handle && mouse_events)
+        return _process_mouse_events();
+
+    if (old_shift && !kbdinfo.fsState)
+    {
+        key = -1;
+
+        if (old_shift & KBDSTF_LEFTALT)
+        {
+            key = KEY_ALT_L;
+        }
+        else if (old_shift & KBDSTF_RIGHTALT)
+        {
+            key = KEY_ALT_R;
+        }
+        else if (old_shift & KBDSTF_LEFTCONTROL)
+        {
+            key = KEY_CONTROL_L;
+        }
+        else if (old_shift & KBDSTF_RIGHTCONTROL)
+        {
+            key = KEY_CONTROL_R;
+        }
+        else if (old_shift & KBDSTF_LEFTSHIFT)
+        {
+            key = KEY_SHIFT_L;
+        }
+        else if (old_shift & KBDSTF_RIGHTSHIFT)
+        {
+            key = KEY_SHIFT_R;
+        }
+
+        key_pressed = FALSE;
+        old_shift = kbdinfo.fsState;
+
+        SP->key_code = TRUE;
+        return key;
+    }
+
+    KbdCharIn(&keyInfo, IO_WAIT, 0);    /* get a character */
+
+    key = keyInfo.chChar;
+    scan = keyInfo.chScan;
+
+    if (SP->save_key_modifiers)
+    {
+        if (keyInfo.fsState & KBDSTF_ALT)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_ALT;
+
+        if (keyInfo.fsState & KBDSTF_CONTROL)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_CONTROL;
+
+        if (keyInfo.fsState & KBDSTF_NUMLOCK_ON)
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_NUMLOCK;
+
+        if (keyInfo.fsState & (KBDSTF_LEFTSHIFT|KBDSTF_RIGHTSHIFT))
+            pdc_key_modifiers |= PDC_KEY_MODIFIER_SHIFT;
+    }
+#endif
+    if (scan == 0x1c && key == 0x0a)    /* ^Enter */
+        key = CTL_ENTER;
+    else if (scan == 0xe0 && key == 0x0d)   /* PadEnter */
+        key = PADENTER;
+    else if (scan == 0xe0 && key == 0x0a)   /* ^PadEnter */
+        key = CTL_PADENTER;
+    else if (scan == 0x37 && key == 0x2a)   /* Star */
+        key = PADSTAR;
+    else if (scan == 0x4a && key == 0x2d)   /* Minus */
+        key = PADMINUS;
+    else if (scan == 0x4e && key == 0x2b)   /* Plus */
+        key = PADPLUS;
+    else if (scan == 0xe0 && key == 0x2f)   /* Slash */
+        key = PADSLASH;
+    else if (key == 0x00 || (key == 0xe0 && scan > 53 && scan != 86))
+        key = (scan > 0xa7) ? -1 : key_table[scan];
+
+    if (keyInfo.fsState & (KBDSTF_LEFTSHIFT|KBDSTF_RIGHTSHIFT))
+    {
+        switch (key)
+        {
+        case KEY_HOME:  /* Shift Home */
+            key = KEY_SHOME;
+            break;
+        case KEY_UP:    /* Shift Up */
+            key = KEY_SUP;
+            break;
+        case KEY_PPAGE: /* Shift PgUp */
+            key = KEY_SPREVIOUS;
+            break;
+        case KEY_LEFT:  /* Shift Left */
+            key = KEY_SLEFT;
+            break;
+        case KEY_RIGHT: /* Shift Right */
+            key = KEY_SRIGHT;
+            break;
+        case KEY_END:   /* Shift End */
+            key = KEY_SEND;
+            break;
+        case KEY_DOWN:  /* Shift Down */
+            key = KEY_SDOWN;
+            break;
+        case KEY_NPAGE: /* Shift PgDn */
+            key = KEY_SNEXT;
+            break;
+        case KEY_IC:    /* Shift Ins */
+            key = KEY_SIC;
+            break;
+        case KEY_DC:    /* Shift Del */
+            key = KEY_SDC;
+        }
+    }
+
+    key_pressed = TRUE;
+    SP->key_code = ((unsigned)key >= 256);
+
+    return key;
+}
+
+/* discard any pending keyboard or mouse input -- this is the core
+   routine for flushinp() */
+
+void PDC_flushinp(void)
+{
+    PDC_LOG(("PDC_flushinp() - called\n"));
+
+#ifdef EMXVIDEO
+    tcflush(0, TCIFLUSH);
+#else
+    if (mouse_handle)
+        MouFlushQue(mouse_handle);
+
+    KbdFlushBuffer(0);
+#endif
+}
+
+int PDC_mouse_set(void)
+{
+#ifndef EMXVIDEO
+
+    unsigned long mbe = SP->_trap_mbe;
+
+    if (mbe && !mouse_handle)
+    {
+        memset(&old_mouse_status, 0, sizeof(MOUSE_STATUS));
+        MouOpen(NULL, &mouse_handle);
+        if (mouse_handle)
+            MouDrawPtr(mouse_handle);
+    }
+    else if (!mbe && mouse_handle)
+    {
+        MouClose(mouse_handle);
+        mouse_handle = 0;
+    }
+
+    if (mbe && mouse_handle)
+    {
+        USHORT mask = ((mbe & (BUTTON1_PRESSED | BUTTON1_CLICKED |
+                               BUTTON1_MOVED)) ? 6 : 0) |
+
+                      ((mbe & (BUTTON3_PRESSED | BUTTON3_CLICKED | 
+                               BUTTON3_MOVED)) ? 24 : 0) |
+
+                      ((mbe & (BUTTON2_PRESSED | BUTTON2_CLICKED | 
+                               BUTTON2_MOVED)) ? 96 : 0);
+
+        MouSetEventMask(&mask, mouse_handle);
+    }
+#endif
+    return OK;
+}
+
+int PDC_modifiers_set(void)
+{
+    key_pressed = FALSE;
+
+    return OK;
+}