curses 1.6.1 → 1.7.0

data/vendor/PDCursesMod/pdcurses/keyname.c

@@ -0,0 +1,149 @@
+/* PDCurses */
+
+#include <curspriv.h>
+#include <assert.h>
+
+/*man-start**************************************************************
+
+keyname
+-------
+
+### Synopsis
+
+    char *keyname(int key);
+
+    char *key_name(wchar_t c);
+
+    bool has_key(int key);
+
+### Description
+
+   keyname() returns a string corresponding to the argument key. key may
+   be any key returned by wgetch().
+
+   key_name() is the wide-character version. It takes a wchar_t
+   parameter, but still returns a char *.
+
+   has_key() returns TRUE for recognized keys, FALSE otherwise. This
+   function is an ncurses extension.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   keyname               |    Y   |    Y    |   Y
+   key_name              |    Y   |    Y    |   Y
+   has_key               |    -   |    Y    |   Y
+
+**man-end****************************************************************/
+
+#include <string.h>
+
+char *keyname(int key)
+{
+    static char _keyname[16];
+
+    /* Key names must be in exactly the same order as in curses.h */
+
+    static const char *key_names[] =
+    {
+    "KEY_BREAK", "KEY_DOWN", "KEY_UP", "KEY_LEFT", "KEY_RIGHT",
+    "KEY_HOME", "KEY_BACKSPACE", "KEY_F0", "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)", "KEY_F(11)", "KEY_F(12)",
+    "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(23)", "KEY_F(24)", "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(35)", "KEY_F(36)", "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)", "KEY_F(47)",
+    "KEY_F(48)", "KEY_F(49)", "KEY_F(50)", "KEY_F(51)", "KEY_F(52)",
+    "KEY_F(53)", "KEY_F(54)", "KEY_F(55)", "KEY_F(56)", "KEY_F(57)",
+    "KEY_F(58)", "KEY_F(59)", "KEY_F(60)", "KEY_F(61)", "KEY_F(62)",
+    "KEY_F(63)", "KEY_DL", "KEY_IL", "KEY_DC", "KEY_IC", "KEY_EIC",
+    "KEY_CLEAR", "KEY_EOS", "KEY_EOL", "KEY_SF", "KEY_SR", "KEY_NPAGE",
+    "KEY_PPAGE", "KEY_STAB", "KEY_CTAB", "KEY_CATAB", "KEY_ENTER",
+    "KEY_SRESET", "KEY_RESET", "KEY_PRINT", "KEY_LL", "KEY_ABORT",
+    "KEY_SHELP", "KEY_LHELP", "KEY_BTAB", "KEY_BEG", "KEY_CANCEL",
+    "KEY_CLOSE", "KEY_COMMAND", "KEY_COPY", "KEY_CREATE", "KEY_END",
+    "KEY_EXIT", "KEY_FIND", "KEY_HELP", "KEY_MARK", "KEY_MESSAGE",
+    "KEY_MOVE", "KEY_NEXT", "KEY_OPEN", "KEY_OPTIONS", "KEY_PREVIOUS",
+    "KEY_REDO", "KEY_REFERENCE", "KEY_REFRESH", "KEY_REPLACE",
+    "KEY_RESTART", "KEY_RESUME", "KEY_SAVE", "KEY_SBEG", "KEY_SCANCEL",
+    "KEY_SCOMMAND", "KEY_SCOPY", "KEY_SCREATE", "KEY_SDC", "KEY_SDL",
+    "KEY_SELECT", "KEY_SEND", "KEY_SEOL", "KEY_SEXIT", "KEY_SFIND",
+    "KEY_SHOME", "KEY_SIC", "UNKNOWN KEY", "KEY_SLEFT", "KEY_SMESSAGE",
+    "KEY_SMOVE", "KEY_SNEXT", "KEY_SOPTIONS", "KEY_SPREVIOUS",
+    "KEY_SPRINT", "KEY_SREDO", "KEY_SREPLACE", "KEY_SRIGHT",
+    "KEY_SRSUME", "KEY_SSAVE", "KEY_SSUSPEND", "KEY_SUNDO",
+    "KEY_SUSPEND", "KEY_UNDO", "ALT_0", "ALT_1", "ALT_2", "ALT_3",
+    "ALT_4", "ALT_5", "ALT_6", "ALT_7", "ALT_8", "ALT_9", "ALT_A",
+    "ALT_B", "ALT_C", "ALT_D", "ALT_E", "ALT_F", "ALT_G", "ALT_H",
+    "ALT_I", "ALT_J", "ALT_K", "ALT_L", "ALT_M", "ALT_N", "ALT_O",
+    "ALT_P", "ALT_Q", "ALT_R", "ALT_S", "ALT_T", "ALT_U", "ALT_V",
+    "ALT_W", "ALT_X", "ALT_Y", "ALT_Z", "CTL_LEFT", "CTL_RIGHT",
+    "CTL_PGUP", "CTL_PGDN", "CTL_HOME", "CTL_END", "KEY_A1", "KEY_A2",
+    "KEY_A3", "KEY_B1", "KEY_B2", "KEY_B3", "KEY_C1", "KEY_C2",
+    "KEY_C3", "PADSLASH", "PADENTER", "CTL_PADENTER", "ALT_PADENTER",
+    "PADSTOP", "PADSTAR", "PADMINUS", "PADPLUS", "CTL_PADSTOP",
+    "CTL_PADCENTER", "CTL_PADPLUS", "CTL_PADMINUS", "CTL_PADSLASH",
+    "CTL_PADSTAR", "ALT_PADPLUS", "ALT_PADMINUS", "ALT_PADSLASH",
+    "ALT_PADSTAR", "ALT_PADSTOP", "CTL_INS", "ALT_DEL", "ALT_INS",
+    "CTL_UP", "CTL_DOWN", "CTL_TAB", "ALT_TAB", "ALT_MINUS",
+    "ALT_EQUAL", "ALT_HOME", "ALT_PGUP", "ALT_PGDN", "ALT_END",
+    "ALT_UP", "ALT_DOWN", "ALT_RIGHT", "ALT_LEFT", "ALT_ENTER",
+    "ALT_ESC", "ALT_BQUOTE", "ALT_LBRACKET", "ALT_RBRACKET",
+    "ALT_SEMICOLON", "ALT_FQUOTE", "ALT_COMMA", "ALT_STOP",
+    "ALT_FSLASH", "ALT_BKSP", "CTL_BKSP", "PAD0", "CTL_PAD0",
+    "CTL_PAD1", "CTL_PAD2", "CTL_PAD3", "CTL_PAD4", "CTL_PAD5",
+    "CTL_PAD6", "CTL_PAD7","CTL_PAD8", "CTL_PAD9", "ALT_PAD0",
+    "ALT_PAD1", "ALT_PAD2", "ALT_PAD3", "ALT_PAD4", "ALT_PAD5",
+    "ALT_PAD6", "ALT_PAD7", "ALT_PAD8", "ALT_PAD9", "CTL_DEL",
+    "ALT_BSLASH", "CTL_ENTER", "SHF_PADENTER", "SHF_PADSLASH",
+    "SHF_PADSTAR", "SHF_PADPLUS", "SHF_PADMINUS", "SHF_UP", "SHF_DOWN",
+    "SHF_IC", "SHF_DC", "KEY_MOUSE", "KEY_SHIFT_L", "KEY_SHIFT_R",
+    "KEY_CONTROL_L", "KEY_CONTROL_R", "KEY_ALT_L", "KEY_ALT_R",
+    "KEY_RESIZE", "KEY_SUP", "KEY_SDOWN",
+                  /* PDCursesMod additions: */
+              "KEY_APPS", "KEY_PAUSE",
+              "KEY_PRINTSCREEN", "KEY_SCROLLLOCK",
+              "BROWSER_BACK", "BROWSER_FWD", "BROWSER_REF", "BROWSER_STOP",
+              "SEARCH", "FAVORITES", "BROWSER_HOME",
+              "VOLUME_MUTE", "VOLUME_DOWN", "VOLUME_UP",
+              "NEXT_TRACK", "PREV_TRACK", "MEDIA_STOP", "PLAY_PAUSE",
+              "LAUNCH_MAIL", "MEDIA_SELECT",
+              "LAUNCH_APP1", "LAUNCH_APP2", "LAUNCH_APP3", "LAUNCH_APP4",
+              "LAUNCH_APP5", "LAUNCH_APP6", "LAUNCH_APP7", "LAUNCH_APP8",
+              "LAUNCH_APP9", "LAUNCH_APP10", "FOCUS_IN", "FOCUS_OUT" };
+    const size_t n_keys = sizeof( key_names) / sizeof( key_names[0]);
+
+    PDC_LOG(("keyname() - called: key %d\n", key));
+
+    if( key >= 0 && key < 0x80)
+        strcpy( _keyname, unctrl( (chtype)key));
+    else if( has_key(key) && (size_t)( key - KEY_MIN) < n_keys)
+    {
+        assert( strlen( key_names[key - KEY_MIN]) < sizeof( _keyname));
+        strcpy( _keyname, key_names[key - KEY_MIN]);
+    }
+    else
+        strcpy( _keyname, "UNKNOWN KEY");
+
+    return _keyname;
+}
+
+bool has_key(int key)
+{
+    PDC_LOG(("has_key() - called: key %d\n", key));
+
+    return (key >= KEY_MIN && key <= KEY_MAX);
+}
+
+#ifdef PDC_WIDE
+char *key_name(wchar_t c)
+{
+    PDC_LOG(("key_name() - called\n"));
+
+    return keyname((int)c);
+}
+#endif

data/vendor/PDCursesMod/pdcurses/mouse.c

@@ -0,0 +1,469 @@
+/* PDCurses */
+
+#include <curspriv.h>
+#include <assert.h>
+
+/*man-start**************************************************************
+
+mouse
+-----
+
+### Synopsis
+
+    int mouse_set(mmask_t mbe);
+    int mouse_on(mmask_t mbe);
+    int mouse_off(mmask_t mbe);
+    int request_mouse_pos(void);
+    void wmouse_position(WINDOW *win, int *y, int *x);
+    mmask_t getmouse(void);
+
+    int mouseinterval(int wait);
+    bool wenclose(const WINDOW *win, int y, int x);
+    bool wmouse_trafo(const WINDOW *win, int *y, int *x, bool to_screen);
+    bool mouse_trafo(int *y, int *x, bool to_screen);
+    mmask_t mousemask(mmask_t mask, mmask_t *oldmask);
+    int nc_getmouse(MEVENT *event);
+    int ungetmouse(MEVENT *event);
+    bool has_mouse(void);
+
+### Description
+
+   As of PDCurses 3.0, there are two separate mouse interfaces: the
+   classic interface, which is based on the undocumented Sys V mouse
+   functions; and an ncurses-compatible interface. Both are active at
+   all times, and you can mix and match functions from each, though it's
+   not recommended. The ncurses interface is essentially an emulation
+   layer built on top of the classic interface; it's here to allow
+   easier porting of ncurses apps.
+
+   The classic interface: mouse_set(), mouse_on(), mouse_off(),
+   request_mouse_pos(), wmouse_position(), and getmouse(). An
+   application using this interface would start by calling mouse_set()
+   or mouse_on() with a non-zero value, often ALL_MOUSE_EVENTS. Then it
+   would check for a KEY_MOUSE return from getch(). If found, it would
+   call request_mouse_pos() to get the current mouse status.
+
+   mouse_set(), mouse_on() and mouse_off() are analagous to attrset(),
+   attron() and attroff(). These functions set the mouse button events
+   to trap. The button masks used in these functions are defined in
+   curses.h and can be or'ed together. They are the group of masks
+   starting with BUTTON1_RELEASED.
+
+   request_mouse_pos() requests curses to fill in the Mouse_status
+   structure with the current state of the mouse.
+
+   wmouse_position() determines if the current mouse position is within
+   the window passed as an argument. If the mouse is outside the current
+   window, -1 is returned in the y and x arguments; otherwise the y and
+   x coordinates of the mouse (relative to the top left corner of the
+   window) are returned in y and x.
+
+   getmouse() returns the current status of the trapped mouse buttons as
+   set by mouse_set() or mouse_on().
+
+   The ncurses interface: mouseinterval(), wenclose(), wmouse_trafo(),
+   mouse_trafo(), mousemask(), nc_getmouse(), ungetmouse() and
+   has_mouse(). A typical application using this interface would start
+   by calling mousemask() with a non-zero value, often ALL_MOUSE_EVENTS.
+   Then it would check for a KEY_MOUSE return from getch(). If found, it
+   would call nc_getmouse() to get the current mouse status.
+
+   mouseinterval() sets the timeout for a mouse click. On all current
+   platforms, PDCurses receives mouse button press and release events,
+   but must synthesize click events. It does this by checking whether a
+   release event is queued up after a press event. If it gets a press
+   event, and there are no more events waiting, it will wait for the
+   timeout interval, then check again for a release. A press followed by
+   a release is reported as BUTTON_CLICKED; otherwise it's passed
+   through as BUTTON_PRESSED. The default timeout is 150ms; valid values
+   are 0 (no clicks reported) through 1000ms. In x11, the timeout can
+   also be set via the clickPeriod resource. The return value from
+   mouseinterval() is the old timeout. To check the old value without
+   setting a new one, call it with a parameter of -1. Note that although
+   there's no classic equivalent for this function (apart from the
+   clickPeriod resource), the value set applies in both interfaces.
+
+   wenclose() reports whether the given screen-relative y, x coordinates
+   fall within the given window.
+
+   wmouse_trafo() converts between screen-relative and window-relative
+   coordinates. A to_screen parameter of TRUE means to convert from
+   window to screen; otherwise the reverse. The function returns FALSE
+   if the coordinates aren't within the window, or if any of the
+   parameters are NULL. The coordinates have been converted when the
+   function returns TRUE.
+
+   mouse_trafo() is the stdscr version of wmouse_trafo().
+
+   mousemask() is nearly equivalent to mouse_set(), but instead of
+   OK/ERR, it returns the value of the mask after setting it. (This
+   isn't necessarily the same value passed in, since the mask could be
+   altered on some platforms.) And if the second parameter is a non-null
+   pointer, mousemask() stores the previous mask value there. Also,
+   since the ncurses interface doesn't work with PDCurses' BUTTON_MOVED
+   events, mousemask() filters them out.
+
+   nc_getmouse() returns the current mouse status in an MEVENT struct.
+   This is equivalent to ncurses' getmouse(), renamed to avoid conflict
+   with PDCurses' getmouse(). But if you define PDC_NCMOUSE before
+   including curses.h, it defines getmouse() to nc_getmouse(), along
+   with a few other redefintions needed for compatibility with ncurses
+   code. nc_getmouse() calls request_mouse_pos(), which (not getmouse())
+   is the classic equivalent.
+
+   ungetmouse() is the mouse equivalent of ungetch(). However, PDCurses
+   doesn't maintain a queue of mouse events; only one can be pushed
+   back, and it can overwrite or be overwritten by real mouse events.
+
+   has_mouse() reports whether the mouse is available at all on the
+   current platform.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   mouse_set             |    -   |    -    |   -
+   mouse_on              |    -   |    -    |   -
+   mouse_off             |    -   |    -    |   -
+   request_mouse_pos     |    -   |    -    |   -
+   wmouse_position       |    -   |    -    |   -
+   getmouse              |    -   |    *    |   -
+   mouseinterval         |    -   |    Y    |   -
+   wenclose              |    -   |    Y    |   -
+   wmouse_trafo          |    -   |    Y    |   -
+   mouse_trafo           |    -   |    Y    |   -
+   mousemask             |    -   |    Y    |   -
+   nc_getmouse           |    -   |    *    |   -
+   ungetmouse            |    -   |    Y    |   -
+   has_mouse             |    -   |    Y    |   -
+
+    * See above, under Description
+
+**man-end****************************************************************/
+
+#include <string.h>
+
+static bool ungot = FALSE;
+
+int mouse_set(mmask_t mbe)
+{
+    PDC_LOG(("mouse_set() - called: event %x\n", mbe));
+
+    assert( SP);
+    if (!SP)
+        return ERR;
+
+    SP->_trap_mbe = mbe;
+    return PDC_mouse_set();
+}
+
+int mouse_on(mmask_t mbe)
+{
+    PDC_LOG(("mouse_on() - called: event %x\n", mbe));
+
+    assert( SP);
+    if (!SP)
+        return ERR;
+
+    SP->_trap_mbe |= mbe;
+    return PDC_mouse_set();
+}
+
+int mouse_off(mmask_t mbe)
+{
+    PDC_LOG(("mouse_off() - called: event %x\n", mbe));
+
+    assert( SP);
+    if (!SP)
+        return ERR;
+
+    SP->_trap_mbe &= ~mbe;
+    return PDC_mouse_set();
+}
+
+int request_mouse_pos(void)
+{
+    PDC_LOG(("request_mouse_pos() - called\n"));
+
+    Mouse_status = SP->mouse_status;
+
+    return OK;
+}
+
+void wmouse_position(WINDOW *win, int *y, int *x)
+{
+    PDC_LOG(("wmouse_position() - called\n"));
+
+    if (win && wenclose(win, MOUSE_Y_POS, MOUSE_X_POS))
+    {
+        if (y)
+            *y = MOUSE_Y_POS - win->_begy;
+        if (x)
+            *x = MOUSE_X_POS - win->_begx;
+    }
+    else
+    {
+        if (y)
+            *y = -1;
+        if (x)
+            *x = -1;
+    }
+}
+
+mmask_t getmouse(void)
+{
+    PDC_LOG(("getmouse() - called\n"));
+
+    assert( SP);
+    return SP ? SP->_trap_mbe : (mmask_t)0;
+}
+
+/* ncurses mouse interface */
+
+const int max_mouse_interval = 32767;        /* 32.767 seconds */
+
+int mouseinterval(int wait)
+{
+    int old_wait;
+
+    PDC_LOG(("mouseinterval() - called: %d\n", wait));
+
+    if (!SP)
+        return max_mouse_interval;
+
+    old_wait = SP->mouse_wait;
+
+    if (wait >= 0 && wait <= max_mouse_interval)
+        SP->mouse_wait = wait;
+
+    return old_wait;
+}
+
+bool wenclose(const WINDOW *win, int y, int x)
+{
+    PDC_LOG(("wenclose() - called: %p %d %d\n", win, y, x));
+
+    assert( win);
+    return (win && y >= win->_begy && y < win->_begy + win->_maxy
+                && x >= win->_begx && x < win->_begx + win->_maxx);
+}
+
+bool wmouse_trafo(const WINDOW *win, int *y, int *x, bool to_screen)
+{
+    int newy, newx;
+
+    PDC_LOG(("wmouse_trafo() - called\n"));
+
+    assert( win);
+    assert( x);
+    assert( y);
+    if (!win || !y || !x)
+        return FALSE;
+
+    newy = *y;
+    newx = *x;
+
+    if (to_screen)
+    {
+        newy += win->_begy;
+        newx += win->_begx;
+
+        if (!wenclose(win, newy, newx))
+            return FALSE;
+    }
+    else
+    {
+        if (wenclose(win, newy, newx))
+        {
+            newy -= win->_begy;
+            newx -= win->_begx;
+        }
+        else
+            return FALSE;
+    }
+
+    *y = newy;
+    *x = newx;
+
+    return TRUE;
+}
+
+bool mouse_trafo(int *y, int *x, bool to_screen)
+{
+    PDC_LOG(("mouse_trafo() - called\n"));
+
+    return wmouse_trafo(stdscr, y, x, to_screen);
+}
+
+#define BUTTON_MOVE_EVENTS (BUTTON1_MOVED | BUTTON2_MOVED | BUTTON3_MOVED \
+                          | BUTTON4_MOVED | BUTTON5_MOVED)
+#define ALL_MOVE_EVENTS  (BUTTON_MOVE_EVENTS | REPORT_MOUSE_POSITION)
+#define NO_MOUSE_EVENT        -42
+
+mmask_t mousemask(mmask_t mask, mmask_t *oldmask)
+{
+    PDC_LOG(("mousemask() - called\n"));
+
+    assert( SP);
+    if (!SP)
+        return (mmask_t)0;
+
+    if (oldmask)
+        *oldmask = SP->_trap_mbe;
+
+    /* The ncurses interface doesn't work with our move events
+       when using 32-bit mmask_ts,  so filter them here */
+
+#if !defined( PDC_LONG_MMASK)
+    mask &= ~BUTTON_MOVE_EVENTS;
+#endif
+
+    mouse_set(mask);
+    SP->mouse_status.x = NO_MOUSE_EVENT;
+
+    return SP->_trap_mbe;
+}
+
+/* For full compatibility with the ncurses mouse interface,  we need
+to account for the fact that ncurses maps wheel-up to a button4 press
+and wheel-down to a button5 press.  It lacks PDCursesMod's separate
+wheel scroll event flag.        */
+
+mmask_t nc_mousemask(mmask_t mask, mmask_t *oldmask)
+{
+    SP->ncurses_mouse = TRUE;
+    return( mousemask( mask, oldmask));
+}
+
+int nc_getmouse(MEVENT *event)
+{
+    int i;
+    mmask_t bstate = 0;
+
+    PDC_LOG(("nc_getmouse() - called\n"));
+
+    assert( SP);
+    assert( event);
+    if (!event || !SP || SP->mouse_status.x == NO_MOUSE_EVENT)
+        return ERR;
+
+    ungot = FALSE;
+
+    request_mouse_pos();
+    SP->mouse_status.x = NO_MOUSE_EVENT;
+
+    event->id = 0;
+
+    event->x = Mouse_status.x;
+    event->y = Mouse_status.y;
+    event->z = 0;
+
+    for (i = 0; i < 3; i++)
+    {
+        if (Mouse_status.changes & (1 << i))
+        {
+            const int shf = i * PDC_BITS_PER_BUTTON;
+            const short button = Mouse_status.button[i] & BUTTON_ACTION_MASK;
+
+            if (button == BUTTON_RELEASED)
+                bstate |= (BUTTON1_RELEASED << shf);
+            else if (button == BUTTON_PRESSED)
+                bstate |= (BUTTON1_PRESSED << shf);
+            else if (button == BUTTON_CLICKED)
+                bstate |= (BUTTON1_CLICKED << shf);
+            else if (button == BUTTON_DOUBLE_CLICKED)
+                bstate |= (BUTTON1_DOUBLE_CLICKED << shf);
+            else if (button == BUTTON_TRIPLE_CLICKED)
+                bstate |= (BUTTON1_TRIPLE_CLICKED << shf);
+        }
+    }
+
+    if (MOUSE_WHEEL_UP || (Mouse_status.changes & 0x200))
+        bstate |= BUTTON4_PRESSED;
+    else if (MOUSE_WHEEL_DOWN || (Mouse_status.changes & 0x400))
+        bstate |= BUTTON5_PRESSED;
+
+    for( i = 0; i < 5; i++)
+    {
+       if( Mouse_status.button[i] & PDC_BUTTON_SHIFT)
+           bstate |= BUTTON_MODIFIER_SHIFT;
+       if( Mouse_status.button[i] & PDC_BUTTON_CONTROL)
+           bstate |= BUTTON_MODIFIER_CONTROL;
+       if( Mouse_status.button[i] & PDC_BUTTON_ALT)
+           bstate |= BUTTON_MODIFIER_ALT;
+    }
+
+    /* extra filter pass -- mainly for button modifiers */
+
+    event->bstate = bstate & SP->_trap_mbe;
+
+                     /* 'Moves' (i.e.,  button is pressed) and 'position reports' */
+                     /* (mouse moved with no button down) are all reported as     */
+                     /* 'position reports' in NCurses,  which lacks 'move' events. */
+    if( MOUSE_MOVED && (SP->_trap_mbe & ALL_MOVE_EVENTS))
+       event->bstate |= REPORT_MOUSE_POSITION;
+
+    return OK;
+}
+
+int ungetmouse(MEVENT *event)
+{
+    int i;
+    mmask_t bstate;
+
+    PDC_LOG(("ungetmouse() - called\n"));
+
+    assert( event);
+    if (!event || ungot)
+        return ERR;
+
+    ungot = TRUE;
+
+    SP->mouse_status.x = event->x;
+    SP->mouse_status.y = event->y;
+
+    SP->mouse_status.changes = 0;
+    bstate = event->bstate;
+
+    for (i = 0; i < 3; i++)
+    {
+        int shf = i * PDC_BITS_PER_BUTTON;
+        short button = 0;
+
+        if (bstate & ((BUTTON1_RELEASED | BUTTON1_PRESSED |
+            BUTTON1_TRIPLE_CLICKED |
+            BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED) << shf))
+        {
+            SP->mouse_status.changes |= 1 << i;
+
+            if (bstate & (BUTTON1_PRESSED << shf))
+                button = BUTTON_PRESSED;
+            if (bstate & (BUTTON1_CLICKED << shf))
+                button = BUTTON_CLICKED;
+            if (bstate & (BUTTON1_DOUBLE_CLICKED << shf))
+                button = BUTTON_DOUBLE_CLICKED;
+            if (bstate & (BUTTON1_TRIPLE_CLICKED << shf))
+                button = BUTTON_TRIPLE_CLICKED;
+
+            if (bstate & BUTTON_MODIFIER_SHIFT)
+                button |= PDC_BUTTON_SHIFT;
+            if (bstate & BUTTON_MODIFIER_CONTROL)
+                button |= PDC_BUTTON_CONTROL;
+            if (bstate & BUTTON_MODIFIER_ALT)
+                button |= PDC_BUTTON_ALT;
+        }
+
+        SP->mouse_status.button[i] = button;
+    }
+
+    if (bstate & BUTTON4_PRESSED)
+        SP->mouse_status.changes |= PDC_MOUSE_WHEEL_UP;
+    else if (bstate & BUTTON5_PRESSED)
+        SP->mouse_status.changes |= PDC_MOUSE_WHEEL_DOWN;
+
+    return PDC_ungetch((int)KEY_MOUSE);
+}
+
+bool has_mouse(void)
+{
+    return PDC_has_mouse();
+}

data/vendor/PDCursesMod/pdcurses/move.c

@@ -0,0 +1,84 @@
+/* PDCurses */
+
+#include <curspriv.h>
+#include <assert.h>
+
+/*man-start**************************************************************
+
+move
+----
+
+### Synopsis
+
+    int move(int y, int x);
+    int mvcur(int oldrow, int oldcol, int newrow, int newcol);
+    int wmove(WINDOW *win, int y, int x);
+
+### Description
+
+   move() and wmove() move the cursor associated with the window to the
+   given location. This does not move the physical cursor of the
+   terminal until refresh() is called. The position specified is
+   relative to the upper left corner of the window, which is (0,0).
+
+   mvcur() moves the physical cursor without updating any window cursor
+   positions.
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   move                  |    Y   |    Y    |   Y
+   mvcur                 |    Y   |    Y    |   Y
+   wmove                 |    Y   |    Y    |   Y
+
+**man-end****************************************************************/
+
+int move(int y, int x)
+{
+    PDC_LOG(("move() - called: y=%d x=%d\n", y, x));
+
+    assert( stdscr);
+    if (!stdscr || x < 0 || y < 0 || x >= stdscr->_maxx || y >= stdscr->_maxy)
+        return ERR;
+
+    stdscr->_curx = x;
+    stdscr->_cury = y;
+
+    return OK;
+}
+
+int mvcur(int oldrow, int oldcol, int newrow, int newcol)
+{
+    PDC_LOG(("mvcur() - called: oldrow %d oldcol %d newrow %d newcol %d\n",
+             oldrow, oldcol, newrow, newcol));
+
+    assert( SP);
+    INTENTIONALLY_UNUSED_PARAMETER( oldrow);
+    INTENTIONALLY_UNUSED_PARAMETER( oldcol);
+    if (!SP || newrow < 0 || newrow >= LINES || newcol < 0 || newcol >= COLS)
+        return ERR;
+
+    PDC_gotoyx(newrow, newcol);
+    SP->cursrow = newrow;
+    SP->curscol = newcol;
+
+    return OK;
+}
+
+int wmove(WINDOW *win, int y, int x)
+{
+    PDC_LOG(("wmove() - called: y=%d x=%d\n", y, x));
+
+    assert( win);
+    if (!win || x < 0 || y < 0 || x >= win->_maxx || y >= win->_maxy)
+        return ERR;
+
+    win->_curx = x;
+    win->_cury = y;
+
+    return OK;
+}