curses 1.3.0 → 1.4.2

data/vendor/PDCurses/x11/pdcscrn.c

@@ -0,0 +1,258 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+/* special purpose function keys */
+
+static int PDC_shutdown_key[PDC_MAX_FUNCTION_KEYS] = { 0, 0, 0, 0, 0 };
+
+/* COLOR_PAIR to attribute encoding table. */
+
+short *xc_atrtab = (short *)NULL;
+
+/* close the physical screen */
+
+void PDC_scr_close(void)
+{
+    PDC_LOG(("PDC_scr_close() - called\n"));
+}
+
+void PDC_scr_free(void)
+{
+    XCursesExit();
+
+    xc_atrtab = (short *)NULL;
+}
+
+/* open the physical screen -- allocate SP, miscellaneous intialization */
+
+int PDC_scr_open(int argc, char **argv)
+{
+    extern bool sb_started;
+
+    PDC_LOG(("PDC_scr_open() - called\n"));
+
+    if ((XCursesInitscr(argc, argv) == ERR) || !SP)
+        return ERR;
+
+    SP->cursrow = SP->curscol = 0;
+    SP->orig_attr = FALSE;
+    SP->sb_on = sb_started;
+    SP->sb_total_y = 0;
+    SP->sb_viewport_y = 0;
+    SP->sb_cur_y = 0;
+    SP->sb_total_x = 0;
+    SP->sb_viewport_x = 0;
+    SP->sb_cur_x = 0;
+
+    return OK;
+}
+
+/* the core of resize_term() */
+
+int PDC_resize_screen(int nlines, int ncols)
+{
+    PDC_LOG(("PDC_resize_screen() - called. Lines: %d Cols: %d\n",
+             nlines, ncols));
+
+    if( !stdscr)      /* window hasn't been created yet;  we're */
+    {                 /* specifying its size before doing so    */
+        XCursesLINES = nlines;
+        XCursesCOLS = ncols;
+        return OK;
+    }
+
+    if (nlines || ncols || !SP->resized)
+        return ERR;
+
+    shmdt((char *)Xcurscr);
+    XCursesInstructAndWait(CURSES_RESIZE);
+
+    if ((shmid_Xcurscr = shmget(shmkey_Xcurscr,
+        SP->XcurscrSize + XCURSESSHMMIN, 0700)) < 0)
+    {
+        perror("Cannot allocate shared memory for curscr");
+        kill(xc_otherpid, SIGKILL);
+        return ERR;
+    }
+
+    XCursesLINES = SP->lines;
+    XCursesCOLS = SP->cols;
+
+    PDC_LOG(("%s:shmid_Xcurscr %d shmkey_Xcurscr %d SP->lines %d "
+             "SP->cols %d\n", XCLOGMSG, shmid_Xcurscr,
+             shmkey_Xcurscr, SP->lines, SP->cols));
+
+    Xcurscr = (unsigned char*)shmat(shmid_Xcurscr, 0, 0);
+    xc_atrtab = (short *)(Xcurscr + XCURSCR_ATRTAB_OFF);
+
+    SP->resized = FALSE;
+
+    return OK;
+}
+
+void PDC_reset_prog_mode(void)
+{
+    PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
+}
+
+void PDC_reset_shell_mode(void)
+{
+    PDC_LOG(("PDC_reset_shell_mode() - called.\n"));
+}
+
+void PDC_restore_screen_mode(int i)
+{
+}
+
+void PDC_save_screen_mode(int i)
+{
+}
+
+void PDC_init_pair(short pair, short fg, short bg)
+{
+    xc_atrtab[pair * 2] = fg;
+    xc_atrtab[pair * 2 + 1] = bg;
+}
+
+int PDC_pair_content(short pair, short *fg, short *bg)
+{
+    *fg = xc_atrtab[pair * 2];
+    *bg = xc_atrtab[pair * 2 + 1];
+
+    return OK;
+}
+
+bool PDC_can_change_color(void)
+{
+    return TRUE;
+}
+
+int PDC_color_content(short color, short *red, short *green, short *blue)
+{
+    XColor *tmp = (XColor *)(Xcurscr + XCURSCR_XCOLOR_OFF);
+
+    tmp->pixel = color;
+
+    XCursesInstructAndWait(CURSES_GET_COLOR);
+
+    *red = ((double)(tmp->red) * 1000 / 65535) + 0.5;
+    *green = ((double)(tmp->green) * 1000 / 65535) + 0.5;
+    *blue = ((double)(tmp->blue) * 1000 / 65535) + 0.5;
+
+    return OK;
+}
+
+int PDC_init_color(short color, short red, short green, short blue)
+{
+    XColor *tmp = (XColor *)(Xcurscr + XCURSCR_XCOLOR_OFF);
+
+    tmp->pixel = color;
+
+    tmp->red = ((double)red * 65535 / 1000) + 0.5;
+    tmp->green = ((double)green * 65535 / 1000) + 0.5;
+    tmp->blue = ((double)blue * 65535 / 1000) + 0.5;
+
+    XCursesInstructAndWait(CURSES_SET_COLOR);
+
+    return OK;
+}
+
+/*man-start**************************************************************
+
+Function keys
+-------------
+
+### Synopsis
+
+   int PDC_set_function_key( const unsigned function, const int new_key);
+
+### Description
+
+   Allows one to set a 'shut down' key,  and reassign hotkeys used for
+   pasting from the clipboard and enlarging and decreasing the font size,
+   and for using the font selection dialog (on platforms where these
+   things are possible and implemented).  For example, calling
+
+   PDC_set_function_key( FUNCTION_KEY_SHUT_DOWN, ALT_Q);
+
+   would reset PDCurses such that,  if the user clicks on the 'close' box,
+   Alt-Q would be added to the key queue.  This would give the app the
+   opportunity to shut things down gracefully,  perhaps asking "are you
+   sure",  and/or "save changes or discard or cancel",  rather than just
+   having the window close (the default behavior).
+
+   Similarly,  one can set FUNCTION_KEY_ABORT to a key which,  when pressed,
+   will cause the program to abort gracelessly (no key returned to the
+   application).  One would normally use this to enable/disable Ctrl-C or
+   Ctrl-Break.
+
+### Return Value
+
+   Returns key code previously set for that function,  or -1 if the
+   function does not actually exist.
+
+### Portability
+
+   PDCurses-only function.
+
+**man-end****************************************************************/
+
+int PDC_set_function_key( const unsigned function, const int new_key)
+{
+    int old_key = -1;
+
+    if (function < PDC_MAX_FUNCTION_KEYS)
+    {
+         old_key = PDC_shutdown_key[function];
+         PDC_shutdown_key[function] = new_key;
+    }
+    if (function == FUNCTION_KEY_SHUT_DOWN)
+    {
+        SP->exit_key = new_key;
+    }
+    return(old_key);
+}
+
+
+/*man-start**************************************************************
+
+Resize limits
+-------------
+
+### Synopsis
+
+    void PDC_set_resize_limits( const int new_min_lines,
+                                const int new_max_lines,
+                                const int new_min_cols,
+                                const int new_max_cols);
+
+### Description
+
+   For platforms supporting resizable windows (SDLx, WinGUI, X11).  Some
+   programs may be unprepared for a resize event;  for these,  calling
+   this function with the max and min limits equal ensures that no
+   user resizing can be done.  Other programs may require at least a
+   certain number,  and/or no more than a certain number,  of columns
+   and/or lines.
+
+### Portability
+
+   PDCurses-only function.
+
+**man-end****************************************************************/
+
+/* Note that at least at present,  only WinGUI pays any attention to
+resize limits. */
+
+int PDC_min_lines = 25, PDC_min_cols = 80;
+int PDC_max_lines = 25, PDC_max_cols = 80;
+
+void PDC_set_resize_limits( const int new_min_lines, const int new_max_lines,
+                  const int new_min_cols, const int new_max_cols)
+{
+    PDC_min_lines = max( new_min_lines, 2);
+    PDC_max_lines = max( new_max_lines, PDC_min_lines);
+    PDC_min_cols = max( new_min_cols, 2);
+    PDC_max_cols = max( new_max_cols, PDC_min_cols);
+}

data/vendor/PDCurses/x11/pdcsetsc.c

@@ -0,0 +1,95 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+#include <string.h>
+
+/*man-start**************************************************************
+
+pdcsetsc
+--------
+
+### Synopsis
+
+    int PDC_set_blink(bool blinkon);
+    void PDC_set_title(const char *title);
+
+### Description
+
+   PDC_set_blink() toggles whether the A_BLINK attribute sets an
+   actual blink mode (TRUE), or sets the background color to high
+   intensity (FALSE). The default is platform-dependent (FALSE in
+   most cases). It returns OK if it could set the state to match
+   the given parameter, ERR otherwise. Current platforms also
+   adjust the value of COLORS according to this function -- 16 for
+   FALSE, and 8 for TRUE.
+
+   PDC_set_title() sets the title of the window in which the curses
+   program is running. This function may not do anything on some
+   platforms. (Currently it only works in Win32 and X11.)
+
+### Portability
+                             X/Open    BSD    SYS V
+    PDC_set_blink               -       -       -
+    PDC_set_title               -       -       -
+
+**man-end****************************************************************/
+
+int PDC_curs_set(int visibility)
+{
+    int ret_vis = SP->visibility;
+
+    PDC_LOG(("PDC_curs_set() - called: visibility=%d\n", visibility));
+
+    if (visibility != -1)
+        SP->visibility = visibility;
+
+    PDC_display_cursor(SP->cursrow, SP->curscol, SP->cursrow,
+                       SP->curscol, visibility);
+
+    return ret_vis;
+}
+
+void PDC_set_title(const char *title)
+{
+    int len;
+
+    PDC_LOG(("PDC_set_title() - called:<%s>\n", title));
+
+    len = strlen(title) + 1;        /* write nul character */
+
+    XCursesInstruct(CURSES_TITLE);
+
+    if (XC_write_display_socket_int(len) >= 0)
+        if (XC_write_socket(xc_display_sock, title, len) >= 0)
+            return;
+
+    XCursesExitCursesProcess(1, "exiting from PDC_set_title");
+}
+
+        /* If PDC_really_blinking is TRUE,  then text with the A_BLINK   */
+        /* attribute will actually blink.  Otherwise,  such text will    */
+        /* be shown with higher color intensity (the R, G, and B values  */
+        /* are averaged with pure white).  See pdcdisp.c for details of  */
+        /* how this is done.                                             */
+        /*     Unlike on other PDCurses platforms,  this doesn't require */
+        /* decreasing the number of colors by half.  Also,  the choice   */
+        /* indicated by 'blinkon' will actually be respected,  so OK is  */
+        /* always returned (most platforms don't actually support        */
+        /* blinking).                                                    */
+        /*      The default behavior is to not show A_BLINK text as      */
+        /* blinking,  i.e.,  PDC_really_blinking = FALSE.  Blinking text */
+        /* can be pretty annoying to some people.  You should probably   */
+        /* call PDC_set_blink( TRUE) only if there is something to which */
+        /* the user _must_ pay attention;  say,  "the nuclear reactor    */
+        /* is about to melt down".  Otherwise,  the bolder,  brighter    */
+        /* text should be attention-getting enough.                      */
+
+int PDC_set_blink(bool blinkon)
+{
+    if (pdc_color_started)       /* We've got 256 colors in this version */
+        COLORS = 256;
+
+    XCursesInstruct( blinkon ? CURSES_BLINK_ON : CURSES_BLINK_OFF);
+    return OK;
+}

data/vendor/PDCurses/x11/pdcutil.c

@@ -0,0 +1,52 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+#if defined(HAVE_POLL) && !defined(HAVE_USLEEP)
+# include <poll.h>
+#endif
+
+void PDC_beep(void)
+{
+    PDC_LOG(("PDC_beep() - called\n"));
+
+    XCursesInstruct(CURSES_BELL);
+}
+
+void PDC_napms(int ms)
+{
+    PDC_LOG(("PDC_napms() - called: ms=%d\n", ms));
+
+#if defined(HAVE_USLEEP)
+
+    usleep(1000 * ms);
+
+#elif defined(HAVE_POLL)
+    {
+        struct pollfd fd;
+        fd.fd = -1;
+        fd.events = 0;
+        poll(&fd, 1, ms);
+    }
+#endif
+}
+
+const char *PDC_sysname(void)
+{
+    return "X11";
+}
+
+PDC_version_info PDC_version = { PDC_PORT_WINGUI,
+          PDC_VER_MAJOR, PDC_VER_MINOR, PDC_VER_CHANGE,
+          sizeof( chtype),
+#ifdef PDC_WIDE
+          TRUE,
+#else
+          FALSE,
+#endif
+#ifdef PDC_FORCE_UTF8
+          TRUE,
+#else
+          FALSE,
+#endif
+          };

data/vendor/PDCurses/x11/pdcx11.c

@@ -0,0 +1,316 @@
+/* Public Domain Curses */
+
+#include "pdcx11.h"
+
+#include <errno.h>
+#include <stdlib.h>
+
+/*** Functions that are called by both processes ***/
+
+unsigned char *Xcurscr;
+
+int XCursesProcess = 1;
+int shmidSP;
+int shmid_Xcurscr;
+int shmkeySP;
+int shmkey_Xcurscr;
+int xc_otherpid;
+int XCursesLINES = 24;
+int XCursesCOLS = 80;
+int xc_display_sock;
+int xc_key_sock;
+int xc_display_sockets[2];
+int xc_key_sockets[2];
+int xc_exit_sock;
+
+fd_set xc_readfds;
+
+static void _dummy_function(void)
+{
+    PDC_napms( 1);
+}
+
+void XC_get_line_lock(int row)
+{
+    /* loop until we can write to the line -- Patch by:
+       Georg Fuchs, georg.fuchs@rz.uni-regensburg.de */
+
+    while (*(Xcurscr + XCURSCR_FLAG_OFF + row))
+        _dummy_function();
+
+    *(Xcurscr + XCURSCR_FLAG_OFF + row) = 1;
+}
+
+void XC_release_line_lock(int row)
+{
+    *(Xcurscr + XCURSCR_FLAG_OFF + row) = 0;
+}
+
+int XC_write_socket(int sock_num, const void *buf, int len)
+{
+    int start = 0, rc;
+
+    PDC_LOG(("%s:XC_write_socket called: sock_num %d len %d\n",
+             XCLOGMSG, sock_num, len));
+
+#ifdef MOUSE_DEBUG
+    if (sock_num == xc_key_sock)
+        printf("%s:XC_write_socket(key) len: %d\n", XCLOGMSG, len);
+#endif
+    while (1)
+    {
+        rc = write(sock_num, (const char *)buf + start, len);
+
+        if (rc < 0 || rc == len)
+            return rc;
+
+        len -= rc;
+        start = rc;
+    }
+}
+
+int XC_read_socket(int sock_num, void *buf, int len)
+{
+    int start = 0, length = len, rc;
+
+    PDC_LOG(("%s:XC_read_socket called: sock_num %d len %d\n",
+             XCLOGMSG, sock_num, len));
+
+    while (1)
+    {
+        rc = read(sock_num, (char *)buf + start, length);
+
+#ifdef MOUSE_DEBUG
+        if (sock_num == xc_key_sock)
+            printf("%s:XC_read_socket(key) rc %d errno %d "
+                   "resized: %d\n", XCLOGMSG, rc, errno, SP->resized);
+#endif
+        if (rc < 0 && sock_num == xc_key_sock && errno == EINTR
+            && SP->resized != FALSE)
+        {
+            MOUSE_LOG(("%s:continuing\n", XCLOGMSG));
+
+            rc = 0;
+
+            if (SP->resized > 1)
+                SP->resized = TRUE;
+            else
+                SP->resized = FALSE;
+
+            memcpy(buf, &rc, sizeof(int));
+
+            return 0;
+        }
+
+        if (rc <= 0 || rc == length)
+            return rc;
+
+        length -= rc;
+        start = rc;
+    }
+}
+
+int XC_write_display_socket_int(int x)
+{
+    return XC_write_socket(xc_display_sock, &x, sizeof(int));
+}
+
+#ifdef PDCDEBUG
+void XC_say(const char *msg)
+{
+    PDC_LOG(("%s:%s", XCLOGMSG, msg));
+}
+#endif
+
+/*** Functions that are called by the "curses" process ***/
+
+int XCursesInstruct(int flag)
+{
+    PDC_LOG(("%s:XCursesInstruct() - called flag %d\n", XCLOGMSG, flag));
+
+    /* Send a request to X */
+
+    if (XC_write_display_socket_int(flag) < 0)
+        XCursesExitCursesProcess(4, "exiting from XCursesInstruct");
+
+    return OK;
+}
+
+int XCursesInstructAndWait(int flag)
+{
+    int result;
+
+    XC_LOG(("XCursesInstructAndWait() - called\n"));
+
+    /* tell X we want to do something */
+
+    XCursesInstruct(flag);
+
+    /* wait for X to say the refresh has occurred*/
+
+    if (XC_read_socket(xc_display_sock, &result, sizeof(int)) < 0)
+        XCursesExitCursesProcess(5, "exiting from XCursesInstructAndWait");
+
+    if (result != CURSES_CONTINUE)
+        XCursesExitCursesProcess(6, "exiting from XCursesInstructAndWait"
+                                    " - synchronization error");
+
+    return OK;
+}
+
+static int _setup_curses(void)
+{
+    int wait_value;
+
+    XC_LOG(("_setup_curses called\n"));
+
+    close(xc_display_sockets[1]);
+    close(xc_key_sockets[1]);
+
+    xc_display_sock = xc_display_sockets[0];
+    xc_key_sock = xc_key_sockets[0];
+
+    FD_ZERO(&xc_readfds);
+
+    XC_read_socket(xc_display_sock, &wait_value, sizeof(int));
+
+    if (wait_value != CURSES_CHILD)
+        return ERR;
+
+    /* Set LINES and COLS now so that the size of the shared memory
+       segment can be allocated */
+
+    if ((shmidSP = shmget(shmkeySP, sizeof(SCREEN) + XCURSESSHMMIN, 0700)) < 0)
+    {
+        perror("Cannot allocate shared memory for SCREEN");
+        kill(xc_otherpid, SIGKILL);
+        return ERR;
+    }
+
+    SP = (SCREEN*)shmat(shmidSP, 0, 0);
+
+    XCursesLINES = SP->lines;
+    LINES = XCursesLINES - SP->linesrippedoff - SP->slklines;
+    XCursesCOLS = COLS = SP->cols;
+
+    if ((shmid_Xcurscr = shmget(shmkey_Xcurscr,
+                                SP->XcurscrSize + XCURSESSHMMIN, 0700)) < 0)
+    {
+        perror("Cannot allocate shared memory for curscr");
+        kill(xc_otherpid, SIGKILL);
+        return ERR;
+    }
+
+    PDC_LOG(("%s:shmid_Xcurscr %d shmkey_Xcurscr %d LINES %d COLS %d\n",
+             XCLOGMSG, shmid_Xcurscr, shmkey_Xcurscr, LINES, COLS));
+
+    Xcurscr = (unsigned char *)shmat(shmid_Xcurscr, 0, 0);
+    xc_atrtab = (short *)(Xcurscr + XCURSCR_ATRTAB_OFF);
+
+    XC_LOG(("cursesprocess exiting from Xinitscr\n"));
+
+    /* Always trap SIGWINCH if the C library supports SIGWINCH */
+
+    XCursesSetSignal(SIGWINCH, XCursesSigwinchHandler);
+
+    atexit(XCursesExit);
+
+    return OK;
+}
+
+int XCursesInitscr(int argc, char *argv[])
+{
+    int pid, rc;
+
+    XC_LOG(("XCursesInitscr() - called\n"));
+
+    shmkeySP = getpid();
+
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, xc_display_sockets) < 0)
+    {
+        fprintf(stderr, "ERROR: cannot create display socketpair\n");
+        return ERR;
+    }
+
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, xc_key_sockets) < 0)
+    {
+        fprintf(stderr, "ERROR: cannot create key socketpair\n");
+        return ERR;
+    }
+
+    pid = fork();
+
+    switch(pid)
+    {
+    case -1:
+        fprintf(stderr, "ERROR: cannot fork()\n");
+        return ERR;
+        break;
+
+    case 0: /* child */
+        shmkey_Xcurscr = getpid();
+#ifdef XISPARENT
+        XCursesProcess = 0;
+        rc = _setup_curses();
+#else
+        XCursesProcess = 1;
+        xc_otherpid = getppid();
+        rc = XCursesSetupX(argc, argv);
+#endif
+        break;
+
+    default:  /* parent */
+        shmkey_Xcurscr = pid;
+#ifdef XISPARENT
+        XCursesProcess = 1;
+        xc_otherpid = pid;
+        rc = XCursesSetupX(argc, argv);
+#else
+        XCursesProcess = 0;
+        rc = _setup_curses();
+#endif
+    }
+
+    return rc;
+}
+
+static void _cleanup_curses_process(int rc)
+{
+    PDC_LOG(("%s:_cleanup_curses_process() - called: %d\n", XCLOGMSG, rc));
+
+    shutdown(xc_display_sock, 2);
+    close(xc_display_sock);
+
+    shutdown(xc_key_sock, 2);
+    close(xc_key_sock);
+
+    shmdt((char *)SP);
+    shmdt((char *)Xcurscr);
+
+    if (rc)
+        _exit(rc);
+}
+
+void XCursesExitCursesProcess(int rc, char *msg)
+{
+    PDC_LOG(("%s:XCursesExitCursesProcess() - called: %d %s\n",
+             XCLOGMSG, rc, msg));
+
+    endwin();
+    _cleanup_curses_process(rc);
+}
+
+void XCursesExit(void)
+{
+    static bool called = FALSE;
+
+    XC_LOG(("XCursesExit() - called\n"));
+
+    if (FALSE == called)
+    {
+        XCursesInstruct(CURSES_EXIT);
+        _cleanup_curses_process(0);
+
+        called = TRUE;
+    }
+}