curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/dos/pdcdos.h

@@ -0,0 +1,173 @@
+/* PDCurses */
+
+#include <curspriv.h>
+
+#if defined( PDC_WIDE)
+   #error DOS port has no WIDE support
+#endif
+
+#include <string.h>
+
+/*----------------------------------------------------------------------
+ *  MEMORY MODEL SUPPORT:
+ *
+ *  MODELS
+ *    TINY    cs,ds,ss all in 1 segment (not enough memory!)
+ *    SMALL   cs:1 segment, ds:1 segment
+ *    MEDIUM  cs:many segments, ds:1 segment
+ *    COMPACT cs:1 segment, ds:many segments
+ *    LARGE   cs:many segments, ds:many segments
+ *    HUGE    cs:many segments, ds:segments > 64K
+ */
+
+#ifdef __TINY__
+# define SMALL 1
+#endif
+#ifdef __SMALL__
+# define SMALL 1
+#endif
+#ifdef __MEDIUM__
+# define MEDIUM 1
+#endif
+#ifdef __COMPACT__
+# define COMPACT 1
+#endif
+#ifdef __LARGE__
+# define LARGE 1
+#endif
+#ifdef __HUGE__
+# define HUGE 1
+#endif
+
+#include <dos.h>
+
+extern short pdc_curstoreal[16];
+extern int pdc_adapter;
+extern int pdc_scrnmode;
+extern int pdc_font;
+extern bool pdc_direct_video;
+extern bool pdc_bogus_adapter;
+extern unsigned pdc_video_seg;
+extern unsigned pdc_video_ofs;
+
+#ifdef __DJGPP__        /* Note: works only in plain DOS... */
+# if DJGPP == 2
+#  define _FAR_POINTER(s,o) ((((int)(s)) << 4) + ((int)(o)))
+# else
+#  define _FAR_POINTER(s,o) (0xe0000000 + (((int)(s)) << 4) + ((int)(o)))
+# endif
+# define _FP_SEGMENT(p)     (unsigned short)((((long)p) >> 4) & 0xffff)
+#else
+# ifdef __TURBOC__
+#  define _FAR_POINTER(s,o) MK_FP(s,o)
+# else
+#  if defined(__WATCOMC__) && defined(__FLAT__)
+#   define _FAR_POINTER(s,o) ((((int)(s)) << 4) + ((int)(o)))
+#  else
+#   define _FAR_POINTER(s,o) (((long)s << 16) | (long)o)
+#  endif
+# endif
+# define _FP_SEGMENT(p)     (unsigned short)(((long)p) >> 4)
+#endif
+#define _FP_OFFSET(p)       ((unsigned short)p & 0x000f)
+
+#ifdef __DJGPP__
+# include <sys/movedata.h>
+unsigned char getdosmembyte(int offs);
+unsigned short getdosmemword(int offs);
+unsigned long getdosmemdword(int offs);
+void setdosmembyte(int offs, unsigned char b);
+void setdosmemword(int offs, unsigned short w);
+#else
+# if SMALL || MEDIUM
+#  define PDC_FAR far
+# else
+#  define PDC_FAR
+# endif
+# define getdosmembyte(offs) \
+    (*((unsigned char PDC_FAR *) _FAR_POINTER(0,offs)))
+# define getdosmemword(offs) \
+    (*((unsigned short PDC_FAR *) _FAR_POINTER(0,offs)))
+# define getdosmemdword(offs) \
+    (*((unsigned long PDC_FAR *) _FAR_POINTER(0,offs)))
+# define setdosmembyte(offs,x) \
+    (*((unsigned char PDC_FAR *) _FAR_POINTER(0,offs)) = (x))
+# define setdosmemword(offs,x) \
+    (*((unsigned short PDC_FAR *) _FAR_POINTER(0,offs)) = (x))
+#endif
+
+#if defined(__WATCOMC__) && defined(__386__)
+
+typedef union
+{
+    struct
+    {
+        unsigned long edi, esi, ebp, res, ebx, edx, ecx, eax;
+    } d;
+
+    struct
+    {
+        unsigned short di, di_hi, si, si_hi, bp, bp_hi, res, res_hi,
+                       bx, bx_hi, dx, dx_hi, cx, cx_hi, ax, ax_hi,
+                       flags, es, ds, fs, gs, ip, cs, sp, ss;
+    } w;
+
+    struct
+    {
+        unsigned char edi[4], esi[4], ebp[4], res[4],
+                      bl, bh, ebx_b2, ebx_b3, dl, dh, edx_b2, edx_b3,
+                      cl, ch, ecx_b2, ecx_b3, al, ah, eax_b2, eax_b3;
+    } h;
+} pdc_dpmi_regs;
+
+void PDC_dpmi_int(int, pdc_dpmi_regs *);
+
+#endif
+
+#ifdef __DJGPP__
+# include <dpmi.h>
+# define PDCREGS __dpmi_regs
+# define PDCINT(vector, regs) __dpmi_int(vector, &regs)
+#else
+# ifdef __WATCOMC__
+#  ifdef __386__
+#   define PDCREGS pdc_dpmi_regs
+#   define PDCINT(vector, regs) PDC_dpmi_int(vector, &regs)
+#  else
+#   define PDCREGS union REGPACK
+#   define PDCINT(vector, regs) intr(vector, &regs)
+#  endif
+# else
+#  define PDCREGS union REGS
+#  define PDCINT(vector, regs) int86(vector, &regs, &regs)
+# endif
+#endif
+
+/* Wide registers in REGS: w or x? */
+
+#ifdef __WATCOMC__
+# define W w
+#else
+# define W x
+#endif
+
+/* Monitor (terminal) type information */
+
+enum
+{
+    _NONE, _MDA, _CGA,
+    _EGACOLOR = 0x04, _EGAMONO,
+    _VGACOLOR = 0x07, _VGAMONO,
+    _MCGACOLOR = 0x0a, _MCGAMONO,
+    _MDS_GENIUS = 0x30
+};
+
+/* Text-mode font size information */
+
+enum
+{
+    _FONT8 = 8,
+    _FONT14 = 14,
+    _FONT15,    /* GENIUS */
+    _FONT16
+};

data/vendor/PDCursesMod/dos/pdcgetsc.c

@@ -0,0 +1,81 @@
+/* PDCurses */
+
+#include "pdcdos.h"
+
+#include <stdlib.h>
+
+/* return width of screen/viewport */
+
+int PDC_get_columns(void)
+{
+    PDCREGS regs;
+    int cols;
+
+    PDC_LOG(("PDC_get_columns() - called\n"));
+
+    regs.h.ah = 0x0f;
+    PDCINT(0x10, regs);
+    cols = (int)regs.h.ah;
+
+    PDC_LOG(("PDC_get_columns() - returned: cols %d\n", cols));
+
+    return cols;
+}
+
+/* get the cursor size/shape */
+
+int PDC_get_cursor_mode(void)
+{
+    PDC_LOG(("PDC_get_cursor_mode() - called\n"));
+
+    return getdosmemword(0x460);
+}
+
+/* return number of screen rows */
+
+int PDC_get_rows(void)
+{
+    int rows;
+
+    PDC_LOG(("PDC_get_rows() - called\n"));
+
+    rows = getdosmembyte(0x484) + 1;
+
+    if (rows == 1 && pdc_adapter == _MDS_GENIUS)
+        rows = 66;
+    if (rows == 1 && pdc_adapter == _MDA)
+        rows = 25;
+
+    if (rows == 1)
+    {
+        rows = 25;
+        pdc_direct_video = FALSE;
+    }
+
+    switch (pdc_adapter)
+    {
+    case _EGACOLOR:
+    case _EGAMONO:
+        switch (rows)
+        {
+        case 25:
+        case 43:
+            break;
+        default:
+            rows = 25;
+        }
+        break;
+
+    case _VGACOLOR:
+    case _VGAMONO:
+        break;
+
+    default:
+        rows = 25;
+        break;
+    }
+
+    PDC_LOG(("PDC_get_rows() - returned: rows %d\n", rows));
+
+    return rows;
+}

data/vendor/PDCursesMod/dos/pdckbd.c

@@ -0,0 +1,428 @@
+/* PDCurses */
+
+#include "pdcdos.h"
+
+#ifdef __DJGPP__
+# include <fcntl.h>
+# include <io.h>
+# include <signal.h>
+#endif
+
+#include "../common/dos_key.h"
+
+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 ^ old_ms.W.cx) >> 3) ||
+                     ((ms_regs.W.dx ^ old_ms.W.dx) >> 3));
+
+        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 = -1;
+        SP->mouse_status.y = -1;
+
+        return 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 >> 3;
+    SP->mouse_status.y = ms_regs.W.dx >> 3;
+
+    old_ms = ms_regs;
+
+    return KEY_MOUSE;
+}
+
+/* return the next available key or mouse event */
+
+int PDC_get_key(void)
+{
+    PDCREGS regs;
+    int key, 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 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;
+}