3 Utilities using ncurses
  
  In  this  chapter  we describe the usage of some example applications of the
  ncurses interface provided by the Browse package. They may be of interest by
  themselves,  or  they  may  be  used  as  utility  functions  within  larger
  applications.
  
  
  3.1 ncurses utilities
  
  If  you  call  the  functions NCurses.Alert (3.1-1), NCurses.Select (3.1-2),
  NCurses.GetLineFromUser  (3.1-3),  or  NCurses.Pager  (3.1-4)  from  another
  ncurses  application in visual mode, you should refresh the windows that are
  still   open,   by   calling   NCurses.update_panels   and  NCurses.doupdate
  afterwards, see Section 2.1-3 and 2.1-2. Also, if the cursor shall be hidden
  after  that,  you  should  call curs_set with argument 0, see Section 2.1-1,
  since the cursor is automatically made visible in NCurses.endwin.
  
  3.1-1 NCurses.Alert
  
  > NCurses.Alert( messages, timeout[, attrs] ) ______________________function
  Returns:  the integer corresponding to the character entered, or fail.
  
  In  visual  mode,  Print  (Reference: Print) cannot be used for messages. An
  alternative is given by NCurses.Alert.
  
  Let  messages  be  either  an attribute line or a nonempty list of attribute
  lines, and timeout be a nonnegative integer. NCurses.Alert shows messages in
  a bordered box in the middle of the screen.
  
  If  timeout  is  zero  then  the box is closed after any user input, and the
  integer  corresponding  to  the  entered  key  is  returned. If timeout is a
  positive  number  n,  say,  then the box is closed after n milliseconds, and
  fail is returned.
  
  If  timeout  is  zero  and  mouse  events  are enabled (see NCurses.UseMouse
  (2.2-10)) then the box can be moved inside the window via mouse events.
  
  If  the optional argument attrs is given, it must be an integer representing
  attributes  such  as  the components of NCurses.attrs (see Section 2.1-7) or
  the return value of NCurses.ColorAttr (2.2-1); these attributes are used for
  the border of the box. The default is NCurses.attrs.NORMAL.
  
  ---------------------------  Example  ----------------------------
    gap> NCurses.Alert( "Hello world!", 1000 );
    fail
    gap> NCurses.Alert( [ "Hello world!",
    >      [ "Hello ", NCurses.attrs.BOLD, "bold!" ] ], 1500,
    >      NCurses.ColorAttr( "red", -1 ) + NCurses.attrs.BOLD );
    fail
  ------------------------------------------------------------------
  
  3.1-2 NCurses.Select
  
  > NCurses.Select( poss[, single[, none]] ) _________________________function
  Returns:  Position or list of positions, or false.
  
  This  function  allows  the user to select one or several items from a given
  list.  In  the  simplest  case  poss  is  a  list  of  attribute  lines (see
  NCurses.IsAttributeLine (2.2-3)), each of which should fit on one line. Then
  NCurses.Select  displays  these lines and lets the user browse through them.
  After pressing the Return key the index of the highlighted item is returned.
  Note  that attributes in your lines should be switched on and off separately
  by true/false entries such that the lines can be nicely highlighted.
  
  The  optional argument single must be true (default) or false. In the second
  case,  an  arbitrary  number of items can be marked and the function returns
  the list of their indices.
  
  If  single is true a third argument none can be given. If it is true then it
  is  possible  to  leave the selection without choosing an item, in this case
  false is returned.
  
  More  details  can  be  given to the function by giving a record as argument
  poss. It can have the following components:
  
  items
        The list of attribute lines as described above.
  
  single
        Boolean with the same meaning as the optional argument single.
  
  none
        Boolean with the same meaning as the optional argument none.
  
  size
        The  size of the window like the first two arguments of NCurses.newwin
        (default is [0, 0], as big as possible).
  
  begin
        Top-left  corner  of  the  window  like  the  last  two  arguments  of
        NCurses.newwin (default is [0, 0], top-left of the screen).
  
  attribute
        An   attribute  used  for  the  display  of  the  window  (default  is
        NCurses.attrs.NORMAL).
  
  border
        Set  to  true if the window should be displayed with a border (default
        is false).
  
  header
        An  attribute  line  used  as  header line (the default depends on the
        settings of single and none).
  
  hint
        An  attribute  line  used  as hint in the last line of the window (the
        default depends on the settings of single and none).
  
  ---------------------------  Example  ----------------------------
    gap> index := NCurses.Select(["Apples", "Pears", "Oranges"]);
    gap> index := NCurses.Select(rec(
    >                     items := ["Apples", "Pears", "Oranges"],
    >                     single := false,
    >                     border := true,
    >                     begin := [5, 5],
    >                     size := [8, 60],
    >                     header := "Choose fruits",
    >                     attribute := NCurses.ColorAttr("yellow","red") ) );
  ------------------------------------------------------------------
  
  3.1-3 NCurses.GetLineFromUser
  
  > NCurses.GetLineFromUser( pre ) ___________________________________function
  Returns:  User input as string.
  
  This  function  can be used to get an input string from the user. It opens a
  one  line  window and writes the given string pre into it. Then it waits for
  user  input.  After  hitting  the Return key the typed line is returned as a
  string  to GAP. If the user exits via hitting the Esc key instead of hitting
  the  Return  key, the function returns false. (The Esc key may be recognized
  as input only after a delay of about a second.)
  
  Some simple editing is possible during user input: The Left, Right, Home and
  End  keys,  the  Insert/Replace  keys,  and  the  Backspace/Delete  keys are
  supported.
  
  Instead  of  a  string,  pre can also be a record with the component prefix,
  whose value is the string described above. The following optional components
  of this record are supported.
  
  window
        The  window  with  the input field is created relative to this window,
        the default is 0.
  
  begin
        This  is  a  list with the coordinates of the upper left corner of the
        window  with  the input field, relative to the window described by the
        window  component; the default is [ y-4, 2 ], where y is the height of
        this window.
  
  default
        This  string  appears as result when the window is opened, the default
        is an empty string.
  
  ---------------------------  Example  ----------------------------
    gap> str := NCurses.GetLineFromUser("Your Name: ");;
    gap> Print("Hello ", str, "!\n");
  ------------------------------------------------------------------
  
  3.1-4 NCurses.Pager
  
  > NCurses.Pager( lines[, border[, ly, lx, y, x]] ) _________________function
  
  This  is  a  simple  pager  utility  for  displaying and scrolling text. The
  argument lines can be a list of attribute lines (see NCurses.IsAttributeLine
  (2.2-3))  or  a  string (the lines are separated by newline characters) or a
  record. In case of a record the following components are recognized:
  
  More  details  can  be  given  to the function by using a record as argument
  poss. It can have the following components:
  
  lines
        The list of attribute lines or a string as described above.
  
  start
        Line number to start the display.
  
  size
        The  size  [ly,  lx]  of  the  window  like the first two arguments of
        NCurses.newwin (default is [0, 0], as big as possible).
  
  begin
        Top-left  corner  [y,  x] of the window like the last two arguments of
        NCurses.newwin (default is [0, 0], top-left of the screen).
  
  attribute
        An   attribute  used  for  the  display  of  the  window  (default  is
        NCurses.attrs.NORMAL).
  
  border
        Either  one  of  true/false to show the pager window with or without a
        standard  border.  Or  it  can  be  string  with  eight,  two  or  one
        characters,   giving   characters   to  be  used  for  a  border,  see
        NCurses.WBorder (2.2-9).
  
  hint
        A text for usage info in the last line of the window.
  
  As  an  abbreviation the information from border, size and begin can also be
  specified in optional arguments.
  
  ---------------------------  Example  ----------------------------
    gap> lines := List([1..100],i-> ["line ",NCurses.attrs.BOLD,String(i)]);;
    gap> NCurses.Pager(lines);
  ------------------------------------------------------------------
  
  
  3.1-5 Selection of help matches
  
  After  loading  the  Browse  package  GAP's  help  system  behaves  slightly
  different  when  a request yields several matches. The matches are shown via
  NCurses.Select  (3.1-2)  and one can choose one match for immediate display.
  It is possible to not choose a match and the ?<nr> syntax still works.
  
  If  you  want  the original behavior define NoSelectHelpMatches := false; in
  your GAP session or .gaprc file, see 'Reference: The .gaprc file'.
  
  
  3.2 A Demo Function
  
  3.2-1 NCurses.Demo
  
  > NCurses.Demo( [inputs] ) _________________________________________function
  
  Let  inputs be a list of records, each with the components title (a string),
  inputblocks  (a  list  of strings, each describing some GAP statements), and
  optionally   footer   (a  string)  and  cleanup  (a  string  describing  GAP
  statements). The default is NCurses.DemoDefaults.
  
  NCurses.Demo  lets  the user choose an entry from inputs, via NCurses.Select
  (3.1-2),  and  then  executes  the  GAP statements in the first entry of the
  inputblocks  list  of this entry; these strings, together with the values of
  title  and  footer,  are shown in a window, at the bottom of the screen. The
  effects  of  calls  to  functions using ncurses are shown in the rest of the
  screen.  After  the  execution  of  the  statements  (which may require user
  input),  the user can continue with the next entry of inputblocks, or return
  to  the  inputs  selection  (and  thus  cancel the current inputs entry), or
  return to the execution of the beginning of the current inputs entry. At the
  end  of  the  current  entry  of  inputs,  the  user  returns  to the inputs
  selection.
  
  The  GAP  statements  in  the  cleanup component, if available, are executed
  whenever  the user does not continue; this is needed for deleting panels and
  windows that are defined in the statements of the current entry.
  
  Note that the GAP statements are executed in the global scope, that is, they
  have  the  same  effect  as  if  they  would  be  entered at the GAP prompt.
  Initially,        NCurses.Demo        sets        the        value        of
  BrowseData.defaults.work.windowParameters  to  the  parameters that describe
  the  part  of  the  screen  above  the  window  that  shows  the  inputs; so
  applications  of NCurses.BrowseGeneric (4.3-1) use automatically the maximal
  part  of  the screen as their window. It is recommended to use a screen with
  at least 80 columns and at least 37 rows.