curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/dosvga/pdckbd.c

@@ -0,0 +1,484 @@
+/* PDCurses */
+
+#include "pdcdos.h"
+
+#ifdef __DJGPP__
+# include <fcntl.h>
+# include <io.h>
+# include <signal.h>
+#endif
+
+/************************************************************************
+ *    Table for key code translation of function keys in keypad mode    *
+ *    These values are for strict IBM keyboard compatibles only         *
+ ************************************************************************/
+
+#ifdef PDC_WIDE
+   typedef int32_t key_t;
+#else
+   typedef int key_t;
+#endif
+
+static key_t 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
+};
+
+static struct {unsigned short pressed, released;} button[3];
+
+static bool mouse_avail = FALSE, mouse_vis = FALSE, mouse_moved = FALSE,
+            mouse_button = FALSE, key_pressed = FALSE;
+
+static unsigned char mouse_scroll = 0;
+static PDCREGS ms_regs, old_ms;
+static unsigned short shift_status, old_shift = 0;
+static unsigned char keyboard_function = 0xff, shift_function = 0xff,
+                     check_function = 0xff;
+
+static const unsigned short button_map[3] = {0, 2, 1};
+
+void PDC_set_keyboard_binary(bool on)
+{
+    PDC_LOG(("PDC_set_keyboard_binary() - called\n"));
+
+#ifdef __DJGPP__
+    setmode(fileno(stdin), on ? O_BINARY : O_TEXT);
+    signal(SIGINT, on ? SIG_IGN : SIG_DFL);
+#else
+    INTENTIONALLY_UNUSED_PARAMETER(on);
+#endif
+}
+
+/* check if a key or mouse event is waiting */
+
+bool PDC_check_key(void)
+{
+    PDCREGS regs;
+
+    if (shift_function == 0xff)
+    {
+        int scan;
+
+        /* get shift status for all keyboards */
+
+        regs.h.ah = 0x02;
+        PDCINT(0x16, regs);
+        scan = regs.h.al;
+
+        /* get shift status for enhanced keyboards */
+
+        regs.h.ah = 0x12;
+        PDCINT(0x16, regs);
+
+        if (scan == regs.h.al && getdosmembyte(0x496) == 0x10)
+        {
+            keyboard_function = 0x10;
+            check_function = 0x11;
+            shift_function = 0x12;
+        }
+        else
+        {
+            keyboard_function = 0;
+            check_function = 1;
+            shift_function = 2;
+        }
+    }
+
+    regs.h.ah = shift_function;
+    PDCINT(0x16, regs);
+
+    shift_status = regs.W.ax;
+
+    if (mouse_vis)
+    {
+        unsigned short i;
+
+        ms_regs.W.ax = 3;
+        PDCINT(0x33, ms_regs);
+
+        mouse_button = FALSE;
+
+        for (i = 0; i < 3; i++)
+        {
+            regs.W.ax = 6;
+            regs.W.bx = button_map[i];
+            PDCINT(0x33, regs);
+            button[i].released = regs.W.bx;
+            if (regs.W.bx)
+            {
+                ms_regs.W.cx = regs.W.cx;
+                ms_regs.W.dx = regs.W.dx;
+                mouse_button = TRUE;
+            }
+
+            regs.W.ax = 5;
+            regs.W.bx = button_map[i];
+            PDCINT(0x33, regs);
+            button[i].pressed = regs.W.bx;
+            if (regs.W.bx)
+            {
+                ms_regs.W.cx = regs.W.cx;
+                ms_regs.W.dx = regs.W.dx;
+                mouse_button = TRUE;
+            }
+        }
+
+        mouse_scroll = ms_regs.h.bh;
+
+        mouse_moved = !mouse_button && ms_regs.h.bl &&
+                       ms_regs.h.bl == old_ms.h.bl &&
+                    (((ms_regs.W.cx / PDC_state.font_width) ^ (old_ms.W.cx / PDC_state.font_width)) ||
+                     ((ms_regs.W.dx / PDC_state.font_height) ^ (old_ms.W.dx / PDC_state.font_height)));
+
+        if (mouse_scroll || mouse_button || mouse_moved)
+            return TRUE;
+    }
+
+    if (old_shift && !shift_status)     /* modifier released */
+    {
+        if (!key_pressed && SP->return_key_modifiers)
+            return TRUE;
+    }
+    else if (!old_shift && shift_status)    /* modifier pressed */
+        key_pressed = FALSE;
+
+    old_shift = shift_status;
+
+    regs.h.ah = check_function;
+    PDCINT(0x16, regs);
+
+    return !(regs.W.flags & 64);
+}
+
+static int _process_mouse_events(void)
+{
+    int i;
+    short shift_flags = 0;
+
+    memset(&SP->mouse_status, 0, sizeof(SP->mouse_status));
+
+    key_pressed = TRUE;
+    old_shift = shift_status;
+
+    /* Set shift modifiers */
+
+    if (shift_status & 3)
+        shift_flags |= BUTTON_SHIFT;
+
+    if (shift_status & 4)
+        shift_flags |= BUTTON_CONTROL;
+
+    if (shift_status & 8)
+        shift_flags |= BUTTON_ALT;
+
+    /* Scroll wheel support for CuteMouse */
+
+    if (mouse_scroll)
+    {
+        SP->mouse_status.changes = mouse_scroll & 0x80 ?
+            PDC_MOUSE_WHEEL_UP : PDC_MOUSE_WHEEL_DOWN;
+
+        SP->mouse_status.x = ms_regs.W.cx / PDC_state.font_width;
+        SP->mouse_status.y = ms_regs.W.dx / PDC_state.font_height;
+
+        return (int)KEY_MOUSE;
+    }
+
+    if (mouse_moved)
+    {
+        SP->mouse_status.changes = PDC_MOUSE_MOVED;
+
+        for (i = 0; i < 3; i++)
+        {
+            if (ms_regs.h.bl & (1 << button_map[i]))
+            {
+                SP->mouse_status.button[i] = BUTTON_MOVED | shift_flags;
+                SP->mouse_status.changes |= (1 << i);
+            }
+        }
+    }
+    else    /* button event */
+    {
+        for (i = 0; i < 3; i++)
+        {
+            if (button[i].pressed)
+            {
+                /* Check for a click -- a PRESS followed
+                   immediately by a release */
+
+                if (!button[i].released)
+                {
+                    if (SP->mouse_wait)
+                    {
+                        PDCREGS regs;
+
+                        napms(SP->mouse_wait);
+
+                        regs.W.ax = 6;
+                        regs.W.bx = button_map[i];
+                        PDCINT(0x33, regs);
+
+                        SP->mouse_status.button[i] = regs.W.bx ?
+                            BUTTON_CLICKED : BUTTON_PRESSED;
+                    }
+                    else
+                        SP->mouse_status.button[i] = BUTTON_PRESSED;
+                }
+                else
+                    SP->mouse_status.button[i] = BUTTON_CLICKED;
+            }
+
+            if (button[i].pressed || button[i].released)
+            {
+                SP->mouse_status.button[i] |= shift_flags;
+                SP->mouse_status.changes |= (1 << i);
+            }
+        }
+    }
+
+    SP->mouse_status.x = ms_regs.W.cx / PDC_state.font_width;
+    SP->mouse_status.y = ms_regs.W.dx / PDC_state.font_height;
+
+    old_ms = ms_regs;
+
+    return (int)KEY_MOUSE;
+}
+
+/* return the next available key or mouse event */
+
+int PDC_get_key(void)
+{
+    PDCREGS regs;
+    key_t key;
+    int scan;
+
+    SP->key_modifiers = 0;
+
+    if (mouse_vis && (mouse_scroll || mouse_button || mouse_moved))
+        return _process_mouse_events();
+
+    /* Return modifiers as keys? */
+
+    if (old_shift && !shift_status)
+    {
+        key = -1;
+
+        if (old_shift & 1)
+            key = KEY_SHIFT_R;
+
+        if (old_shift & 2)
+            key = KEY_SHIFT_L;
+
+        if (shift_function == 0x12)
+        {
+            if (old_shift & 0x400)
+                key = KEY_CONTROL_R;
+
+            if (old_shift & 0x100)
+                key = KEY_CONTROL_L;
+
+            if (old_shift & 0x800)
+                key = KEY_ALT_R;
+
+            if (old_shift & 0x200)
+                key = KEY_ALT_L;
+        }
+        else
+        {
+            if (old_shift & 4)
+                key = KEY_CONTROL_R;
+
+            if (old_shift & 8)
+                key = KEY_ALT_R;
+        }
+
+        key_pressed = FALSE;
+        old_shift = shift_status;
+
+        return key;
+    }
+
+    regs.h.ah = keyboard_function;
+    PDCINT(0x16, regs);
+    key = regs.h.al;
+    scan = regs.h.ah;
+
+    if (shift_status & 3)
+        SP->key_modifiers |= PDC_KEY_MODIFIER_SHIFT;
+
+    if (shift_status & 4)
+        SP->key_modifiers |= PDC_KEY_MODIFIER_CONTROL;
+
+    if (shift_status & 8)
+        SP->key_modifiers |= PDC_KEY_MODIFIER_ALT;
+
+    if (shift_status & 0x20)
+        SP->key_modifiers |= PDC_KEY_MODIFIER_NUMLOCK;
+
+    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 (shift_status & 3)
+    {
+        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;
+
+    return (int)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"));
+
+    /* Force the BIOS keyboard buffer head and tail pointers to be
+       the same...  Real nasty trick... */
+
+    setdosmemword(0x41a, getdosmemword(0x41c));
+}
+
+bool PDC_has_mouse(void)
+{
+    PDCREGS regs;
+
+    if (!mouse_avail)
+    {
+        regs.W.ax = 0;
+        PDCINT(0x33, regs);
+
+        mouse_avail = !!(regs.W.ax);
+    }
+
+    return mouse_avail;
+}
+
+int PDC_mouse_set(void)
+{
+    PDCREGS regs;
+    unsigned long mbe = SP->_trap_mbe;
+
+    if (mbe && !mouse_avail)
+        mouse_avail = PDC_has_mouse();
+
+    if (mbe)
+    {
+        if (mouse_avail && !mouse_vis)
+        {
+            memset(&old_ms, 0, sizeof(old_ms));
+
+            regs.W.ax = 1;
+            PDCINT(0x33, regs);
+
+            mouse_vis = TRUE;
+        }
+    }
+    else
+    {
+        if (mouse_avail && mouse_vis)
+        {
+            regs.W.ax = 2;
+            PDCINT(0x33, regs);
+
+            mouse_vis = FALSE;
+        }
+    }
+
+    return (mouse_avail || !mbe) ? OK : ERR;
+}
+
+int PDC_modifiers_set(void)
+{
+    key_pressed = FALSE;
+
+    return OK;
+}