curses 1.2.6 → 1.4.0

data/vendor/PDCurses/x11/little_icon.xbm

@@ -0,0 +1,14 @@
+#define little_icon_width 32
+#define little_icon_height 32
+static unsigned char little_icon_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0xfc, 0x30, 0x00, 0x00, 0xfc, 0x31, 0x00, 0x00, 0x8c, 0x33, 0x00,
+   0x00, 0x0c, 0x33, 0x00, 0x00, 0x0c, 0x33, 0x00, 0x00, 0x8c, 0x33, 0x00,
+   0x00, 0xcc, 0x39, 0x00, 0x00, 0xec, 0x3c, 0x00, 0x00, 0x7c, 0x3e, 0x00,
+   0x00, 0x3c, 0x37, 0x00, 0x00, 0x9c, 0x33, 0x00, 0x00, 0xcc, 0x31, 0x00,
+   0x00, 0xcc, 0x30, 0x00, 0x00, 0xcc, 0x30, 0x00, 0x00, 0xcc, 0x31, 0x00,
+   0x00, 0x8c, 0x3f, 0x00, 0x00, 0x0c, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x4c, 0x2a, 0xc6, 0x18, 0x52, 0x5a, 0x29, 0x25,
+   0x42, 0x0a, 0x21, 0x05, 0x42, 0x0a, 0xe6, 0x18, 0x42, 0x0a, 0x28, 0x20,
+   0x52, 0x0a, 0x29, 0x25, 0x8c, 0x09, 0xc6, 0x18, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

data/vendor/PDCurses/x11/ncurses_cfg.h

@@ -0,0 +1,45 @@
+/* This file is only used with the ncurses test programs.
+ *
+ * Have ncurses-5.6 unpacked in your $(HOME) (you don't need to build 
+ * it), or edit ncurses_testdir appropriately in the Makefile. Configure 
+ * and build PDCurses for X11. (Sorry, other ports won't work yet.) 
+ * Change to this directory, and:
+ *
+ * "make ncurses_tests" to start.
+ * "make ncurses_clean" when you're done.
+ *
+ * Builds: bs gdc hanoi knight tclock ncurses
+ */
+
+#define NCURSES_MOUSE_VERSION 2
+
+#include "../config.h"
+#include <curses.h>
+
+#define ExitProgram exit
+
+#define HAVE_CURSES_VERSION 1
+#define HAVE_GETBEGX 1
+#define HAVE_GETCURX 1
+#define HAVE_GETMAXX 1
+#define HAVE_GETNSTR 1
+#define HAVE_GETTIMEOFDAY 1
+#define HAVE_GETWIN 1
+#define HAVE_LIBPANEL 1
+#define HAVE_LOCALE_H 1
+#define HAVE_NAPMS 1
+#define HAVE_PANEL_H 1
+#define HAVE_PUTWIN 1
+#define HAVE_SLK_COLOR 1
+#define HAVE_SLK_INIT 1
+#define HAVE_WRESIZE 1
+
+#ifdef PDC_WIDE
+# define USE_WIDEC_SUPPORT 1
+#endif
+
+/* Fool ncurses.c so it gives us all the tests, and doesn't redefine 
+   ACS_ chars
+*/
+
+#define NCURSES_VERSION PDCURSES

data/vendor/PDCurses/x11/pdcclip.c

@@ -0,0 +1,173 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+#include <stdlib.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)
+{
+#ifdef PDC_WIDE
+    wchar_t *wcontents;
+#endif
+    int result = 0;
+    int len;
+
+    PDC_LOG(("PDC_getclipboard() - called\n"));
+
+    XCursesInstructAndWait(CURSES_GET_SELECTION);
+
+    if (XC_read_socket(xc_display_sock, &result, sizeof(int)) < 0)
+        XCursesExitCursesProcess(5, "exiting from PDC_getclipboard");
+
+    if (result == PDC_CLIP_SUCCESS)
+    {
+        if (XC_read_socket(xc_display_sock, &len, sizeof(int)) < 0)
+            XCursesExitCursesProcess(5, "exiting from PDC_getclipboard");
+#ifdef PDC_WIDE
+        wcontents = malloc((len + 1) * sizeof(wchar_t));
+        *contents = malloc(len * 3 + 1);
+
+        if (!wcontents || !*contents)
+#else
+            *contents = malloc(len + 1);
+
+        if (!*contents)
+#endif
+        XCursesExitCursesProcess(6, "exiting from PDC_getclipboard - "
+                                    "synchronization error");
+
+        if (len)
+        {
+            if (XC_read_socket(xc_display_sock,
+#ifdef PDC_WIDE
+                wcontents, len * sizeof(wchar_t)) < 0)
+#else
+                *contents, len) < 0)
+#endif
+                XCursesExitCursesProcess(5, "exiting from PDC_getclipboard");
+        }
+
+#ifdef PDC_WIDE
+        wcontents[len] = 0;
+        len = PDC_wcstombs(*contents, wcontents, len * 3);
+        free(wcontents);
+#endif
+        (*contents)[len] = '\0';
+        *length = len;
+    }
+
+    return result;
+}
+
+int PDC_setclipboard(const char *contents, long length)
+{
+#ifdef PDC_WIDE
+    wchar_t *wcontents;
+#endif
+    int rc;
+
+    PDC_LOG(("PDC_setclipboard() - called\n"));
+
+#ifdef PDC_WIDE
+    wcontents = malloc((length + 1) * sizeof(wchar_t));
+    if (!wcontents)
+        return PDC_CLIP_MEMORY_ERROR;
+
+    length = PDC_mbstowcs(wcontents, contents, length);
+#endif
+    XCursesInstruct(CURSES_SET_SELECTION);
+
+    /* Write, then wait for X to do its stuff; expect return code. */
+
+    if (XC_write_socket(xc_display_sock, &length, sizeof(long)) >= 0)
+    {
+        if (XC_write_socket(xc_display_sock,
+#ifdef PDC_WIDE
+            wcontents, length * sizeof(wchar_t)) >= 0)
+        {
+            free(wcontents);
+#else
+            contents, length) >= 0)
+        {
+#endif
+            if (XC_read_socket(xc_display_sock, &rc, sizeof(int)) >= 0)
+                return rc;
+        }
+    }
+
+    XCursesExitCursesProcess(5, "exiting from PDC_setclipboard");
+
+    return PDC_CLIP_ACCESS_ERROR;   /* not reached */
+}
+
+int PDC_freeclipboard(char *contents)
+{
+    PDC_LOG(("PDC_freeclipboard() - called\n"));
+
+    free(contents);
+    return PDC_CLIP_SUCCESS;
+}
+
+int PDC_clearclipboard(void)
+{
+    int rc;
+    long len = 0;
+
+    PDC_LOG(("PDC_clearclipboard() - called\n"));
+
+    XCursesInstruct(CURSES_CLEAR_SELECTION);
+
+    /* Write, then wait for X to do its stuff; expect return code. */
+
+    if (XC_write_socket(xc_display_sock, &len, sizeof(long)) >= 0)
+        if (XC_read_socket(xc_display_sock, &rc, sizeof(int)) >= 0)
+            return rc;
+
+    XCursesExitCursesProcess(5, "exiting from PDC_clearclipboard");
+
+    return PDC_CLIP_ACCESS_ERROR;   /* not reached */
+}

data/vendor/PDCurses/x11/pdcdisp.c

@@ -0,0 +1,85 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+#include <string.h>
+
+#ifdef CHTYPE_LONG
+
+#ifdef PDC_WIDE
+   #define USE_UNICODE_ACS_CHARS 1
+#else
+   #define USE_ISO8859_CHARSET
+#endif
+
+#include "acs_defs.h"
+
+#endif
+
+int PDC_display_cursor(int oldrow, int oldcol, int newrow, int newcol,
+                       int visibility)
+{
+    char buf[30];
+    int idx, pos;
+
+    PDC_LOG(("%s:PDC_display_cursor() - called: NEW row %d col %d, vis %d\n",
+             XCLOGMSG, newrow, newcol, visibility));
+
+    if (visibility == -1)
+    {
+        /* Only send the CURSES_DISPLAY_CURSOR message, no data */
+
+        idx = CURSES_DISPLAY_CURSOR;
+        memcpy(buf, &idx, sizeof(int));
+        idx = sizeof(int);
+    }
+    else
+    {
+        idx = CURSES_CURSOR;
+        memcpy(buf, &idx, sizeof(int));
+
+        idx = sizeof(int);
+        pos = oldrow + (oldcol << 8);
+        memcpy(buf + idx, &pos, sizeof(int));
+
+        idx += sizeof(int);
+        pos = newrow + (newcol << 8);
+        memcpy(buf + idx, &pos, sizeof(int));
+
+        idx += sizeof(int);
+    }
+
+    if (XC_write_socket(xc_display_sock, buf, idx) < 0)
+        XCursesExitCursesProcess(1, "exiting from PDC_display_cursor");
+
+    return OK;
+}
+
+/* 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));
+
+    PDC_display_cursor(SP->cursrow, SP->curscol, row, col, SP->visibility);
+}
+
+/* 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)
+{
+    PDC_LOG(("PDC_transform_line() - called: line %d\n", lineno));
+
+    XC_get_line_lock(lineno);
+
+    memcpy(Xcurscr + XCURSCR_Y_OFF(lineno) + (x * sizeof(chtype)), srcp,
+           len * sizeof(chtype));
+
+    *(Xcurscr + XCURSCR_START_OFF + lineno) = x;
+    *(Xcurscr + XCURSCR_LENGTH_OFF + lineno) = len;
+
+    XC_release_line_lock(lineno);
+
+    XCursesInstructAndWait(CURSES_REFRESH);
+}

data/vendor/PDCurses/x11/pdcgetsc.c

@@ -0,0 +1,28 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+/* return width of screen/viewport */
+
+int PDC_get_columns(void)
+{
+    PDC_LOG(("PDC_get_columns() - called\n"));
+
+    return XCursesCOLS;
+}
+
+/* get the cursor size/shape */
+
+int PDC_get_cursor_mode(void)
+{
+    return 0;
+}
+
+/* return number of screen rows */
+
+int PDC_get_rows(void)
+{
+    PDC_LOG(("PDC_get_rows() - called\n"));
+
+    return XCursesLINES;
+}

data/vendor/PDCurses/x11/pdckbd.c

@@ -0,0 +1,104 @@
+/* Public Domain Curses */
+
+#include "pdcx11.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****************************************************************/
+
+/* check if a key or mouse event is waiting */
+
+bool PDC_check_key(void)
+{
+    struct timeval socket_timeout = {0};
+    int s;
+
+    /* Is something ready to be read on the socket ? Must be a key. */
+
+    FD_ZERO(&xc_readfds);
+    FD_SET(xc_key_sock, &xc_readfds);
+
+    if ((s = select(FD_SETSIZE, (FD_SET_CAST)&xc_readfds, NULL, 
+        NULL, &socket_timeout)) < 0)
+        XCursesExitCursesProcess(3, "child - exiting from "
+                                    "PDC_check_key select failed");
+
+    PDC_LOG(("%s:PDC_check_key() - returning %s\n", XCLOGMSG,
+             s ? "TRUE" : "FALSE"));
+
+    return !!s;
+}
+
+/* return the next available key or mouse event */
+
+int PDC_get_key(void)
+{
+    unsigned long newkey = 0;
+    int key = 0;
+
+    if (XC_read_socket(xc_key_sock, &newkey, sizeof(unsigned long)) < 0)
+        XCursesExitCursesProcess(2, "exiting from PDC_get_key");
+
+    pdc_key_modifiers = (newkey >> 24) & 0xFF;
+    key = (int)(newkey & 0x00FFFFFF);
+
+    if (key == KEY_MOUSE && SP->key_code)
+    {
+        if (XC_read_socket(xc_key_sock, &pdc_mouse_status,
+            sizeof(MOUSE_STATUS)) < 0)
+            XCursesExitCursesProcess(2, "exiting from PDC_get_key");
+    }
+
+    PDC_LOG(("%s:PDC_get_key() - key %d returned\n", XCLOGMSG, key));
+
+    return key;
+}
+
+unsigned long PDC_get_input_fd(void)
+{
+    PDC_LOG(("PDC_get_input_fd() - called\n"));
+
+    return xc_key_sock;
+}
+
+void PDC_set_keyboard_binary(bool on)
+{
+    PDC_LOG(("PDC_set_keyboard_binary() - called\n"));
+}
+
+/* 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();
+}
+
+int PDC_mouse_set(void)
+{
+    return OK;
+}
+
+int PDC_modifiers_set(void)
+{
+    return OK;
+}