|[ << ]||[ >> ]||[Top]||[Contents]||[Index]||[ ? ]|
As indicated above, the main module of the Forms Library communicates
with the objects by calling the associated handling routine with, as
one of the arguments, the particular event for which action must be
taken. In the following we assume that
obj is the object to
which the event is sent.
The following types of events can be sent to an object:
The object has to be (re)drawn. To figure out the actual size of the
object you can use the fields
obj->h. Many Xlib drawing routines require a
window ID, which you can obtain from the object pointer using
FL_ObjWin(obj). Some other aspects might also influence the way
the object has to be drawn. E.g., you might want to draw the object
differently when the mouse is on top of it or when the mouse is
pressed on it. This can be figured out the following way: The field
obj->belowmouse tells you whether the object is below the
mouse. The field
obj->pushed indicates whether the object is
currently being pushed with the mouse. Finally,
indicate whether input focus is directed towards this object. Note
that drawing of the object is the full responsibility of the object
class, including the bounding box and the label, which can be found in
obj->label. The Forms Library provides a large number
of routines to help you draw object. See section Drawing Objects, for more details on drawing objects and an overview
of all available routines.
One important caution about your draw event handling code: none of the
high level routines (
fl_deactivate_form()) etc. can be used. The only
routines allowed to be used are (direct) drawing functions and object
internal book keeping routines. Attribute modifying routines, such as
fl_set_object_color() etc. are not allowed (using them
can lead to infinite recursions). In addition, (re)drawing of other
fl_redraw_object() while handling
FL_DRAW will also not work.
Due to the way double buffering is handled, at the time the
FL_DRAW event is passed to the handling function (and only
FL_ObjWin(obj) might return a pixmap used as the
backbuffer (at least if the object is double buffered). What that
means is that
FL_ObjWin(obj) should not be used when a real
window is needed. For a real window you can change the window's cursor
or query the mouse position within it. You can't do either of these
with the backbuffer pixmap. If there is a need to obtain the real
window ID the following routine can be used:
Window fl_get_real_object_window(FL_OBJECT *)
To summarize: use
FL_ObjWin(obj) when drawing and use
fl_get_real_object_window() for cursor or pointer
routines. This distinction is important only while handling
FL_ObjWin(obj) should be used anywhere
This event typically follows
FL_DRAW and indicates that the
object label needs to be (re)drawn. If the object in question always
draws its label inside the bounding box and this is taken care of by
FL_DRAW, you can ignore this event.
This event is sent when the mouse has entered the bounding box and
might require some action. Note also that the field
obj->belowmouse in the object is being set. If entering an
objects area only changes its appearance, redrawing it normally
suffices. Don't do this directly! Always redraw the object by calling
fl_redraw_object(). It will send an
to the object but also does some other things (like setting window IDs
and taking care of double buffering etc.).
The mouse has left the bounding box. Again, normally a redraw is enough (or nothing at all).
Motion events get sent between
events when the mouse position changes on the object. The mouse
position is given as an argument to the handle routine.
The user has pushed a mouse button on the object. Normally this
requires some actual action. The number of the mouse button pushed is
given in the
key parameter, having one of the following
Left mouse button was pressed.
Middle mouse button was pressed.
Right mouse button was pressed.
Mouse scroll wheel was rotated in up direction.
Mouse scroll wheel was rotated in down direction.
The user has released the mouse button. This event is only sent if a
FL_PUSH event was sent before.
The user has pushed a mouse button twice within a certain time limit
FL_CLICK_TIMEOUT), which by default is 400 msec. This
event is sent after two
FL_DBLCLICK is only generated for objects that have
obj->click timeout fields and it will not be generated
for events from the scroll wheel.
The user has pushed a mouse button three times within a certain time
window. This event is sent after a
FL_RELEASE sequence. Set click
timeout to none-zero to activate
Input got focussed to this object. This type of event and the next two
are only sent to objects for which the field
obj->input is set
to 1 (see below).
Input is no longer focussed on the object.
A key was pressed. The ASCII value (or KeySym if non-ASCII) is passed
to the routine via the
key argument, modifier keys can be
retrieved from the
state member of the XEvent also passed to
the function via
This event only happens between
FL_UNFOCUS events. Not all objects are sent keyboard
events, only those that have non-zero value in field
The user used a keyboard shortcut. The shortcut used is given in the parameter key. See below for more on shortcuts.
FL_STEP event is sent all the time (typically about 20 times
a second but possibly less often because of system delays and other
time-consuming tasks) to objects for which the field
obj->automatic has been set to a non-zero value. The handling
routine receives a synthetic
MotionNotify event as the XEvent.
This can be used to make an object change appearance without user
action. Clock and timer objects use this type of event.
FL_UPDATE event, like the
FL_STEP event, also
gets send about every 50 msec (but less often under high load) to
objects while they are "pushed", i.e., between receiving a
FL_PUSH and a
FL_RELEASE event if their
obj->want_update field is set. Like for the
event the handling routine receives a synthetic
event as the XEvent. This is typically used by objects that have to
perform tasks at regular time intervals while they are "pushed"
(e.g., counters that need to count up or down while the mouse is
pushed on one of its buttons).
FL_ATTRIB event is sent to an object (via calling the
handler function each object type must define for this purpose)
whenever one of it's properties changes, be it its size, position, box
type, border width, colors, label, label color, style or alignment
etc. This can e.g., be used by the object to do preparations for
later drawing of it or check that what got set is reasonable. It
should not use this event to actually draw anything (this is to be
done only when an
FL_DRAW event is received). When the
handler function for events is called all the arguments it gets passed
This event is sent when the object is to be freed. All memory allocated for the object internally must be freed when this event is received.
Events other than the above. These events currently include
ClientMessage, Selection and possibly other window manager events. All
information about the event is contained in
xev parameter and
my may or may not reflect the actual position of
Many of these events might make it necessary that the object has to be
redrawn or partially redrawn. Always do this using the routine
The Forms Library has a mechanism of dealing with keyboard shortcuts. In this way the user can use the keyboard rather than the mouse for particular actions. Obviously, only "active" objects can have shortcuts (i.e., not objects like boxes, texts etc.).
The mechanism works as follows. There is a routine
void fl_set_object_shortcut(FL_OBJECT *obj, const char *str, int showit);
with which one can bind a series of keys to an object. E.g., when
"acE#d^h" the keys
<Ctrl>h are associated with the
object. The precise format is as follows: Any character in the string
is considered as a shortcut, except
stand for combinations with the
(The case of the key following
'^' is not
important, i.e., no distiction is made between e.g.,
"^c", both encode the key combination
<Crl>C as well as
<Crtl>C.) The key
'^' itself can be set as a shortcut
key by using
"^^" in the string defining the shortcut. The key
'#' can be obtained as a shortcut by using th string
"^#". So, e.g.,
<Esc> key can be given as
Another special character not mentioned yet is
indicates function and arrow keys. Use a sequence starting with
'&' and directly followed by a number between 1 and 35 to
represent one of the function keys. For example,
<F2> function key. The four cursors keys (up, down,
right, and left) can be given as
"&D", respectively. The key
'&' itself can be
obtained as a shortcut by prefixing it with
showit tells whether the shortcut letter in the
object label should be underlined if a match exists. Although the
entire object label is searched for matches, only the first
alphanumerical character in the shortcut string is used. E.g., for the
"foobar" the shortcut
"oO" would result in
a match at the first
would not. However,
"#O" would match since for
keys used in combination with
distiction is made between upper and lower case.
To use other special keys not described above as shortcuts, the following routine must be used
void fl_set_object_shortcutkey(FL_OBJECT *obj, unsigned int key);
key is an X KeySym, for example
XK_F1 etc. Note that the function
fl_set_object_shortcutkey() always appends the key
specified to the current shortcuts while
fl_set_object_shortcut() resets the shortcuts. Of course,
special keys can't be underlined.
Now, whenever the user presses one of these keys, an
FL_SHORTCUT event is sent to the object. The key pressed
is passed to the handle routine (in the argument
Combinations with the
<Alt> key are given by adding
FL_ALT_MASK (currently the 25th bit, i.e.,
0x1000000) to the ASCII value of the key. E.g., the key
<Alt>e are passed as
FL_ALT_MASK + 'E'. The object can now take action
accordingly. If you use shortcuts to manipulate class object specific
things, you will need to create a routine to communicate with the
fl_set_NEW_shortcut(), and do your own internal
bookkeeping to track what keys do what and then call
fl_set_object_shortcut() to register the shortcut in the
event dispatching module. The idea is NOT that the user himself calls
fl_set_object_shortcut() but that the class provides a
routine for this that also keeps track of the required internal
bookkeeping. Of course, if there is no internal bookkeeping, a macro
to this effect will suffice. For example
fl_set_button_shortcut() is defined as
The order in which keys are handled is as follows: First for a key it
is tested whether any object in the form has the key as a shortcut. If
yes, the first of those objects gets the shortcut event. Otherwise,
the key is checked to see if it is
it is, the
obj->wantkey field is checked. If the field does not
FL_KEY_TAB bit, input is focussed on the next
input field. Otherwise the key is sent to the current input field.
This means that input objects only get a
<Return> key sent to them if in the
FL_KEY_TAB bit is set. This is e.g., used in
multi-line input fields. If the object wants all cursor keys
<PgUp> etc.), the
obj->wantkey field must
FL_KEY_SPECIAL bit set.
To summarize, the
obj->wantkey field can take on the following
values (or the bit-wise or of them):
The default. The object receives left and right cursor,
<End> keys plus all normal keys (0-255) except
Object receives the
<Return> as well as the
<Down> cursor keys.
The object receives all keys with a KeySym above 255 which aren't
already covered by
function keys etc.)
Object receives all keys.
This way it is possible for a non-input object (i.e., if
obj->input is zero) to obtain special keyboard event by setting
|[ << ]||[ >> ]||[Top]||[Contents]||[Index]||[ ? ]|
This document was generated by Jens Thoms Toerring on January 5, 2014 using texi2html 1.82.