curses 1.3.2 → 1.4.3

data/vendor/PDCurses/pdcurses/color.c

@@ -0,0 +1,298 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+color
+-----
+
+### Synopsis
+
+    int start_color(void);
+    int init_pair(short pair, short fg, short bg);
+    int init_color(short color, short red, short green, short blue);
+    bool has_colors(void);
+    bool can_change_color(void);
+    int color_content(short color, short *red, short *green, short *blue);
+    int pair_content(short pair, short *fg, short *bg);
+
+    int assume_default_colors(int f, int b);
+    int use_default_colors(void);
+
+    int PDC_set_line_color(short color);
+
+### Description
+
+   To use these routines, start_color() must be called, usually
+   immediately after initscr(). Colors are always used in pairs,
+   referred to as color-pairs. A color-pair consists of a
+   foreground color and a background color. A color-pair is
+   initialized via init_pair(). After initialization, COLOR_PAIR(n)
+   can be used like any other video attribute.
+
+   start_color() initializes eight basic colors (black, red, green,
+   yellow, blue, magenta, cyan, and white), and two global
+   variables; COLORS and COLOR_PAIRS (respectively defining the
+   maximum number of colors and color-pairs the terminal is capable
+   of displaying).
+
+   init_pair() changes the definition of a color-pair. It takes
+   three arguments: the number of the color-pair to be redefined,
+   and the new values of the foreground and background colors. The
+   pair number must be between 0 and COLOR_PAIRS - 1, inclusive.
+   The foreground and background must be between 0 and COLORS - 1,
+   inclusive. If the color pair was previously initialized, the
+   screen is refreshed, and all occurrences of that color-pair are
+   changed to the new definition.
+
+   has_colors() indicates if the terminal supports, and can
+   maniplulate color. It returns TRUE or FALSE.
+
+   can_change_color() indicates if the terminal has the capability
+   to change the definition of its colors.
+
+   pair_content() is used to determine what the colors of a given
+   color-pair consist of.
+
+   assume_default_colors() and use_default_colors() emulate the
+   ncurses extensions of the same names. assume_default_colors(f,
+   b) is essentially the same as init_pair(0, f, b) (which isn't
+   allowed); it redefines the default colors. use_default_colors()
+   allows the use of -1 as a foreground or background color with
+   init_pair(), and calls assume_default_colors(-1, -1); -1
+   represents the foreground or background color that the terminal
+   had at startup. If the environment variable PDC_ORIGINAL_COLORS
+   is set at the time start_color() is called, that's equivalent to
+   calling use_default_colors().
+
+   PDC_set_line_color() is used to set the color, globally, for
+   the color of the lines drawn for the attributes: A_UNDERLINE,
+   A_OVERLINE, A_LEFTLINE and A_RIGHTLINE. A value of -1 (the
+   default) indicates that the current foreground color should be
+   used.
+
+   NOTE: COLOR_PAIR() and PAIR_NUMBER() are implemented as macros.
+
+### Return Value
+
+   All functions return OK on success and ERR on error, except for
+   has_colors() and can_change_colors(), which return TRUE or FALSE.
+
+### Portability
+                             X/Open    BSD    SYS V
+    start_color                 Y       -      3.2
+    init_pair                   Y       -      3.2
+    init_color                  Y       -      3.2
+    has_colors                  Y       -      3.2
+    can_change_color            Y       -      3.2
+    color_content               Y       -      3.2
+    pair_content                Y       -      3.2
+    assume_default_colors       -       -       -
+    use_default_colors          -       -       -
+    PDC_set_line_color          -       -       -
+
+**man-end****************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+int COLORS = 0;
+int COLOR_PAIRS = PDC_COLOR_PAIRS;
+
+bool pdc_color_started = FALSE;
+
+/* pair_set[] tracks whether a pair has been set via init_pair() */
+
+static bool pair_set[PDC_COLOR_PAIRS];
+static bool default_colors = FALSE;
+static short first_col = 0;
+
+int start_color(void)
+{
+    PDC_LOG(("start_color() - called\n"));
+
+    if (SP->mono)
+        return ERR;
+
+    pdc_color_started = TRUE;
+
+    PDC_set_blink(FALSE);   /* Also sets COLORS, to 8 or 16 */
+
+    if (!default_colors && SP->orig_attr && getenv("PDC_ORIGINAL_COLORS"))
+        default_colors = TRUE;
+
+    PDC_init_atrtab();
+
+    memset(pair_set, 0, PDC_COLOR_PAIRS);
+
+    return OK;
+}
+
+static void _normalize(short *fg, short *bg)
+{
+    if (*fg == -1)
+        *fg = SP->orig_attr ? SP->orig_fore : COLOR_WHITE;
+
+    if (*bg == -1)
+        *bg = SP->orig_attr ? SP->orig_back : COLOR_BLACK;
+}
+
+int init_pair(short pair, short fg, short bg)
+{
+    PDC_LOG(("init_pair() - called: pair %d fg %d bg %d\n", pair, fg, bg));
+
+    if (!pdc_color_started || pair < 1 || pair >= COLOR_PAIRS ||
+        fg < first_col || fg >= COLORS || bg < first_col || bg >= COLORS)
+        return ERR;
+
+    _normalize(&fg, &bg);
+
+    /* To allow the PDC_PRESERVE_SCREEN option to work, we only reset
+       curscr if this call to init_pair() alters a color pair created by
+       the user. */
+
+    if (pair_set[pair])
+    {
+        short oldfg, oldbg;
+
+        PDC_pair_content(pair, &oldfg, &oldbg);
+
+        if (oldfg != fg || oldbg != bg)
+            curscr->_clear = TRUE;
+    }
+
+    PDC_init_pair(pair, fg, bg);
+
+    pair_set[pair] = TRUE;
+
+    return OK;
+}
+
+bool has_colors(void)
+{
+    PDC_LOG(("has_colors() - called\n"));
+
+    return !(SP->mono);
+}
+
+int init_color(short color, short red, short green, short blue)
+{
+    PDC_LOG(("init_color() - called\n"));
+
+    if (color < 0 || color >= COLORS || !PDC_can_change_color() ||
+        red < 0 || red > 1000 || green < 0 || green > 1000 ||
+        blue < 0 || blue > 1000)
+        return ERR;
+
+    return PDC_init_color(color, red, green, blue);
+}
+
+int color_content(short color, short *red, short *green, short *blue)
+{
+    PDC_LOG(("color_content() - called\n"));
+
+    if (color < 0 || color >= COLORS || !red || !green || !blue)
+        return ERR;
+
+    if (PDC_can_change_color())
+        return PDC_color_content(color, red, green, blue);
+    else
+    {
+        /* Simulated values for platforms that don't support palette
+           changing */
+
+        short maxval = (color & 8) ? 1000 : 680;
+
+        *red = (color & COLOR_RED) ? maxval : 0;
+        *green = (color & COLOR_GREEN) ? maxval : 0;
+        *blue = (color & COLOR_BLUE) ? maxval : 0;
+
+        return OK;
+    }
+}
+
+bool can_change_color(void)
+{
+    PDC_LOG(("can_change_color() - called\n"));
+
+    return PDC_can_change_color();
+}
+
+int pair_content(short pair, short *fg, short *bg)
+{
+    PDC_LOG(("pair_content() - called\n"));
+
+    if (pair < 0 || pair >= COLOR_PAIRS || !fg || !bg)
+        return ERR;
+
+    return PDC_pair_content(pair, fg, bg);
+}
+
+int assume_default_colors(int f, int b)
+{
+    PDC_LOG(("assume_default_colors() - called: f %d b %d\n", f, b));
+
+    if (f < -1 || f >= COLORS || b < -1 || b >= COLORS)
+        return ERR;
+
+    if (pdc_color_started)
+    {
+        short fg, bg, oldfg, oldbg;
+
+        fg = f;
+        bg = b;
+
+        _normalize(&fg, &bg);
+
+        PDC_pair_content(0, &oldfg, &oldbg);
+
+        if (oldfg != fg || oldbg != bg)
+            curscr->_clear = TRUE;
+
+        PDC_init_pair(0, fg, bg);
+    }
+
+    return OK;
+}
+
+int use_default_colors(void)
+{
+    PDC_LOG(("use_default_colors() - called\n"));
+
+    default_colors = TRUE;
+    first_col = -1;
+
+    return assume_default_colors(-1, -1);
+}
+
+int PDC_set_line_color(short color)
+{
+    PDC_LOG(("PDC_set_line_color() - called: %d\n", color));
+
+    if (color < -1 || color >= COLORS)
+        return ERR;
+
+    SP->line_color = color;
+
+    return OK;
+}
+
+void PDC_init_atrtab(void)
+{
+    int i;
+    short fg, bg;
+
+    if (pdc_color_started && !default_colors)
+    {
+        fg = COLOR_WHITE;
+        bg = COLOR_BLACK;
+    }
+    else
+        fg = bg = -1;
+
+    _normalize(&fg, &bg);
+
+    for (i = 0; i < PDC_COLOR_PAIRS; i++)
+        PDC_init_pair( (short)i, fg, bg);
+}

data/vendor/PDCurses/pdcurses/debug.c

@@ -0,0 +1,109 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+debug
+-----
+
+### Synopsis
+
+    void traceon(void);
+    void traceoff(void);
+    void PDC_debug(const char *, ...);
+
+### Description
+
+   traceon() and traceoff() toggle the recording of debugging
+   information to the file "trace". Although not standard, similar
+   functions are in some other curses implementations.
+
+   PDC_debug() is the function that writes to the file, based on
+   whether traceon() has been called. It's used from the PDC_LOG()
+   macro.
+
+   The environment variable PDC_TRACE_FLUSH controls whether the
+   trace file contents are fflushed after each write.  The default
+   is not. Set it to 1 to enable this (may affect performance).
+
+### Portability
+                             X/Open    BSD    SYS V
+    traceon                     -       -       -
+    traceoff                    -       -       -
+    PDC_debug                   -       -       -
+
+**man-end****************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <time.h>
+
+FILE *pdc_dbfp = NULL;
+static bool trace_on = FALSE;
+static bool want_fflush = FALSE;
+
+void PDC_debug(const char *fmt, ...)
+{
+    va_list args;
+    char hms[9];
+    time_t now;
+
+    if( !trace_on)
+        return;
+    if (!pdc_dbfp)
+    {
+        pdc_dbfp = fopen("trace", "a");
+        if (!pdc_dbfp)
+        {
+            fprintf(stderr,
+                "PDC_debug(): Unable to open debug log file\n");
+            return;
+        }
+    }
+
+    time(&now);
+    strftime(hms, 9, "%H:%M:%S", localtime(&now));
+    fprintf(pdc_dbfp, "At: %8.8ld - %s ", (long) clock(), hms);
+
+    va_start(args, fmt);
+    vfprintf(pdc_dbfp, fmt, args);
+    va_end(args);
+
+    /* If you are crashing and losing debugging information, enable this
+     * by setting the environment variable PDC_TRACE_FLUSH to 1. This may
+     * impact performance.
+     */
+    if (want_fflush)
+        fflush(pdc_dbfp);
+
+    /* If with PDC_TRACE_FLUSH enabled you are still losing logging in
+     * crashes, you may need to add a platform-dependent mechanism to flush
+     * the OS buffers as well (such as fsync() on POSIX) -- but expect
+     * terrible performance.
+     */
+}
+
+void traceon(void)
+{
+    char *env;
+
+    trace_on = TRUE;
+    if ((env = getenv("PDC_TRACE_FLUSH")))
+        want_fflush = atoi(env);
+
+    PDC_LOG(("traceon() - called\n"));
+}
+
+void traceoff(void)
+{
+    if (!pdc_dbfp)
+        return;
+
+    PDC_LOG(("traceoff() - called\n"));
+
+    fclose(pdc_dbfp);
+    pdc_dbfp = NULL;
+    want_fflush = trace_on = FALSE;
+}

data/vendor/PDCurses/pdcurses/delch.c

@@ -0,0 +1,96 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+delch
+-----
+
+### Synopsis
+
+    int delch(void);
+    int wdelch(WINDOW *win);
+    int mvdelch(int y, int x);
+    int mvwdelch(WINDOW *win, int y, int x);
+
+### Description
+
+   The character under the cursor in the window is deleted.  All
+   characters to the right on the same line are moved to the left
+   one position and the last character on the line is filled with
+   a blank.  The cursor position does not change (after moving to
+   y, x if coordinates are specified).
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+                             X/Open    BSD    SYS V
+    delch                       Y       Y       Y
+    wdelch                      Y       Y       Y
+    mvdelch                     Y       Y       Y
+    mvwdelch                    Y       Y       Y
+
+**man-end****************************************************************/
+
+#include <string.h>
+
+int wdelch(WINDOW *win)
+{
+    int y, x, maxx;
+    chtype *temp1;
+
+    PDC_LOG(("wdelch() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    y = win->_cury;
+    x = win->_curx;
+    maxx = win->_maxx - 1;
+    temp1 = &win->_y[y][x];
+
+    memmove(temp1, temp1 + 1, (maxx - x) * sizeof(chtype));
+
+    /* wrs (4/10/93) account for window background */
+
+    win->_y[y][maxx] = win->_bkgd;
+
+    win->_lastch[y] = maxx;
+
+    if ((win->_firstch[y] == _NO_CHANGE) || (win->_firstch[y] > x))
+        win->_firstch[y] = x;
+
+    PDC_sync(win);
+
+    return OK;
+}
+
+int delch(void)
+{
+    PDC_LOG(("delch() - called\n"));
+
+    return wdelch(stdscr);
+}
+
+int mvdelch(int y, int x)
+{
+    PDC_LOG(("mvdelch() - called\n"));
+
+    if (move(y, x) == ERR)
+        return ERR;
+
+    return wdelch(stdscr);
+}
+
+int mvwdelch(WINDOW *win, int y, int x)
+{
+    PDC_LOG(("mvwdelch() - called\n"));
+
+    if (wmove(win, y, x) == ERR)
+        return ERR;
+
+    return wdelch(win);
+}

data/vendor/PDCurses/pdcurses/deleteln.c

@@ -0,0 +1,211 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+deleteln
+--------
+
+### Synopsis
+
+    int deleteln(void);
+    int wdeleteln(WINDOW *win);
+    int insdelln(int n);
+    int winsdelln(WINDOW *win, int n);
+    int insertln(void);
+    int winsertln(WINDOW *win);
+
+    int mvdeleteln(int y, int x);
+    int mvwdeleteln(WINDOW *win, int y, int x);
+    int mvinsertln(int y, int x);
+    int mvwinsertln(WINDOW *win, int y, int x);
+
+### Description
+
+   With the deleteln() and wdeleteln() functions, the line under
+   the cursor in the window is deleted.  All lines below the
+   current line are moved up one line.  The bottom line of the
+   window is cleared.  The cursor position does not change.
+
+   With the insertln() and winsertn() functions, a blank line is
+   inserted above the current line and the bottom line is lost.
+
+   mvdeleteln(), mvwdeleteln(), mvinsertln() and mvwinsertln()
+   allow moving the cursor and inserting/deleting in one call.
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+                             X/Open    BSD    SYS V
+    deleteln                    Y       Y       Y
+    wdeleteln                   Y       Y       Y
+    mvdeleteln                  -       -       -
+    mvwdeleteln                 -       -       -
+    insdelln                    Y       -      4.0
+    winsdelln                   Y       -      4.0
+    insertln                    Y       Y       Y
+    winsertln                   Y       Y       Y
+    mvinsertln                  -       -       -
+    mvwinsertln                 -       -       -
+
+**man-end****************************************************************/
+
+int wdeleteln(WINDOW *win)
+{
+    chtype blank, *temp, *ptr;
+    int y;
+
+    PDC_LOG(("wdeleteln() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    /* wrs (4/10/93) account for window background */
+
+    blank = win->_bkgd;
+
+    temp = win->_y[win->_cury];
+
+    for (y = win->_cury; y < win->_bmarg; y++)
+    {
+        win->_y[y] = win->_y[y + 1];
+        win->_firstch[y] = 0;
+        win->_lastch[y] = win->_maxx - 1;
+    }
+
+    for (ptr = temp; (ptr - temp < win->_maxx); ptr++)
+        *ptr = blank;           /* make a blank line */
+
+    if (win->_cury <= win->_bmarg) 
+    {
+        win->_firstch[win->_bmarg] = 0;
+        win->_lastch[win->_bmarg] = win->_maxx - 1;
+        win->_y[win->_bmarg] = temp;
+    }
+
+    return OK;
+}
+
+int deleteln(void)
+{
+    PDC_LOG(("deleteln() - called\n"));
+
+    return wdeleteln(stdscr);
+}
+
+int mvdeleteln(int y, int x)
+{
+    PDC_LOG(("mvdeleteln() - called\n"));
+
+    if (move(y, x) == ERR)
+        return ERR;
+
+    return wdeleteln(stdscr);
+}
+
+int mvwdeleteln(WINDOW *win, int y, int x)
+{
+    PDC_LOG(("mvwdeleteln() - called\n"));
+
+    if (wmove(win, y, x) == ERR)
+        return ERR;
+
+    return wdeleteln(win);
+}
+
+int winsdelln(WINDOW *win, int n)
+{
+    int i;
+
+    PDC_LOG(("winsdelln() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    if (n > 0)
+    {
+        for (i = 0; i < n; i++)
+            if (winsertln(win) == ERR)
+                return ERR;
+    }
+    else if (n < 0)
+    {
+        n = -n;
+        for (i = 0; i < n; i++)
+            if (wdeleteln(win) == ERR)
+                return ERR;
+    }
+
+    return OK;
+}
+
+int insdelln(int n)
+{
+    PDC_LOG(("insdelln() - called\n"));
+
+    return winsdelln(stdscr, n);
+}
+
+int winsertln(WINDOW *win)
+{
+    chtype blank, *temp, *end;
+    int y;
+
+    PDC_LOG(("winsertln() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    /* wrs (4/10/93) account for window background */
+
+    blank = win->_bkgd;
+
+    temp = win->_y[win->_maxy - 1];
+
+    for (y = win->_maxy - 1; y > win->_cury; y--)
+    {
+        win->_y[y] = win->_y[y - 1];
+        win->_firstch[y] = 0;
+        win->_lastch[y] = win->_maxx - 1;
+    }
+
+    win->_y[win->_cury] = temp;
+
+    for (end = &temp[win->_maxx - 1]; temp <= end; temp++)
+        *temp = blank;
+
+    win->_firstch[win->_cury] = 0;
+    win->_lastch[win->_cury] = win->_maxx - 1;
+
+    return OK;
+}
+
+int insertln(void)
+{
+    PDC_LOG(("insertln() - called\n"));
+
+    return winsertln(stdscr);
+}
+
+int mvinsertln(int y, int x)
+{
+    PDC_LOG(("mvinsertln() - called\n"));
+
+    if (move(y, x) == ERR)
+        return ERR;
+
+    return winsertln(stdscr);
+}
+
+int mvwinsertln(WINDOW *win, int y, int x)
+{
+    PDC_LOG(("mvwinsertln() - called\n"));
+
+    if (wmove(win, y, x) == ERR)
+        return ERR;
+
+    return winsertln(win);
+}