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

FreeBSD Manual Pages


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

       event,  einit, estart, estartfn,	etimer,	eread, emouse, ekbd, ecanread,
       ecanmouse, ecankbd, ereadmouse, eatomouse, eresized, egetrect, edrawge-
       trect,  emenuhit,  emoveto,  esetcursor,	 Event,	Mouse, Menu - graphics

       #include	 <u.h>
       #include	 <libc.h>
       #include	 <draw.h>
       #include	 <event.h>
       #include	 <cursor.h>

       void	 einit(ulong keys)

       ulong	 event(Event *e)

       Mouse	 emouse(void)

       int	 ekbd(void)

       int	 ecanmouse(void)

       int	 ecankbd(void)

       int	 ereadmouse(Mouse *m)

       int	 eatomouse(Mouse *m, char *buf,	int n)

       ulong	 estart(ulong key, int fd, int n)

       ulong	 estartfn(int id, ulong	key, int fd, int n,
		     int (*fn)(Event*, uchar*, int))

       ulong	 etimer(ulong key, int n)

       ulong	 eread(ulong keys, Event *e)

       int	 ecanread(ulong	keys)

       void	 eresized(int new)

       Rectangle egetrect(int but, Mouse *m)

       void	 edrawgetrect(Rectangle	r, int up)

       int	 emenuhit(int but, Mouse *m, Menu *menu)

       int	 emoveto(Point p)

       int	 esetcursor(Cursor *c)

       extern Mouse    *mouse

		 Emouse	= 1,
		 Ekeyboard = 2,

       These routines provide an interface to multiple sources	of  input  for
       unthreaded  programs.  Threaded programs	(see thread(3))	should instead
       use the threaded	mouse and keyboard interface described in mouse(3) and

       Einit  must  be	called first.  If the argument to einit	has the	Emouse
       and Ekeyboard bits set, the mouse and keyboard events will be  enabled;
       in this case, initdraw (see graphics(3))	must have already been called.
       The user	must provide a function	called eresized	to be called  whenever
       the  window in which the	process	is running has been resized; the argu-
       ment new	is a flag specifying whether the program must  call  getwindow
       (see  graphics(3))  to  re-establish a connection to its	window.	 After
       resizing	(and perhaps calling getwindow), the  global  variable	screen
       will be updated to point	to the new window's Image structure.

       As  characters  are  typed  on the keyboard, they are read by the event
       mechanism and put in a queue.  Ekbd returns  the	 next  rune  from  the
       queue,  blocking	until the queue	is non-empty.  The characters are read
       in raw mode, so they are	available as soon as a complete	rune is	typed.

       When the	mouse moves or a mouse button is pressed or  released,	a  new
       mouse  event is queued by the event mechanism.  Emouse returns the next
       mouse event from	the queue, blocking  until  the	 queue	is  non-empty.
       Emouse returns a	Mouse structure:

	      struct Mouse
		    int	  buttons;
		    Point xy;
		    ulong msec;

       Buttons&1  is set when the left mouse button is pressed,	buttons&2 when
       the middle button is pressed, and buttons&4 when	the  right  button  is
       pressed.	 The current mouse position is always returned in xy.  Msec is
       a time stamp in units of	milliseconds.

       Ecankbd and ecanmouse return non-zero when there	are keyboard or	 mouse
       events available	to be read.

       Ereadmouse  reads  the  next  mouse event from the file descriptor con-
       nected to the mouse, converts the textual data into a  Mouse  structure
       by  calling eatomouse with the buffer and count from the	read call, and
       returns the number of bytes read, or -1 for an error.

       Estart can be used to register additional file descriptors to scan  for
       input.  It takes	as arguments the file descriptor to register, the max-
       imum length of an event message on that descriptor, and	a  key	to  be
       used in accessing the event.  The key must be a power of	2 and must not
       conflict	with any previous keys.	 If a zero key is given, a key will be
       allocated  and  returned.  Estartfn is similar to estart, but processes
       the data	received by calling fn before returning	the event to the user.
       The function fn is called with the id of	the event; it should return id
       if the event is to be passed to the user, 0 if it  is  to  be  ignored.
       The variable Event.v can	be used	by fn to attach	an arbitrary data item
       to the returned Event structure.	 Ekeyboard and Emouse are the keyboard
       and mouse event keys.

       Etimer starts a repeating timer with a period of	n milliseconds;	it re-
       turns the timer event key, or zero if it	fails.	Only one timer can  be
       started.	  Extra	 timer events are not queued and the timer channel has
       no associated data.

       Eread waits for the next	event specified	by the mask keys of event keys
       submitted to estart.  It	fills in the appropriate field of the argument
       Event structure,	which looks like:

	      struct Event
		    int	  kbdc;
		    Mouse mouse;
		    int	  n;
		    void  *v;
		    uchar data[EMAXMSG];

       Data is an array	which is large enough to hold a	9P message.  Eread re-
       turns  the key for the event which was chosen.  For example, if a mouse
       event was read, Emouse will be returned.

       Event waits for the next	event of any kind.  The	return is the same  as
       for eread.

       As  described  in  graphics(3),	the  graphics  functions are buffered.
       Event, eread, emouse, and ekbd all cause	a buffer flush unless there is
       an event	of the appropriate type	already	queued.

       Ecanread	 checks	whether	a call to eread(keys) would block, returning 0
       if it would, 1 if it would not.

       Getrect prompts the user	to sweep a rectangle.	It  should  be	called
       with  m	holding	 the  mouse  event that	triggered the egetrect (or, if
       none, a Mouse with buttons set to 7).  It changes to the	sweep  cursor,
       waits  for  the	buttons	 all to	be released, and then waits for	button
       number but to be	pressed, marking the initial corner.  If another  but-
       ton is pressed instead, egetrect	returns	a rectangle with zero for both
       corners,	after waiting for all the buttons to be	released.   Otherwise,
       egetrect	 continually draws the swept rectangle until the button	is re-
       leased again, and returns the swept  rectangle.	 The  mouse  structure
       pointed to by m will contain the	final mouse event.

       Egetrect	uses successive	calls to edrawgetrect to maintain the red rec-
       tangle showing the sweep-in-progress.  The rectangle  to	 be  drawn  is
       specified  by rc	and the	up parameter says whether to draw (1) or erase
       (0) the rectangle.

       Emenuhit	displays a menu	and returns a selected menu item  number.   It
       should  be  called  with	 m  holding the	mouse event that triggered the
       emenuhit; it will call emouse to	update it.  A Menu is a	structure:

	      struct Menu
		    char  **item;
		    char  *(*gen)(int);
		    int	  lasthit;

       If item is nonzero, it should be	a null-terminated array	of the charac-
       ter  strings to be displayed as menu items.  Otherwise, gen should be a
       function	that, given an item number, returns the	character  string  for
       that  item,  or	zero if	the number is past the end of the list.	 Items
       are numbered starting at	zero.  Menuhit waits until  but	 is  released,
       and  then  returns the number of	the selection, or -1 for no selection.
       The m argument is filled	in with	the final mouse	event.

       Emoveto moves the mouse cursor to the position p	on the screen.

       Esetcursor changes the cursor image to that described by	the  Cursor  c
       (see  mouse(3)).	 If c is nil, it restores the image to the default ar-


       rio(1), graphics(3), plumb(3), draw(3)



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

home | help