Stars of Shareware: Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / windows / c / uw260 / uw_help2.hlp < prev next >

Wrap

Text File | 1994-04-26 | 23.0 KB | 766 lines

`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. UltraWin even has 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 );