curses 1.4.6 → 1.5.0

data/vendor/PDCurses/pdcurses/attr.c

@@ -0,0 +1,359 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+attr
+----
+
+### Synopsis
+
+    int attroff(chtype attrs);
+    int wattroff(WINDOW *win, chtype attrs);
+    int attron(chtype attrs);
+    int wattron(WINDOW *win, chtype attrs);
+    int attrset(chtype attrs);
+    int wattrset(WINDOW *win, chtype attrs);
+    int standend(void);
+    int wstandend(WINDOW *win);
+    int standout(void);
+    int wstandout(WINDOW *win);
+
+    int color_set(short color_pair, void *opts);
+    int wcolor_set(WINDOW *win, short color_pair, void *opts);
+
+    int attr_get(attr_t *attrs, short *color_pair, void *opts);
+    int attr_off(attr_t attrs, void *opts);
+    int attr_on(attr_t attrs, void *opts);
+    int attr_set(attr_t attrs, short color_pair, void *opts);
+    int wattr_get(WINDOW *win, attr_t *attrs, short *color_pair,
+                  void *opts);
+    int wattr_off(WINDOW *win, attr_t attrs, void *opts);
+    int wattr_on(WINDOW *win, attr_t attrs, void *opts);
+    int wattr_set(WINDOW *win, attr_t attrs, short color_pair,
+                  void *opts);
+
+    int chgat(int n, attr_t attr, short color, const void *opts);
+    int mvchgat(int y, int x, int n, attr_t attr, short color,
+                const void *opts);
+    int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr,
+                 short color, const void *opts);
+    int wchgat(WINDOW *win, int n, attr_t attr, short color,
+               const void *opts);
+
+    chtype getattrs(WINDOW *win);
+
+### Description
+
+   These functions manipulate the current attributes and/or colors
+   of the named window.  These attributes can be any combination
+   of A_STANDOUT, A_REVERSE, A_BOLD, A_DIM, A_BLINK, A_UNDERLINE.
+
+   These constants are defined in <curses.h> and can be combined
+   with the bitwise-OR operator (|).
+
+   The current attributes of a window are applied to all chtypes
+   that are written into the window with waddch(). Attributes are
+   a property of the chtype, and move with the character through
+   any scrolling or insert/delete operations.
+
+   attrset() sets the current attributes of the given window to
+   attrs. attroff() turns off the named attributes without
+   affecting any other attributes; attron() turns them on.
+   color_set() sets the window color to the value of color_pair.
+
+   standout() is the same as attron(A_STANDOUT). standend() is the
+   same as attrset(A_NORMAL); that is, it turns off all attributes.
+
+   wchgat() sets the attributes of the n symbols starts from current
+   position of the given window.
+
+   mvwchgat() moves the cursor to the specified position and sets
+   the attributes of the n symbols starts from current position of
+   the given window.
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+                             X/Open    BSD    SYS V
+    attroff                     Y       Y       Y
+    wattroff                    Y       Y       Y
+    attron                      Y       Y       Y
+    wattron                     Y       Y       Y
+    attrset                     Y       Y       Y
+    wattrset                    Y       Y       Y
+    standend                    Y       Y       Y
+    wstandend                   Y       Y       Y
+    standout                    Y       Y       Y
+    wstandout                   Y       Y       Y
+    color_set                   Y
+    wcolor_set                  Y
+    attr_get                    Y
+    wattr_get                   Y
+    attr_on                     Y
+    wattr_on                    Y
+    attr_off                    Y
+    wattr_off                   Y
+    attr_set                    Y
+    wattr_set                   Y
+    chgat                       Y
+    wchgat                      Y
+    mvchgat                     Y
+    mvwchgat                    Y
+    getattrs                    -
+
+**man-end****************************************************************/
+
+int wattroff(WINDOW *win, chtype attrs)
+{
+    PDC_LOG(("wattroff() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_attrs &= (~attrs & A_ATTRIBUTES);
+
+    return OK;
+}
+
+int attroff(chtype attrs)
+{
+    PDC_LOG(("attroff() - called\n"));
+
+    return wattroff(stdscr, attrs);
+}
+
+int wattron(WINDOW *win, chtype attrs)
+{
+    chtype newcolr, oldcolr, newattr, oldattr;
+
+    PDC_LOG(("wattron() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    if ((win->_attrs & A_COLOR) && (attrs & A_COLOR))
+    {
+        oldcolr = win->_attrs & A_COLOR;
+        oldattr = win->_attrs ^ oldcolr;
+        newcolr = attrs & A_COLOR;
+        newattr = (attrs & A_ATTRIBUTES) ^ newcolr;
+        newattr |= oldattr;
+        win->_attrs = newattr | newcolr;
+    }
+    else
+        win->_attrs |= (attrs & A_ATTRIBUTES);
+
+    return OK;
+}
+
+int attron(chtype attrs)
+{
+    PDC_LOG(("attron() - called\n"));
+
+    return wattron(stdscr, attrs);
+}
+
+int wattrset(WINDOW *win, chtype attrs)
+{
+    PDC_LOG(("wattrset() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_attrs = attrs & A_ATTRIBUTES;
+
+    return OK;
+}
+
+int attrset(chtype attrs)
+{
+    PDC_LOG(("attrset() - called\n"));
+
+    return wattrset(stdscr, attrs);
+}
+
+int standend(void)
+{
+    PDC_LOG(("standend() - called\n"));
+
+    return wattrset(stdscr, A_NORMAL);
+}
+
+int standout(void)
+{
+    PDC_LOG(("standout() - called\n"));
+
+    return wattrset(stdscr, A_STANDOUT);
+}
+
+int wstandend(WINDOW *win)
+{
+    PDC_LOG(("wstandend() - called\n"));
+
+    return wattrset(win, A_NORMAL);
+}
+
+int wstandout(WINDOW *win)
+{
+    PDC_LOG(("wstandout() - called\n"));
+
+    return wattrset(win, A_STANDOUT);
+}
+
+chtype getattrs(WINDOW *win)
+{
+    return win ? win->_attrs : 0;
+}
+
+int wcolor_set(WINDOW *win, short color_pair, void *opts)
+{
+    PDC_LOG(("wcolor_set() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_attrs = (win->_attrs & ~A_COLOR) | COLOR_PAIR(color_pair);
+
+    return OK;
+}
+
+int color_set(short color_pair, void *opts)
+{
+    PDC_LOG(("color_set() - called\n"));
+
+    return wcolor_set(stdscr, color_pair, opts);
+}
+
+int wattr_get(WINDOW *win, attr_t *attrs, short *color_pair, void *opts)
+{
+    PDC_LOG(("wattr_get() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    if (attrs)
+        *attrs = win->_attrs & (A_ATTRIBUTES & ~A_COLOR);
+
+    if (color_pair)
+        *color_pair = (short)PAIR_NUMBER(win->_attrs);
+
+    return OK;
+}
+
+int attr_get(attr_t *attrs, short *color_pair, void *opts)
+{
+    PDC_LOG(("attr_get() - called\n"));
+
+    return wattr_get(stdscr, attrs, color_pair, opts);
+}
+
+int wattr_off(WINDOW *win, attr_t attrs, void *opts)
+{
+    PDC_LOG(("wattr_off() - called\n"));
+
+    return wattroff(win, attrs);
+}
+
+int attr_off(attr_t attrs, void *opts)
+{
+    PDC_LOG(("attr_off() - called\n"));
+
+    return wattroff(stdscr, attrs);
+}
+
+int wattr_on(WINDOW *win, attr_t attrs, void *opts)
+{
+    PDC_LOG(("wattr_off() - called\n"));
+
+    return wattron(win, attrs);
+}
+
+int attr_on(attr_t attrs, void *opts)
+{
+    PDC_LOG(("attr_on() - called\n"));
+
+    return wattron(stdscr, attrs);
+}
+
+int wattr_set(WINDOW *win, attr_t attrs, short color_pair, void *opts)
+{
+    PDC_LOG(("wattr_set() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_attrs = (attrs & (A_ATTRIBUTES & ~A_COLOR)) | COLOR_PAIR(color_pair);
+
+    return OK;
+}
+
+int attr_set(attr_t attrs, short color_pair, void *opts)
+{
+    PDC_LOG(("attr_get() - called\n"));
+
+    return wattr_set(stdscr, attrs, color_pair, opts);
+}
+
+int wchgat(WINDOW *win, int n, attr_t attr, short color, const void *opts)
+{
+    chtype *dest, newattr;
+    int startpos, endpos;
+
+    PDC_LOG(("wchgat() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    newattr = (attr & A_ATTRIBUTES) | COLOR_PAIR(color);
+
+    startpos = win->_curx;
+    endpos = ((n < 0) ? win->_maxx : min(startpos + n, win->_maxx)) - 1;
+    dest = win->_y[win->_cury];
+
+    for (n = startpos; n <= endpos; n++)
+        dest[n] = (dest[n] & A_CHARTEXT) | newattr;
+
+    n = win->_cury;
+
+    if (startpos < win->_firstch[n] || win->_firstch[n] == _NO_CHANGE)
+        win->_firstch[n] = startpos;
+
+    if (endpos > win->_lastch[n])
+        win->_lastch[n] = endpos;
+
+    PDC_sync(win);
+
+    return OK;
+}
+
+int chgat(int n, attr_t attr, short color, const void *opts)
+{
+    PDC_LOG(("chgat() - called\n"));
+
+    return wchgat(stdscr, n, attr, color, opts);
+}
+
+int mvchgat(int y, int x, int n, attr_t attr, short color, const void *opts)
+{
+    PDC_LOG(("mvchgat() - called\n"));
+
+    if (move(y, x) == ERR)
+        return ERR;
+
+    return wchgat(stdscr, n, attr, color, opts);
+}
+
+int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr, short color,
+             const void *opts)
+{
+    PDC_LOG(("mvwchgat() - called\n"));
+
+    if (wmove(win, y, x) == ERR)
+        return ERR;
+
+    return wchgat(win, n, attr, color, opts);
+}

data/vendor/PDCurses/pdcurses/beep.c

@@ -0,0 +1,68 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+beep
+----
+
+### Synopsis
+
+    int beep(void);
+    int flash(void);
+
+### Description
+
+   beep() sounds the audible bell on the terminal, if possible;
+   if not, it calls flash().
+
+   flash() "flashes" the screen, by inverting the foreground and
+   background of every cell, pausing, and then restoring the
+   original attributes.
+
+### Return Value
+
+   These functions return OK.
+
+### Portability
+                             X/Open    BSD    SYS V
+    beep                        Y       Y       Y
+    flash                       Y       Y       Y
+
+**man-end****************************************************************/
+
+int beep(void)
+{
+    PDC_LOG(("beep() - called\n"));
+
+    if (SP->audible)
+        PDC_beep();
+    else
+        flash();
+
+    return OK;
+}
+
+int flash(void)
+{
+    int z, y, x;
+
+    PDC_LOG(("flash() - called\n"));
+
+    /* Reverse each cell; wait; restore the screen */
+
+    for (z = 0; z < 2; z++)
+    {
+        for (y = 0; y < LINES; y++)
+            for (x = 0; x < COLS; x++)
+                curscr->_y[y][x] ^= A_REVERSE;
+
+        wrefresh(curscr);
+
+        if (!z)
+            napms(50);
+    }
+
+    return OK;
+}

data/vendor/PDCurses/pdcurses/bkgd.c

@@ -0,0 +1,223 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+bkgd
+----
+
+### Synopsis
+
+    int bkgd(chtype ch);
+    void bkgdset(chtype ch);
+    chtype getbkgd(WINDOW *win);
+    int wbkgd(WINDOW *win, chtype ch);
+    void wbkgdset(WINDOW *win, chtype ch);
+
+    int bkgrnd(const cchar_t *wch);
+    void bkgrndset(const cchar_t *wch);
+    int getbkgrnd(cchar_t *wch);
+    int wbkgrnd(WINDOW *win, const cchar_t *wch);
+    void wbkgrndset(WINDOW *win, const cchar_t *wch);
+    int wgetbkgrnd(WINDOW *win, cchar_t *wch);
+
+### Description
+
+   bkgdset() and wbkgdset() manipulate the background of a window.
+   The background is a chtype consisting of any combination of
+   attributes and a character; it is combined with each chtype
+   added or inserted to the window by waddch() or winsch(). Only
+   the attribute part is used to set the background of non-blank
+   characters, while both character and attributes are used for
+   blank positions.
+
+   bkgd() and wbkgd() not only change the background, but apply it
+   immediately to every cell in the window.
+
+   The attributes that are defined with the attrset()/attron() set
+   of functions take precedence over the background attributes if
+   there is a conflict (e.g., different color pairs).
+
+### Return Value
+
+   bkgd() and wbkgd() return OK, unless the window is NULL, in
+   which case they return ERR.
+
+### Portability
+                             X/Open    BSD    SYS V
+    bkgd                        Y       -      4.0
+    bkgdset                     Y       -      4.0
+    getbkgd                     Y
+    wbkgd                       Y       -      4.0
+    wbkgdset                    Y       -      4.0
+    bkgrnd                      Y
+    bkgrndset                   Y
+    getbkgrnd                   Y
+    wbkgrnd                     Y
+    wbkgrndset                  Y
+    wgetbkgrnd                  Y
+
+**man-end****************************************************************/
+
+int wbkgd(WINDOW *win, chtype ch)
+{
+    int x, y;
+    chtype oldcolr, oldch, newcolr, newch, colr, attr;
+    chtype oldattr = 0, newattr = 0;
+    chtype *winptr;
+
+    PDC_LOG(("wbkgd() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    if (win->_bkgd == ch)
+        return OK;
+
+    oldcolr = win->_bkgd & A_COLOR;
+    if (oldcolr)
+        oldattr = (win->_bkgd & A_ATTRIBUTES) ^ oldcolr;
+
+    oldch = win->_bkgd & A_CHARTEXT;
+
+    wbkgdset(win, ch);
+
+    newcolr = win->_bkgd & A_COLOR;
+    if (newcolr)
+        newattr = (win->_bkgd & A_ATTRIBUTES) ^ newcolr;
+
+    newch = win->_bkgd & A_CHARTEXT;
+
+    /* what follows is what seems to occur in the System V 
+       implementation of this routine */
+
+    for (y = 0; y < win->_maxy; y++)
+    {
+        for (x = 0; x < win->_maxx; x++)
+        {
+            winptr = win->_y[y] + x;
+
+            ch = *winptr;
+
+            /* determine the colors and attributes of the character read 
+               from the window */
+
+            colr = ch & A_COLOR;
+            attr = ch & (A_ATTRIBUTES ^ A_COLOR);
+
+            /* if the color is the same as the old background color, 
+               then make it the new background color, otherwise leave it */
+
+            if (colr == oldcolr)
+                colr = newcolr;
+
+            /* remove any attributes (non color) from the character that 
+               were part of the old background, then combine the 
+               remaining ones with the new background */
+
+            attr ^= oldattr;
+            attr |= newattr;
+
+            /* change character if it is there because it was the old 
+               background character */
+
+            ch &= A_CHARTEXT;
+            if (ch == oldch)
+                ch = newch;
+
+            ch |= (attr | colr);
+
+            *winptr = ch;
+
+        }
+    }
+
+    touchwin(win);
+    PDC_sync(win);
+    return OK;
+}
+
+int bkgd(chtype ch)
+{
+    PDC_LOG(("bkgd() - called\n"));
+
+    return wbkgd(stdscr, ch);
+}
+
+void wbkgdset(WINDOW *win, chtype ch)
+{
+    PDC_LOG(("wbkgdset() - called\n"));
+
+    if (win)
+    {
+        if (!(ch & A_CHARTEXT))
+            ch |= ' ';
+
+        win->_bkgd = ch;
+    }
+}
+
+void bkgdset(chtype ch)
+{
+    PDC_LOG(("bkgdset() - called\n"));
+
+    wbkgdset(stdscr, ch);
+}
+
+chtype getbkgd(WINDOW *win)
+{
+    PDC_LOG(("getbkgd() - called\n"));
+
+    return win ? win->_bkgd : (chtype)ERR;
+}
+
+#ifdef PDC_WIDE
+int wbkgrnd(WINDOW *win, const cchar_t *wch)
+{
+    PDC_LOG(("wbkgrnd() - called\n"));
+
+    return wch ? wbkgd(win, *wch) : ERR;
+}
+
+int bkgrnd(const cchar_t *wch)
+{
+    PDC_LOG(("bkgrnd() - called\n"));
+
+    return wbkgrnd(stdscr, wch);
+}
+
+void wbkgrndset(WINDOW *win, const cchar_t *wch)
+{
+    PDC_LOG(("wbkgdset() - called\n"));
+
+    if (wch)
+        wbkgdset(win, *wch);
+}
+
+void bkgrndset(const cchar_t *wch)
+{
+    PDC_LOG(("bkgrndset() - called\n"));
+
+    wbkgrndset(stdscr, wch);
+}
+
+int wgetbkgrnd(WINDOW *win, cchar_t *wch)
+{
+    PDC_LOG(("wgetbkgrnd() - called\n"));
+
+    if (!win || !wch)
+        return ERR;
+
+    *wch = win->_bkgd;
+
+    return OK;
+}
+
+int getbkgrnd(cchar_t *wch)
+{
+    PDC_LOG(("getbkgrnd() - called\n"));
+
+    return wgetbkgrnd(stdscr, wch);
+}
+#endif