`co(4,7);────────────────────────── /// Window I/O Routines ───────────────────────────`co();
 ┌──────────────────────────────────────────────────────────────────────────┐	
 │        `keyword(wn_plst,/// wn_plst);                `keyword(wn_printf,/// wn_printf);           `keyword(wn_st,/// wn_st);                  │
 │        `keyword(wn_st_qty,/// wn_st_qty);              `keyword(wn_qch,/// wn_qch);              `keyword(wn_ch,/// wn_ch);                  │
 │        `keyword(wn_och,/// wn_och);                 `keyword(wn_co,/// wn_co);               `keyword(wn_hline,/// wn_hline);               │
 │        `keyword(wn_vline,/// wn_vline);               `keyword(wn_cleol,/// wn_cleol);            `keyword(wn_clbol,/// wn_clbol);               │     
 │        `keyword(wn_claol,/// wn_claol);               `keyword(wn_cleos,/// wn_cleos);            `keyword(wn_clbos,/// wn_clbos);               │
 │        `keyword(wn_claos,/// wn_claos);               `keyword(wn_cln,/// wn_cln);              `keyword(wn_ins_del_chars,/// wn_ins_del_chars);       │  
 │        `keyword(wn_ins_del_lines,/// wn_ins_del_lines);       `keyword(wn_csr_dn,/// wn_csr_dn);           `keyword(wn_csr_up,/// wn_csr_up);              │
 │        `keyword(wn_csr_left,/// wn_csr_left);            `keyword(wn_csr_right,/// wn_csr_right);        `keyword(wn_csr_pos,/// wn_csr_pos);             │
 │        `keyword(wn_scroll_reg,/// wn_scroll_reg);          `keyword(wn_bksp,/// wn_bksp);                                    │
 │        `keyword(wn_st_fmt,/// wn_st_fmt);                                                         │
 └──────────────────────────────────────────────────────────────────────────┘

		These functions allow a great deal of flexibility for input/output to a
	window. Included are string output routines, window "printf" capability,
	multiple character output in both vertical and horizontal directions, line
	drawing in a window with automatic blending of crossover points and border
	intersection, clearing to the end of a line, beginning of line, end of
	screen, and many others.  New for V2.5 is an output routine that will
	process control characters such as bell, backspace, tabs, carriage returns
	and line feeds.  It will even word wrap for you!  See `keyword(wn_st_fmt,/// wn_st_fmt);
	for more details.

`co(10,1);/// wn_plst`co();   `keyword(source,[UW_ST.C]~wn_plst);
		Outputs a string to a window starting at a specific row and column.

Prototype:
	void wn_plst( int col, int line, char *s, WINDOW *wnp );

Parameters:
`co(11,1);	int col, row`co();
		The location of the window to begin output.  The column can also be set
		to one of the three predefined values CENTERED, LEFT_JUST, and
		RIGHT_JUST (defined in the file UW.H).

`co(11,1);	uchar *s`co();
		A pointer to the characters to place in the window.
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which the string is to be placed.

Usage:
	wn_plst( 10, 20, "This string starts at x = 10, y = 20.", wnp );

`co(10,1);/// wn_printf`co();   `keyword(source,[UW_PRTF.C]~wn_printf);
		Outputs formatted text to a window at the current window cursor
	position. The formatted output takes the same format string as the printf
	family of functions.

Prototype:
	int wn_printf( WINDOW *wnp, char *fmt, ... );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window in which to place the formatted output.
`co(11,1);	char *fmt`co();
		The format string, followed by any variables, strings, etc...

Usage:
	WINDOW *wnp;
	int x = 10;
	float f = 3.14;
	...
	wn_printf( wnp, "The value of x is %d, f is %4.2f", x, f );

`co(10,1);/// wn_st`co();   `keyword(source,[UW_ST.C]~wn_st);
		Outputs the string at the current window cursor position.

Prototype:
	void wn_st( char *s, WINDOW *wnp );

Parameters:
`co(11,1);	uchar *s;`co();
		The string to output to the window.
`co(11,1);	WINDOW *wnp;`co();
		The window in which the string will be placed.

Usage:
	WINDOW *wnp;
	...
	wn_st( "This line will print at the window cursor position", wnp );

`co(10,1);/// wn_st_qty`co();   `keyword(source,[UW_ST.C]~wn_st_qty);
		Outputs a specific number of characters from a string to the window at
	the current window position.  If the number to output is greater than the
	string length, this function will output to the end of the string and
	stop.

Prototype:
	void wn_st_qty( char *s, int qty, WINDOW *wnp );

Parameters:
`co(11,1);	uchar *s`co();
		The string to output to the window.
`co(11,1);	int qty`co();
		The number of characters from the string to output.
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which the output is to occur.

Usage:
	WINDOW *wnp;
	...
	wn_st_qty( "Only 20 chars of this will be output", 20, wnp );

`co(10,1);/// wn_qch`co();   `keyword(source,[UW_CH.C]~wn_qch);
		Outputs a character to a window a repeated number of times.

Prototype:
	void wn_qch( int cnt, uchar c, WINDOW *wnp );

Parameters:
`co(11,1);	int cnt`co();
		The number of times to output the character.
`co(11,1);	uchar c`co();
		The character to output to the window.
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which the output is to occur.

Usage:
	WINDOW *wnp;
	...
	wn_qch( 20, '*', wnp );

`co(10,1);/// wn_ch`co();   `keyword(source,[UW_CH.C]~wn_ch);
		Outputs one character at the current window cursor location.
	
Prototype:
	void wn_ch( uchar c, WINDOW *wnp );

Parameters:
`co(11,1);	uchar c`co();
		The character to output to the window.
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which the character is to be drawn.
		
Usage:
	WINDOW *wnp;
	...
	wn_ch( 'A', wnp );

`co(10,1);/// wn_och`co();   `keyword(source,[UW_CH.C]~wn_och);
		Returns the character located at the window cursor location.
	
Prototype:
	uchar wn_och( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which to retrieve the character.

Usage:
	WINDOW *wnp;
	uchar val;
	...
	val = wn_och( wnp );

`co(10,1);/// wn_oatt`co();   `keyword(source,[UW_CH.C]~wn_oatt);
		Returns the attribute located at the window cursor location.
	
Prototype:
	uchar wn_oatt( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which to retrieve the attribute.

Usage:
	WINDOW *wnp;
	uchar val;
	...
	val = wn_oatt( wnp );

`co(10,1);/// wn_co`co();   `keyword(source,[UW_BDR.C]~wn_co);
		Writes a specific number of characters starting at the current window
	cursor location and moving downward.	This is, in effect, a vertical
	wn_qch routine.
	
Prototype:
	void wn_co( int cnt, uchar c, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of times to output the character.
`co(11,1);	uchar c`co();
		The character to output to the window.
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which to output the vertical string.

Usage:
	WINDOW *wnp;
	...
	wn_co( 10, '*', wnp );

`co(10,1);/// wn_hline`co();   `keyword(source,[UW_BDR.C]~wn_hline);
		Draws a horizontal line across the window, blending any intersections
	with other lines and points where the line meets the window's left and
	right border.
	
Prototype:
	void wn_hline( int row, int style, WINDOW *wnp );

Parameters:
`co(11,1);	int row`co();
		The row number to place the horizontal line.
`co(11,1);	int style`co();
		The style of the line, SGL_BDR or DBL_BDR.
`co(11,1);	WINDOW *wnp`co();
		The window pointer for output.

Usage:
	WINDOW *wnp;
	...
	wn_hline( 5, SGL_BDR, wnp );

`co(10,1);/// wn_vline`co();   `keyword(source,[UW_BDR.C]~wn_vline);
		Draws a vertical line down the window, blending any intersections with
	other lines and points where the line meets the window's bottom and top
	border.
	
Prototype:
	void wn_vline( int col, int style, WINDOW *wnp );

Parameters:
`co(11,1);	int col`co();
		The column number to place the vertical line.
`co(11,1);	int style`co();
		The style of the line, SGL_BDR or DBL_BDR.
`co(11,1);	WINDOW *wnp`co();
		The pointer to the window for output.

Usage:
	WINDOW *wnp;
	...
	wn_vline( 40, DBL_BDR, wnp );

`co(10,1);/// wn_cleol`co();   `keyword(source,[UW_TERM.C]~wn_cleol);
		Clears from the current window cursor location to the end of the line.
	
Prototype:
	void wn_cleol( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the action is to take place.

Usage:
	WINDOW *wnp;
	...
	wn_cleol( wnp );

`co(10,1);/// wn_clbol`co();   `keyword(source,[UW_TERM.C]~wn_clbol);
		Clears from the current window cursor location to the beginning of the
	line.
	
Prototype:
	void wn_clbol( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the action is to take place.

Usage:
	WINDOW *wnp;
	...
	wn_clbol( wnp );

`co(10,1);/// wn_claol`co();   `keyword(source,[UW_TERM.C]~wn_claol);
		Clears all of the line on which the window cursor currently resides.
	
Prototype:
	void wn_claol( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the action is to take place.

Usage:
	WINDOW *wnp;
	...
	wn_claol( wnp );

`co(10,1);/// wn_cleos`co();   `keyword(source,[UW_TERM.C]~wn_cleos);
		Clears from the current window cursor location to the lower right corner
	of the window (clears to the end of the window).
	
Prototype:
	void wn_cleos( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the action is to take place.

Usage:
	WINDOW *wnp;
	...
	wn_cleos( wnp );

`co(10,1);/// wn_clbos`co();   `keyword(source,[UW_TERM.C]~wn_clbos);
		Clears from the current window cursor location to the upper left corner
	of the window (clears to the beginning of the window).
	
Prototype:
	void wn_clbos( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the action is to take place.

Usage:
	WINDOW *wnp;
	...
	wn_clbos( wnp );

`co(10,1);/// wn_claos`co();   `keyword(source,[UW_TERM.C]~wn_claos);
		Clears the entire window scrolling region, which by default is the
	entire window.  See also wn_clear;
	
Prototype:
	void wn_claos( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the action is to take place.

Usage:
	WINDOW *wnp;
	...
	wn_claos( wnp );

`co(10,1);/// wn_cln`co();   `keyword(source,[UW_TERM.C]~wn_cln);
		Clears a specific number of cells to the right of the current window
	cursor location.
		
Prototype:
	void wn_cln( int qty, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of cells to clear.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the cells are to be cleared.

Usage:
	WINDOW *wnp;
	...
	wn_cln( 20, wnp );

`co(10,1);/// wn_ins_del_chars`co();   `keyword(source,[UW_TERM.C]~wn_ins_del_chars);
		Inserts or deletes characters at the current window location.

Prototype:
	void wn_ins_del_chars(int mode, char c, int cnt, WINDOW *wnp );

Parameters:
`co(11,1);	int mode`co();
		INSERT or DELETE (defined in uw.h).
`co(11,1);	int c`co();
		the character to output for each position (for INSERT mode).
`co(11,1);	int cnt`co();
		the number of characters to output.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the characters are inserted/deleted.
	
Usage:
	WINDOW *wnp;
	...
	wn_ins_del_chars(INSERT, '*', 12, wnp );

`co(10,1);/// wn_ins_del_lines`co();   `keyword(source,[UW_TERM.C]~wn_ins_del_lines);
		Inserts or deletes lines at the current window location.

Prototype:
	void wn_ins_del_lines(int mode, char c, int cnt, WINDOW *wnp );

Parameters:
`co(11,1);	int mode`co();
		INSERT or DELETE (defined in uw.h).
`co(11,1);	int c`co();
		The character to output on inserted lines.
`co(11,1);	int cnt`co();
		The number of lines to insert or delete.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the lines are inserted/deleted.

Usage:
	WINDOW *wnp;
	...
	wn_ins_del_lines(DELETE, ' ', 3, wnp );

`co(10,1);/// wn_csr_dn`co();   `keyword(source,[UW_TERM.C]~wn_csr_dn);
		Moves the window cursor down "qty" lines.

Prototype:
	void wn_csr_dn( int qty, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of lines to move down.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the cursor will be moved.
	
Usage:
	WINDOW *wnp;
	...
	wn_csr_dn( 4, wnp );

`co(10,1);/// wn_csr_up`co();   `keyword(source,[UW_TERM.C]~wn_csr_up);
		Moves the window cursor up "qty" lines.

Prototype:
	void wn_csr_up( int qty, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of lines to move up.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the cursor will be moved.
	
Usage:
	WINDOW *wnp;
	...
	wn_csr_up(4, wnp );

`co(10,1);/// wn_csr_left`co();   `keyword(source,[UW_TERM.C]~wn_csr_left);
		Moves the window cursor left "qty" columns.

Prototype:
	void wn_csr_left( int qty, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of columns to move left.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the cursor will be moved.
	
Usage:
	WINDOW *wnp;
	...
	wn_csr_left( 2, wnp );

`co(10,1);/// wn_csr_right`co();   `keyword(source,[UW_TERM.C]~wn_csr_right);
		Moves the window cursor right "qty" columns.

Prototype:
	void wn_csr_right( int qty, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of columns to move right.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the cursor will be moved.
	
Usage:
	WINDOW *wnp;
	...
	wn_csr_right( 3, wnp );

`co(10,1);/// wn_csr_pos`co();   `keyword(source,[UW_TERM.C]~wn_csr_pos);
		Moves the window cursor to a certain position.

Prototype:
	void wn_csr_pos( int line, int col, WINDOW *wnp );

Parameters:
`co(11,1);	int line, col`co();
		The line and column to move the cursor to.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the cursor will be moved.
	
Usage:
	WINDOW *wnp;
	...
	wn_csr_pos( 4, 3, wnp );

`co(10,1);/// wn_scroll_reg`co();   `keyword(source,[UW_TERM.C]~wn_scroll_reg);
		Sets a scrolling region within a window.

Prototype:
	void wn_scroll_reg( int line_s, int line_e, WINDOW *wnp );

Parameters:
`co(11,1);  int line_s, line_e`co();
		The starting and ending lines for the scrolling region.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the region is set.
	
Usage:
	WINDOW *wnp;
	...
	wn_scroll_reg( 3, 6, wnp );

`co(10,1);/// wn_bksp`co();   `keyword(source,[UW_TERM.C]~wn_bksp);
		Backspaces "qty" positions.             

Prototype:
	void wn_bksp( int qty, WINDOW *wnp );

Parameters:
`co(11,1);	int qty`co();
		The number of positions to backspace.
`co(11,1);	WINDOW *wnp`co();
		The window pointer in which the backspaces will occur.

Usage:
	WINDOW *wnp;
	...
	wn_bksp( 4, wnp );

`co(10,1);/// wn_st_fmt`co();   `keyword(source,[UW_ST.C]~wn_st_fmt);
		Outputs the string at the current window cursor position, using control
	bits set by the window macros described below. 
  
	`keyword(A) wn_set_bell_flag,[uw_help5.hlp]/// wn_set_bell_flag);    - turns on the processing of the bell character. 
	`keyword(B) wn_set_bk_flag,[uw_help5.hlp]/// wn_set_bk_flag);      - turns on the processing of backspaces. 
	`keyword(C) wn_set_cr_flag,[uw_help5.hlp]/// wn_set_cr_flag);      - turns on the processing of carriage returns. 
	`keyword(D) wn_set_lf_flag,[uw_help5.hlp]/// wn_set_lf_flag);      - turns on the processing of line feeds. 
	`keyword(E) wn_set_cr_lf_flag,[uw_help5.hlp]/// wn_set_cr_lf_flag);   - turns on the processing of both carriage
                           returns and line feeds. 
	`keyword(F) wn_set_tab_flag,[uw_help5.hlp]/// wn_set_tab_flag);     - turns on the processing of tabs. 
	`keyword(G) wn_set_w_wrap,[uw_help5.hlp]/// wn_set_w_wrap);       - turns on word wrap. 
	
  NOTE: All of these bits default to ON when a window is created except
  for cr_lf_flag.  This flag is mutually exclusive with the cr_flag and
  lf_flag.  By default, a carriage return moves the cursor to the start
  of the current line, and a line feed moves it down one line.  Therefore,
  both a carriage return AND line feed are required to move to the start
  of the next line.
  		
Prototype:
	void wn_st_fmt( char *s, WINDOW *wnp );

Parameters:
`co(11,1);	uchar *s;`co();
		The string to output to the window.
`co(11,1);	WINDOW *wnp;`co();
		The window in which the string will be placed.

Usage:
	WINDOW *wnp;
	...
	wn_st_fmt("This line will\r\nprint at tr\bhe window\007 cursor 
	           position and beep.", wnp);

	This line will
	print at the window cursor position and beep.

`co(4,7);────────────────────────── /// Cursor Routines ───────────────────────────────`co();

 ┌──────────────────────────────────────────────────────────────────────────┐	
 │            `keyword(rd_csr,/// rd_csr);               `keyword(mv_csr,/// mv_csr);            `keyword(csr_style,/// csr_style);              │
 │            `keyword(csr_hide,/// csr_hide);             `keyword(csr_show,/// csr_show);          `keyword(pl_csr,/// pl_csr);                 │
 └──────────────────────────────────────────────────────────────────────────┘
	
	  These functions allow manipulation of the hardware cursor. The cursor
	style, location, visibility, and window placement are all supported, along
	with the ability to read its current location.

`co(10,1);/// rd_csr`co();   `keyword(source,[UW_CSR.C]~rd_csr);
		Gets the current screen column and row where the hardware text cursor
	currently resides.  The upper-left corner of the screen is defined as
	(0,0).

Prototype:
	void rd_csr( int *col, int *line );

Parameters:
`co(11,1);	int *col, int *row`co();
		Pointers to integers where the location is to be placed.  By passing the
		address of an integer for each of these parameters, you can have this
		function set their values for you.

Usage:
	int column, row;
	...
	rd_csr( &column, &row );

`co(10,1);/// mv_csr`co();   `keyword(source,[UW_CSR.C]~mv_csr);
		Moves the hardware text cursor to the specified column and row.

Prototype:
	void mv_csr( int col, int line );

Parameters:
`co(11,1);	int col, int row`co();
		Integers containing the new column and row values.

Usage:
	mv_csr( 20, 10 );

`co(10,1);/// csr_style`co();   `keyword(source,[UW_CSR.C]~csr_style);
		Changes the hardware text cursor to one of several forms.	 The choices
	are a "thin line" cursor, a "small block" cursor, and a "fat block"
	cursor.

Prototype:
	void csr_style( int style );

Parameters:
`co(11,1);	int style`co();
		A value used to specify the new hardware text cursor appearance. This
		number can be one of the defined (uw.h) values C_LINE, C_SBLOCK, or
		C_FBLOCK.

Usage:
	csr_style(C_FBLOCK);

`co(10,1);/// csr_hide`co();   `keyword(source,[UW_CSR.C]~csr_hide);
		Makes the hardware text cursor invisible by moving it off the visible
	screen.

Prototype:
	void csr_hide(void);

Parameters:
	None.

Usage:
	csr_hide();

`co(10,1);/// csr_show`co();   `keyword(source,[UW_CSR.C]~csr_show);
		causes the hardware text cursor to appear at the location it existed
	when csr_hide was called.

Prototype:
	void csr_show(void);

Parameters:
	None.

Usage:
	csr_show();

`co(10,1);/// pl_csr`co();   `keyword(source,[UW_CSR.C]~pl_csr);
		Places the hardware text cursor at the column and row of the "soft"
	cursor position within a window.  This function allows you to track the
	hardware cursor with the window cursor.  The window cursor is simply the
	csr_x and csr_y members of the window structure, and is the place where
	output is directed.  NOTE: To position the soft cursor within a window,
	use the mv_cs macro.

Prototype:
	void pl_csr( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which the hardware text cursor is to be
		placed.

Usage:
	WINDOW *wnp;
	...
	pl_csr( wnp );

`co(4,7);────────────────────────── /// Tab Stop Control ──────────────────────────────`co();

 ┌──────────────────────────────────────────────────────────────────────────┐	
 │        `keyword(wn_init_tabs,/// wn_init_tabs);         `keyword(wn_clear_tabs,/// wn_clear_tabs);         `keyword(wn_set_tab,/// wn_set_tab);             │
 │        `keyword(wn_reset_tab,/// wn_reset_tab);         `keyword(wn_tab_right,/// wn_tab_right);          `keyword(wn_tab_left,/// wn_tab_left);            │
 └──────────────────────────────────────────────────────────────────────────┘
	
    UltraWin supports full tab control.  Functions for setting global tab
	stops, individual tab stops, clearing tab stops, and moving the window
	cursor either left or right by tab are included.	These routines are very
	useful when writing programs that use tabs, such as terminal emulators.

`co(10,1);/// wn_init_tabs`co();   `keyword(source,[UW_TERM.C]~wn_init_tabs);
		Sets the window tab stops to a tab every nth position.  This gives you
	the ability to set tab stops for a window with a single function call.

Prototype:
	void wn_init_tabs( int space, WINDOW *wnp );

Parameters:
`co(11,1);	int space`co();
		A number that indicates the distance of one tab stop to another. For
		example, a value of 10 would set tab stops at every 10th column, accross
		the full width of the window.
`co(11,1);	WINDOW *wnp`co();
		A pointer to the window in which the tabs are to be set.

Usage:
	WINDOW *wnp;
	...
	wn_init_tabs( wnp );

`co(10,1);/// wn_clear_tabs`co();   `keyword(source,[UW_TERM.C]~wn_clear_tabs);
		Clears all tab stops for a window.

Prototype:
	void wn_clear_tabs( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window for which to clear all tabs.

Usage:
	WINDOW *wnp;
	...
	wn_clear_tabs( wnp );

`co(10,1);/// wn_set_tab`co();   `keyword(source,[UW_TERM.C]~wn_set_tab);
		Sets a tab at the current cursor column.

Prototype:
	void wn_set_tab( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window in which the tab is to be set.

Usage:
	WINDOW *wnp;
	...
	wn_set_tab( wnp );

`co(10,1);/// wn_reset_tab`co();   `keyword(source,[UW_TERM.C]~wn_reset_tab);
		Resets the tab at the current cursor column.

Prototype:
	void wn_reset_tab( WINDOW *wnp );

Parameters:
`co(11,1);	WINDOW *wnp`co();
		The window in which the tab is to be reset.

Usage:
	WINDOW *wnp;
	...
	wn_reset_tab( wnp );

`co(10,1);/// wn_tab_right`co();   `keyword(source,[UW_TERM.C]~wn_tab_right);
		Moves from the current cursor column to the next tab stop.

Prototype:
	void wn_tab_right( int cnt, WINDOW *wnp );

Parameters:
`co(11,1);	int cnt`co();
		The number of tabs to move right.
`co(11,1);	WINDOW *wnp`co();
		The window in which to tab right.

Usage:
	WINDOW *wnp;
	...
	wn_tab_right( 3, wnp );

`co(10,1);/// wn_tab_left`co();   `keyword(source,[UW_TERM.C]~wn_tab_left);
		Moves from the current cursor column to the previous tab.

Prototype:
	void wn_tab_left( int cnt, WINDOW *wnp );

Parameters:
`co(11,1);	int cnt`co();
		The number of tabs to move left.
`co(11,1);	WINDOW *wnp`co();
		The window in which to tab left.

Usage:
	WINDOW *wnp;
	...
	wn_tab_left( 3, wnp );


