term% ls -F
term% cat index.txt
FRAME(2)                      System Calls Manual                     FRAME(2)

       frinit,   frsetrects,   frclear,   frcharofpt,   frptofchar,  frinsert,
       frdelete, frselect, frselectp, frselectf, frgetmouse - frames of text

       #include <u.h>
       #include <libc.h>
       #include <libg.h>
       #include <frame.h>

       void  frinit(Frame *f, Rectangle r, Font *ft, Bitmap *b);

       void  frsetrects(Frame *f, Rectangle r, Bitmap *b);

       void  frclear(Frame *f);

       ulong frcharofpt(Frame *f, Point pt);

       Point frptofchar(Frame *f, ulong p);

       void  frinsert(Frame *f, Rune *r0, Rune *r1, ulong p);

       int   frdelete(Frame *f, ulong p0, ulong p1);

       void  frselect(Frame *f, Mouse *m);

       void  frselectp(Frame *f, Fcode fc);

       void  frselectf(Frame *f, Point p0, Point p1, Fcode c);

       extern void frgetmouse(void);

       This library supports frames of editable text in a single font on  bit‐
       map  displays, such as in sam(1) and 8½(1).  Frames may hold any char‐
       acter except NUL (0).  Long lines are folded and tabs are at fixed  in‐

       The user-visible data structure, a Frame, is defined in <frame.h>:

              typedef struct Frame Frame;
              struct Frame
                    Font      *font;          /* of chars in the frame */
                    Bitmap    *b;             /* on which frame appears */
                    Rectangle r;              /* in which text appears */
                    Rectangle entire;         /* of full frame */
                    Frbox     *box;
                    ulong     p0, p1;         /* selection */
                    short     left;           /* left edge of text */
                    ushort    nbox, nalloc;
                    ushort    maxtab;         /* max size of tab,in pixels */
                    ushort    nchars;         /* # runes in frame */
                    ushort    nlines;         /* # lines with text */
                    ushort    maxlines;       /* total # lines in frame */
                    ushort    lastlinefull;   /* last line fills frame */
                    ushort    modified;       /* changed since frselect() */

       Frbox  is an internal type and is not used by the interface.  P0 and p1
       may be changed by the application provided the selection  routines  are
       called  afterwards to maintain a consistent display.  Maxtab determines
       the size of tab stops.  Frinit sets it to 8 times  the  width  of  a  0
       (zero)  character  in  the  font;  it may be changed before any text is
       added to the frame.  The other elements of the structure are maintained
       by the library and should not be modified directly.

       The  text within frames is not directly addressable; instead frames are
       designed to work alongside another structure that holds the text.   The
       typical  application  is to display a section of a longer document such
       as a text file or terminal session.  Usually the application will  keep
       its  own copy of the text in the window (probably as an array of Runes)
       and pass components of this text to the frame routines to  display  the
       visible  portion.   Only the text that is visible is held by the Frame;
       the application must check maxlines, nlines, and lastlinefull to deter‐
       mine,  for example, whether new text needs to be appended at the end of
       the Frame after calling frdelete (q.v.).

       There are no routines in the library to allocate  Frames;  instead  the
       interface  assumes that Frames will be components of larger structures.
       Frinit prepares the Frame f so characters drawn in it  will  appear  in
       the  single Font ft.  It then calls frsetrects to initialize the geome‐
       try for the Frame.  The Bitmap b is where the Frame  is  to  be  drawn;
       Rectangle  r  defines  the  limit of the portion of the Bitmap the text
       will occupy.  The Bitmap pointer may be null, allowing the  other  rou‐
       tines  to  be  called to maintain the associated data structure in, for
       example, an obscured window.

       Frclear frees the internal structures associated with f, permitting an‐
       other  frinit  or  frsetrects on the Frame.  If f is to be deallocated,
       the associated Font and Bitmap must be freed separately.

       To reshape a Frame, use frclear and frinit and then frinsert (q.v.)  to
       recreate the display.  If a Frame is being moved but not reshaped, that
       is, if the shape of its containing rectangle is unchanged, it is suffi‐
       cient to bitblt(2) the containing rectangle from the old to the new lo‐
       cation and then call frsetrects to establish the new geometry.  No  re‐
       drawing is necessary.

       Frames  hold text as runes, not as bytes.  Frptofchar returns the loca‐
       tion of the upper left corner of the p'th rune, starting from 0, in the
       Frame  f.   If f holds fewer than p runes, frptofchar returns the loca‐
       tion of the upper right corner of the last character in f.   Frcharofpt
       is  the inverse: it returns the index of the closest rune whose image's
       upper left corner is up and to the left of pt.

       Frinsert inserts into Frame f starting at rune index p  the  runes  be‐
       tween r0 and r1.  If a NUL (0) character is inserted, chaos will ensue.
       Tabs and newlines are handled by the library, but all other characters,
       including   control  characters,  are  just  displayed.   For  example,
       backspaces are printed; to erase a character, use frdelete.

       Frdelete deletes from the Frame the text between p0 and p1;  p1  points
       at the first rune beyond the deletion.

       Frselect  tracks the mouse to select a contiguous string of text in the
       Frame.  When called, a mouse button is typically down.   Frselect  will
       return  when  the  button  state has changed (some buttons may still be
       down) and will set f->p0 and f->p1 to the selected range of text.  Frs‐
       electf  and  frselectp  modify the display of the selected text.  Frse‐
       lectf highlights the text between p0 and p1 (which must have  been  re‐
       turned by frptofchar) using bitblt in mode c.  Frselectp is similar but
       highlights the text from f->p0 to f->p1.  Neither frselectf  nor  frse‐
       lectp modifies f->p0 or f->p1.

       Upon  return  from frinsert or frdelete, the display will be consistent
       but f->p0 and f->p1 may not point to the desired selection.  It may  be
       necessary to adjust the selection and use frselectf or frselectp to fix
       the display.

       Frgetmouse must be provided by the application; frselect  calls  it  to
       get  mouse  updates.   Each  call to frgetmouse should update the Mouse
       structure pointed to by frselect's argument m.  Frgetmouse should block
       until the mouse status has changed.


       graphics(2), bitblt(2), cachechars(2).