home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / dev / c / curses / curses.doc next >
Text File  |  1994-02-21  |  23KB  |  817 lines
  1.                 AMIGA CURSES PACKAGE
  2.                 ====================
  3.  
  4. Author   : Simon John Raybould    (sie@fulcrum.co.uk)
  5. Mod Date : 14th August 1992
  6.  
  7.  
  8. Version
  9. =======
  10.  
  11. $Id: curses.doc,v 1.4 1993/06/12 20:24:20 sie Exp $
  12.  
  13.  
  14. Modification History
  15. ====================
  16.  
  17. $Log: curses.doc,v $
  18. Revision 1.4  1993/06/12  20:24:20  sie
  19. Minor updates
  20.  
  21. Revision 1.3  92/06/29  22:33:08  sie
  22. Added some more function descriptions.
  23.  
  24. Revision 1.2  92/06/23  22:38:14  sie
  25. Documentation for amiga curses library.
  26.  
  27.  
  28.  
  29. Description
  30. ===========
  31.  
  32. Curses is a screen manipulation package that is used quite extensively
  33. in the UNIX environment.
  34.  
  35. I wrote this because I had several UNIX programs that used curses that
  36. I wanted to port to the Amiga. 
  37.  
  38. Version 2.00 and above now support ANSI sequences to allow curses
  39. applications to be executes through the serial port to a terminal or
  40. over a modem to a terminal or terminal package such as "Term20" or
  41. "jrcomm". To enable this, simply set the environment variable
  42. "cursestype" to "ansi" before running the program. If this variable is
  43. not set, curses will open a custom screen.
  44.  
  45. The default number of colours for the custom screen is now 2 (black
  46. and white). To enable 8 colours, call start_color() before initscr().
  47. has_colors() will return TRUE if start_color() has been called else it
  48. will return FALSE.
  49.  
  50. If you require further documentation to that provided here then I
  51. would recommend:
  52.  
  53. "Programming with curses" by John Strang ISBN 0-937175-02-1
  54. published by O'Reilly & Associates, Inc.
  55.  
  56. This book is very good and very cheap (10 pound in the UK).
  57.  
  58.  
  59. Short descriptions of functions provided
  60. ========================================
  61.  
  62. int initscr(void)
  63.  
  64.     This must be called before any window can be created or
  65.     manipulated. It creates "stdscr" and "curscr". curscr is a copy of
  66.     what curses thinks is currently on the display. Calling
  67.     wrefresh(curscr) will redraw the entire screen and is useful for
  68.     noisy modem lines. This is usually called when the user types ^L
  69.     or sometimes ^R in older programs.
  70.  
  71.     Return value
  72.     ============
  73.     On Success, OK is returned.
  74.     On error, ERR is returned
  75.  
  76.  
  77. int endwin(void)
  78.  
  79.     This should be called before exiting a curses program.
  80.     It frees all memory used and dismantles all structures.
  81.     It closes the custom screen and window used if curses is used in
  82.     non-ANSI mode.
  83.  
  84.     Return value
  85.     ============
  86.     On Success, OK is returned.
  87.     On error, ERR is returned
  88.  
  89.  
  90. int beep(void)
  91.  
  92.     Produces an audible beep from the speaker. This beep is similar in pitch
  93.     and duration to the beep from a terminal when a BEL (^G) character is
  94.     received. If curses is running in ANSI mode, a BEL character will
  95.     be sent to the terminal.
  96.  
  97.     Return value
  98.     ============
  99.     On Success, OK is returned.
  100.     On error, ERR is returned
  101.  
  102.  
  103. int flash(void)
  104.  
  105.     Flashes the display by complementing the background colour. With the
  106.     default black background, this will flash the screen yellow. If
  107.     curses is being used in ANSI mode, a BEL character will be sent to
  108.     the terminal.
  109.  
  110.     Return value
  111.     ============
  112.     On Success, OK is returned.
  113.     On error, ERR is returned
  114.  
  115.  
  116. int baudrate(void)
  117.  
  118.     Returns current baudrate. On the Amiga, it just returns 19200. It is
  119.     used to decide how much to refresh over slow serial lines such as
  120.     modems.
  121.  
  122.     Return value
  123.     ============
  124.     19200 is returned.
  125.  
  126.  
  127. int box(WINDOW *win, char vert, char hor)
  128.  
  129.     Draws a box around the INSIDE edge of the window.
  130.     win   - pointer returned from newwin or subwin, or stdscr even.
  131.     vert  - character to use for the vertical.
  132.     hor   - character to use for the horizontal.
  133.  
  134.     Either of the characters may be zero. In this case, the defaults of
  135.     "|" and "-" will be used for vertical and horizontal respectively.
  136.  
  137.     NOTE
  138.     ----
  139.     The box drawn is INSIDE the window. Therefore any of the clear routines
  140.     will effect the box if carried out on its window. The normal thing
  141.     to do is open two windows, one for the box two columns wider and
  142.     two lines higher than the window for the text. Then use the inner
  143.     window for the text. This way the box is only drawn once.
  144.  
  145.     Return value
  146.     ============
  147.     On Success, OK is returned.
  148.     On error, ERR is returned
  149.  
  150.  
  151. int cbreak(void)
  152. int nocbreak(void)
  153.  
  154.     cbreak() puts the terminal into CBREAK mode, making characters typed
  155.     available immediately.
  156.  
  157.     nocbreak() sets NOCBREAK mode and characters are not available until
  158.     carriage return is pressed.
  159.  
  160.     The default is NOCBREAK mode, so most programs call cbreak() before
  161.     doing any reads on the keyboard for interactive use.
  162.  
  163.     Return value
  164.     ============
  165.     On Success, OK is returned.
  166.     On error, ERR is returned
  167.  
  168.  
  169. int crmode(void)
  170. int nocrmode(void)
  171.  
  172.     As cbreak() and nocbreak() as shown above.
  173.  
  174.     Return value
  175.     ============
  176.     On Success, OK is returned.
  177.     On error, ERR is returned
  178.  
  179.  
  180. int clearok(WINDOW *win, int flag)
  181.  
  182.     If flag is TRUE then it is OK to clear the window on the next refresh.
  183.  
  184.     Return value
  185.     ============
  186.     On Success, OK is returned.
  187.     On error, ERR is returned
  188.  
  189.  
  190. int leaveok(WINDOW *win, int flag)
  191.  
  192.     If flag is TRUE then curses doesn"t care where it leaves the
  193.     cursor. If possible, the cursor will not be displayed.
  194.     The default is FALSE and the cursor is displayed correctly.
  195.  
  196.     Return value
  197.     ============
  198.     On Success, OK is returned.
  199.     On error, ERR is returned
  200.  
  201.  
  202. WINDOW *subwin(WINDOW *orig, int lines, int cols, int beg_line, int beg_col)
  203.  
  204.     Creates a new window within another window. The original window has
  205.     its pointer passed as "orig".
  206.     The new window will be at line "beg_line" and column "beg_col" of the
  207.     window pointed to by "orig". It will be of size "lines" lines of "cols"
  208.     columns.
  209.  
  210.     A sub-window is part of its surrounding window. When the surrounding
  211.     window is refreshed, the sub-window is refreshed as well.
  212.  
  213.     Return value
  214.     ============
  215.     On success, a pointer to a new window is returned.
  216.     On failure, a NULL pointer is returned.
  217.  
  218.  
  219. WINDOW *newwin(int lines, int cols, int beg_line, int beg_col)
  220.  
  221.     Creates a new window at line "beg_line" and column "beg_col",
  222.     "lines" high by "cols" wide.
  223.  
  224.     The new window has its own data structures and does not affect any
  225.     data in other windows. It is only refreshed by a call like
  226.     wrefresh(win) where "win" was returned by this function.
  227.  
  228.     Return value
  229.     ============
  230.     On success, a pointer to a new window is returned.
  231.     On failure, a NULL pointer is returned.
  232.  
  233.  
  234. int delwin(WINDOW *win)
  235.  
  236.     Deletes a window and frees the associated memory. This should be done if
  237.     the window is no longer used.
  238.  
  239.     It is not necessary to free all windows, endwin() will free all windows
  240.     still allocated before returning.
  241.  
  242.     Return value
  243.     ============
  244.     On Success, OK is returned.
  245.     On error, ERR is returned
  246.  
  247.  
  248. int mvwin(WINDOW *win, int new_line, int new_col)
  249.  
  250.     Moves a window to a new position on the screen. This position is relative
  251.     to the top left of the screen and NOT to the start of any surrounding
  252.     window in the case of sub-windows.
  253.  
  254.     Return value
  255.     ============
  256.     On Success, OK is returned.
  257.     On error, ERR is returned
  258.  
  259.  
  260. int nl(void)
  261. int nonl(void)
  262.  
  263.     nl() - Causes newline to newline/carriage return mapping on output and
  264.     return to newline mapping on input.
  265.  
  266.     nonl() - disables this.
  267.     The DEFAULT is that mapping is done (nl).
  268.  
  269.     Return value
  270.     ============
  271.     On Success, OK is returned.
  272.     On error, ERR is returned
  273.  
  274.  
  275. int echo(void)
  276. int noecho(void)
  277.  
  278.     echo() causes characters read from the keyboard to be echoed to the
  279.     display. noecho() prevents the echo, this is useful when reading
  280.     keys that you don"t want echoed to the screen.
  281.     The DEFAULT is that echoing is performed (echo).
  282.  
  283.     Return value
  284.     ============
  285.     On Success, OK is returned.
  286.     On error, ERR is returned
  287.  
  288.  
  289. int nodelay(WINDOW *win, int flag)
  290.  
  291.     nodelay() sets nodelay mode if "flag" is TRUE.  When in nodelay mode,
  292.     getch() will return ERR if there is no input pending.  The DEFAULT is
  293.     nodelay not set and getch() will block, waiting for at least one char
  294.     in CBREAK mode or a line followed by carriage return in non CBREAK
  295.     mode.
  296.  
  297.     Return value
  298.     ============
  299.     On Success, OK is returned.
  300.     On error, ERR is returned
  301.  
  302.  
  303. int has_colors(void)
  304. int start_color(void)
  305. int init_color(int n, int r, int g, int b) 
  306.  
  307.     has_colors() is to check if colours are available on this terminal.
  308.     On the Amiga, it will return TRUE if start_color() has been called
  309.     else it will return FALSE.
  310.  
  311.     start_colour() is to tell the terminal that you wish to use colour. In
  312.     Amiga curses, this MUST be called before initscr() or it will have no
  313.     effect because initscr() sets up the screen and needs to know how many
  314.     colours you want.
  315.  
  316.     init_color() will alter the Red, Green and Blue content of colour n.
  317.     r, g and b are in the range 1 to 1000. The colour number "n" is in the
  318.     range 0 to 15 and it should be noted that colour 0 is the background
  319.     colour. Initially the foreground is set to colour 1 but can be changed
  320.     with the attron() or attrset() function to any of the colours 1 to 15,
  321.     0 is not allowed as this is the background. If 0 is selected, the
  322.     foreground colour will be set to 1.
  323.  
  324.     Return value
  325.     ============
  326.     On Success, OK is returned.
  327.     On error, ERR is returned
  328.  
  329.  
  330. int keypad(WINDOW *win, int flag)
  331.  
  332.     If "flag" is TRUE then the ANSI sequences for the function keys and
  333.     the cursor keys will be converted to the tokens KEY_UP, KEY_HELP,
  334.     e.t.c.  The DEFAULT is that the ANSI sequences will returned.  So to
  335.     cause special keys to be returned as tokens in the standard screen,
  336.     add the following line:
  337.  
  338.         keypad(stdscr, TRUE);
  339.  
  340.     Return value
  341.     ============
  342.     On Success, OK is returned.
  343.     On error, ERR is returned
  344.  
  345.  
  346. int printw(char *fmt, ...)
  347. int wprintw(WINDOW *win, char *fmt, ...)
  348. int mvprintw(int line, int col, char *fmt, ...)
  349. int mvwprintw(WINDOW *win, int line, int col, char *fmt, ...)
  350.  
  351.     Produce formatted output similar to printf(3).
  352.     printw() - prints at the current position in stdscr.
  353.     wprintw() - prints at the current position in win.
  354.     mvprintw() - prints at line "line" column "col" in stdscr.
  355.     mvwprintw() - prints at line "line" column "col" in "win".
  356.  
  357.     Return value
  358.     ============
  359.     On Success, number of formats successfully replaced is returned.
  360.     On error, -1 is returned.
  361.  
  362.  
  363. scanw(char *fmt, ...)
  364. wscanw(WINDOW *win, char *fmt, ...)
  365. mvscanw(int line, int col, char *fmt, ...)
  366. mvwscanw(WINDOW *win, int line, int col, char *fmt, ...)
  367.  
  368.     Produce formatted input similar to scanf(3).
  369.     scanw() - scans at the current position in stdscr.
  370.     wscanw() - scans at the current position in win.
  371.     mvscanw() - scans at line "line" column "col" in stdscr.
  372.     mvwscanw() - scans at line "line" column "col" in "win".
  373.  
  374.     Return value
  375.     ============
  376.     On Success, number of formats successfully replaced is returned.
  377.     On error, -1 is returned.
  378.  
  379.  
  380. int scrollok(WINDOW *win, int flag)
  381.  
  382.     When flag is true, curses will automatically scroll the window up one
  383.     line when output goes off the bottom of "win".
  384.     E.g.
  385.             scrollok(stdscr, TRUE);
  386.     
  387.     "stdscr" will then be automatically scrolled up one line when output goes
  388.     off bottom.
  389.     The DEFAULT is that the window will NOT be scrolled, the bottom line
  390.     will be used over and over again without scrolling.
  391.  
  392.     Return value
  393.     ============
  394.     On Success, OK is returned.
  395.     On error, ERR is returned
  396.  
  397.  
  398. int scroll(WINDOW *win)
  399.  
  400.     The window "win" is scrolled up one line.
  401.  
  402.     Return value
  403.     ============
  404.     On Success, OK is returned.
  405.     On error, ERR is returned
  406.  
  407.  
  408. int setscrreg(int top, int bottom)
  409. int wsetscrreg(WINDOW *win, int top, int bottom)
  410.  
  411.     Sets the scrolling region from line "top" to line "bottom" inclusive.
  412.     Only the region between these two lines is scrolled when scroll() is
  413.     called or when output moves off the end of line "bottom", the region
  414.     is scrolled up one line (if scrollok() has been called).
  415.  
  416.     Return value
  417.     ============
  418.     On Success, OK is returned.
  419.     On error, ERR is returned
  420.  
  421.  
  422. int touchwin(WINDOW *win)
  423.  
  424.     Will force the window to be completely refreshed on the next call to
  425.     refresh() by dumping all optimization information. This can be useful if
  426.     the state of the screen is unknown or if a window was obscured by
  427.     another window which was not a subwindow of the one it covered. Then
  428.     you may need to touchwin() the window that was covered and refresh it.
  429.  
  430.     If you have several windows and wish to redraw the entire display,
  431.     such as when ^L is pressed in many applications, you could touchwin
  432.     all of your windows, clear the screen and refresh each one in turn.
  433.     The recommended way to do this however is to simply wrefresh(curscr).
  434.  
  435.     Return value
  436.     ============
  437.     On Success, OK is returned.
  438.     On error, ERR is returned
  439.  
  440.  
  441. int addch(char c)
  442. int waddch(WINDOW *win, char c)
  443. int mvaddch(int int line, int col, char c)
  444. int mvwaddch(WINDOW *win, int line, int col, char c)
  445.  
  446.     addch(c) - Prints character "c" at current screen position in "stdscr".
  447.  
  448.     waddch(win, c) - Prints character "c" at current screen position in "win".
  449.  
  450.     mvaddch(line, col, c) - Prints character "c" at line "line" column "col" in
  451.             "stdscr".
  452.  
  453.     mvwaddch(win, line, col, c) - Prints character "c" at line "line" column
  454.             "col" in win.
  455.  
  456.     Return value
  457.     ============
  458.     On Success, OK is returned.
  459.     On error, ERR is returned
  460.  
  461.  
  462. int addstr(char *str)
  463. int waddstr(WINDOW *win, char *str)
  464. int mvaddstr(int line, int col, char *str)
  465. int mvwaddstr(WINDOW *win, int line, int col, char *str)
  466.  
  467.     addstr(str) - Prints string "str" at the current screen position in "stdscr".
  468.  
  469.     waddstr(win, str) - Prints string "str" at current screen position in "win".
  470.  
  471.     mvaddstr(line, col, str) - Prints string "str" at line "line" column "col"
  472.             in "stdscr".
  473.  
  474.     mvwaddstr(win, line, col, str) - Prints string "str" at line "line"
  475.               column "col" in window "win".
  476.  
  477.     Return value
  478.     ============
  479.     On Success, OK is returned.
  480.     On error, ERR is returned
  481.  
  482.  
  483. int attrset(UBYTE attrs)
  484. int wattrset(WINDOW *win, UBYTE attrs)
  485.  
  486.     These routines set the attributes for "stdscr" or the specified window
  487.     (in the case of wattrset()) to the value specified in "attrs". This is
  488.     usually used to get the attributes to a known state before using
  489.     attron() and attroff() to add and remove extra attributes
  490.     respectively. The danger is that all previous attributes are lost and
  491.     replaced by the new ones. Consequently they are not really necessary.
  492.  
  493.     See attron() and attroff().
  494.  
  495.     Return value
  496.     ============
  497.     On Success, OK is returned.
  498.     On error, ERR is returned
  499.  
  500.  
  501. int attron(UBYTE attrs)
  502. int wattron(WINDOW *win, UBYTE attrs)
  503.  
  504.     These routines add the attributes specified in "attrs" to those
  505.     already set for "stdscr" or the window specified (in the case of
  506.     wattron()). Any previous attributes that are not directly affected by
  507.     the changes will be left as they were. This is the preferred way to
  508.     set and unset attributes as it has no effect on other attributes.
  509.  
  510.     Return value
  511.     ============
  512.     On Success, OK is returned.
  513.     On error, ERR is returned
  514.  
  515.  
  516. int attroff(UBYTE attrs)
  517. int wattroff(WINDOW *win, UBYTE attrs)
  518.  
  519.     These routines remove the attributes specified in attrs from those set
  520.     for stdscr or the window specified in the case of wattroff().  Any
  521.     previous attributes that are not directly affected by the changes will
  522.     be left as they were.  This is the preferred method of resetting
  523.     attributes rather than calling attrset.
  524.  
  525.     Example:
  526.  
  527.         attron(A_REVERSE)
  528.         addstr("This is in inverse");
  529.         attroff(A_REVERSE);
  530.         refresh();
  531.  
  532.     Return value
  533.     ============
  534.     On Success, OK is returned.
  535.     On error, ERR is returned
  536.  
  537.  
  538. int standout(void)
  539. int wstandout(WINDOW *win)
  540. int standend(void)
  541. int wstandend(WINDOW *win)
  542.  
  543.     These routines set and reset inverse video mode.
  544.  
  545.     Example
  546.     =======
  547.  
  548.     standout();
  549.     addstr("This is inverse video");
  550.     standend();
  551.     addstr("This is normal video");
  552.     refresh();
  553.  
  554.     Return value
  555.     ============
  556.     On Success, OK is returned.
  557.     On error, ERR is returned
  558.  
  559.  
  560. int erase(void)
  561. int werase(WINDOW *win)
  562.  
  563.     These routines will empty the screen buffer and will cause the screen
  564.     to be cleared on the next call to refresh().
  565.  
  566.     Return value
  567.     ============
  568.     On Success, OK is returned.
  569.     On error, ERR is returned
  570.  
  571.  
  572. int clear(void)
  573. int wclear(WINDOW *win)
  574.  
  575.     These routines will empty the screen buffer and will cause the screen
  576.     to be cleared on the next call to refresh(). Similar to erase() except
  577.     that these will call clearok() as well. If possible, a clear sequence
  578.     will be sent to the screen whereas erase() just fills the buffer with
  579.     spaces.
  580.  
  581.     Return value
  582.     ============
  583.     On Success, OK is returned.
  584.     On error, ERR is returned
  585.  
  586.  
  587. int clrtobot(void)
  588. int wclrtobot(WINDOW *win)
  589.  
  590.     On the next call to refresh(), the window will be cleared from the
  591.     current position to bottom righthand corner.
  592.  
  593.     Return value
  594.     ============
  595.     On Success, OK is returned.
  596.     On error, ERR is returned
  597.  
  598.  
  599. int clrtoeol(void)
  600. int wclrtoeol(win)
  601.  
  602.     On the next call to refresh(), the window will be cleared from the
  603.     current position to the end of the line.
  604.  
  605.     Return value
  606.     ============
  607.     On Success, OK is returned.
  608.     On error, ERR is returned
  609.  
  610.  
  611. int delch(void)
  612. int wdelch(WINDOW *win)
  613. int mvdelch(int line, int col)
  614. int mvwdelch(WINDOW *win, int line, int col)
  615.  
  616.     These routines delete the character at the current position, the rest
  617.     of the line to the right of this character is slid along to the left
  618.     to fill the gap. This can be very useful in editors and the like.
  619.  
  620.     Return value
  621.     ============
  622.     On Success, OK is returned.
  623.     On error, ERR is returned
  624.  
  625.  
  626. int getch(void)
  627. int wgetch(WINDOW *win)
  628. int mvgetch(int line, int col)
  629. int mvwgetch(WINDOW *win, int line, int col)
  630.  
  631.     These routines return the next character from the keyboard. If
  632.     cbreak() has been called then they return as soon as there is a
  633.     character to read else they wait for a <CR> before returning. If
  634.     nodelay() has been called then they will return a character if there
  635.     is one or ERR if not.
  636.  
  637.     Return value
  638.     ============
  639.     On Success, the character read is returned.
  640.     On error, ERR is returned
  641.  
  642.  
  643. int getstr(void)
  644. int wgetstr(WINDOW *win)
  645. int mvgetstr(int line, int col)
  646. int mvwgetstr(WINDOW *win, int line, int col)
  647.  
  648.     These routines should be used to read a string in from the keyboard.
  649.     Delete is processed for you.
  650.  
  651.     Return value
  652.     ============
  653.     On Success, OK is returned.
  654.     On error, ERR is returned
  655.  
  656.  
  657. int inch(void)
  658. int winch(WINDOW *win)
  659. int mvinch(int line, int col)
  660. int mvwinch(WINDOW *win, int line, int col)
  661.  
  662.     These routines return the character at the current position in the
  663.     window or stdscr if the window is not required.
  664.     The routines that take a line and column move the cursor to that
  665.     position in the window and then return the char at that position.
  666.  
  667.     Return value
  668.     ============
  669.     On Success, OK is returned.
  670.     On error, ERR is returned
  671.  
  672.  
  673. int insch(void)
  674. int winsch(WINDOW *win)
  675. int mvinsch(int line, int col)
  676. int mvwinsch(WINDOW *win, int line, int col)
  677.  
  678.     These routines insert a character at the current window position, or at
  679.     the specified position in the "mv" cases. The remainder of the line is
  680.     shifted along to the right to make room. The character at the far right
  681.     is lost.
  682.  
  683.     Return value
  684.     ============
  685.     On Success, OK is returned.
  686.     On error, ERR is returned
  687.  
  688.  
  689. int insertln(void)
  690. int winsterln(WINDOW *win)
  691.  
  692.     These routines insert one line at the current window position.
  693.     All of the lines below are shifted down and the bottom line is lost.
  694.  
  695.     Return value
  696.     ============
  697.     On Success, OK is returned.
  698.     On error, ERR is returned
  699.  
  700.  
  701. int deleteln(void)
  702. int wdeleteln(WINDOW *win)
  703.  
  704.     These routines delete one line at the current window position.
  705.     All of the lines below are shifted up into the space and the bottom line
  706.     is left blank.
  707.  
  708.     Return value
  709.     ============
  710.     On Success, OK is returned.
  711.     On error, ERR is returned
  712.  
  713.  
  714. int move(int line, int col)
  715. int wmove(WINDOW *win, int line, int col)
  716.  
  717.     These routines set the current coordinates to "line" and "col". The
  718.     next text added to this window will then go at this position.
  719.  
  720.     Return value
  721.     ============
  722.     On Success, OK is returned.
  723.     On error, ERR is returned
  724.  
  725.  
  726. int refresh(void)
  727. int wrefresh(WINDOW *win)
  728.  
  729.     refresh() will cause all outstanding characters for stdscr to be sent.
  730.     wrefresh() will do the same a refresh but on the window specified.
  731.  
  732.     Return value
  733.     ============
  734.     On Success, OK is returned.
  735.     On error, ERR is returned
  736.  
  737.  
  738. int wnoutrefresh(WINDOW *win)
  739. int doupdate(void)
  740.  
  741.     Will cause "win" to be refreshed when doupdate() is next called.
  742.     You can then wnoutrefresh() several windows and make one call to
  743.     doupdate() to do all the updates at once.
  744.  
  745.     Return value
  746.     ============
  747.     On Success, OK is returned.
  748.     On error, ERR is returned
  749.  
  750.  
  751. int fixterm(void)
  752.  
  753.     This function does nothing on the Amiga, it is provided to allow
  754.     programs that use it to link without trouble.
  755.  
  756.     Return value
  757.     ============
  758.     OK is returned.
  759.  
  760.  
  761. int flushinp(void)
  762.  
  763.     This function empties the keyboard buffer. It will trash all
  764.     characters that have been buffered up.
  765.  
  766.     Return value
  767.     ============
  768.     OK is returned.
  769.  
  770.  
  771. int idlok(WINDOW *WinPtr, int flag)
  772.  
  773.     This fuction enables hardware insert & delete line. This does not
  774.     currently have any effect.
  775.  
  776.     Return value
  777.     ============
  778.     OK is returned.
  779.  
  780.  
  781. int saveterm(void)
  782. int resetterm(void)
  783.  
  784.     saveterm() saves the current terminal settings and resetterm() resets
  785.     the terminal to the state it was in when the last save was done. On
  786.     the Amiga, they have no effect.
  787.  
  788.     Return value
  789.     ============
  790.     OK is returned.
  791.  
  792.  
  793. int savetty(void)
  794. int resetty(void)
  795.  
  796.     savetty() saves the current terminal settings and resettty() resets
  797.     the terminal to the state it was in when the last save was done. On
  798.     the Amiga, they have no effect.
  799.  
  800.     Return value
  801.     ============
  802.     OK is returned.
  803.  
  804.  
  805. int mvcur(int oldline, int oldcol, int newline, int newcol)
  806.  
  807.     This will move the cursor to the position specified by "newline" and
  808.     "newcol". The move is immediate and so refresh() does not need to be
  809.     called, in fact a call to refresh() will cause the cursor to be moved
  810.     after the last char printed during that refresh.
  811.     oldline and oldcol are currently ignored.
  812.  
  813.     Return value
  814.     ============
  815.     On Success, OK is returned.
  816.     On error, ERR is returned
  817.