curses 1.3.0 → 1.4.2

data/vendor/PDCurses/pdcurses/scr_dump.c

@@ -0,0 +1,213 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+scr_dump
+--------
+
+### Synopsis
+
+    int putwin(WINDOW *win, FILE *filep);
+    WINDOW *getwin(FILE *filep);
+    int scr_dump(const char *filename);
+    int scr_init(const char *filename);
+    int scr_restore(const char *filename);
+    int scr_set(const char *filename);
+
+### Description
+
+   getwin() reads window-related data previously stored in a file
+   by putwin(). It then creates and initialises a new window using
+   that data.
+
+   putwin() writes all data associated with a window into a file,
+   using an unspecified format. This information can be retrieved
+   later using getwin().
+
+   scr_dump() writes the current contents of the virtual screen to
+   the file named by filename in an unspecified format.
+
+   scr_restore() function sets the virtual screen to the contents
+   of the file named by filename, which must have been written
+   using scr_dump(). The next refresh operation restores the screen
+   to the way it looked in the dump file.
+
+   In PDCurses, scr_init() does nothing, and scr_set() is a synonym
+   for scr_restore(). Also, scr_dump() and scr_restore() save and
+   load from curscr. This differs from some other implementations,
+   where scr_init() works with curscr, and scr_restore() works with
+   newscr; but the effect should be the same. (PDCurses has no
+   newscr.)
+
+### Return Value
+
+   On successful completion, getwin() returns a pointer to the
+   window it created. Otherwise, it returns a null pointer. Other
+   functions return OK or ERR.
+
+### Portability
+                             X/Open    BSD    SYS V
+    putwin                      Y
+    getwin                      Y
+    scr_dump                    Y
+    scr_init                    Y
+    scr_restore                 Y
+    scr_set                     Y
+
+**man-end****************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#define DUMPVER 1   /* Should be updated whenever the WINDOW struct is
+                       changed */
+
+int putwin(WINDOW *win, FILE *filep)
+{
+    static const char *marker = "PDC";
+    static const unsigned char version = DUMPVER;
+
+    PDC_LOG(("putwin() - called\n"));
+
+    /* write the marker and the WINDOW struct */
+
+    if (filep && fwrite(marker, strlen(marker), 1, filep)
+              && fwrite(&version, 1, 1, filep)
+              && fwrite(win, sizeof(WINDOW), 1, filep))
+    {
+        int i;
+
+        /* write each line */
+
+        for (i = 0; i < win->_maxy && win->_y[i]; i++)
+            if (!fwrite(win->_y[i], win->_maxx * sizeof(chtype), 1, filep))
+                return ERR;
+
+        return OK;
+    }
+
+    return ERR;
+}
+
+WINDOW *getwin(FILE *filep)
+{
+    WINDOW *win;
+    char marker[4];
+    int i, nlines, ncols;
+
+    PDC_LOG(("getwin() - called\n"));
+
+    if ( !(win = malloc(sizeof(WINDOW))) )
+        return (WINDOW *)NULL;
+
+    /* check for the marker, and load the WINDOW struct */
+
+    if (!filep || !fread(marker, 4, 1, filep) || strncmp(marker, "PDC", 3)
+        || marker[3] != DUMPVER || !fread(win, sizeof(WINDOW), 1, filep))
+    {
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    nlines = win->_maxy;
+    ncols = win->_maxx;
+
+    /* allocate the line pointer array */
+
+    if ( !(win->_y = malloc(nlines * sizeof(chtype *))) )
+    {
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    /* allocate the minchng and maxchng arrays */
+
+    if ( !(win->_firstch = malloc(nlines * sizeof(int))) )
+    {
+        free(win->_y);
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    if ( !(win->_lastch = malloc(nlines * sizeof(int))) )
+    {
+        free(win->_firstch);
+        free(win->_y);
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    /* allocate the lines */
+
+    if ( !(win = PDC_makelines(win)) )
+        return (WINDOW *)NULL;
+
+    /* read them */
+
+    for (i = 0; i < nlines; i++)
+    {
+        if (!fread(win->_y[i], ncols * sizeof(chtype), 1, filep))
+        {
+            delwin(win);
+            return (WINDOW *)NULL;
+        }
+    }
+
+    touchwin(win);
+
+    return win;
+}
+
+int scr_dump(const char *filename)
+{
+    FILE *filep;
+
+    PDC_LOG(("scr_dump() - called: filename %s\n", filename));
+
+    if (filename && (filep = fopen(filename, "wb")) != NULL)
+    {
+        int result = putwin(curscr, filep);
+        fclose(filep);
+        return result;
+    }
+
+    return ERR;
+}
+
+int scr_init(const char *filename)
+{
+    PDC_LOG(("scr_init() - called: filename %s\n", filename));
+
+    return OK;
+}
+
+int scr_restore(const char *filename)
+{
+    FILE *filep;
+
+    PDC_LOG(("scr_restore() - called: filename %s\n", filename));
+
+    if (filename && (filep = fopen(filename, "rb")) != NULL)
+    {
+        WINDOW *replacement = getwin(filep);
+        fclose(filep);
+
+        if (replacement)
+        {
+            int result = overwrite(replacement, curscr);
+            delwin(replacement);
+            return result;
+        }
+    }
+
+    return ERR;
+}
+
+int scr_set(const char *filename)
+{
+    PDC_LOG(("scr_set() - called: filename %s\n", filename));
+
+    return scr_restore(filename);
+}

data/vendor/PDCurses/pdcurses/scroll.c

@@ -0,0 +1,101 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+scroll
+------
+
+### Synopsis
+
+    int scroll(WINDOW *win);
+    int scrl(int n);
+    int wscrl(WINDOW *win, int n);
+
+### Description
+
+   scroll() causes the window to scroll up one line.  This involves
+   moving the lines in the window data strcture.
+ 
+   With a positive n, scrl() and wscrl() scroll the window up n
+   lines (line i + n becomes i); otherwise they scroll the window
+   down n lines.
+ 
+   For these functions to work, scrolling must be enabled via
+   scrollok(). Note also that scrolling is not allowed if the
+   supplied window is a pad.
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+                             X/Open    BSD    SYS V
+    scroll                      Y       Y       Y
+    scrl                        Y       -      4.0
+    wscrl                       Y       -      4.0
+
+**man-end****************************************************************/
+
+int wscrl(WINDOW *win, int n)
+{
+    int i, l, dir, start, end;
+    chtype blank, *temp;
+
+    /* Check if window scrolls. Valid for window AND pad */
+
+    if (!win || !win->_scroll || !n)
+        return ERR;
+
+    blank = win->_bkgd;
+
+    if (n > 0)
+    {
+        start = win->_tmarg;
+        end = win->_bmarg;
+        dir = 1;
+    }
+    else
+    {
+        start = win->_bmarg;
+        end = win->_tmarg;
+        dir = -1;
+    }
+
+    for (l = 0; l < (n * dir); l++) 
+    {
+        temp = win->_y[start];
+
+        /* re-arrange line pointers */
+
+        for (i = start; i != end; i += dir)
+            win->_y[i] = win->_y[i + dir];
+
+        win->_y[end] = temp;
+
+        /* make a blank line */
+
+        for (i = 0; i < win->_maxx; i++)
+            *temp++ = blank;
+    }
+
+    touchline(win, win->_tmarg, win->_bmarg - win->_tmarg + 1);
+
+    PDC_sync(win);
+    return OK;
+}
+
+int scrl(int n)
+{
+    PDC_LOG(("scrl() - called\n"));
+
+    return wscrl(stdscr, n);
+}
+
+int scroll(WINDOW *win)
+{
+    PDC_LOG(("scroll() - called\n"));
+
+    return wscrl(win, 1);
+}

data/vendor/PDCurses/pdcurses/slk.c

@@ -0,0 +1,591 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+slk
+---
+
+### Synopsis
+
+    int slk_init(int fmt);
+    int slk_set(int labnum, const char *label, int justify);
+    int slk_refresh(void);
+    int slk_noutrefresh(void);
+    char *slk_label(int labnum);
+    int slk_clear(void);
+    int slk_restore(void);
+    int slk_touch(void);
+    int slk_attron(const chtype attrs);
+    int slk_attr_on(const attr_t attrs, void *opts);
+    int slk_attrset(const chtype attrs);
+    int slk_attr_set(const attr_t attrs, short color_pair, void *opts);
+    int slk_attroff(const chtype attrs);
+    int slk_attr_off(const attr_t attrs, void *opts);
+    int slk_color(short color_pair);
+
+    int slk_wset(int labnum, const wchar_t *label, int justify);
+
+    int PDC_mouse_in_slk(int y, int x);
+    void PDC_slk_free(void);
+    void PDC_slk_initialize(void);
+
+    wchar_t *slk_wlabel(int labnum)
+
+### Description
+
+   These functions manipulate a window that contain Soft Label Keys
+   (SLK). To use the SLK functions, a call to slk_init() must be
+   made BEFORE initscr() or newterm(). slk_init() removes 1 or 2
+   lines from the useable screen, depending on the format selected.
+
+   The line(s) removed from the screen are used as a separate
+   window, in which SLKs are displayed.
+
+   slk_init() requires a single parameter which describes the
+   format of the SLKs as follows:
+
+   0       3-2-3 format
+   1       4-4 format
+   2       4-4-4 format (ncurses extension)
+   3       4-4-4 format with index line (ncurses extension)
+   2 lines used
+   55      5-5 format (pdcurses format)
+
+   In PDCurses,  one can alternatively set fmt as a series of hex
+   digits specifying the format.  For example,  0x414 would result
+   in 4-1-4 format; 0x21b3 would result in 2-1-11-3 format;  and
+   so on.  Also,  negating fmt results in the index line being added.
+
+   Also,  in PDCurses,  one can call slk_init() at any time
+   _after_ initscr(),  to reset the label format.  If you do this,
+   you'll need to reset the label text and call slk_refresh().  And
+   you can't toggle the index line.  (Doing so would add/remove a line
+   from the useable screen,  which would be hard to handle correctly.)
+
+   slk_refresh(), slk_noutrefresh() and slk_touch() are analogous
+   to refresh(), noutrefresh() and touch().
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+                             X/Open    BSD    SYS V
+    slk_init                    Y       -       Y
+    slk_set                     Y       -       Y
+    slk_refresh                 Y       -       Y
+    slk_noutrefresh             Y       -       Y
+    slk_label                   Y       -       Y
+    slk_clear                   Y       -       Y
+    slk_restore                 Y       -       Y
+    slk_touch                   Y       -       Y
+    slk_attron                  Y       -       Y
+    slk_attrset                 Y       -       Y
+    slk_attroff                 Y       -       Y
+    slk_attr_on                 Y
+    slk_attr_set                Y
+    slk_attr_off                Y
+    slk_wset                    Y
+    PDC_mouse_in_slk            -       -       -
+    PDC_slk_free                -       -       -
+    PDC_slk_initialize          -       -       -
+    slk_wlabel                  -       -       -
+
+**man-end****************************************************************/
+
+#include <stdlib.h>
+
+static int label_length = 0;
+static int n_labels = 0;
+static int label_fmt = 0;
+static int label_line = 0;
+static bool hidden = FALSE;
+
+#define MAX_LABEL_LENGTH 32
+
+static struct SLK {
+    chtype label[MAX_LABEL_LENGTH];
+    int len;
+    int format;
+    int start_col;
+} *slk = (struct SLK *)NULL;
+
+/* See comments above on this function.   */
+
+int slk_init(int fmt)
+{
+    int i;
+
+    PDC_LOG(("slk_init() - called\n"));
+
+    switch (fmt)
+    {
+    case 0:  /* 3 - 2 - 3 */
+        label_fmt = 0x323;
+        break;
+
+    case 1:   /* 4 - 4 */
+        label_fmt = 0x44;
+        break;
+
+    case 2:   /* 4 4 4 */
+        label_fmt = 0x444;
+        break;
+
+    case 3:   /* 4 4 4  with index */
+        label_fmt = -0x444;
+        break;
+
+    case 55:  /* 5 - 5 */
+        label_fmt = 0x55;
+        break;
+
+    default:
+        label_fmt = fmt;
+        break;
+    }
+
+    n_labels = 0;
+    for( i = abs( label_fmt); i; i /= 16)
+       n_labels += i % 16;
+
+    PDC_LOG(("slk_init: fmt %d, %d labels, %p\n",
+               fmt, n_labels, slk));
+    if( slk)
+        free( slk);
+    slk = calloc(n_labels, sizeof(struct SLK));
+    PDC_LOG(( "New slk: %p; SP = %p\n", slk, SP));
+
+    if (!slk)
+        n_labels = 0;
+    if( SP)
+        {
+        if( SP->slk_winptr)
+            wclear( SP->slk_winptr);
+        PDC_slk_initialize( );
+        }
+
+    return slk ? OK : ERR;
+}
+
+/* draw a single button */
+
+static void _drawone(int num)
+{
+    int i, col, slen;
+
+    if (hidden)
+        return;
+
+    slen = slk[num].len;
+
+    switch (slk[num].format)
+    {
+    case 0:  /* LEFT */
+        col = 0;
+        break;
+
+    case 1:  /* CENTER */
+        col = (label_length - slen) / 2;
+
+        if (col + slen > label_length)
+            --col;
+        break;
+
+    default:  /* RIGHT */
+        col = label_length - slen;
+    }
+
+    if( col < 0)  /* Ensure start of label is visible */
+        col = 0;
+    wmove(SP->slk_winptr, label_line, slk[num].start_col);
+
+    for (i = 0; i < label_length; ++i)
+        waddch(SP->slk_winptr, (i >= col && i < (col + slen)) ?
+               slk[num].label[i - col] : ' ');
+}
+
+/* redraw each button */
+
+static void _redraw(void)
+{
+    int i;
+
+    if( !hidden)
+    {
+        for (i = 0; i < n_labels; ++i)
+            _drawone(i);
+        if (label_fmt < 0)
+        {
+            const chtype save_attr = SP->slk_winptr->_attrs;
+
+            wattrset(SP->slk_winptr, A_NORMAL);
+            wmove(SP->slk_winptr, 0, 0);
+            whline(SP->slk_winptr, 0, COLS);
+
+            for (i = 0; i < n_labels; i++)
+                mvwprintw(SP->slk_winptr, 0, slk[i].start_col, "F%d", i + 1);
+
+            SP->slk_winptr->_attrs = save_attr;
+        }
+    }
+}
+
+/* slk_set() Used to set a slk label to a string.
+
+   labnum  = 1 - 8 (or 10) (number of the label)
+   label   = string (8 or 7 bytes total), or NULL
+   justify = 0 : left, 1 : center, 2 : right  */
+
+int slk_set(int labnum, const char *label, int justify)
+{
+#ifdef PDC_WIDE
+    wchar_t wlabel[MAX_LABEL_LENGTH];
+
+    PDC_mbstowcs(wlabel, label, MAX_LABEL_LENGTH - 1);
+    return slk_wset(labnum, wlabel, justify);
+#else
+    PDC_LOG(("slk_set() - called\n"));
+
+    if (labnum < 1 || labnum > n_labels || justify < 0 || justify > 2)
+        return ERR;
+
+    labnum--;
+
+    if (!label || !(*label))
+    {
+        /* Clear the label */
+
+        *slk[labnum].label = 0;
+        slk[labnum].format = 0;
+        slk[labnum].len = 0;
+    }
+    else
+    {
+        int i;
+
+        /* Skip leading spaces */
+
+        while( *label == ' ')
+            label++;
+
+        /* Copy it */
+
+        for (i = 0; label[i] && i < MAX_LABEL_LENGTH - 1; i++)
+            slk[labnum].label[i] = label[i];
+
+        /* Drop trailing spaces */
+
+        while( i && label[i - 1] == ' ')
+            i--;
+
+        slk[labnum].label[i] = 0;
+        slk[labnum].format = justify;
+        slk[labnum].len = i;
+    }
+
+    _drawone(labnum);
+
+    return OK;
+#endif
+}
+
+int slk_refresh(void)
+{
+    PDC_LOG(("slk_refresh() - called\n"));
+
+    return (slk_noutrefresh() == ERR) ? ERR : doupdate();
+}
+
+int slk_noutrefresh(void)
+{
+    PDC_LOG(("slk_noutrefresh() - called\n"));
+
+    return wnoutrefresh(SP->slk_winptr);
+}
+
+char *slk_label(int labnum)
+{
+    static char temp[MAX_LABEL_LENGTH + 1];
+#ifdef PDC_WIDE
+    wchar_t *wtemp = slk_wlabel(labnum);
+
+    PDC_wcstombs(temp, wtemp, MAX_LABEL_LENGTH);
+#else
+    chtype *p;
+    int i;
+
+    PDC_LOG(("slk_label() - called\n"));
+
+    if (labnum < 1 || labnum > n_labels)
+        return (char *)0;
+
+    for (i = 0, p = slk[labnum - 1].label; *p; i++)
+        temp[i] = (char)*p++;    /* BJG */
+
+    temp[i] = '\0';
+#endif
+    return temp;
+}
+
+int slk_clear(void)
+{
+    PDC_LOG(("slk_clear() - called\n"));
+
+    hidden = TRUE;
+    werase(SP->slk_winptr);
+    return wrefresh(SP->slk_winptr);
+}
+
+int slk_restore(void)
+{
+    PDC_LOG(("slk_restore() - called\n"));
+
+    hidden = FALSE;
+    _redraw();
+    return wrefresh(SP->slk_winptr);
+}
+
+int slk_touch(void)
+{
+    PDC_LOG(("slk_touch() - called\n"));
+
+    return touchwin(SP->slk_winptr);
+}
+
+int slk_attron(const chtype attrs)
+{
+    int rc;
+
+    PDC_LOG(("slk_attron() - called\n"));
+
+    rc = wattron(SP->slk_winptr, attrs);
+    _redraw();
+
+    return rc;
+}
+
+int slk_attr_on(const attr_t attrs, void *opts)
+{
+    PDC_LOG(("slk_attr_on() - called\n"));
+
+    return slk_attron(attrs);
+}
+
+int slk_attroff(const chtype attrs)
+{
+    int rc;
+
+    PDC_LOG(("slk_attroff() - called\n"));
+
+    rc = wattroff(SP->slk_winptr, attrs);
+    _redraw();
+
+    return rc;
+}
+
+int slk_attr_off(const attr_t attrs, void *opts)
+{
+    PDC_LOG(("slk_attr_off() - called\n"));
+
+    return slk_attroff(attrs);
+}
+
+int slk_attrset(const chtype attrs)
+{
+    int rc;
+
+    PDC_LOG(("slk_attrset() - called\n"));
+
+    rc = wattrset(SP->slk_winptr, attrs);
+    _redraw();
+
+    return rc;
+}
+
+int slk_color(short color_pair)
+{
+    int rc;
+
+    PDC_LOG(("slk_color() - called\n"));
+
+    rc = wcolor_set(SP->slk_winptr, color_pair, NULL);
+    _redraw();
+
+    return rc;
+}
+
+int slk_attr_set(const attr_t attrs, short color_pair, void *opts)
+{
+    PDC_LOG(("slk_attr_set() - called\n"));
+
+    return slk_attrset(attrs | COLOR_PAIR(color_pair));
+}
+
+static void _slk_calc(void)
+{
+    int i, j, idx, remaining_space;
+    int n_groups = 0, group_size[10];
+
+    label_length = COLS / n_labels;
+    if (label_length > MAX_LABEL_LENGTH)
+        label_length = MAX_LABEL_LENGTH;
+    remaining_space = COLS - label_length * n_labels + 1;
+    for( i = abs( label_fmt); i; i /= 16)
+        group_size[n_groups++] = i % 16;
+               /* We really want at least two spaces between groups: */
+    while( label_length > 1 && remaining_space < n_groups - 1)
+    {
+        label_length--;
+        remaining_space += n_labels;
+    }
+
+    for( i = idx = 0; i < n_groups; i++)
+        for( j = 0; j < group_size[i]; j++, idx++)
+            slk[idx].start_col = label_length * idx
+                     + (i ? (i * remaining_space) / (n_groups - 1) : 0);
+
+    if( label_length)
+       --label_length;
+
+    /* make sure labels are all in window */
+
+    _redraw();
+}
+
+void PDC_slk_initialize(void)
+{
+    if (slk)
+    {
+        if( label_fmt < 0)
+        {
+            SP->slklines = 2;
+            label_line = 1;
+        }
+        else
+            SP->slklines = 1;
+
+        if (!SP->slk_winptr)
+        {
+            if ( !(SP->slk_winptr = newwin(SP->slklines, COLS,
+                                           LINES - SP->slklines, 0)) )
+                return;
+
+            wattrset(SP->slk_winptr, A_REVERSE);
+        }
+
+        _slk_calc();
+
+        touchwin(SP->slk_winptr);
+    }
+}
+
+void PDC_slk_free(void)
+{
+    if (slk)
+    {
+        if (SP->slk_winptr)
+        {
+            delwin(SP->slk_winptr);
+            SP->slk_winptr = (WINDOW *)NULL;
+        }
+
+        free(slk);
+        slk = (struct SLK *)NULL;
+
+        label_length = 0;
+        n_labels = 0;
+        label_fmt = 0;
+        label_line = 0;
+        hidden = FALSE;
+    }
+}
+
+int PDC_mouse_in_slk(int y, int x)
+{
+    int i;
+
+    PDC_LOG(("PDC_mouse_in_slk() - called: y->%d x->%d\n", y, x));
+
+    /* If the line on which the mouse was clicked is NOT the last line
+       of the screen, or the SLKs are hidden,  we are not interested in it. */
+
+    if (!slk || hidden || !SP->slk_winptr
+                        || (y != SP->slk_winptr->_begy + label_line))
+        return 0;
+
+    for (i = 0; i < n_labels; i++)
+        if (x >= slk[i].start_col && x < (slk[i].start_col + label_length))
+            return i + 1;
+
+    return 0;
+}
+
+#ifdef PDC_WIDE
+int slk_wset(int labnum, const wchar_t *label, int justify)
+{
+    PDC_LOG(("slk_wset() - called\n"));
+
+    if (labnum < 1 || labnum > n_labels || justify < 0 || justify > 2)
+        return ERR;
+
+    labnum--;
+
+    if (!label || !(*label))
+    {
+        /* Clear the label */
+
+        *slk[labnum].label = 0;
+        slk[labnum].format = 0;
+        slk[labnum].len = 0;
+    }
+    else
+    {
+        int i;
+
+        /* Skip leading spaces */
+
+        while( *label == L' ')
+            label++;
+
+        /* Copy it */
+
+        for (i = 0; label[i] && i < MAX_LABEL_LENGTH - 1; i++)
+            slk[labnum].label[i] = label[i];
+
+        /* Drop trailing spaces */
+
+        while( i && label[i - 1] == L' ')
+            i--;
+
+        slk[labnum].label[i] = 0;
+        slk[labnum].format = justify;
+        slk[labnum].len = i;
+    }
+
+    _drawone(labnum);
+
+    return OK;
+}
+
+wchar_t *slk_wlabel(int labnum)
+{
+    static wchar_t temp[MAX_LABEL_LENGTH + 1];
+    chtype *p;
+    int i;
+
+    PDC_LOG(("slk_wlabel() - called\n"));
+
+    if (labnum < 1 || labnum > n_labels)
+        return (wchar_t *)0;
+
+    for (i = 0, p = slk[labnum - 1].label; *p; i++)
+        temp[i] = (wchar_t)*p++;
+
+    temp[i] = '\0';
+
+    return temp;
+}
+#endif