giieventselect(3) [debian man page]
giiEventPoll(3) GGI giiEventPoll(3) NAME
giiEventPoll, giiEventSelect, giiEventsQueued, giiEventRead - Wait for and receive events SYNOPSIS
#include <ggi/gii.h> gii_event_mask giiEventPoll(gii_input_t inp, gii_event_mask mask, struct timeval *t); int giiEventSelect(gii_input_t inp, gii_event_mask *mask, int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); int giiEventsQueued(gii_input_t inp, gii_event_mask mask); int giiEventRead(gii_input_t inp, gii_event *ev, gii_event_mask mask); DESCRIPTION
giiEventPoll waits for specific events to become available on an input. This call somewhat resembles the Unix select(2) call, but only for LibGII events and is more portable. The function returns after an event matching the given event mask is available or after the amount of time specified by t has elapsed, whichever occurs first. If t is NULL, there is no timeout. The timeout value on return is updated to the time that would have been remaining. So make sure to re-setup this value when calling giiEventPoll in a loop. giiEventSelect is the combination of giiEventPoll and select(2) allowing to wait for both LibGII events and arbitrary file descriptors in any of the three states. However, this function is not available if the operating system does not support the select(2) call, not even as a stub. giiEventsQueued returns the number of events matching the specified event mask that are currently queued in the input. giiEventRead blocks for and transfers an event from the given input to the location pointed to by ev. The event with the earliest timestamp that matches the given mask is returned to the application. RETURN VALUE
giiEventPoll returns a mask of available events (constrained by the given mask). It is 0 if no events are available. On error, an nega- tive gii-error(3) code is returned. giiEventSelect returns the same values as select(2). Unlike other LibGGI/LibGII functions, it also uses errno. It will update the timeout regardless of whether or not the system call does so. giiEventsQueued returns the number of events. giiEventRead returns the size of event on success, and 0 on error. EXAMPLES
This is one of the various ways of coding an event-polling loop: for(;;) { tv.tv_sec = 0; tv.tv_usec = 100; /* change to 0 for non-blocking behaviour */ ggiEventPoll(vis, emAll, &tv); n = ggiEventsQueued(vis, emAll); /* Process events in one gulp, when available */ while(n--) { ggiEventRead(vis, &ggievent, emAll); switch(ggievent.any.type) { /* ... */ } } /* Do other stuff */ } Note: This code uses the LibGGI functions and types instead of the LibGII ones, since the former is the more common case. libgii-1.0.x 2006-12-30 giiEventPoll(3)
Check Out this Related Man Page
giiOpen(3) GGI giiOpen(3) NAME
giiOpen, giiJoinInputs, giiSplitInputs, giiClose - Open, join, split and close inputs SYNOPSIS
#include <ggi/gii.h> gii_input_t giiOpen(const char * input, ...); gii_input_t giiJoinInputs(gii_input_t inp, gii_input_t inp2); int giiSplitInputs(gii_input_t inp, gii_input_t *newhand, uint32_t origin, uint32_t flags); int giiClose(gii_input_t inp); DESCRIPTION
giiOpen opens an input. This function is given the name of an input driver to load. Passing NULL here results in an auto-select mechanism, which currently means examining the contents of GII_INPUT. The optional arguments are a NULL-terminated list of pointers, which are used to give additional information to the targets. Currently only the first pointer is specified: void * argptr, a pointer to a library-specific struct. It is used to pass parameters that are not eas- ily transferable in textual form. Parameters which can be represented in text format are usually transfered in the input parameter, in the format: library_name:arguments giiJoinInputs joins two inputs into one. From a programmers' point of view, this closes both inp and inp2 and opens an new input that com- bines both inputs into one. That is, after giiJoinInputs has completed, there is no need to giiClose inp and inp2 any more. When cleaning up, you need to close the returned input instead. See the example for details. However the inputs are not actually closed or reopened internally. That is, you will not get any startup-events or similar the driver generates, though pending events of both old inputs are transferred to the newly created input. giiSplitInputs splits one of the inputs from a group of joined inputs and returns the handle. The parameter origin can be used to choose which input to detach (use GGI_EV_ORIGIN_NONE to match any input.) The detached handle is returned in newhand. Note, though, that if the detached input is the same one given in inp, then the handle returned in newhand will be that of the rest of the joined inputs instead. You can tell whether this happened by checking the return code. Events queued in the joined input for the newly split input are not trans- ferred automatically. You must drain them out yourself. The parameter flags is reserved for future use and should be set to 0. giiClose releases and destroys an open input and its associated internal control structures. This will put back input streams to their default modes, etc. Important: If you want to handle input while also using LibGGI, using LibGII functions such as giiOpen is almost certainly not what you want. Use LibGGI functions such as ggiEventRead(3) with the LibGGI visual instead. RETURN VALUE
giiOpen and giiJoinInputs return the opened or joined input, or NULL for error. The gii_input_t type is opaque to the programmer and can only be used through GII functions. giiClose returns GGI_OK (== 0) on success, otherwise an gii-error(3) code. giiSplitInputs returns 0 for normal success, or 1 if the input which was split off was the same as the one passed in inp (in which case, newhand may contain a handle to a joined set of visuals.) Otherwise, it returns an gii-error(3) code. EXAMPLES
GII input management: gii_input_t inp, inp2, inp3; /* Initialize the GII library. This must be called before any other * GII function. */ if (giiInit() != 0) exit(1); /* Open the nulldevice for testing ... */ if ((inp=giiOpen("input-null",NULL)) == NULL) { giiExit(); exit(1); } /* Open stdin for testing ... */ if ((inp2=giiOpen("input-stdin",NULL)) == NULL) { giiExit(); exit(1); } /* Open evdev for testing ... */ if ((inp3=giiOpen("input-linux-evdev",NULL)) == NULL) { giiExit(); exit(1); } /* Now join them. Note the usage of _i_n_p_=_giiJoin(inp,inp2); * This is the recommended way to do this. */ inp=giiJoinInputs(inp,inp2); /* Note that this mends inp2 into inp. That is you may not call giiClose(inp2) - this happens together with giiClose(inp) ! */ /* Join another */ inp=giiJoinInputs(inp,inp3); /* ... do the real work here ... */ /* Split one of them back out of the join. */ res = ggiSplitInputs(inp, &inp2, GII_EV_ORIGIN_NONE, 0); if (res == 1) { gii_input_t tmp; tmp = imp2; imp2 = imp1; imp1 = tmp; } else if (res < 0) fprintf(stderr, "Failed to split inputs "); /* Close the single input */ giiClose(inp2); /* Close the joined input */ giiClose(inp); /* Now close down LibGII. */ giiExit(); SEE ALSO
giiInit(3) libgii-1.0.x 2006-12-30 giiOpen(3)