From c78dcd55ec0b09329c509668507922683f90aab4 Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Wed, 28 Nov 2001 20:43:44 +0000 Subject: More doco updates. Enable tooltips by default, and don't enable them when setting the tooltip value, since that will negate any changes a program might make when displaying the file chooser dialog, etc. git-svn-id: file:///fltk/svn/fltk/branches/branch-1.1@1777 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- documentation/functions.html | 863 +------------------------------------------ 1 file changed, 5 insertions(+), 858 deletions(-) (limited to 'documentation/functions.html') diff --git a/documentation/functions.html b/documentation/functions.html index d6ff340e0..a227ff5c7 100644 --- a/documentation/functions.html +++ b/documentation/functions.html @@ -2,9 +2,9 @@

B - Function Reference

-This appendix describes all of the fl_ functions and Fl:: -methods. For a description of the FLTK widgets, see Appendix A. +This appendix describes all of the fl_ functions. For a +description of the FLTK classes, see Appendix +A.

Functions

@@ -235,858 +235,5 @@ subexpressions literally.
  • x all other characters must be matched exactly.
    • -

    Fl:: Methods

    - -

    static void Fl::add_fd(int fd, void (*cb)(int, void -*), void* = 0) -
    static void Fl::add_fd(int fd, int when, void (*cb)(int, void*), -void* = 0)     -
    static void Fl::remove_fd(int)

    - -Add file descriptor fd to listen to. When the fd -becomes ready for reading Fl::wait() will call the callback -and then return. The callback is -passed the fd and the arbitrary void* argument. - -

    The second version takes a when bitfield, with the bits -FL_READ, FL_WRITE, and FL_EXCEPT defined, -to indicate when the callback should be done. - -

    There can only be one callback of each type for a file descriptor. -Fl::remove_fd() gets rid of all the callbacks for a given -file descriptor. - -

    Under UNIX any file descriptor can be monitored (files, -devices, pipes, sockets, etc.) Due to limitations in Microsoft Windows, -WIN32 applications can only monitor sockets. - -

    static void Fl::add_handler(int (*f)(int))

    - -Install a function to parse unrecognized events. If FLTK cannot -figure out what to do with an event, it calls each of these functions -(most recent first) until one of them returns non-zero. If none of -them returns non zero then the event is ignored. Events that cause -this to be called are: - - - -

    static Fl::add_idle(void (*cb)(void*), void*)

    - -Adds a callback function that is called every time by -Fl::wait() and also makes it act as though the timeout is -zero (this makes Fl::wait() return immediately, so if it is -in a loop it is called repeatedly, and thus the idle fucntion is -called repeatedly). The idle function can be used to get background -processing done. - -

    You can have multiple idle callbacks. To remove an idle callback use Fl::remove_idle(). - -

    Fl::wait() and Fl::check() call idle callbacks, -but Fl::ready() does not. - -

    The idle callback can call any FLTK functions, including -Fl::wait(), Fl::check(), and Fl::ready(). -Fltk will not recursively call the idle callback. - -

    static void Fl::add_timeout(float t, void (*cb)(void*),void*v=0)

    - -Add a one-shot timeout callback. The function will be called by -Fl::wait() at t seconds after this function is called. -The optional void* argument is passed to the callback. - -

    static void Fl::repeat_timeout(float t, void (*cb)(void*),void*v=0)

    - -Inside a timeout callback you can call this to add another timeout. -Rather than the time being measured from "now", it is measured from -when the system call elapsed that caused this timeout to be called. This -will result in far more accurate spacing of the timeout callbacks, it -also has slightly less system call overhead. (It will also use all -your machine time if your timeout code and fltk's overhead take more -than t seconds, as the real timeout will be reduced to zero). - -

    It is undefined what this does if called from outside a timeout -callback. - -

    This code will print "TICK" each second on stdout, with a -fair degree of accuracy: - -

    - -

    static void Fl::add_check(void (*cb)(void*),void*v=0)

    - -Fltk will call this callback just before it flushes the display and -waits for events. This is different than an idle callback because it -is only called once, then fltk calls the system and tells it not to -return until an event happens. - -

    This can be used by code that wants to monitor the -application's state, such as to keep a display up to date. The -advantage of using a check callback is that it is called only when no -events are pending. If events are coming in quickly, whole blocks of -them will be processed before this is called once. This can save -significant time and avoid the application falling behind the events. - -

    Sample code: - -

    - -

    static int Fl::arg(int argc, char **argv, int &i)

    - -Consume a single switch from argv, starting at word i. -Returns the number of words eaten (1 or 2, or 0 if it is not -recognized) and adds the same value to i. You can use this -function if you prefer to control the incrementing through the -arguments yourself. - -

    static int Fl::args(int argc, char **argv, int &i, int -(*callback)(int, char**,int &)=0) -
    void Fl::args(int argc, char **argv)

    - -FLTK provides an entirely optional command-line switch parser. -You don't have to call it if you don't like them! Everything it can do -can be done with other calls to FLTK. - -

    To use the switch parser, call Fl::args(...) near the start -of your program. This does not open the display, instead -switches that need the display open are stashed into static variables. -Then you must display your first window by calling -window->show(argc,argv), which will do anything stored in the -static variables. - -

    callback lets you define your own switches. It is called -with the same argc and argv, and with i the -index of each word. The callback should return zero if the switch is -unrecognized, and not change i. It should return non-zero if -the switch is recognized, and add at least 1 to i (it can add -more to consume words after the switch). This function is called -before any other tests, so you can override any FLTK -switch (this is why fltk can use very short switches instead of -the long ones all other toolkits force you to use). - -

    On return i is set to the index of the first non-switch. -This is either: - -

    -The return value is i unless an unrecognized switch is found, -in which case it is zero. If your program takes no arguments other -than switches you should produce an error if the return value is less -than argc. - -

    All switches except -bg2 may be abbreviated one letter and case is ignored: - -

    - -The second form of Fl::args() is useful if your program does -not have command line switches of its own. It parses all the switches, -and if any are not recognized it calls Fl::abort(Fl::help). - -

    static void Fl::background(uchar, uchar, uchar) -

    - -Changes fl_color(FL_GRAY) to the given color, and changes the -gray ramp from 32 to 56 to black to white. These are the colors used -as backgrounds by almost all widgets and used to draw the edges of all -the boxtypes. - -

    static void Fl::background2(uchar, uchar, uchar) -

    - -Changes fl_color(FL_WHITE) and the same colors as -Fl::foreground(). This color is used as a background by -Fl_Input and other text widgets. - -

    static Fl_Widget *Fl::belowmouse() const -
    static void Fl::belowmouse(Fl_Widget *)

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

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

    static int Fl::box_dh(Fl_Boxtype)

    - -Returns the height offset for the given boxtype. - -

    static int Fl::box_dw(Fl_Boxtype)

    - -Returns the width offset for the given boxtype. - -

    static int Fl::box_dx(Fl_Boxtype)

    - -Returns the X offset for the given boxtype. - -

    static int Fl::box_dy(Fl_Boxtype)

    - -Returns the Y offset for the given boxtype. - -

    static int Fl::check()

    - -Same as Fl::wait(0). Calling this during a big calculation -will keep the screen up to date and the interface responsive: - - - -The returns non-zero if any windows are displayed, and 0 if no -windows are displayed (this is likely to change in future versions of -fltk). - -

    static int Fl::damage()

    - -If true then flush() will do something. - -

    static void Fl::display(const char *)

    - -Sets the X display to use for all windows. Actually this just sets -the environment variable $DISPLAY to the passed string, so this only -works before you show() the first window or otherwise open the display, -and does nothing useful under WIN32. - -

    static void Fl::enable_symbols()

    - -Enables the symbol drawing code. - -

    static int Fl::event_button()

    - -Returns which mouse button was pressed. This returns garbage if the -most recent event was not a FL_PUSH or FL_RELEASE -event. - -

    int Fl::event_clicks() -
    void Fl::event_clicks(int)

    - -The first form returns non-zero if the most recent FL_PUSH or -FL_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. - -

    The second form directly sets the number returned by -Fl::event_clicks(). This can be used to set it to zero so that -later code does not think an item was double-clicked. - -

    int Fl::event_inside(const Fl_Widget *) const -
    int Fl::event_inside(int x, int y, int w, int h)

    - -Returns non-zero if the current event_x and event_y -put it inside the widget or inside an arbitrary bounding box. You -should always call this rather than doing your own comparison so you -are consistent about edge effects. - -

    int Fl::event_is_click() -
    void Fl::event_is_click(0)

    - -The first form returns non-zero if the mouse has not moved far enough -and not enough time has passed since the last FL_PUSH or -FL_KEYBOARD event for it to be considered a "drag" rather than a -"click". You can test this on FL_DRAG, FL_RELEASE, -and FL_MOVE events. The second form clears the value returned -by Fl::event_is_click(). Useful to prevent the next -click from being counted as a double-click or to make a popup menu -pick an item with a single click. Don't pass non-zero to this. - -

    int Fl::event_key() -
    int Fl::event_key(int)     -
    int Fl::get_key(int)

    - -Fl::event_key() returns which key on the keyboard was last -pushed. It returns zero if the last event was not a key press or release. - -

    Fl::event_key(int) returns 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(int) 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(int). - -

    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: - -

    - -On X Fl::get_key(FL_Button+n) does not work. - -

    On WIN32 Fl::get_key(FL_KP_Enter) and -Fl::event_key(FL_KP_Enter) do not work. - -

    char *Fl::event_length()

    - -Returns the length of the text in Fl::event_text(). There -will always be a nul at this position in the text. However there may -be a nul before that if the keystroke translates to a nul character or -you paste a nul character. - -

    ulong Fl::event_state() -
    unsigned int Fl::event_state(ulong)

    - -This is a bitfield of what shift states were on and what mouse buttons -were held down during the most recent event. The second version -returns non-zero if any of the passed bits are turned on. The legal -bits are: - - - -X servers do not agree on shift states, and FL_NUM_LOCK, FL_META, and -FL_SCROLL_LOCK may not work. The values were selected to match the -XFree86 server on Linux. In addition there is a bug in the way X works -so that the shift state is not correctly reported until the first event -after the shift key is pressed or released. - -

    char *Fl::event_text()

    - -Returns the ASCII text (in the future this may be UTF-8) produced by -the last FL_KEYBOARD or FL_PASTE or possibly other -event. A zero-length string is returned for any keyboard function keys -that do not produce text. This pointer points at a static buffer and is -only valid until the next event is processed. - -

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

    static int Fl::event_x() -
    static int Fl::event_y()

    - -Returns the mouse position of the event relative to the Fl_Window -it was passed to. - -

    static int Fl::event_x_root() -
    static int Fl::event_y_root()

    - -Returns the mouse position on the screen of the event. To find the -absolute position of an Fl_Window on the screen, use the -difference between event_x_root(),event_y_root() and -event_x(),event_y(). - -

    static Fl_Window *Fl::first_window()

    - -Returns the first top-level window in the list of shown() windows. If -a modal() window is shown this is the top-most modal window, otherwise -it is the most recent window to get an event. - -

    static Fl_Window *Fl::next_window(Fl_Window *)

    - -Returns the next top-level window in the list of shown() windows. You can -use this call to iterate through all the windows that are shown(). - -

    static void Fl::first_window(Fl_Window*)

    - -Sets the window that is returned by first_window. The window is -removed from wherever it is in the list and inserted at the top. This -is not done if Fl::modal() is on or if the window is not shown(). -Because the first window is used to set the "parent" of modal windows, -this is often useful. - -

    static void Fl::flush()

    - -Causes all the windows that need it to be redrawn and graphics forced -out through the pipes. This is what wait() does before -looking for events. - -

    static Fl_Widget *Fl::focus() const -
    static void Fl::focus(Fl_Widget *)

    - -Get or set the widget that will receive FL_KEYBOARD events. - -

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

    static void Fl::foreground(uchar, uchar, uchar)

    - -Changes fl_color(FL_BLACK). Also changes -FL_INACTIVE_COLOR and FL_SELECTION_COLOR to be a ramp -between this and FL_WHITE. - -

    static void Fl::free_color(Fl_Color, int overlay = 0)

    - -Frees the specified color from the colormap, if applicable. If -overlay is non-zero then the color is freed from the overlay -colormap. - -

    static unsigned Fl::get_color(Fl_Color) -
    static void Fl::get_color(Fl_Color, uchar &r, uchar &g, uchar &b)

    - -Returns the color index or RGB value for the given FLTK color index. - -

    static const char *Fl::get_font(int face)

    - -Get the string for this face. This string is different for each -face. Under X this value is passed to XListFonts to get all the sizes -of this face. - -

    static const char *Fl::get_font_name(int -face, int *attributes = 0)

    - -Get a human-readable string describing the family of this face. This -is useful if you are presenting a choice to the user. There is no -guarantee that each face has a different name. The return value points -to a static buffer that is overwritten each call. - -

    The integer pointed to by attributes (if the pointer is not -zero) is set to zero, FL_BOLD or FL_ITALIC or -FL_BOLD | FL_ITALIC. To locate a "family" of fonts, search -forward and back for a set with non-zero attributes, these faces along -with the face with a zero attribute before them constitute a family. - -

    int get_font_sizes(int face, int *&sizep)

    - -Return an array of sizes in sizep. The return value is the -length of this array. The sizes are sorted from smallest to largest -and indicate what sizes can be given to fl_font() that will -be matched exactly (fl_font() will pick the closest size for -other sizes). A zero in the first location of the array indicates a -scalable font, where any size works, although the array may list sizes -that work "better" than others. Warning: the returned array -points at a static buffer that is overwritten each call. Under X this -will open the display. - -

    static void Fl::get_mouse(int &x, int &y)

    - -Return where the mouse is on the screen by doing a round-trip query to -the server. You should use Fl::event_x_root() and -Fl::event_y_root() if possible, but this is necessary if you are -not sure if a mouse event has been processed recently (such as to -position your first window). If the display is not open, this will -open it. - -

    static void Fl::get_system_colors()

    - -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. - -

    On X this reads some common values from the Xdefaults database. -KDE users can set these values by running the "krdb" program, and -newer versions of KDE set this automatically if you check the "apply -style to other X programs" switch in their control panel. - -

    static int Fl::gl_visual(int)

    - -This does the same thing as Fl::visual(int) but also requires OpenGL -drawing to work. This must be done if you want to draw in -normal windows with OpenGL with -gl_start() and gl_end(). It may be useful to -call this so your X windows use the same visual as an Fl_Gl_Window, which -on some servers will reduce colormap flashing. - -

    See Fl_Gl_Window -for a list of additional values for the argument. - -

    static void Fl::grab(Fl_Window*) -
    static Fl_Window* Fl::grab()

    - -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(0). - -

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

    static int Fl::h()

    - -Returns the height of the screen in pixels. - -

    static int Fl::handle(int, Fl_Window *)

    - -Sends the event to a window for processing. Returns non-zero if any -widget uses the event. - -

    static const char *Fl::help

    - -This is the usage string that is displayed if Fl::args() -detects an invalid argument on the command-line. - -

    static Fl_Window *Fl::modal()

    - -Returns the top-most modal() window currently shown. -This is the most recently -shown() window with -modal() true, or NULL if there are no modal() -windows shown(). -The modal() window has its handle() method called -for all events, and no other windows will have handle() -called (grab() overrides this). - -

    static void Fl::own_colormap()

    - -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. - -

    static void Fl::paste(Fl_Widget *receiver)

    - -Set things up so the receiver widget will be called with an -FL_PASTE event some time in the future. The reciever -should be prepared to be called directly by this, or for it to -happen later, or possibly not at all. This allows the -window system to take as long as necessary to retrieve the paste buffer -(or even to screw up completely) without complex and error-prone -synchronization code in FLTK. - -

    static Fl_Widget *Fl::pushed() const -
    static void Fl::pushed(Fl_Widget *)

    - -Get or set the widget that is being pushed. FL_DRAG or -FL_RELEASE (and any more FL_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 FL_RELEASE -events. Changing this does not send FL_PUSH to this -or any widget, because sending FL_PUSH is supposed to test -if the widget wants the mouse (by it returning non-zero from -handle()). - -

    static Fl_Widget *Fl::readqueue()

    - -All Fl_Widgets that don't have a callback defined use a -default callback that puts a pointer to the widget in this queue, and -this method reads the oldest widget out of this queue. - -

    static int Fl::ready()

    - -This is similar to Fl::check() except this does not -call Fl::flush() or any callbacks, which is useful if your -program is in a state where such callbacks are illegal. This returns -true if Fl::check() would do anything (it will continue to -return true until you call Fl::check() or Fl::wait()). - - - -

    static void Fl::redraw()

    - -Redraws all widgets. - -

    static int Fl::has_idle(void (*cb)(void*), void* = 0)

    - -Returns true if the specified idle callback is currently installed. - -

    static void Fl::remove_idle(void (*cb)(void*), void* = 0)

    - -Removes the specified idle callback, if it is installed. - -

    static int Fl::has_timeout(void (*cb)(void*), void* = 0)

    - -Returns true if the timeout exists and has not been called yet. - -

    static void Fl::remove_timeout(void (*cb)(void*), void* = 0)

    - -Removes a timeout callback. It is harmless to remove a timeout -callback that no longer exists. - -

    static int Fl::has_check(void (*cb)(void*), void* = 0)

    - -Returns true if the check exists and has not been called yet. - -

    static void Fl::remove_check(void (*cb)(void*), void* = 0)

    - -Removes a check callback. It is harmless to remove a check -callback that no longer exists. - -

    static Fl::run()

    - -As long as any windows are displayed this calls Fl::wait() -repeatedly. When all the windows are closed it returns zero -(supposedly it would return non-zero on any errors, but fltk calls -exit directly for these). A normal program will end main() -with return Fl::run();. - -

    static void Fl::selection(Fl_Widget *owner, const -char *stuff, int len) -
    static const char* Fl::selection() -
    static int Fl::selection_length()

    - -The first form changes the current selection. The block of text is -copied to an internal buffer by FLTK (be careful if doing this in -response to an FL_PASTE as this may be the same buffer -returned by event_text()). The selection_owner() -widget is set to the passed owner (possibly sending -FL_SELECTIONCLEAR to the previous owner). The second form looks -at the buffer containing the current selection. The contents of this -buffer are undefined if this program does not own the current -selection. - -

    static Fl_Widget *Fl::selection_owner() const -
    static void Fl::selection_owner(Fl_Widget *)

    - -The single-argument selection_owner(x) call can be used to -move the selection to another widget or to set the owner to -NULL, without changing the actual text of the -selection. FL_SELECTIONCLEAR is sent to the previous -selection owner, if any. - -

    Copying the buffer every time the selection is changed is -obviously wasteful, especially for large selections. An interface will -probably be added in a future version to allow the selection to be made -by a callback function. The current interface will be emulated on top -of this. - -

    static void Fl::set_boxtype(Fl_Boxtype, -Fl_Box_Draw_F *, uchar, uchar, uchar, uchar) -
    static void Fl::set_boxtype(Fl_Boxtype, Fl_Boxtype from)

    - -The first form sets the function to call to draw a specific boxtype. - -

    The second form copies the from boxtype. - -

    static void Fl::set_color(Fl_Color, uchar r, -uchar g, uchar b)

    - -Sets an entry in the fl_color index table. You can set it to -any 8-bit RGB color. The color is not allocated until fl_color(i) -is used. - -

    static int Fl::set_font(int face, const char *) -
    static int Fl::set_font(int face, int from)

    - -The first form changes a face. The string pointer is simply stored, -the string is not copied, so the string must be in static memory. - -

    The second form copies one face to another. - -

    int Fl::set_fonts(const char * = 0)

    - -FLTK will open the display, and add every font on the server to the -face table. It will attempt to put "families" of faces together, so -that the normal one is first, followed by bold, italic, and bold -italic. - -

    The optional argument is a string to describe the set of fonts to -add. Passing NULL will select only fonts that have the -ISO8859-1 character set (and are thus usable by normal text). Passing -"-*" will select all fonts with any encoding as long as they have -normal X font names with dashes in them. Passing "*" will list every -font that exists (on X this may produce some strange output). Other -values may be useful but are system dependent. With WIN32 NULL -selects fonts with ISO8859-1 encoding and non-NULL selects -all fonts. - -

    The return value is how many faces are in the table after this is -done. - -

    static void Fl::set_labeltype(Fl_Labeltype, -Fl_Label_Draw_F *, Fl_Label_Measure_F *) -
    static void Fl:set_labeltype(Fl_Labeltype, Fl_Labeltype from)

    - -The first form sets the functions to call to draw and measure a -specific labeltype. - -

    The second form copies the from labeltype. - -

    int Fl::test_shortcut(ulong) const

    - -Test the current event, which must be an FL_KEYBOARD or -FL_SHORTCUT, against a shortcut value (described in -Fl_Button). Returns non-zero if there is a match. Not to -be confused with -Fl_Widget::test_shortcut(). - -

    static int Fl::visual(int)

    - -Selects a visual so that your graphics are drawn correctly. This is -only allowed before you call show() on any windows. 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: - -

    - -This returns true if the system has the capabilities by default or -FLTK suceeded in turing them on. Your program will still work even if -this returns false (it just won't look as good). - -

    static int Fl::w()

    - -Returns the width of the screen in pixels. - -

    static int Fl::wait()

    - -Waits until "something happens" and then returns. Call this -repeatedly to "run" your program. You can also check what happened -each time after this returns, which is quite useful for managing -program state. - -

    What this really does is call all idle callbacks, all elapsed -timeouts, call Fl::flush() to get the screen to update, and -then wait some time (zero if there are idle callbacks, the shortest of -all pending timeouts, or infinity), for any events from the user or -any Fl::add_fd() callbacks. It then handles the events and -calls the callbacks and then returns. - -

    The return value is non-zero if there are any visible windows (this -may change in future versions of fltk). - -

    static double Fl::wait(double time)

    - -Same as Fl::wait() except it waits a maximum of time -seconds. It can return much sooner if something happens. - -

    The return value is positive if an event or fd happens before the -time elapsed. It is zero if nothing happens (on Win32 this will only -return zero if time is zero). It is negative if an error -occurs (this will happen on Unix if a signal happens). - -

    static void (*Fl::warning)(const char *, ...) -
    static void (*Fl::error)(const char *, ...) -
    static void (*Fl::fatal)(const char *, ...)

    - -FLTK will call these to print messages when unexpected conditions -occur. By default they fprintf to stderr, and -Fl::error and Fl::fatal call exit(1). You can -override the behavior by setting the function pointers to your own -routines. - -

    Fl::warning means that there was a recoverable problem, the -display may be messed up but the user can probably keep working (all X -protocol errors call this). Fl::error means there is a -recoverable error, but the display is so messed up it is unlikely the -user can continue (very little calls this now). Fl::fatal must -not return, as FLTK is in an unusable state, however your version may -be able to use longjmp or an exception to continue, as long as -it does not call FLTK again. - - + + -- cgit v1.2.3