GRAPHICS(3G)                                                      GRAPHICS(3G)

       Point, Rectangle, Bitmap, Cursor, xtbinit, bclose, berror, bscreenrect,
       bflush, clipr, cursorswitch, cursorset, rdfontfile, ffree, charwidth,
       getsubfont, mkfont, scrollfwdbut - graphics

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

       void      xtbinit(void (*errfun)(char *), char *class, int *pargc,
       char **argv, char **fallbacks)

       void      bclose(void)

       void      berror(char *msg)

       Rectangle bscreenrect(Rectangle *clipr)

       void      bflush(void)

       int       clipr(Bitmap *b, Rectangle cr)

       void      cursorswitch(Cursor *curs)

       void      cursorset(Point p)

       Font*     rdfontfile(char *name, int ldepth)

       void      ffree(Font *f)

       int       charwidth(Font *f, Rune r)

       Subfont   *getsubfont(char *name)

       Font      *mkfont(Subfont *subfont);

       int       scrollfwdbut(void);

       extern Bitmap    screen

       extern Font      *font

       A Point is a location in a bitmap (see below), such as the screen, and
       is defined as:

              struct Point {
                    int x;
                    int y;
              } Point;

       The coordinate system has x increasing to the right and y increasing

       A Rectangle is a rectangular area in a bitmap.

              struct Rectangle {
                    Point min;      /* upper left */
                    Point max;      /* lower right */
              } Rectangle;

       By definition, min.x <= max.x and min.y <= max.y.  By convention, the
       right (maximum x) and bottom (maximum y) edges are excluded from the
       represented rectangle, so abutting rectangles have no points in common.
       Thus, max contains the coordinates of the first point beyond the

       A Bitmap holds a rectangular image.

              struct Bitmap {
                    Rectangle r;       /* rectangle in data area, local coords */
                    Rectangle clipr;   /* clipping region */
                    int       ldepth;  /* log base 2 of number of bits per pixel */
                    int       id;      /* id as known in the X server */
                    Bitmap*   cache;   /* zero; distinguishes bitmap from layer */
                    int       flag;    /* flag used by X implementation of libg */
              } Bitmap;

       R.min is the location in the bitmap of the upper-leftmost point in the
       image.  There are 2^ldepth contiguous bits for each pixel of the image;
       the bits form a binary number giving the pixel value.  is the clipping
       rectangle; typically it is the same as r except in a window, where it
       is inset by the width of the border.  Graphical operations on the
       Bitmap will be confined to the clipping rectangle.  The subroutine
       Clipr sets the clipping rectangle of b to the intersection of cr and
       b->r.  If cr does not intersect b->r it does nothing.  Clipr returns 1
       if the clipping region was set, 0 if it was not.

       A Font is a set of character images, indexed by runes (see utf(5g)).
       The images are organized into Subfonts, each containing the images for
       a small, contiguous set of runes.  Font and Subfont structures contain
       two related fields: the distance from the top of the highest character
       (actually the top of the bitmap holding all the characters) to the
       baseline, and the distance from the top of the highest character to the
       bottom of the lowest character (and hence, the interline spacing).  The
       width of any particular character in a font is returned by charwidth.
       The width is defined as the amount to add to the horizontal position
       after drawing the character.  Charwidth calls the graphics error
       function if r is zero (NUL) because string (see bitblt(3g)) cannot draw
       a NUL.  The other fields are used internally by the text-drawing
       functions.  See cachechars(3g) for a detailed description.

       Rdfontfile reads the font description in file name and returns a
       pointer that can by used by string (see bitblt(3g)) to draw characters
       from the font.  The ldepth argument specifies how characters will be
       cached; it should usually be the ldepth of the bitmap that will most
       often be the target of string.  [ ldepth is unused in the X
       implementation of libg.]  Ffree frees a font.  The convention for
       naming font files is:


       where size is approximately the height in pixels of the lower case
       letters (without ascenders or descenders).  Range gives some indication
       of which characters will be available: for example ascii, latin1, euro,
       or unicode.  Euro includes most European languages, punctuation marks,
       the International Phonetic Alphabet, etc., but no Oriental languages.
       Unicode includes every character for which images exist on the system.

       A font is selected by notifying the X server of the location of the
       subfonts and then specifying the desired font file.  The directory
       containing the subfonts must be added to the server's font search path
       using the xset command.  For example,

       xset +fp /usr/local/p9snf

       adds the directory /usr/local/p9snf to the font search path.  The
       p9font resource contains the full path name of the desired font file;
       it is usually specified in the .Xdefaults or .xrdb startup file.  For
       example, the entry:

       *p9font: /n/pyxis/usr/local/p9fonts/pelm.unicode.9.font

       selects the 9-point Pellucida Modern unicode font.

       A Cursor is defined:

              typedef struct
              Cursor {
                    Point offset;
                    uchar clr[2*16];
                    uchar set[2*16];
              } Cursor;

       The arrays are arranged in rows, two bytes per row, left to right in
       big-endian order to give 16 rows of 16 bits each.  A cursor is
       displayed on the screen by adding offset to the current mouse position,
       using clr as a mask to zero the pixels where clr is 1, and then setting
       pixels to ones where set is one.

       The function xtbinit should be called before using any graphics
       operations.  The errfun argument is a function that will be called with
       an error message argument when the graphics functions detect an error;
       such an error function should not return.  A zero for the errfun
       argument means use berror, which prints the message and exits.  The
       class argument is the name of the class of X application, or zero to
       use the capitalized version of the program name.  The pargc and argv
       arguments should be a pointer to the main program's argc and argv; any
       standard toolkit options in the argument list will be used to
       initialize the window's options, and after xtbinit returns, those
       options will have been removed from the argument list.  The fallbacks
       argument, when non-null, specifies a list of fallback resources for the
       application.  Xtbinit sets up the global screen to be a bitmap
       describing the area of the screen that the program can use.  Xtbinit
       also initializes the global default font.  By default, xtbinit does not
       install the standard Plan 9 colourmap, see rgbpix(3g).

       Bclose releases the resources allocated by xtbinit and the other
       graphics functions.  It usually isn't necessary, since the resources
       will be released on program exit.  [ Bclose is currently

       The screen.r field is not guaranteed to be always accurate; the
       bscreenrect function returns the current size (see event(3g) to see how
       to get reshape notification).

       The mouse cursor is always displayed.  The initial cursor is an arrow.
       Cursorswitch causes the argument cursor to be displayed instead.  A
       zero argument causes a switch back to the arrow cursor.  Cursorset
       moves the mouse cursor to position p, provided (if in a window) that
       the requesting program is executing in the current window and the mouse
       is within the window boundaries; otherwise cursorset is a no-op.

       The graphics functions described in bitblt(3g) and balloc(3g) are
       implemented by writing commands to the X server; the writes are
       buffered, so the functions may not take effect immediately.  Bflush
       flushes the buffer, doing all pending graphics operations.  Xtbinit
       arranges that bflush will be called on exit, and the following graphics
       functions all cause a flush: balloc, bfree, bscreenrect, cursorset,
       cursorswitch, ecankbd, ecanmouse, ekbd, emouse, event, rdbitmap, and

       Getsubfont attempts to load the font given by name; it returns a
       pointer to a Subfont struct if it succeeds, zero otherwise, see
       font(5g).  The subfont returned by getsubfont may be passed to mkfont
       to generate a Font suitable for use in string.

       Scrollfwdbut returns 3 or 1 depending on which buttons is to be used as
       the forward scrolling button on the mouse.  The default is to return 3.

       LibXg understands all of the core X Toolkit resource names and classes
       as well as:

       p9font (class P9font)
               Specifies the path name of a font file.  If the file does not
               exist or is not a properly formatted font file, the default X11
               font directory is searched for an X11 font of the same name.

       composeMod (class ComposeMod)
               Specifies the modifier key to be used in composing characters.
               The integers 1 to 5 correspond to using modifier keys 1 to 5.
               When this resource is non-zero it is only necessary to press
               the compose modifier once before beginning a compose sequence,
               i.e., it need not be held down for any of the characters in the
               sequence.  A zero for composeMod means use modifier key 1 and
               this key must be held down in conjuction with the first key of
               the sequence.

       scrollForwardR (class ScrollForwardR)
               The value true for this resource reverses the value returned by
               scrollfwdbut, i.e., it returns 3 instead of 1.  This reverses
               the scroll direction selected by clicks of the left or right
               mouse buttons in the scrollbar.

       add(3g), balloc(3g), cachechars(3g), bitblt(3g), event(3g), frame(3g),
       rgbpix(3g), bitmap(5g), font(5g).

       An error function may call errstr(3g) for further diagnostics.