curses 1.2.6 → 1.4.0

data/vendor/PDCurses/pdcurses/util.c

@@ -0,0 +1,312 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+util
+----
+
+### Synopsis
+
+    char *unctrl(chtype c);
+    void filter(void);
+    void use_env(bool x);
+    int delay_output(int ms);
+
+    int getcchar(const cchar_t *wcval, wchar_t *wch, attr_t *attrs,
+                 short *color_pair, void *opts);
+    int setcchar(cchar_t *wcval, const wchar_t *wch, const attr_t attrs,
+                 short color_pair, const void *opts);
+    wchar_t *wunctrl(cchar_t *wc);
+
+    int PDC_mbtowc(wchar_t *pwc, const char *s, size_t n);
+    size_t PDC_mbstowcs(wchar_t *dest, const char *src, size_t n);
+    size_t PDC_wcstombs(char *dest, const wchar_t *src, size_t n);
+
+### Description
+
+   unctrl() expands the text portion of the chtype c into a
+   printable string. Control characters are changed to the "^X"
+   notation; others are passed through. wunctrl() is the wide-
+   character version of the function.
+
+   filter() and use_env() are no-ops in PDCurses.
+
+   delay_output() inserts an ms millisecond pause in output.
+
+   getcchar() works in two modes: When wch is not NULL, it reads
+   the cchar_t pointed to by wcval and stores the attributes in
+   attrs, the color pair in color_pair, and the text in the
+   wide-character string wch. When wch is NULL, getcchar() merely
+   returns the number of wide characters in wcval. In either mode,
+   the opts argument is unused.
+
+   setcchar constructs a cchar_t at wcval from the wide-character
+   text at wch, the attributes in attr and the color pair in
+   color_pair. The opts argument is unused.
+
+   Currently, the length returned by getcchar() is always 1 or 0.
+   Similarly, setcchar() will only take the first wide character
+   from wch, and ignore any others that it "should" take (i.e.,
+   combining characters). Nor will it correctly handle any
+   character outside the basic multilingual plane (UCS-2).
+
+### Return Value
+
+   unctrl() and wunctrl() return NULL on failure. delay_output()
+   always returns OK.
+
+   getcchar() returns the number of wide characters wcval points to
+   when wch is NULL; when it's not, getcchar() returns OK or ERR.
+
+   setcchar() returns OK or ERR.
+
+### Portability
+                             X/Open    BSD    SYS V
+    unctrl                      Y       Y       Y
+    filter                      Y       -      3.0
+    use_env                     Y       -      4.0
+    delay_output                Y       Y       Y
+    getcchar                    Y
+    setcchar                    Y
+    wunctrl                     Y
+    PDC_mbtowc                  -       -       -
+    PDC_mbstowcs                -       -       -
+    PDC_wcstombs                -       -       -
+
+**man-end****************************************************************/
+
+#ifdef PDC_WIDE
+# ifdef PDC_FORCE_UTF8
+#  include <string.h>
+# else
+#  include <stdlib.h>
+# endif
+#endif
+
+char *unctrl(chtype c)
+{
+    static char strbuf[3] = {0, 0, 0};
+
+    chtype ic;
+
+    PDC_LOG(("unctrl() - called\n"));
+
+    ic = c & A_CHARTEXT;
+
+    if (ic >= 0x20 && ic != 0x7f)       /* normal characters */
+    {
+        strbuf[0] = (char)ic;
+        strbuf[1] = '\0';
+        return strbuf;
+    }
+
+    strbuf[0] = '^';            /* '^' prefix */
+
+    if (ic == 0x7f)             /* 0x7f == DEL */
+        strbuf[1] = '?';
+    else                    /* other control */
+        strbuf[1] = (char)(ic + '@');
+
+    return strbuf;
+}
+
+void filter(void)
+{
+    PDC_LOG(("filter() - called\n"));
+}
+
+void use_env(bool x)
+{
+    PDC_LOG(("use_env() - called: x %d\n", x));
+}
+
+int delay_output(int ms)
+{
+    PDC_LOG(("delay_output() - called: ms %d\n", ms));
+
+    return napms(ms);
+}
+
+#ifdef PDC_WIDE
+int getcchar(const cchar_t *wcval, wchar_t *wch, attr_t *attrs,
+             short *color_pair, void *opts)
+{
+    if (!wcval)
+        return ERR;
+
+    if (wch)
+    {
+        if (!attrs || !color_pair)
+            return ERR;
+
+        *wch = (wchar_t)(*wcval & A_CHARTEXT);
+        *attrs = (*wcval & (A_ATTRIBUTES & ~A_COLOR));
+        *color_pair = (short)( PAIR_NUMBER(*wcval & A_COLOR));
+
+        if (*wch)
+            *++wch = L'\0';
+
+        return OK;
+    }
+    else
+        return ((*wcval & A_CHARTEXT) != L'\0');
+}
+
+int setcchar(cchar_t *wcval, const wchar_t *wch, const attr_t attrs,
+             short color_pair, const void *opts)
+{
+    if (!wcval || !wch)
+        return ERR;
+
+    *wcval = *wch | attrs | COLOR_PAIR(color_pair);
+
+    return OK;
+}
+
+wchar_t *wunctrl(cchar_t *wc)
+{
+    static wchar_t strbuf[3] = {0, 0, 0};
+
+    cchar_t ic;
+
+    PDC_LOG(("wunctrl() - called\n"));
+
+    ic = *wc & A_CHARTEXT;
+
+    if (ic >= 0x20 && ic != 0x7f)       /* normal characters */
+    {
+        strbuf[0] = (wchar_t)ic;
+        strbuf[1] = L'\0';
+        return strbuf;
+    }
+
+    strbuf[0] = '^';            /* '^' prefix */
+
+    if (ic == 0x7f)             /* 0x7f == DEL */
+        strbuf[1] = '?';
+    else                    /* other control */
+        strbuf[1] = (wchar_t)(ic + '@');
+
+    return strbuf;
+}
+
+int PDC_mbtowc(wchar_t *pwc, const char *s, size_t n)
+{
+# ifdef PDC_FORCE_UTF8
+    wchar_t key;
+    int i = -1;
+    const unsigned char *string;
+
+    if (!s || (n < 1))
+        return -1;
+
+    if (!*s)
+        return 0;
+
+    string = (const unsigned char *)s;
+
+    key = string[0];
+
+    /* Simplistic UTF-8 decoder -- only does the BMP, minimal validation */
+
+    if (key & 0x80)
+    {
+        if ((key & 0xe0) == 0xc0)
+        {
+            if (1 < n)
+            {
+                key = ((key & 0x1f) << 6) | (string[1] & 0x3f);
+                i = 2;
+            }
+        }
+        else if ((key & 0xe0) == 0xe0)
+        {
+            if (2 < n)
+            {
+                key = ((key & 0x0f) << 12) | ((string[1] & 0x3f) << 6) |
+                      (string[2] & 0x3f);
+                i = 3;
+            }
+        }
+    }
+    else
+        i = 1;
+
+    if (i)
+        *pwc = key;
+
+    return i;
+# else
+    return mbtowc(pwc, s, n);
+# endif
+}
+
+size_t PDC_mbstowcs(wchar_t *dest, const char *src, size_t n)
+{
+# ifdef PDC_FORCE_UTF8
+    size_t i = 0, len;
+
+    if (!src || !dest)
+        return 0;
+
+    len = strlen(src);
+
+    while (*src && i < n)
+    {
+        int retval = PDC_mbtowc(dest + i, src, len);
+
+        if (retval < 1)
+            return -1;
+
+        src += retval;
+        len -= retval;
+        i++;
+    }
+# else
+    size_t i = mbstowcs(dest, src, n);
+# endif
+    dest[i] = 0;
+    return i;
+}
+
+size_t PDC_wcstombs(char *dest, const wchar_t *src, size_t n)
+{
+# ifdef PDC_FORCE_UTF8
+    size_t i = 0;
+
+    if (!src || !dest)
+        return 0;
+
+    while (*src && i < n)
+    {
+        chtype code = *src++;
+
+        if (code < 0x80)
+        {
+            dest[i] = (char)code;
+            i++;
+        }
+        else
+            if (code < 0x800)
+            {
+                dest[i] = (char)((code & 0x07c0) >> 6) | 0xc0;
+                dest[i + 1] = (char)( (code & 0x003f) | 0x80);
+                i += 2;
+            }
+            else
+            {
+                dest[i] = (char)( ((code & 0xf000) >> 12) | 0xe0);
+                dest[i + 1] = (char)((code & 0x0fc0) >> 6) | 0x80;
+                dest[i + 2] = (char)( (code & 0x003f) | 0x80);
+                i += 3;
+            }
+    }
+# else
+    size_t i = wcstombs(dest, src, n);
+# endif
+    dest[i] = '\0';
+    return i;
+}
+#endif

data/vendor/PDCurses/pdcurses/window.c

@@ -0,0 +1,569 @@
+/* Public Domain Curses */
+
+#include <curspriv.h>
+
+/*man-start**************************************************************
+
+window
+------
+
+### Synopsis
+
+    WINDOW *newwin(int nlines, int ncols, int begy, int begx);
+    WINDOW *derwin(WINDOW* orig, int nlines, int ncols,
+                   int begy, int begx);
+    WINDOW *subwin(WINDOW* orig, int nlines, int ncols,
+                   int begy, int begx);
+    WINDOW *dupwin(WINDOW *win);
+    int delwin(WINDOW *win);
+    int mvwin(WINDOW *win, int y, int x);
+    int mvderwin(WINDOW *win, int pary, int parx);
+    int syncok(WINDOW *win, bool bf);
+    void wsyncup(WINDOW *win);
+    void wcursyncup(WINDOW *win);
+    void wsyncdown(WINDOW *win);
+
+    WINDOW *resize_window(WINDOW *win, int nlines, int ncols);
+    int wresize(WINDOW *win, int nlines, int ncols);
+    WINDOW *PDC_makelines(WINDOW *win);
+    WINDOW *PDC_makenew(int nlines, int ncols, int begy, int begx);
+    void PDC_sync(WINDOW *win);
+
+### Description
+
+   newwin() creates a new window with the given number of lines,
+   nlines and columns, ncols. The upper left corner of the window
+   is at line begy, column begx. If nlines is zero, it defaults to
+   LINES - begy; ncols to COLS - begx. Create a new full-screen
+   window by calling newwin(0, 0, 0, 0).
+
+   delwin() deletes the named window, freeing all associated
+   memory. In the case of overlapping windows, subwindows should be
+   deleted before the main window.
+
+   mvwin() moves the window so that the upper left-hand corner is
+   at position (y,x). If the move would cause the window to be off
+   the screen, it is an error and the window is not moved. Moving
+   subwindows is allowed.
+
+   subwin() creates a new subwindow within a window.  The
+   dimensions of the subwindow are nlines lines and ncols columns.
+   The subwindow is at position (begy, begx) on the screen.  This
+   position is relative to the screen, and not to the window orig.
+   Changes made to either window will affect both.  When using this
+   routine, you will often need to call touchwin() before calling
+   wrefresh().
+
+   derwin() is the same as subwin(), except that begy and begx are
+   relative to the origin of the window orig rather than the
+   screen.  There is no difference between subwindows and derived
+   windows.
+
+   mvderwin() moves a derived window (or subwindow) inside its
+   parent window.  The screen-relative parameters of the window are
+   not changed.  This routine is used to display different parts of
+   the parent window at the same physical position on the screen.
+
+   dupwin() creates an exact duplicate of the window win.
+
+   wsyncup() causes a touchwin() of all of the window's parents.
+
+   If wsyncok() is called with a second argument of TRUE, this
+   causes a wsyncup() to be called every time the window is
+   changed.
+
+   wcursyncup() causes the current cursor position of all of a
+   window's ancestors to reflect the current cursor position of the
+   current window.
+
+   wsyncdown() causes a touchwin() of the current window if any of
+   its parent's windows have been touched.
+
+   resize_window() allows the user to resize an existing window. It
+   returns the pointer to the new window, or NULL on failure.
+
+   wresize() is an ncurses-compatible wrapper for resize_window().
+   Note that, unlike ncurses, it will NOT process any subwindows of
+   the window. (However, you still can call it _on_ subwindows.) It
+   returns OK or ERR.
+
+   PDC_makenew() allocates all data for a new WINDOW * except the
+   actual lines themselves. If it's unable to allocate memory for
+   the window structure, it will free all allocated memory and
+   return a NULL pointer.
+
+   PDC_makelines() allocates the memory for the lines.
+
+   PDC_sync() handles wrefresh() and wsyncup() calls when a window
+   is changed.
+
+### Return Value
+
+   newwin(), subwin(), derwin() and dupwin() return a pointer
+   to the new window, or NULL on failure. delwin(), mvwin(),
+   mvderwin() and syncok() return OK or ERR. wsyncup(),
+   wcursyncup() and wsyncdown() return nothing.
+
+### Errors
+
+   It is an error to call resize_window() before calling initscr().
+   Also, an error will be generated if we fail to create a newly
+   sized replacement window for curscr, or stdscr. This could
+   happen when increasing the window size. NOTE: If this happens,
+   the previously successfully allocated windows are left alone;
+   i.e., the resize is NOT cancelled for those windows.
+
+### Portability
+                             X/Open    BSD    SYS V
+    newwin                      Y       Y       Y
+    delwin                      Y       Y       Y
+    mvwin                       Y       Y       Y
+    subwin                      Y       Y       Y
+    derwin                      Y       -       Y
+    mvderwin                    Y       -       Y
+    dupwin                      Y       -      4.0
+    wsyncup                     Y       -      4.0
+    syncok                      Y       -      4.0
+    wcursyncup                  Y       -      4.0
+    wsyncdown                   Y       -      4.0
+    resize_window               -       -       -
+    wresize                     -       -       -
+    PDC_makelines               -       -       -
+    PDC_makenew                 -       -       -
+    PDC_sync                    -       -       -
+
+**man-end****************************************************************/
+
+#include <stdlib.h>
+
+WINDOW *PDC_makenew(int nlines, int ncols, int begy, int begx)
+{
+    WINDOW *win;
+
+    PDC_LOG(("PDC_makenew() - called: lines %d cols %d begy %d begx %d\n",
+             nlines, ncols, begy, begx));
+
+    /* allocate the window structure itself */
+
+    if ((win = calloc(1, sizeof(WINDOW))) == (WINDOW *)NULL)
+        return win;
+
+    /* allocate the line pointer array */
+
+    if ((win->_y = malloc(nlines * sizeof(chtype *))) == NULL)
+    {
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    /* allocate the minchng and maxchng arrays */
+
+    if ((win->_firstch = malloc(nlines * sizeof(int))) == NULL)
+    {
+        free(win->_y);
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    if ((win->_lastch = malloc(nlines * sizeof(int))) == NULL)
+    {
+        free(win->_firstch);
+        free(win->_y);
+        free(win);
+        return (WINDOW *)NULL;
+    }
+
+    /* initialize window variables */
+
+    win->_maxy = nlines;  /* real max screen size */
+    win->_maxx = ncols;   /* real max screen size */
+    win->_begy = begy;
+    win->_begx = begx;
+    win->_bkgd = ' ';     /* wrs 4/10/93 -- initialize background to blank */
+    win->_clear = (bool) ((nlines == LINES) && (ncols == COLS));
+    win->_bmarg = nlines - 1;
+    win->_parx = win->_pary = -1;
+
+    /* init to say window all changed */
+
+    touchwin(win);
+
+    return win;
+}
+
+WINDOW *PDC_makelines(WINDOW *win)
+{
+    int i, j, nlines, ncols;
+
+    PDC_LOG(("PDC_makelines() - called\n"));
+
+    if (!win)
+        return (WINDOW *)NULL;
+
+    nlines = win->_maxy;
+    ncols = win->_maxx;
+
+    for (i = 0; i < nlines; i++)
+    {
+        if ((win->_y[i] = malloc(ncols * sizeof(chtype))) == NULL)
+        {
+            /* if error, free all the data */
+
+            for (j = 0; j < i; j++)
+                free(win->_y[j]);
+
+            free(win->_firstch);
+            free(win->_lastch);
+            free(win->_y);
+            free(win);
+
+            return (WINDOW *)NULL;
+        }
+    }
+
+    return win;
+}
+
+void PDC_sync(WINDOW *win)
+{
+    PDC_LOG(("PDC_sync() - called:\n"));
+
+    if (win->_immed)
+        wrefresh(win);
+    if (win->_sync)
+        wsyncup(win);
+}
+
+WINDOW *newwin(int nlines, int ncols, int begy, int begx)
+{
+    WINDOW *win;
+
+    PDC_LOG(("newwin() - called:lines=%d cols=%d begy=%d begx=%d\n",
+             nlines, ncols, begy, begx));
+
+    if (!nlines)
+        nlines = LINES - begy;
+    if (!ncols)
+        ncols  = COLS  - begx;
+
+    if ( (begy + nlines > SP->lines || begx + ncols > SP->cols)
+        || !(win = PDC_makenew(nlines, ncols, begy, begx))
+        || !(win = PDC_makelines(win)) )
+        return (WINDOW *)NULL;
+
+    werase(win);
+
+    return win;
+}
+
+int delwin(WINDOW *win)
+{
+    int i;
+
+    PDC_LOG(("delwin() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    /* subwindows use parents' lines */
+
+    if (!(win->_flags & (_SUBWIN|_SUBPAD)))
+        for (i = 0; i < win->_maxy && win->_y[i]; i++)
+            if (win->_y[i])
+                free(win->_y[i]);
+
+    free(win->_firstch);
+    free(win->_lastch);
+    free(win->_y);
+    free(win);
+
+    return OK;
+}
+
+int mvwin(WINDOW *win, int y, int x)
+{
+    PDC_LOG(("mvwin() - called\n"));
+
+    if (!win || (y + win->_maxy > LINES || y < 0)
+             || (x + win->_maxx > COLS || x < 0))
+        return ERR;
+
+    win->_begy = y;
+    win->_begx = x;
+    touchwin(win);
+
+    return OK;
+}
+
+WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begy, int begx)
+{
+    WINDOW *win;
+    int i;
+    int j = begy - orig->_begy;
+    int k = begx - orig->_begx;
+
+    PDC_LOG(("subwin() - called: lines %d cols %d begy %d begx %d\n",
+             nlines, ncols, begy, begx));
+
+    /* make sure window fits inside the original one */
+
+    if (!orig || (begy < orig->_begy) || (begx < orig->_begx) ||
+        (begy + nlines) > (orig->_begy + orig->_maxy) ||
+        (begx + ncols) > (orig->_begx + orig->_maxx))
+        return (WINDOW *)NULL;
+
+    if (!nlines)
+        nlines = orig->_maxy - 1 - j;
+    if (!ncols)
+        ncols  = orig->_maxx - 1 - k;
+
+    if ( !(win = PDC_makenew(nlines, ncols, begy, begx)) )
+        return (WINDOW *)NULL;
+
+    /* initialize window variables */
+
+    win->_attrs = orig->_attrs;
+    win->_bkgd = orig->_bkgd;
+    win->_leaveit = orig->_leaveit;
+    win->_scroll = orig->_scroll;
+    win->_nodelay = orig->_nodelay;
+    win->_delayms = orig->_delayms;
+    win->_use_keypad = orig->_use_keypad;
+    win->_immed = orig->_immed;
+    win->_sync = orig->_sync;
+    win->_pary = j;
+    win->_parx = k;
+    win->_parent = orig;
+
+    for (i = 0; i < nlines; i++, j++)
+        win->_y[i] = orig->_y[j] + k;
+
+    win->_flags |= _SUBWIN;
+
+    return win;
+}
+
+WINDOW *derwin(WINDOW *orig, int nlines, int ncols, int begy, int begx)
+{
+    return subwin(orig, nlines, ncols, begy + orig->_begy, begx + orig->_begx);
+}
+
+int mvderwin(WINDOW *win, int pary, int parx)
+{
+    int i, j;
+    WINDOW *mypar;
+
+    if (!win || !(win->_parent))
+        return ERR;
+
+    mypar = win->_parent;
+
+    if (pary < 0 || parx < 0 || (pary + win->_maxy) > mypar->_maxy ||
+                                (parx + win->_maxx) > mypar->_maxx)
+        return ERR;
+
+    j = pary;
+
+    for (i = 0; i < win->_maxy; i++)
+        win->_y[i] = (mypar->_y[j++]) + parx;
+
+    win->_pary = pary;
+    win->_parx = parx;
+
+    return OK;
+}
+
+WINDOW *dupwin(WINDOW *win)
+{
+    WINDOW *new;
+    chtype *ptr, *ptr1;
+    int nlines, ncols, begy, begx, i;
+
+    if (!win)
+        return (WINDOW *)NULL;
+
+    nlines = win->_maxy;
+    ncols = win->_maxx;
+    begy = win->_begy;
+    begx = win->_begx;
+
+    if ( !(new = PDC_makenew(nlines, ncols, begy, begx))
+        || !(new = PDC_makelines(new)) )
+        return (WINDOW *)NULL;
+
+    /* copy the contents of win into new */
+
+    for (i = 0; i < nlines; i++)
+    {
+        for (ptr = new->_y[i], ptr1 = win->_y[i];
+             ptr < new->_y[i] + ncols; ptr++, ptr1++)
+            *ptr = *ptr1;
+
+        new->_firstch[i] = 0;
+        new->_lastch[i] = ncols - 1;
+    }
+
+    new->_curx = win->_curx;
+    new->_cury = win->_cury;
+    new->_maxy = win->_maxy;
+    new->_maxx = win->_maxx;
+    new->_begy = win->_begy;
+    new->_begx = win->_begx;
+    new->_flags = win->_flags;
+    new->_attrs = win->_attrs;
+    new->_clear = win->_clear;
+    new->_leaveit = win->_leaveit;
+    new->_scroll = win->_scroll;
+    new->_nodelay = win->_nodelay;
+    new->_delayms = win->_delayms;
+    new->_use_keypad = win->_use_keypad;
+    new->_tmarg = win->_tmarg;
+    new->_bmarg = win->_bmarg;
+    new->_parx = win->_parx;
+    new->_pary = win->_pary;
+    new->_parent = win->_parent;
+    new->_bkgd = win->_bkgd;
+    new->_flags = win->_flags;
+
+    return new;
+}
+
+WINDOW *resize_window(WINDOW *win, int nlines, int ncols)
+{
+    WINDOW *new;
+    int i, save_cury, save_curx, new_begy, new_begx;
+
+    PDC_LOG(("resize_window() - called: nlines %d ncols %d\n",
+             nlines, ncols));
+
+    if (!win)
+        return (WINDOW *)NULL;
+
+    if (win->_flags & _SUBPAD)
+    {
+        if ( !(new = subpad(win->_parent, nlines, ncols,
+                            win->_begy, win->_begx)) )
+            return (WINDOW *)NULL;
+    }
+    else if (win->_flags & _SUBWIN)
+    {
+        if ( !(new = subwin(win->_parent, nlines, ncols,
+                            win->_begy, win->_begx)) )
+            return (WINDOW *)NULL;
+    }
+    else
+    {
+        if (win == SP->slk_winptr)
+        {
+            new_begy = SP->lines - SP->slklines;
+            new_begx = 0;
+        }
+        else
+        {
+            new_begy = win->_begy;
+            new_begx = win->_begx;
+        }
+
+        if ( !(new = PDC_makenew(nlines, ncols, new_begy, new_begx)) )
+            return (WINDOW *)NULL;
+    }
+
+    save_curx = min(win->_curx, (new->_maxx - 1));
+    save_cury = min(win->_cury, (new->_maxy - 1));
+
+    if (!(win->_flags & (_SUBPAD|_SUBWIN)))
+    {
+        if ( !(new = PDC_makelines(new)) )
+            return (WINDOW *)NULL;
+
+        werase(new);
+
+        copywin(win, new, 0, 0, 0, 0, min(win->_maxy, new->_maxy) - 1,
+                min(win->_maxx, new->_maxx) - 1, FALSE);
+
+        for (i = 0; i < win->_maxy && win->_y[i]; i++)
+            if (win->_y[i])
+                free(win->_y[i]);
+    }
+
+    new->_flags = win->_flags;
+    new->_attrs = win->_attrs;
+    new->_clear = win->_clear;
+    new->_leaveit = win->_leaveit;
+    new->_scroll = win->_scroll;
+    new->_nodelay = win->_nodelay;
+    new->_delayms = win->_delayms;
+    new->_use_keypad = win->_use_keypad;
+    new->_tmarg = (win->_tmarg > new->_maxy - 1) ? 0 : win->_tmarg;
+    new->_bmarg = (win->_bmarg == win->_maxy - 1) ?
+                  new->_maxy - 1 : min(win->_bmarg, (new->_maxy - 1));
+    new->_parent = win->_parent;
+    new->_immed = win->_immed;
+    new->_sync = win->_sync;
+    new->_bkgd = win->_bkgd;
+
+    new->_curx = save_curx;
+    new->_cury = save_cury;
+
+    free(win->_firstch);
+    free(win->_lastch);
+    free(win->_y);
+
+    *win = *new;
+    free(new);
+
+    return win;
+}
+
+int wresize(WINDOW *win, int nlines, int ncols)
+{
+    return (resize_window(win, nlines, ncols) ? OK : ERR);
+}
+
+void wsyncup(WINDOW *win)
+{
+    WINDOW *tmp;
+
+    PDC_LOG(("wsyncup() - called\n"));
+
+    for (tmp = win; tmp; tmp = tmp->_parent)
+        touchwin(tmp);
+}
+
+int syncok(WINDOW *win, bool bf)
+{
+    PDC_LOG(("syncok() - called\n"));
+
+    if (!win)
+        return ERR;
+
+    win->_sync = bf;
+
+    return OK;
+}
+
+void wcursyncup(WINDOW *win)
+{
+    WINDOW *tmp;
+
+    PDC_LOG(("wcursyncup() - called\n"));
+
+    for (tmp = win; tmp && tmp->_parent; tmp = tmp->_parent)
+        wmove(tmp->_parent, tmp->_pary + tmp->_cury, tmp->_parx + tmp->_curx);
+}
+
+void wsyncdown(WINDOW *win)
+{
+    WINDOW *tmp;
+
+    PDC_LOG(("wsyncdown() - called\n"));
+
+    for (tmp = win; tmp; tmp = tmp->_parent)
+    {
+        if (is_wintouched(tmp))
+        {
+            touchwin(win);
+            break;
+        }
+    }
+}