Class Fl

Fl:display(string displayname): void

Selects a visual so that your graphics are drawn correctly. This does nothing if the default visual satisfies the capabilities, or if no visual satisfies the capabilities, or on systems that don't have such brain-dead notions.

Only the following combinations do anything useful:

Fl:own_colormap(): void

Makes FLTK use its own colormap. This may make FLTK display better and will reduce conflicts with other programs that want lots of colors. However the colors may flash as you move the cursor between windows.

This does nothing if the current visual is not colormapped.

Fl:get_system_colors(): void

Read the user preference colors from the system and use them to call Fl:foreground(), Fl:background(), and Fl:background2(). (This is done by Fl_Window::show(argc,argv) before applying the -fg and -bg switches; most Lua FLTK apps won't use that function.)

Currently this only does something on WIN32. In future versions for X it may read the window manager (KDE, Gnome, etc.) setup as well.

Fl:foreground(integer r, integer g, integer b): void

Normally called with no argument.

Fl:check(): boolean

This does the same thing as Fl:wait(0), except because it does not have to return the elapsed time value it can be implemented faster on certain systems. Use this to interrupt a big calculation:

while (!calculation_done()) {
  calculate();
  Fl::check();
  if (user_hit_abort_button()) break;
}

Fl:ready(): boolean

Returns non-zero if there are pending timeouts or events or file descriptors. This does not call Fl:flush() or any callbacks, which is useful if your program is in a state where such callbacks are illegal:

while (!calculation_done()) {
  calculate();
  if (Fl::ready()) {
    do_expensive_cleanup();
    Fl::check();
    if (user_hit_abort_button()) break;
  }
}

Fl:run(): boolean

Runs FLTK until there are no windows displayed, and then returns nil. Fl:run() is exactly equivalent to this C++ code:

while (Fl::wait());
return 0;

Fl.damage: readonly boolean

(You probably don't want to use this in Lua FLTK.)

This is used when pop-up menu systems are active. Send all events to the passed window no matter where the pointer or focus is (including in other programs). The window does not have to be shown(); this lets the handle() method of a "dummy" window override all event handling and allows you to map and unmap a complex set of windows (under both X and WIN32 some window must be mapped because the system interface needs a window id).

If grab is on it will also affect show() of windows by doing system-specific operations (on X it turns on override-redirect). These are designed to make menus popup reliably and faster on the system.

To turn off grabbing do Fl:grab(nil).

Be careful that your program does not enter an infinite loop while grab() is on. On X this will lock up your screen!

Fl.event_x: readonly integer

Non-zero if the most recent Event.push or Event.keyboard was a "double click". Returns N-1 for N clicks. A double click is counted if the same button is pressed again while event_is_click is true.

You can modify this property; this can be used to set it to zero so that later code does not think an item was double-clicked.

Fl.event_is_click: boolean

This is a bitfield of what shift states were on and what mouse buttons were held down during the most recent event. Names of modifiers are given in Modifier:

• Modifier.shift
• Modifier.caps_lock
• Modifier.ctrl
• Modifier.alt
• Modifier.num_lock
• Modifier.meta
• Modifier.scroll_lock
• Modifier.button1
• Modifier.button2
• Modifier.button3

Fl:event_state_matches(Modifier m): boolean

Contains the last key on the keyboard pressed.

Keys are identified by the unshifted values. FLTK defines a set of symbols that should work on most modern machines for every key on the keyboard:

Fl:event_key_matches(Key k): boolean

True if the given key was held down (or pressed) during the last event. This is constant until the next event is read from the server.

Fl:get_key(Key k): boolean

Returns true if the given key is held down now. Under X this requires a round-trip to the server and is much slower than Fl:event_key_matches(int).

Fl.event_text: readonly string

Returns the ASCII text (in the future this may be UTF-8) produced by the last Event.keyboard or Event.pastem or possibly other event. A zero-length string is returned for any keyboard function keys that do not produce text.

Under X this is the result of calling XLookupString().

Fl.event_length: readonly integer

You may call this function with a Widget instead of coordinates.

Get or set the widget that is below the mouse. This is for highlighting buttons. It is not used to send Event.push or Event.move directly, for several obscure reasons, but those events typically go to this widget. This is also the first widget tried for Event.shortcut events.

If you change the belowmouse widget, the previous one and all parents (that don't contain the new widget) are sent Event.leave events. Changing this does not send Event.enter to this or any widget, because sending Event.enter is supposed to test if the widget wants the mouse (by it returning true from handle()).

Fl.pushed: Widget

Get or set the widget that is being pushed. Event.drag or Event.release (and any more Event.push) events will be sent to this widget.

If you change the pushed widget, the previous one and all parents (that don't contain the new widget) are sent Event.release events. Changing this does not send Event.push to this or any widget, because sending Event.push is supposed to test if the widget wants the mouse (by it returning true from handle()).

Fl.focus: Widget

Get or set the widget that will receive Event.keyboard events.

If you change Fl.focus, the previous widget and all parents (that don't contain the new widget) are sent Event.unfocus events. Changing the focus does not send Event.focus to this or any widget, because sending Event.focus is supposed to test if the widget wants the focus (by it returning true from handle()).

Fl.selection_owner: Widget