Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
MEMLAYER(3)		   Library Functions Manual		   MEMLAYER(3)

       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(3) 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(3) and probably have	little use outside of the kernel.

       The  basic function is to extend	the definition of a Memimage (see mem-
       draw(3))	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,  ei-
       ther 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  im-
       age.   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, re-
       gardless	 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(3))
       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(3), memdraw(3),	stringsize(3), window(3), draw(3)



Want to link to this manual page? Use this URL:

home | help