curses 1.6.0 → 1.7.0

data/vendor/PDCursesMod/pdcurses/printw.c

@@ -0,0 +1,180 @@
+/* PDCurses */
+
+#include <curspriv.h>
+#include <assert.h>
+#include <stdlib.h>
+
+/*man-start**************************************************************
+
+printw
+------
+
+### Synopsis
+
+    int printw(const char *fmt, ...);
+    int wprintw(WINDOW *win, const char *fmt, ...);
+    int mvprintw(int y, int x, const char *fmt, ...);
+    int mvwprintw(WINDOW *win, int y, int x, const char *fmt,...);
+    int vwprintw(WINDOW *win, const char *fmt, va_list varglist);
+    int vw_printw(WINDOW *win, const char *fmt, va_list varglist);
+
+### Description
+
+   The printw() functions add a formatted string to the window at the
+   current or specified cursor position. The format strings are the same
+   as used in the standard C library's printf(). (printw() can be used
+   as a drop-in replacement for printf().)
+
+   The duplication between vwprintw() and vw_printw() is for historic
+   reasons. In PDCurses, they're the same.
+
+### Return Value
+
+   All functions return the number of characters printed, or ERR on
+   error.  Note that this is nonstandard;  other implementations return
+   OK upon successful completion.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   printw                |    Y   |    Y    |   Y
+   wprintw               |    Y   |    Y    |   Y
+   mvprintw              |    Y   |    Y    |   Y
+   mvwprintw             |    Y   |    Y    |   Y
+   vwprintw              |    Y   |    Y    |   Y
+   vw_printw             |    Y   |    Y    |   Y
+
+**man-end****************************************************************/
+
+#include <string.h>
+
+/* All Windows compilers (MSVC,  OpenWATCOM,  Borland,  Digital Mars)
+appear to have a _vsnprint() function.  Some others have vsnprintf().
+A few have neither.   */
+
+#ifdef _WIN32
+   #define vsnprint_func _vsnprintf
+#endif
+#if defined( HAVE_VSNPRINTF) && !defined( _WIN32)
+   #define vsnprint_func vsnprintf
+#elif defined( __DMC__) && !defined( _WIN32)
+   #define vsnprint_func _vsnprintf
+#endif
+
+
+/* _vsnprintf() and earlier vsnprintf() return -1 if the output doesn't
+fit in the buffer.  When that happens,  we try again with a
+larger buffer, doubling its size until it fits.  C99-compliant
+vsnprintf() returns the number of bytes actually needed (minus the
+trailing zero). */
+
+#ifndef va_copy
+   #define va_copy( dest, src) dest = src
+#endif
+
+int vwprintw(WINDOW *win, const char *fmt, va_list varglist)
+{
+    char printbuf[513];
+    int len, rval;
+#ifdef vsnprint_func
+    char *buf = printbuf;
+    va_list varglist_copy;
+    size_t buffsize = sizeof( printbuf) - 1;
+
+    PDC_LOG(("vwprintw() - called\n"));
+    va_copy( varglist_copy, varglist);
+    len = vsnprint_func( buf, buffsize, fmt, varglist_copy);
+    while( len < 0 || len > (int)buffsize)
+    {
+        if( -1 == len)       /* Microsoft,  glibc 2.0 & earlier */
+            buffsize <<= 1;
+        else                 /* glibc 2.0.6 & later (C99 behavior) */
+            buffsize = len + 1;
+        if( buf != printbuf)
+            free( buf);
+        buf = (char *)malloc( buffsize + 1);
+        va_copy( varglist_copy, varglist);
+        len = vsnprint_func( buf, buffsize, fmt, varglist_copy);
+    }
+    buf[len] = '\0';
+    rval = (waddstr(win, buf) == ERR) ? ERR : len;
+    if( buf != printbuf)
+        free( buf);
+#else       /* no _vsnprintf() or vsnprintf() : buffer may overflow */
+    PDC_LOG(("vwprintw() - called\n"));
+
+    len = vsprintf(printbuf, fmt, varglist);
+    assert( len < (int)sizeof( printbuf) - 1);
+    rval = (waddstr(win, printbuf) == ERR) ? ERR : len;
+#endif
+    return rval;
+}
+
+int printw(const char *fmt, ...)
+{
+    va_list args;
+    int retval;
+
+    PDC_LOG(("printw() - called\n"));
+
+    va_start(args, fmt);
+    retval = vwprintw(stdscr, fmt, args);
+    va_end(args);
+
+    return retval;
+}
+
+int wprintw(WINDOW *win, const char *fmt, ...)
+{
+    va_list args;
+    int retval;
+
+    PDC_LOG(("wprintw() - called\n"));
+
+    va_start(args, fmt);
+    retval = vwprintw(win, fmt, args);
+    va_end(args);
+
+    return retval;
+}
+
+int mvprintw(int y, int x, const char *fmt, ...)
+{
+    va_list args;
+    int retval;
+
+    PDC_LOG(("mvprintw() - called\n"));
+
+    if (move(y, x) == ERR)
+        return ERR;
+
+    va_start(args, fmt);
+    retval = vwprintw(stdscr, fmt, args);
+    va_end(args);
+
+    return retval;
+}
+
+int mvwprintw(WINDOW *win, int y, int x, const char *fmt, ...)
+{
+    va_list args;
+    int retval;
+
+    PDC_LOG(("mvwprintw() - called\n"));
+
+    if (wmove(win, y, x) == ERR)
+        return ERR;
+
+    va_start(args, fmt);
+    retval = vwprintw(win, fmt, args);
+    va_end(args);
+
+    return retval;
+}
+
+int vw_printw(WINDOW *win, const char *fmt, va_list varglist)
+{
+    PDC_LOG(("vw_printw() - called\n"));
+
+    return vwprintw(win, fmt, varglist);
+}

data/vendor/PDCursesMod/pdcurses/refresh.c

@@ -0,0 +1,372 @@
+/* PDCurses */
+
+#include <curspriv.h>
+#include <assert.h>
+
+/*man-start**************************************************************
+
+refresh
+-------
+
+### Synopsis
+
+    int refresh(void);
+    int wrefresh(WINDOW *win);
+    int wnoutrefresh(WINDOW *win);
+    int doupdate(void);
+    int redrawwin(WINDOW *win);
+    int wredrawln(WINDOW *win, int beg_line, int num_lines);
+
+### Description
+
+   wrefresh() copies the named window to the physical terminal screen,
+   taking into account what is already there in order to optimize cursor
+   movement. refresh() does the same, using stdscr. These routines must
+   be called to get any output on the terminal, as other routines only
+   manipulate data structures. Unless leaveok() has been enabled, the
+   physical cursor of the terminal is left at the location of the
+   window's cursor.
+
+   wnoutrefresh() and doupdate() allow multiple updates with more
+   efficiency than wrefresh() alone. wrefresh() works by first calling
+   wnoutrefresh(), which copies the named window to the virtual screen.
+   It then calls doupdate(), which compares the virtual screen to the
+   physical screen and does the actual update. A series of calls to
+   wrefresh() will result in alternating calls to wnoutrefresh() and
+   doupdate(), causing several bursts of output to the screen. By first
+   calling wnoutrefresh() for each window, it is then possible to call
+   doupdate() only once.
+
+   In PDCurses, redrawwin() is equivalent to touchwin(), and wredrawln()
+   is the same as touchline(). In some other curses implementations,
+   there's a subtle distinction, but it has no meaning in PDCurses.
+
+### Return Value
+
+   All functions return OK on success and ERR on error.
+
+### Portability
+   Function              | X/Open | ncurses | NetBSD
+   :---------------------|:------:|:-------:|:------:
+   refresh               |    Y   |    Y    |   Y
+   wrefresh              |    Y   |    Y    |   Y
+   wnoutrefresh          |    Y   |    Y    |   Y
+   doupdate              |    Y   |    Y    |   Y
+   redrawwin             |    Y   |    Y    |   Y
+   wredrawln             |    Y   |    Y    |   Y
+
+**man-end****************************************************************/
+
+#include <string.h>
+
+static void _normalize_cursor( WINDOW *win)
+{
+    if( win->_cury < 0)
+        win->_cury = 0;
+    if( win->_cury >= win->_maxy)
+        win->_cury = win->_maxy - 1;
+    if( win->_curx < 0)
+        win->_curx = 0;
+    if( win->_curx >= win->_maxx)
+        win->_curx = win->_maxx - 1;
+}
+
+int PDC_pnoutrefresh_with_stored_params( WINDOW *pad);       /* pad.c */
+
+int wnoutrefresh(WINDOW *win)
+{
+    int begy, begx;     /* window's place on screen   */
+    int i, j;
+
+    PDC_LOG(("wnoutrefresh() - called: win=%p\n", win));
+
+    assert( win);
+    if ( !win)
+        return ERR;
+    if( is_pad( win))
+        return PDC_pnoutrefresh_with_stored_params( win);
+
+    begy = win->_begy;
+    begx = win->_begx;
+
+    for (i = 0, j = begy; i < win->_maxy && j < curscr->_maxy; i++, j++)
+    {
+        if (win->_firstch[i] != _NO_CHANGE && j >= 0)
+        {
+            const chtype *src = win->_y[i];
+            chtype *dest = curscr->_y[j] + begx;
+
+            int first = win->_firstch[i]; /* first changed */
+            int last = win->_lastch[i];   /* last changed */
+
+            if( last > curscr->_maxx - begx - 1)    /* don't run off right-hand */
+                last = curscr->_maxx - begx - 1;    /* edge of screen */
+            if( first < -begx)       /* ...nor the left edge */
+                first = -begx;
+
+            /* ignore areas on the outside that are marked as changed,
+               but really aren't */
+
+            while (first <= last && src[first] == dest[first])
+                first++;
+
+            while (last >= first && src[last] == dest[last])
+                last--;
+
+            /* if any have really changed... */
+
+            if (first <= last)
+            {
+                memcpy(dest + first, src + first,
+                       (last - first + 1) * sizeof(chtype));
+
+                first += begx;
+                last += begx;
+
+                if (first < curscr->_firstch[j] ||
+                    curscr->_firstch[j] == _NO_CHANGE)
+                    curscr->_firstch[j] = first;
+
+                if (last > curscr->_lastch[j])
+                    curscr->_lastch[j] = last;
+            }
+        }
+        PDC_set_changed_cells_range( win, i, _NO_CHANGE, _NO_CHANGE);
+    }
+
+    if (win->_clear)
+        win->_clear = FALSE;
+
+    if (!win->_leaveit)
+    {
+        curscr->_cury = win->_cury + begy;
+        curscr->_curx = win->_curx + begx;
+        _normalize_cursor( curscr);
+    }
+
+    return OK;
+}
+
+/* The following ensures that PDC_transform_line() is fed a maximum of
+MAX_PACKET_LEN at a time;  'dummy' characters in cells next to fullwidth
+characters are not sent;  and we break packets after combining characters
+and fullwidth characters,  avoiding some possible mis-alignment issues.
+If the cursor is shown,  that character is drawn by itself,  with
+SP->drawing_cursor set to the actual desired cursor (which,  on some
+platforms,  varies as SP->blink_state flips).      */
+
+void PDC_transform_line_sliced( int lineno, int x, int len, const chtype *srcp)
+{
+    assert( x >= 0);
+    assert( len > 0);
+    assert( x + len <= COLS);
+    assert( lineno >= 0);
+    assert( lineno < SP->lines);
+    if( lineno == SP->cursrow && x <= SP->curscol && x + len > SP->curscol)
+    {
+        const int vis = (SP->visibility >> (SP->blink_state ? 8 : 0)) & 0xff;
+
+        if( vis)
+        {
+            const int before = SP->curscol - x;
+
+            if( before)   /* some text before the cursor */
+            {
+                PDC_transform_line_sliced( lineno, x, before, srcp);
+                x += before;
+                len -= before;
+                srcp += before;
+            }
+            if( len > 1)    /* some text after the cursor */
+                PDC_transform_line_sliced( lineno, x + 1, len - 1, srcp + 1);
+            len = 1;        /* ...and now just the cursor itself */
+            SP->drawing_cursor = vis;
+        }
+    }
+#ifdef PDC_WIDE
+    if( x && (*srcp & A_CHARTEXT) == DUMMY_CHAR_NEXT_TO_FULLWIDTH)
+    {                   /* starting on a dummy next to a fullwidth */
+        x--;
+        srcp--;
+        len++;
+    }
+#endif
+    while( len)
+    {
+#ifdef PDC_WIDE
+        int i = 1;
+        chtype ch;
+
+        while( i < MAX_PACKET_LEN - 1
+                     && (ch = (srcp[i - 1] & A_CHARTEXT)) < MAX_UNICODE
+                     && i < len)
+           i++;
+        if( i == 1 && ch == MAX_UNICODE)
+            fprintf( stderr, "line %d, x=%d, len=%d\n", lineno, x, len);
+        assert( i > 1 || ch != MAX_UNICODE);
+        PDC_transform_line( lineno, x,
+                          i - ((ch == MAX_UNICODE) ? 1 : 0), srcp);
+#else
+        const int i = min( len, MAX_PACKET_LEN - 1);
+        PDC_transform_line( lineno, x, i, srcp);
+#endif
+        x += i;
+        len -= i;
+        srcp += i;
+    }
+    SP->drawing_cursor = 0;
+}
+
+int doupdate(void)
+{
+    int y;
+    bool clearall;
+
+    PDC_LOG(("doupdate() - called\n"));
+
+    assert( SP);
+    assert( curscr);
+    if (!SP || !curscr)
+        return ERR;
+
+    if (isendwin())         /* coming back after endwin() called */
+    {
+        reset_prog_mode();
+        clearall = TRUE;
+        SP->alive = TRUE;   /* so isendwin() result is correct */
+    }
+    else
+        clearall = curscr->_clear;
+
+    for (y = 0; y < SP->lines; y++)
+    {
+        PDC_LOG(("doupdate() - Transforming line %d of %d: %s\n",
+                 y, SP->lines, (curscr->_firstch[y] != _NO_CHANGE) ?
+                 "Yes" : "No"));
+
+        if (clearall || curscr->_firstch[y] != _NO_CHANGE)
+        {
+            int first, last;
+
+            const chtype *src = curscr->_y[y];
+            chtype *dest = SP->lastscr->_y[y];
+
+            if (clearall)
+            {
+                first = 0;
+                last = COLS - 1;
+            }
+            else
+            {
+                first = curscr->_firstch[y];
+                last = curscr->_lastch[y];
+            }
+
+            while (first <= last)
+            {
+                int len = 0;
+
+                /* build up a run of changed cells; if two runs are
+                   separated by a single unchanged cell, ignore the
+                   break */
+
+                if (clearall)
+                    len = last - first + 1;
+                else
+                    while (first + len <= last &&
+                           (src[first + len] != dest[first + len] ||
+                            (len && first + len < last &&
+                             src[first + len + 1] != dest[first + len + 1])
+                           )
+                          )
+                        len++;
+
+                /* update the screen, and SP->lastscr */
+
+                if (len)
+                {
+                    PDC_transform_line_sliced(y, first, len, src + first);
+                    memcpy(dest + first, src + first, len * sizeof(chtype));
+                    first += len;
+                }
+
+                /* skip over runs of unchanged cells */
+
+                while (first <= last && src[first] == dest[first])
+                    first++;
+            }
+
+            PDC_set_changed_cells_range( curscr, y, _NO_CHANGE, _NO_CHANGE);
+        }
+    }
+
+    curscr->_clear = FALSE;
+
+    if (SP->visibility)
+        PDC_gotoyx(curscr->_cury, curscr->_curx);
+
+    SP->cursrow = curscr->_cury;
+    SP->curscol = curscr->_curx;
+
+    PDC_doupdate();
+
+    return OK;
+}
+
+int wrefresh(WINDOW *win)
+{
+    bool save_clear;
+
+    PDC_LOG(("wrefresh() - called\n"));
+
+    assert( win && !(win->_flags & (_PAD|_SUBPAD)) );
+    if ( !win || (win->_flags & (_PAD|_SUBPAD)) )
+        return ERR;
+
+    save_clear = win->_clear;
+
+    if (win == curscr)
+        curscr->_clear = TRUE;
+    else
+        wnoutrefresh(win);
+
+    if (save_clear && win->_maxy == SP->lines && win->_maxx == SP->cols)
+        curscr->_clear = TRUE;
+
+    return doupdate();
+}
+
+int refresh(void)
+{
+    PDC_LOG(("refresh() - called\n"));
+
+    return wrefresh(stdscr);
+}
+
+int wredrawln(WINDOW *win, int start, int num)
+{
+    int i;
+
+    PDC_LOG(("wredrawln() - called: win=%p start=%d num=%d\n",
+        win, start, num));
+
+    assert( win);
+    if (!win || start > win->_maxy || start + num > win->_maxy)
+        return ERR;
+
+    for (i = start; i < start + num; i++)
+        PDC_mark_line_as_changed( win, i);
+
+    return OK;
+}
+
+int redrawwin(WINDOW *win)
+{
+    PDC_LOG(("redrawwin() - called: win=%p\n", win));
+
+    assert( win);
+    if (!win)
+        return ERR;
+
+    return wredrawln(win, 0, win->_maxy);
+}