curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/pdcurses/termattr.c

@@ -0,0 +1,177 @@
+/* PDCursesMod */
+
+#include <curspriv.h>
+#include <assert.h>
+
+/*man-start**************************************************************
+
+termattr
+--------
+
+### Synopsis
+
+    int baudrate(void);
+    char erasechar(void);
+    bool has_ic(void);
+    bool has_il(void);
+    char killchar(void);
+    char *longname(void);
+    chtype termattrs(void);
+    attr_t term_attrs(void);
+    char *termname(void);
+
+    int erasewchar(wchar_t *ch);
+    int killwchar(wchar_t *ch);
+
+    char wordchar(void);
+
+### Description
+
+   baudrate() is supposed to return the output speed of the terminal. In
+   PDCurses, it simply returns INT_MAX.
+
+   has_ic and has_il() return TRUE,  indicating that the terminal has the
+   capability to insert and delete characters and lines,  respectively.
+
+   erasechar() and killchar() return ^H and ^U, respectively -- the
+   ERASE and KILL characters. In other curses implementations, these may
+   vary by terminal type. erasewchar() and killwchar() are the wide-
+   character versions; they take a pointer to a location in which to
+   store the character, and return OK or ERR.
+
+   longname() returns a pointer to a static area containing a verbose
+   description of the current terminal. The maximum length of the string
+   is 128 characters. It is defined only after the call to initscr() or
+   newterm().
+
+   termname() returns a pointer to a static area containing a short
+   description of the current terminal (14 characters).
+
+   termattrs() returns a logical OR of all video attributes supported by
+   the terminal.
+
+   wordchar() is a PDCurses extension of the concept behind the
+   functions erasechar() and killchar(), returning the "delete word"
+   character, ^W.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   baudrate              |    Y   |    Y    |   Y
+   erasechar             |    Y   |    Y    |   Y
+   has_ic                |    Y   |    Y    |   Y
+   has_il                |    Y   |    Y    |   Y
+   killchar              |    Y   |    Y    |   Y
+   longname              |    Y   |    Y    |   Y
+   termattrs             |    Y   |    Y    |   Y
+   termname              |    Y   |    Y    |   Y
+   erasewchar            |    Y   |    Y    |   Y
+   killwchar             |    Y   |    Y    |   Y
+   term_attrs            |    Y   |    Y    |   Y
+   wordchar              |    -   |    -    |   -
+
+**man-end****************************************************************/
+
+#include <string.h>
+#include <limits.h>
+
+int baudrate(void)
+{
+    PDC_LOG(("baudrate() - called\n"));
+
+    return INT_MAX;
+}
+
+char erasechar(void)
+{
+    PDC_LOG(("erasechar() - called\n"));
+
+    return _ECHAR;      /* character delete char (^H) */
+}
+
+bool has_ic(void)
+{
+    PDC_LOG(("has_ic() - called\n"));
+
+    return TRUE;
+}
+
+bool has_il(void)
+{
+    PDC_LOG(("has_il() - called\n"));
+
+    return TRUE;
+}
+
+char killchar(void)
+{
+    PDC_LOG(("killchar() - called\n"));
+
+    return _DLCHAR;     /* line delete char (^U) */
+}
+
+char *longname(void)
+{
+    PDC_LOG(("longname() - called\n"));
+
+    sprintf(ttytype, "pdcurses|PDCursesMod for %s", PDC_sysname());
+    return ttytype + 9; /* skip "pdcurses|" */
+}
+
+chtype termattrs(void)
+{
+    PDC_LOG(("termattrs() - called\n"));
+
+    return SP ? (chtype)SP->termattrs : (chtype)0;
+}
+
+attr_t term_attrs(void)
+{
+    PDC_LOG(("term_attrs() - called\n"));
+
+    return SP ? SP->termattrs : (attr_t)0;
+}
+
+char *termname(void)
+{
+    static char _termname[14] = "pdcurses";
+
+    PDC_LOG(("termname() - called\n"));
+
+    return _termname;
+}
+
+char wordchar(void)
+{
+    PDC_LOG(("wordchar() - called\n"));
+
+    return _DWCHAR;         /* word delete char */
+}
+
+#ifdef PDC_WIDE
+int erasewchar(wchar_t *ch)
+{
+    PDC_LOG(("erasewchar() - called\n"));
+
+    assert( ch);
+    if (!ch)
+        return ERR;
+
+    *ch = (wchar_t)_ECHAR;
+
+    return OK;
+}
+
+int killwchar(wchar_t *ch)
+{
+    PDC_LOG(("killwchar() - called\n"));
+
+    assert( ch);
+    if (!ch)
+        return ERR;
+
+    *ch = (wchar_t)_DLCHAR;
+
+    return OK;
+}
+#endif

data/vendor/PDCursesMod/pdcurses/terminfo.c

@@ -0,0 +1,243 @@
+/* PDCursesMod */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+terminfo
+--------
+
+### Synopsis
+
+    int vidattr(chtype attr);
+    int vid_attr(attr_t attr, short color_pair, void *opt);
+    int vidputs(chtype attr, int (*putfunc)(int));
+    int vid_puts(attr_t attr, short color_pair, void *opt,
+    int (*putfunc)(int));
+
+    int del_curterm(TERMINAL *);
+    int putp(const char *);
+    int restartterm(const char *, int, int *);
+    TERMINAL *set_curterm(TERMINAL *);
+    int setterm(const char *term);
+    int setupterm(const char *, int, int *);
+    int tgetent(char *, const char *);
+    int tgetflag(const char *);
+    int tgetnum(const char *);
+    char *tgetstr(const char *, char **);
+    char *tgoto(const char *, int, int);
+    int tigetflag(const char *);
+    int tigetnum(const char *);
+    char *tigetstr(const char *);
+    char *tparm(const char *,long, long, long, long, long, long,
+                long, long, long);
+    int tputs(const char *, int, int (*)(int));
+
+### Description
+
+   These functions are currently implemented as stubs,
+   returning the appropriate errors and doing nothing else.
+   They are only compiled and used for certain ncurses tests.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   mvcur                 |    Y   |    Y    |   Y
+
+**man-end****************************************************************/
+
+#include <term.h>
+
+TERMINAL *cur_term = NULL;
+
+int vidattr(chtype attr)
+{
+    PDC_LOG(("vidattr() - called: attr %d\n", attr));
+
+    INTENTIONALLY_UNUSED_PARAMETER( attr);
+    return ERR;
+}
+
+int vid_attr(attr_t attr, short color_pair, void *opt)
+{
+    PDC_LOG(("vid_attr() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( attr);
+    INTENTIONALLY_UNUSED_PARAMETER( color_pair);
+    INTENTIONALLY_UNUSED_PARAMETER( opt);
+    return ERR;
+}
+
+int vidputs(chtype attr, int (*putfunc)(int))
+{
+    PDC_LOG(("vidputs() - called: attr %d\n", attr));
+
+    INTENTIONALLY_UNUSED_PARAMETER( attr);
+    INTENTIONALLY_UNUSED_PARAMETER( putfunc);
+    return ERR;
+}
+
+int vid_puts(attr_t attr, short color_pair, void *opt, int (*putfunc)(int))
+{
+    PDC_LOG(("vid_puts() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( attr);
+    INTENTIONALLY_UNUSED_PARAMETER( color_pair);
+    INTENTIONALLY_UNUSED_PARAMETER( opt);
+    INTENTIONALLY_UNUSED_PARAMETER( putfunc);
+    return ERR;
+}
+
+int del_curterm(TERMINAL *oterm)
+{
+    PDC_LOG(("del_curterm() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( oterm);
+    return ERR;
+}
+
+int putp(const char *str)
+{
+    PDC_LOG(("putp() - called: str %s\n", str));
+
+    INTENTIONALLY_UNUSED_PARAMETER( str);
+    return ERR;
+}
+
+int restartterm(const char *term, int filedes, int *errret)
+{
+    PDC_LOG(("restartterm() - called\n"));
+
+    if (errret)
+        *errret = -1;
+
+    INTENTIONALLY_UNUSED_PARAMETER( term);
+    INTENTIONALLY_UNUSED_PARAMETER( filedes);
+    return ERR;
+}
+
+TERMINAL *set_curterm(TERMINAL *nterm)
+{
+    PDC_LOG(("set_curterm() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( nterm);
+    return (TERMINAL *)NULL;
+}
+
+int setterm(const char *term)
+{
+    PDC_LOG(("setterm() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( term);
+    return ERR;
+}
+
+int setupterm(const char *term, int filedes, int *errret)
+{
+    PDC_LOG(("setupterm() - called\n"));
+
+    if (errret)
+        *errret = -1;
+    else
+        fprintf(stderr, "There is no terminfo database\n");
+
+    INTENTIONALLY_UNUSED_PARAMETER( term);
+    INTENTIONALLY_UNUSED_PARAMETER( filedes);
+    return ERR;
+}
+
+int tgetent(char *bp, const char *name)
+{
+    PDC_LOG(("tgetent() - called: name %s\n", name));
+
+    INTENTIONALLY_UNUSED_PARAMETER( bp);
+    INTENTIONALLY_UNUSED_PARAMETER( name);
+    return ERR;
+}
+
+int tgetflag(const char *id)
+{
+    PDC_LOG(("tgetflag() - called: id %s\n", id));
+
+    INTENTIONALLY_UNUSED_PARAMETER( id);
+    return ERR;
+}
+
+int tgetnum(const char *id)
+{
+    PDC_LOG(("tgetnum() - called: id %s\n", id));
+
+    INTENTIONALLY_UNUSED_PARAMETER( id);
+    return ERR;
+}
+
+char *tgetstr(const char *id, char **area)
+{
+    PDC_LOG(("tgetstr() - called: id %s\n", id));
+
+    INTENTIONALLY_UNUSED_PARAMETER( id);
+    INTENTIONALLY_UNUSED_PARAMETER( area);
+    return (char *)NULL;
+}
+
+char *tgoto(const char *cap, int col, int row)
+{
+    PDC_LOG(("tgoto() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( cap);
+    INTENTIONALLY_UNUSED_PARAMETER( col);
+    INTENTIONALLY_UNUSED_PARAMETER( row);
+    return (char *)NULL;
+}
+
+int tigetflag(const char *capname)
+{
+    PDC_LOG(("tigetflag() - called: capname %s\n", capname));
+
+    INTENTIONALLY_UNUSED_PARAMETER( capname);
+    return -1;
+}
+
+int tigetnum(const char *capname)
+{
+    PDC_LOG(("tigetnum() - called: capname %s\n", capname));
+
+    INTENTIONALLY_UNUSED_PARAMETER( capname);
+    return -2;
+}
+
+char *tigetstr(const char *capname)
+{
+    PDC_LOG(("tigetstr() - called: capname %s\n", capname));
+
+    INTENTIONALLY_UNUSED_PARAMETER( capname);
+    return (char *)(-1);
+}
+
+char *tparm(const char *cap, long p1, long p2, long p3, long p4,
+            long p5, long p6, long p7, long p8, long p9)
+{
+    PDC_LOG(("tparm() - called: cap %s\n", cap));
+    INTENTIONALLY_UNUSED_PARAMETER( cap);
+    INTENTIONALLY_UNUSED_PARAMETER( p1);
+    INTENTIONALLY_UNUSED_PARAMETER( p2);
+    INTENTIONALLY_UNUSED_PARAMETER( p3);
+    INTENTIONALLY_UNUSED_PARAMETER( p4);
+    INTENTIONALLY_UNUSED_PARAMETER( p5);
+    INTENTIONALLY_UNUSED_PARAMETER( p6);
+    INTENTIONALLY_UNUSED_PARAMETER( p7);
+    INTENTIONALLY_UNUSED_PARAMETER( p8);
+    INTENTIONALLY_UNUSED_PARAMETER( p9);
+
+    return (char *)NULL;
+}
+
+int tputs(const char *str, int affcnt, int (*putfunc)(int))
+{
+    PDC_LOG(("tputs() - called\n"));
+
+    INTENTIONALLY_UNUSED_PARAMETER( str);
+    INTENTIONALLY_UNUSED_PARAMETER( affcnt);
+    INTENTIONALLY_UNUSED_PARAMETER( putfunc);
+    return ERR;
+}

data/vendor/PDCursesMod/pdcurses/touch.c

@@ -0,0 +1,255 @@
+/* PDCursesMod */
+
+#include <curspriv.h>
+#include <assert.h>
+
+/*man-start**************************************************************
+
+touch
+-----
+
+### Synopsis
+
+    int touchwin(WINDOW *win);
+    int touchline(WINDOW *win, int start, int count);
+    int untouchwin(WINDOW *win);
+    int wtouchln(WINDOW *win, int y, int n, int changed);
+    bool is_linetouched(WINDOW *win, int line);
+    bool is_wintouched(WINDOW *win);
+
+    int touchoverlap(const WINDOW *win1, WINDOW *win2);
+
+### Description
+
+   touchwin() and touchline() throw away all information about which
+   parts of the window have been touched, pretending that the entire
+   window has been drawn on. This is sometimes necessary when using
+   overlapping windows, since a change to one window will affect the
+   other window, but the records of which lines have been changed in the
+   other window will not reflect the change.
+
+   untouchwin() marks all lines in the window as unchanged since the
+   last call to wrefresh().
+
+   wtouchln() makes n lines in the window, starting at line y, look as
+   if they have (changed == 1) or have not (changed == 0) been changed
+   since the last call to wrefresh().
+
+   is_linetouched() returns TRUE if the specified line in the specified
+   window has been changed since the last call to wrefresh().
+
+   is_wintouched() returns TRUE if the specified window has been changed
+   since the last call to wrefresh().
+
+   touchoverlap(win1, win2) marks the portion of win2 which overlaps
+   with win1 as modified.
+
+### Return Value
+
+   All functions return OK on success and ERR on error except
+   is_wintouched() and is_linetouched().
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   touchwin              |    Y   |    Y    |   Y
+   touchline             |    Y   |    Y    |   Y
+   untouchwin            |    Y   |    Y    |   Y
+   wtouchln              |    Y   |    Y    |   Y
+   is_linetouched        |    Y   |    Y    |   Y
+   is_wintouched         |    Y   |    Y    |   Y
+   touchoverlap          |    -   |    -    |   Y
+
+**man-end****************************************************************/
+
+void PDC_set_changed_cells_range( WINDOW *win, const int y, const int start, const int end)
+{
+    assert( win);
+    assert( y >= 0 && y < win->_maxy);
+    assert( start >= 0 || start == _NO_CHANGE);
+    assert( start <= end);
+    assert( end < win->_maxx);
+    win->_firstch[y] = start;
+    win->_lastch[y] = end;
+}
+
+void PDC_mark_line_as_changed( WINDOW *win, const int y)
+{
+    assert( win);
+    assert( y >= 0 && y < win->_maxy);
+    win->_firstch[y] = 0;
+    win->_lastch[y] = win->_maxx - 1;
+}
+
+void PDC_mark_cells_as_changed( WINDOW *win, const int y, const int start, const int end)
+{
+    assert( win);
+    assert( y >= 0 && y < win->_maxy);
+    assert( start >= 0 || start == _NO_CHANGE);
+    assert( start <= end);
+    assert( end < win->_maxx);
+    if( win->_firstch[y] == _NO_CHANGE)
+    {
+        win->_firstch[y] = start;
+        win->_lastch[y] = end;
+    }
+    else
+    {
+        if( win->_firstch[y] > start)
+            win->_firstch[y] = start;
+        if( win->_lastch[y] < end)
+            win->_lastch[y] = end;
+    }
+}
+
+bool PDC_touched_range( const WINDOW *win, const int y, int *firstch, int *lastch)
+{
+    assert( win);
+    assert( y >= 0 && y < win->_maxy);
+    if( win->_firstch[y] == _NO_CHANGE)
+    {
+        *firstch = *lastch = 0;
+        return( FALSE);
+    }
+    else
+    {
+        *firstch = win->_firstch[y];
+        *lastch = win->_lastch[y];
+        return( TRUE);
+    }
+}
+
+void PDC_mark_cell_as_changed( WINDOW *win, const int y, const int x)
+{
+    PDC_mark_cells_as_changed( win, y, x, x);
+}
+
+int touchwin(WINDOW *win)
+{
+    int i;
+
+    PDC_LOG(("touchwin() - called: Win=%x\n", win));
+
+    assert( win);
+    if (!win)
+        return ERR;
+
+    for (i = 0; i < win->_maxy; i++)
+        PDC_mark_line_as_changed( win, i);
+
+    return OK;
+}
+
+int touchline(WINDOW *win, int start, int count)
+{
+    int i;
+
+    PDC_LOG(("touchline() - called: win=%p start %d count %d\n",
+             win, start, count));
+
+    assert( win && count > 0 && start >= 0 && start + count <= win->_maxy);
+    if (!win || count <= 0 || start < 0 || start + count > win->_maxy)
+        return ERR;
+
+    for (i = start; i < start + count; i++)
+        PDC_mark_line_as_changed( win, i);
+
+    return OK;
+}
+
+int untouchwin(WINDOW *win)
+{
+    int i;
+
+    PDC_LOG(("untouchwin() - called: win=%p", win));
+
+    assert( win);
+    if (!win)
+        return ERR;
+
+    for (i = 0; i < win->_maxy; i++)
+        PDC_set_changed_cells_range( win, i, _NO_CHANGE, _NO_CHANGE);
+
+    return OK;
+}
+
+int wtouchln(WINDOW *win, int y, int n, int changed)
+{
+    int i;
+
+    PDC_LOG(("wtouchln() - called: win=%p y=%d n=%d changed=%d\n",
+             win, y, n, changed));
+
+    assert( win && n >= 0 && y + n <= win->_maxy);
+    if (!win || n < 0 || y + n > win->_maxy)
+        return ERR;
+
+    for (i = y; i < y + n; i++)
+    {
+        if (changed)
+            PDC_mark_line_as_changed( win, i);
+        else
+            PDC_set_changed_cells_range( win, i, _NO_CHANGE, _NO_CHANGE);
+    }
+
+    return OK;
+}
+
+bool is_linetouched(WINDOW *win, int line)
+{
+    PDC_LOG(("is_linetouched() - called: win=%p line=%d\n", win, line));
+
+    assert( win && line < win->_maxy && line >= 0);
+    if (!win || line >= win->_maxy || line < 0)
+        return FALSE;
+
+    return (win->_firstch[line] != _NO_CHANGE) ? TRUE : FALSE;
+}
+
+bool is_wintouched(WINDOW *win)
+{
+    PDC_LOG(("is_wintouched() - called: win=%p\n", win));
+
+    assert( win);
+    if (win)
+    {
+        int i;
+
+        for (i = 0; i < win->_maxy; i++)
+            if (win->_firstch[i] != _NO_CHANGE)
+                return TRUE;
+    }
+
+    return FALSE;
+}
+
+int touchoverlap(const WINDOW *win1, WINDOW *win2)
+{
+    int y, endy, endx, starty, startx;
+
+    PDC_LOG(("touchoverlap() - called: win1=%p win2=%p\n", win1, win2));
+
+    assert( win1);
+    assert( win2);
+    if (!win1 || !win2)
+        return ERR;
+
+    starty = max(win1->_begy, win2->_begy);
+    startx = max(win1->_begx, win2->_begx);
+    endy = min(win1->_maxy + win1->_begy, win2->_maxy + win2->_begy);
+    endx = min(win1->_maxx + win1->_begx, win2->_maxx + win2->_begx);
+
+    if (starty >= endy || startx >= endx)
+        return OK;       /* there is no overlap */
+
+    starty -= win2->_begy;
+    startx -= win2->_begx;
+    endy -= win2->_begy;
+    endx -= win2->_begx;
+    endx -= 1;
+
+    for (y = starty; y < endy; y++)
+        PDC_mark_cells_as_changed( win2, y, startx, endx);
+
+    return OK;
+}