# curs_refresh

## NAME



           **doupdate** , **redrawwin** , **refresh** , **wnoutrefresh** , **wredrawln** , **wrefresh** -
           refresh **curses** windows and lines
    


## SYNOPSIS



           **#include <curses.h>**
    
           **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



       **refresh/wrefresh**
           The  **refresh** and **wrefresh** routines (or **wnoutrefresh** and **doupdate**)
           must be called to get actual output to the terminal, as other rou‐
           tines merely manipulate data  structures.   The  routine  **wrefresh**
           copies  the  named  window to the _physical screen_ , taking into ac‐
           count what is already there to do optimizations.  The **refresh** rou‐
           tine is the same, using **stdscr** as  the  default  window.   Unless
           **leaveok**(3X)  has been enabled, the physical cursor of the terminal
           is left at the location of the cursor for that window.
    
       **wnoutrefresh/doupdate**
           The **wnoutrefresh** and **doupdate** routines allow multiple updates with
           more efficiency than **wrefresh** alone.  In addition to all the  win‐
           dow  structures, **curses** keeps two data structures representing the
           terminal screen:
    
           •   a _physical screen_ , describing what is actually on the screen,
               and
    
           •   a _virtual screen_ , describing what the programmer wants to have
               on the screen.
    
           The routine **wrefresh** works by
    
           •   first calling **wnoutrefresh** , which copies the named window to
               the _virtual screen_ , and
    
           •   then calling **doupdate** , which compares the _virtual screen_ to
               the _physical screen_ and does the actual update.
    
           If the programmer wishes to output several windows at once, a se‐
           ries of calls to **wrefresh** results in alternating calls to **wnoutre‐**
           **fresh** and **doupdate** , causing several bursts of output to the
           screen.  By first calling **wnoutrefresh** for each window, it is then
           possible to call **doupdate** once, resulting in only one burst of
           output, with fewer total characters transmitted and less CPU time
           used.
    
           If the _win_ argument to **wrefresh** is the _physical screen_ (i.e., the
           global variable **curscr**), the screen is immediately cleared and re‐
           painted from scratch.
    
           The phrase “copies the named window to the virtual screen” above
           is ambiguous.  What actually happens is that all _touched_ (changed)
           lines in the window are copied to the virtual screen.  This af‐
           fects programs that use overlapping windows; it means that if two
           windows overlap, you can refresh them in either order and the
           overlap region will be modified only when it is explicitly
           changed.  (But see the section on **PORTABILITY** below for a warning
           about exploiting this behavior.)
    
       **wredrawln/redrawwin**
           The **wredrawln** routine indicates to **curses** that some screen lines
           are corrupted and should be thrown away before anything is written
           over them.  It touches the indicated lines (marking them changed).
           The routine **redrawwin** touches the entire window.
    


## RETURN VALUE



           Routines that return an integer return **ERR** upon failure, and **OK**
           (SVr4 only specifies "an integer value other than **ERR** ") upon suc‐
           cessful completion.
    
           X/Open does not define any error conditions.  In this implementa‐
           tion
    
              **wnoutrefresh**
                   returns an error if the window pointer is null, or if the
                   window is really a pad.
    
              **wredrawln**
                   returns an error if the associated call to **touchln** returns
                   an error.
    


## NOTES



           Note that **refresh** and **redrawwin** may be macros.
    


## PORTABILITY



           The XSI Curses standard, Issue 4 describes these functions.
    
           Whether **wnoutrefresh** copies to the virtual screen the entire con‐
           tents of a window or just its changed portions has never been
           well-documented in historic curses versions (including SVr4).  It
           might be unwise to rely on either behavior in programs that might
           have to be linked with other curses implementations.  Instead, you
           can do an explicit **touchwin** before the **wnoutrefresh** call to guar‐
           antee an entire-contents copy anywhere.
    


* * *