memlayer man page on Plan9

Printed from

MEMLAYER(2)							   MEMLAYER(2)

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

       #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)

       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  (
       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


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

                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Plan9

List of man pages available for Plan9

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net