glenda.party
term% ls -F
term% cat index.txt
MEMLAYER(2)                   System Calls Manual                  MEMLAYER(2)



NAME
       memdraw,  memlalloc,  memldelete,  memlexpose, memlfree, memlhide, mem‐
       line, memlnorefresh, memload,  memunload,  memlorigin,  memlsetrefresh,
       memltofront, memltofrontn, memltorear, memltorearn - windows of memory-
       resident images

SYNOPSIS
       #include <u.h>
       #include <libc.h>
       #include <draw.h>
       #include <memdraw.h>
       #include <memlayer.h>

       typedef struct Memscreen Memscreen;
       typedef struct Memlayer Memlayer;
       typedef void (*Refreshfn)(Memimage*, Rectangle, void*);

       struct Memscreen
       {
           Memimage  *frontmost; /* frontmost layer on screen */
           Memimage  *rearmost;  /* rearmost layer on screen */
           Memimage  *image;     /* upon which all layers are drawn */
           Memimage  *fill;      /* if non-zero, picture to use when repainting */
       };

       struct Memlayer
       {
           Rectangle screenr;    /* true position of layer on screen */
           Point     delta;      /* add delta to go from image coords to screen */
           Memscreen *screen;    /* screen this layer belongs to */
           Memimage  *front;     /* window in front of this one */
           Memimage  *rear;      /* window behind this one*/
           int       clear;      /* layer is fully visible */
           Memimage  *save;      /* save area for obscured parts */
           Refreshfn refreshfn;  /* fn to refresh obscured parts if save==nil */
           void      *refreshptr;/* argument to refreshfn */
       };

       Memimage* memlalloc(Memscreen *s, Rectangle r, Refreshfn fn, void *arg, ulong col)

       void      memlnorefresh(Memimage *i, Rectangle r, void *arg)

       int       memlsetrefresh(Memimage *i, Refreshfn fn, void *arg)

       int       memldelete(Memimage *i)

       int       memlfree(Memimage *i)

       int       memlexpose(Memimage *i, Rectangle r)

       int       memlhide(Memimage *i, Rectangle r)

       void      memltofront(Memimage *i)

       void      memltofrontn(Memimage**ia, int n)

       void      memltorear(Memimage *i)

       void      memltorearn(Memimage **ia , int n)

       int       memlorigin(Memimage *i, Point log, Point phys)

       void      memdraw(Image *dst, Rectangle r,
                    Image *src, Point sp, Image *mask, Point mp, Drawop op)
       int       memload(Memimage *i, Rectangle r,
                 uchar *buf, int n, int iscompressed)

       int       memunload(Memimage *i, Rectangle r,
                 uchar *buf, int n)

DESCRIPTION
       These functions build upon the memdraw(2) interface to  maintain  over‐
       lapping  graphical  windows  on in-memory images.  They are used by the
       kernel to implement the windows interface presented by draw(3) and win‐
       dow(2) and probably have little use outside of the kernel.

       The  basic function is to extend the definition of a Memimage (see mem‐
       draw(2)) to include overlapping windows defined by the  Memlayer  type.
       The  first  fields  of the Memlayer structure are identical to those in
       Memimage, permitting a function that expects a Memimage to be passed  a
       Memlayer,  and vice versa.  Both structures have a save field, which is
       nil in a Memimage and points to `backing store'  in  a  Memlayer.   The
       layer  routines accept Memimages or Memlayers; if the image is a Memim‐
       age the underlying Memimage routine is called; otherwise the layer rou‐
       tines recursively subdivide the geometry, reducing the operation into a
       smaller component that ultimately  can  be  performed  on  a  Memimage,
       either the display on which the window appears, or the backing store.

       Memlayers  are  associated  with a Memscreen that holds the data struc‐
       tures to maintain the windows  and  connects  them  to  the  associated
       image.  The fill color is used to paint the background when a window is
       deleted.  There is no function to establish a Memscreen; to create one,
       allocate  the  memory, zero frontmost and rearmost, set fill to a valid
       fill color or image, and set image to the  Memimage  (or  Memlayer)  on
       which the windows will be displayed.

       Memlalloc allocates a Memlayer of size r on Memscreen s.  If col is not
       DNofill, the new window will be initialized by painting it that color.

       The refresh function fn and associated argument arg will be  called  by
       routines in the library to restore portions of the window uncovered due
       to another window being deleted or this  window  being  pulled  to  the
       front  of  the stack.  The function, when called, receives a pointer to
       the image (window) being refreshed, the rectangle that has been  uncov‐
       ered,  and  the  arg recorded when the window was created.  A couple of
       predefined functions provide built-in management methods: memlnorefresh
       does  no  backup at all, useful for making efficient temporary windows;
       while a nil function specifies that the backing  store  (Memlayer.save)
       will  be  used  to keep the obscured data.  Other functions may be pro‐
       vided by the client.  Memlsetrefresh allows one to change the  function
       associated with the window.

       Memldelete  deletes  the  window  i,  restoring the underlying display.
       Memlfree frees the data structures without unlinking  the  window  from
       the associated Memscreen or doing any graphics.

       Memlexpose  restores  rectangle  r within the window, using the backing
       store or appropriate refresh method.   Memlhide  goes  the  other  way,
       backing up r so that that portion of the screen may be modified without
       losing the data in this window.

       Memltofront pulls i to the front of the stack  of  windows,  making  it
       fully visible.  Memltofrontn pulls the n windows in the array ia to the
       front as a group, leaving their internal order unaffected.   Memltorear
       and memltorearn push the windows to the rear.

       Memlorigin changes the coordinate systems associated with the window i.
       The points log and phys represent the upper left corner  (min)  of  the
       window's  internal  coordinate  system and its physical location on the
       screen.  Changing log changes the interpretation of coordinates  within
       the window; for example, setting it to (0, 0) makes the upper left cor‐
       ner of the window appear to be the origin  of  the  coordinate  system,
       regardless  of  its  position on the screen.  Changing phys changes the
       physical location of the window on the screen.  When a window  is  cre‐
       ated, its logical and physical coordinates are the same, so
                 memlorigin(i, i->r.min, i->r.min)
       would be a no-op.

       Memdraw  and  memline  are implemented in the layer library but provide
       the main entry points for drawing  on  memory-resident  windows.   They
       have  the  signatures of memimagedraw and memimageline (see memdraw(2))
       but accept Memlayer or Memimage arguments both.

       Memload and memunload are similarly layer-savvy versions of  loadmemim‐
       age  and  unloadmemimage.   The  iscompressed flag to memload specifies
       whether the n bytes of data in buf are in compressed image format  (see
       image(6)).

SOURCE
       /sys/src/libmemlayer

SEE ALSO
       graphics(2), memdraw(2), stringsize(2), window(2), draw(3)



                                                                   MEMLAYER(2)