diff --git a/ncurses/base/lib_refresh.c b/ncurses/base/lib_refresh.c
new file mode 100644
index 0000000..2a9cafb
--- /dev/null
+++ b/ncurses/base/lib_refresh.c
@@ -0,0 +1,288 @@
+/****************************************************************************
+ * Copyright (c) 1998-2006,2007 Free Software Foundation, Inc.              *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
+ *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ *     and: Thomas E. Dickey                        1996-on                 *
+ ****************************************************************************/
+
+/*
+ *	lib_refresh.c
+ *
+ *	The routines wrefresh() and wnoutrefresh().
+ *
+ */
+
+#include <curses.priv.h>
+
+MODULE_ID("$Id: lib_refresh.c,v 1.41 2007/09/29 20:39:34 tom Exp $")
+
+NCURSES_EXPORT(int)
+wrefresh(WINDOW *win)
+{
+    int code;
+
+    T((T_CALLED("wrefresh(%p)"), win));
+
+    if (win == 0) {
+	code = ERR;
+    } else if (win == curscr) {
+	curscr->_clear = TRUE;
+	code = doupdate();
+    } else if ((code = wnoutrefresh(win)) == OK) {
+	if (win->_clear)
+	    newscr->_clear = TRUE;
+	code = doupdate();
+	/*
+	 * Reset the clearok() flag in case it was set for the special
+	 * case in hardscroll.c (if we don't reset it here, we'll get 2
+	 * refreshes because the flag is copied from stdscr to newscr).
+	 * Resetting the flag shouldn't do any harm, anyway.
+	 */
+	win->_clear = FALSE;
+    }
+    returnCode(code);
+}
+
+NCURSES_EXPORT(int)
+wnoutrefresh(WINDOW *win)
+{
+    NCURSES_SIZE_T limit_x;
+    NCURSES_SIZE_T src_row, src_col;
+    NCURSES_SIZE_T begx;
+    NCURSES_SIZE_T begy;
+    NCURSES_SIZE_T dst_row, dst_col;
+#if USE_SCROLL_HINTS
+    bool wide;
+#endif
+
+    T((T_CALLED("wnoutrefresh(%p)"), win));
+#ifdef TRACE
+    if (USE_TRACEF(TRACE_UPDATE)) {
+	_tracedump("...win", win);
+	_nc_unlock_global(tracef);
+    }
+#endif /* TRACE */
+
+    /*
+     * This function will break badly if we try to refresh a pad.
+     */
+    if ((win == 0)
+	|| (win->_flags & _ISPAD))
+	returnCode(ERR);
+
+    /* put them here so "win == 0" won't break our code */
+    begx = win->_begx;
+    begy = win->_begy;
+
+    newscr->_nc_bkgd = win->_nc_bkgd;
+    WINDOW_ATTRS(newscr) = WINDOW_ATTRS(win);
+
+    /* merge in change information from all subwindows of this window */
+    wsyncdown(win);
+
+#if USE_SCROLL_HINTS
+    /*
+     * For pure efficiency, we'd want to transfer scrolling information
+     * from the window to newscr whenever the window is wide enough that
+     * its update will dominate the cost of the update for the horizontal
+     * band of newscr that it occupies.  Unfortunately, this threshold
+     * tends to be complex to estimate, and in any case scrolling the
+     * whole band and rewriting the parts outside win's image would look
+     * really ugly.  So.  What we do is consider the window "wide" if it
+     * either (a) occupies the whole width of newscr, or (b) occupies
+     * all but at most one column on either vertical edge of the screen
+     * (this caters to fussy people who put boxes around full-screen
+     * windows).  Note that changing this formula will not break any code,
+     * merely change the costs of various update cases.
+     */
+    wide = (begx <= 1 && win->_maxx >= (newscr->_maxx - 1));
+#endif
+
+    win->_flags &= ~_HASMOVED;
+
+    /*
+     * Microtweaking alert!  This double loop is one of the genuine
+     * hot spots in the code.  Even gcc doesn't seem to do enough
+     * common-subexpression chunking to make it really tense,
+     * so we'll force the issue.
+     */
+
+    /* limit(dst_col) */
+    limit_x = win->_maxx;
+    /* limit(src_col) */
+    if (limit_x > newscr->_maxx - begx)
+	limit_x = newscr->_maxx - begx;
+
+    for (src_row = 0, dst_row = begy + win->_yoffset;
+	 src_row <= win->_maxy && dst_row <= newscr->_maxy;
+	 src_row++, dst_row++) {
+	register struct ldat *nline = &newscr->_line[dst_row];
+	register struct ldat *oline = &win->_line[src_row];
+
+	if (oline->firstchar != _NOCHANGE) {
+	    int last_src = oline->lastchar;
+
+	    if (last_src > limit_x)
+		last_src = limit_x;
+
+	    src_col = oline->firstchar;
+	    dst_col = src_col + begx;
+
+	    if_WIDEC({
+		register int j;
+
+		/*
+		 * Ensure that we will copy complete multi-column characters
+		 * on the left-boundary.
+		 */
+		if (isWidecExt(oline->text[src_col])) {
+		    j = 1 + dst_col - WidecExt(oline->text[src_col]);
+		    if (j < 0)
+			j = 0;
+		    if (dst_col > j) {
+			src_col -= (dst_col - j);
+			dst_col = j;
+		    }
+		}
+
+		/*
+		 * Ensure that we will copy complete multi-column characters
+		 * on the right-boundary.
+		 */
+		j = last_src;
+		if (WidecExt(oline->text[j])) {
+		    ++j;
+		    while (j <= limit_x) {
+			if (isWidecBase(oline->text[j])) {
+			    break;
+			} else {
+			    last_src = j;
+			}
+			++j;
+		    }
+		}
+	    });
+
+	    if_WIDEC({
+		static cchar_t blank = BLANK;
+		int last_dst = begx + ((last_src < win->_maxx)
+				       ? last_src
+				       : win->_maxx);
+		int fix_left = dst_col;
+		int fix_right = last_dst;
+		register int j;
+
+		/*
+		 * Check for boundary cases where we may overwrite part of a
+		 * multi-column character.  For those, wipe the remainder of
+		 * the character to blanks.
+		 */
+		j = dst_col;
+		if (isWidecExt(nline->text[j])) {
+		    /*
+		     * On the left, we only care about multi-column characters
+		     * that extend into the changed region.
+		     */
+		    fix_left = 1 + j - WidecExt(nline->text[j]);
+		    if (fix_left < 0)
+			fix_left = 0;	/* only if cell is corrupt */
+		}
+
+		j = last_dst;
+		if (WidecExt(nline->text[j]) != 0) {
+		    /*
+		     * On the right, any multi-column character is a problem,
+		     * unless it happens to be contained in the change, and
+		     * ending at the right boundary of the change.  The
+		     * computation for 'fix_left' accounts for the left-side of
+		     * this character.  Find the end of the character.
+		     */
+		    ++j;
+		    while (j <= newscr->_maxx && isWidecExt(nline->text[j])) {
+			fix_right = j++;
+		    }
+		}
+
+		/*
+		 * The analysis is simpler if we do the clearing afterwards.
+		 * Do that now.
+		 */
+		if (fix_left < dst_col || fix_right > last_dst) {
+		    for (j = fix_left; j <= fix_right; ++j) {
+			nline->text[j] = blank;
+			CHANGED_CELL(nline, j);
+		    }
+		}
+	    });
+
+	    /*
+	     * Copy the changed text.
+	     */
+	    for (; src_col <= last_src; src_col++, dst_col++) {
+		if (!CharEq(oline->text[src_col], nline->text[dst_col])) {
+		    nline->text[dst_col] = oline->text[src_col];
+		    CHANGED_CELL(nline, dst_col);
+		}
+	    }
+
+	}
+#if USE_SCROLL_HINTS
+	if (wide) {
+	    int oind = oline->oldindex;
+
+	    nline->oldindex = ((oind == _NEWINDEX)
+			       ? _NEWINDEX
+			       : (begy + oind + win->_yoffset));
+	}
+#endif /* USE_SCROLL_HINTS */
+
+	oline->firstchar = oline->lastchar = _NOCHANGE;
+	if_USE_SCROLL_HINTS(oline->oldindex = src_row);
+    }
+
+    if (win->_clear) {
+	win->_clear = FALSE;
+	newscr->_clear = TRUE;
+    }
+
+    if (!win->_leaveok) {
+	newscr->_cury = win->_cury + win->_begy + win->_yoffset;
+	newscr->_curx = win->_curx + win->_begx;
+    }
+    newscr->_leaveok = win->_leaveok;
+
+#ifdef TRACE
+    if (USE_TRACEF(TRACE_UPDATE)) {
+	_tracedump("newscr", newscr);
+	_nc_unlock_global(tracef);
+    }
+#endif /* TRACE */
+    returnCode(OK);
+}