event, einit, estart, etimer, eread, emouse, ekbd, ecanread, ecanmouse, ecankbd, ere-
shaped, getrect, menuhit, Event, Mouse, Menu - graphics events
void einit(ulong keys)
ulong event(Event *e)
ulong estart(ulong key, int fd, int n)
ulong etimer(ulong key, int n)
ulong eread(ulong keys, Event *e)
int ecanread(ulong keys)
void ereshaped(Rectangle r)
Rectangle getrect(int but, Mouse *m)
int menuhit(int but, Mouse *m, Menu *menu)
Emouse = 1,
Ekeyboard = 2,
/* Alef only */
/* ... */
(int, Mouse) hit(*Menu, int but, chan(Mouse), Mouse);
These routines provide an interface to multiple sources of input. To use them, einit must
be called. If the argument to einit has the Emouse and Ekeyboard bits set, the mouse and
keyboard events will be enabled; in this case, binit (see graphics(2)) must have already
been called. The user must provide a function called ereshaped to be called whenever the
window in which the process is running has been reshaped; the argument will be the Rectan-
gle for the new window shape, including the border.
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 (see cons(3)), so they are available as soon as a com-
plete rune is typed.
When the mouse moves or a mouse button is depressed or released, a new mouse event is
queued by the event mechanism. Emouse returns the next mouse event from the queue, block-
ing until the queue is non-empty. Emouse returns a Mouse structure:
Buttons&1 is set when the left mouse button is depressed, buttons&2 when the middle button
is depressed, and buttons&4 when the right button is depressed. The current mouse posi-
tion 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
Estart can be used to register additional file descriptors to scan for input. It takes as
arguments the file descriptor to register, the maximum 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, one will be allocated
and returned. Ekeyboard and Emouse are the mouse and keyboard event keys.
Etimer starts a repeating timer with a period of n milliseconds; it returns 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
Data is an array which is large enough to hold a 9P message. Eread returns the key for
the event which was chosen. For example, if a mouse event was read, Emouse will be
Event waits for the next event of any kind. The return is the same as for eread.
As described in graphics(2), 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
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 getrect (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 depressed, marking the initial corner. If another button is
depressed instead, getrect returns a rectangle with zero for both corners, after waiting
for all the buttons to be released. Otherwise, getrect continually draws the swept rec-
tangle until the button is released again, and returns the swept rectangle. The mouse
structure pointed to by m will contain the final mouse event.
Menuhit displays a menu and returns a selected menu item number. It should be called with
m holding the mouse event that triggered the menuhit; it will call emouse to update it. A
Menu is a structure:
If item is nonzero, it should be a null-terminated array of the character 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.
Alef has none of the event software, since the language encourages a different approach
using processes to convert mouse and keyboard activity into messages. In this vein, a
function called hit, analogous to menuhit, exists as a part of the Menu adt; it takes as
argument a chan of type Mouse and a Mouse-valued argument reflecting the current state.
It returns the selection and the new state of the mouse.
81/2(1), graphics(2), cons(3), bit(3)
There should be an official Alef interface to the mouse and keyboard.