59f5b732ae
git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@11715 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
1416 lines
53 KiB
C++
1416 lines
53 KiB
C++
//
|
|
// "$Id$"
|
|
//
|
|
// Main header file for the Fast Light Tool Kit (FLTK).
|
|
//
|
|
// Copyright 1998-2016 by Bill Spitzak and others.
|
|
//
|
|
// This library is free software. Distribution and use rights are outlined in
|
|
// the file "COPYING" which should have been included with this file. If this
|
|
// file is missing or damaged, see the license at:
|
|
//
|
|
// http://www.fltk.org/COPYING.php
|
|
//
|
|
// Please report all bugs and problems on the following page:
|
|
//
|
|
// http://www.fltk.org/str.php
|
|
//
|
|
|
|
/** \file
|
|
Fl static class.
|
|
*/
|
|
|
|
#ifndef Fl_H
|
|
# define Fl_H
|
|
|
|
#include <FL/Fl_Export.H>
|
|
|
|
#ifdef FLTK_HAVE_CAIRO
|
|
# include <FL/Fl_Cairo.H>
|
|
#endif
|
|
|
|
# include "fl_utf8.h"
|
|
# include "Enumerations.H"
|
|
# ifndef Fl_Object
|
|
# define Fl_Object Fl_Widget /**< for back compatibility - use Fl_Widget! */
|
|
# endif
|
|
|
|
# ifdef check
|
|
# undef check
|
|
# endif
|
|
|
|
|
|
class Fl_Widget;
|
|
class Fl_Window;
|
|
class Fl_Image;
|
|
struct Fl_Label;
|
|
|
|
// Keep avoiding having the socket deps at that level but mke sure it will work in both 32 & 64 bit builds
|
|
#if defined(WIN32) && !defined(__CYGWIN__)
|
|
# if defined(_WIN64)
|
|
# define FL_SOCKET unsigned __int64
|
|
# else
|
|
# define FL_SOCKET int
|
|
# endif
|
|
#else
|
|
# define FL_SOCKET int
|
|
#endif
|
|
|
|
|
|
// Pointers you can use to change FLTK to a foreign language.
|
|
// Note: Similar pointers are defined in FL/fl_ask.H and src/fl_ask.cxx
|
|
extern FL_EXPORT const char* fl_local_ctrl;
|
|
extern FL_EXPORT const char* fl_local_meta;
|
|
extern FL_EXPORT const char* fl_local_alt;
|
|
extern FL_EXPORT const char* fl_local_shift;
|
|
|
|
/** \defgroup callback_functions Callback function typedefs
|
|
\brief Typedefs defined in <FL/Fl.H> for callback or handler functions passed as function parameters.
|
|
|
|
FLTK uses callback functions as parameters for some function calls, e.g. to
|
|
set up global event handlers (Fl::add_handler()), to add a timeout handler
|
|
(Fl::add_timeout()), and many more.
|
|
|
|
The typedefs defined in this group describe the function parameters used to set
|
|
up or clear the callback functions and should also be referenced to define the
|
|
callback function to handle such events in the user's code.
|
|
|
|
\see Fl::add_handler(), Fl::add_timeout(), Fl::repeat_timeout(),
|
|
Fl::remove_timeout() and others
|
|
@{ */
|
|
|
|
/** Signature of some label drawing functions passed as parameters */
|
|
typedef void (Fl_Label_Draw_F)(const Fl_Label *label, int x, int y, int w, int h, Fl_Align align);
|
|
|
|
/** Signature of some label measurement functions passed as parameters */
|
|
typedef void (Fl_Label_Measure_F)(const Fl_Label *label, int &width, int &height);
|
|
|
|
/** Signature of some box drawing functions passed as parameters */
|
|
typedef void (Fl_Box_Draw_F)(int x, int y, int w, int h, Fl_Color color);
|
|
|
|
/** Signature of some timeout callback functions passed as parameters */
|
|
typedef void (*Fl_Timeout_Handler)(void *data);
|
|
|
|
/** Signature of some wakeup callback functions passed as parameters */
|
|
typedef void (*Fl_Awake_Handler)(void *data);
|
|
|
|
/** Signature of add_idle callback functions passed as parameters */
|
|
typedef void (*Fl_Idle_Handler)(void *data);
|
|
|
|
/** Signature of set_idle callback functions passed as parameters */
|
|
typedef void (*Fl_Old_Idle_Handler)();
|
|
|
|
/** Signature of add_fd functions passed as parameters */
|
|
typedef void (*Fl_FD_Handler)(FL_SOCKET fd, void *data);
|
|
|
|
/** Signature of add_handler functions passed as parameters */
|
|
typedef int (*Fl_Event_Handler)(int event);
|
|
|
|
/** Signature of add_system_handler functions passed as parameters */
|
|
typedef int (*Fl_System_Handler)(void *event, void *data);
|
|
|
|
/** Signature of set_abort functions passed as parameters */
|
|
typedef void (*Fl_Abort_Handler)(const char *format,...);
|
|
|
|
/** Signature of set_atclose functions passed as parameters */
|
|
typedef void (*Fl_Atclose_Handler)(Fl_Window *window, void *data);
|
|
|
|
/** Signature of args functions passed as parameters */
|
|
typedef int (*Fl_Args_Handler)(int argc, char **argv, int &i);
|
|
|
|
/** Signature of event_dispatch functions passed as parameters.
|
|
\see Fl::event_dispatch(Fl_Event_Dispatch) */
|
|
typedef int (*Fl_Event_Dispatch)(int event, Fl_Window *w);
|
|
|
|
/** Signature of add_clipboard_notify functions passed as parameters */
|
|
typedef void (*Fl_Clipboard_Notify_Handler)(int source, void *data);
|
|
|
|
/** @} */ /* group callback_functions */
|
|
|
|
|
|
/**
|
|
The Fl is the FLTK global (static) class containing
|
|
state information and global methods for the current application.
|
|
*/
|
|
class FL_EXPORT Fl {
|
|
Fl() {}; // no constructor!
|
|
|
|
private:
|
|
static int use_high_res_GL_;
|
|
|
|
public: // should be private!
|
|
#ifndef FL_DOXYGEN
|
|
static int e_number;
|
|
static int e_x;
|
|
static int e_y;
|
|
static int e_x_root;
|
|
static int e_y_root;
|
|
static int e_dx;
|
|
static int e_dy;
|
|
static int e_state;
|
|
static int e_clicks;
|
|
static int e_is_click;
|
|
static int e_keysym;
|
|
static char* e_text;
|
|
static int e_length;
|
|
static void *e_clipboard_data;
|
|
static const char *e_clipboard_type;
|
|
static Fl_Event_Dispatch e_dispatch;
|
|
static Fl_Widget* belowmouse_;
|
|
static Fl_Widget* pushed_;
|
|
static Fl_Widget* focus_;
|
|
static int damage_;
|
|
static Fl_Widget* selection_owner_;
|
|
static Fl_Window* modal_;
|
|
static Fl_Window* grab_;
|
|
static int compose_state; // used for dead keys (WIN32) or marked text (MacOS)
|
|
static void call_screen_init(); // recompute screen number and dimensions
|
|
#ifdef __APPLE__
|
|
static void reset_marked_text(); // resets marked text
|
|
static void insertion_point_location(int x, int y, int height); // sets window coordinates & height of insertion point
|
|
#endif
|
|
#endif // FL_DOXYGEN
|
|
|
|
|
|
/**
|
|
If true then flush() will do something.
|
|
*/
|
|
static void damage(int d) {damage_ = d;}
|
|
|
|
public:
|
|
/** Enumerator for global FLTK options.
|
|
These options can be set system wide, per user, or for the running
|
|
application only.
|
|
\see Fl::option(Fl_Option, bool)
|
|
\see Fl::option(Fl_Option)
|
|
*/
|
|
typedef enum {
|
|
/// When switched on, moving the text cursor beyond the start or end of
|
|
/// a text in a text widget will change focus to the next text widget.
|
|
/// (This is considered 'old' behavior)
|
|
///
|
|
/// When switched off (default), the cursor will stop at the end of the text.
|
|
/// Pressing Tab or Ctrl-Tab will advance the keyboard focus.
|
|
///
|
|
/// See also: Fl_Input_::tab_nav()
|
|
///
|
|
OPTION_ARROW_FOCUS = 0,
|
|
// When switched on, FLTK will use the file chooser dialog that comes
|
|
// with your operating system whenever possible. When switched off, FLTK
|
|
// will present its own file chooser.
|
|
// \todo implement me
|
|
// OPTION_NATIVE_FILECHOOSER,
|
|
// When Filechooser Preview is enabled, the FLTK or native file chooser
|
|
// will show a preview of a selected file (if possible) before the user
|
|
// decides to choose the file.
|
|
// \todo implement me
|
|
//OPTION_FILECHOOSER_PREVIEW,
|
|
/// If visible focus is switched on (default), FLTK will draw a dotted rectangle
|
|
/// inside the widget that will receive the next keystroke. If switched
|
|
/// off, no such indicator will be drawn and keyboard navigation
|
|
/// is disabled.
|
|
OPTION_VISIBLE_FOCUS,
|
|
/// If text drag-and-drop is enabled (default), the user can select and drag text
|
|
/// from any text widget. If disabled, no dragging is possible, however
|
|
/// dropping text from other applications still works.
|
|
OPTION_DND_TEXT,
|
|
/// If tooltips are enabled (default), hovering the mouse over a widget with a
|
|
/// tooltip text will open a little tooltip window until the mouse leaves
|
|
/// the widget. If disabled, no tooltip is shown.
|
|
OPTION_SHOW_TOOLTIPS,
|
|
/// When switched on (default), Fl_Native_File_Chooser runs GTK file dialogs
|
|
/// if the GTK library is available on the platform (linux/unix only).
|
|
/// When switched off, GTK file dialogs aren't used even if the GTK library is available.
|
|
OPTION_FNFC_USES_GTK,
|
|
// don't change this, leave it always as the last element
|
|
/// For internal use only.
|
|
OPTION_LAST
|
|
} Fl_Option;
|
|
|
|
private:
|
|
static unsigned char options_[OPTION_LAST];
|
|
static unsigned char options_read_;
|
|
|
|
public:
|
|
/*
|
|
Return a global setting for all FLTK applications, possibly overridden
|
|
by a setting specifically for this application.
|
|
*/
|
|
static bool option(Fl_Option opt);
|
|
|
|
/*
|
|
Override an option while the application is running.
|
|
*/
|
|
static void option(Fl_Option opt, bool val);
|
|
|
|
/**
|
|
The currently executing idle callback function: DO NOT USE THIS DIRECTLY!
|
|
|
|
This is now used as part of a higher level system allowing multiple
|
|
idle callback functions to be called.
|
|
\see add_idle(), remove_idle()
|
|
*/
|
|
static void (*idle)();
|
|
|
|
#ifndef FL_DOXYGEN
|
|
static Fl_Awake_Handler *awake_ring_;
|
|
static void **awake_data_;
|
|
static int awake_ring_size_;
|
|
static int awake_ring_head_;
|
|
static int awake_ring_tail_;
|
|
static const char* scheme_;
|
|
static Fl_Image* scheme_bg_;
|
|
|
|
static int e_original_keysym; // late addition
|
|
static int scrollbar_size_;
|
|
#endif
|
|
|
|
|
|
static int add_awake_handler_(Fl_Awake_Handler, void*);
|
|
static int get_awake_handler_(Fl_Awake_Handler&, void*&);
|
|
|
|
public:
|
|
|
|
// API version number
|
|
static double version();
|
|
static int api_version();
|
|
|
|
// ABI version number
|
|
static int abi_version();
|
|
|
|
/**
|
|
Returns whether the runtime library ABI version is correct.
|
|
|
|
This enables you to check the ABI version of the linked FLTK
|
|
library at runtime.
|
|
|
|
Returns 1 (true) if the compiled ABI version (in the header files)
|
|
and the linked library ABI version (used at runtime) are the same,
|
|
0 (false) otherwise.
|
|
|
|
Argument \p val can be used to query a particular library ABI version.
|
|
Use for instance 10303 to query if the runtime library is compatible
|
|
with FLTK ABI version 1.3.3. This is rarely useful.
|
|
|
|
The default \p val argument is FL_ABI_VERSION, which checks the version
|
|
defined at configure time (i.e. in the header files at program
|
|
compilation time) against the linked library version used at runtime.
|
|
This is particularly useful if you linked with a shared object library,
|
|
but it also concerns static linking.
|
|
|
|
\see Fl::abi_version()
|
|
*/
|
|
static inline int abi_check(const int val = FL_ABI_VERSION) {
|
|
return val == abi_version();
|
|
}
|
|
|
|
// argument parsers:
|
|
static int arg(int argc, char **argv, int& i);
|
|
static int args(int argc, char **argv, int& i, Fl_Args_Handler cb = 0);
|
|
static void args(int argc, char **argv);
|
|
/**
|
|
Usage string displayed if Fl::args() detects an invalid argument.
|
|
This may be changed to point to customized text at run-time.
|
|
*/
|
|
static const char* const help;
|
|
|
|
// things called by initialization:
|
|
static void display(const char*);
|
|
static int visual(int);
|
|
/**
|
|
This does the same thing as Fl::visual(int) but also requires OpenGL
|
|
drawing to work. This <I>must</I> 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 int gl_visual(int, int *alist=0); // platform dependent
|
|
static void own_colormap();
|
|
static void get_system_colors();
|
|
static void foreground(uchar, uchar, uchar);
|
|
static void background(uchar, uchar, uchar);
|
|
static void background2(uchar, uchar, uchar);
|
|
|
|
// schemes:
|
|
static int scheme(const char *name);
|
|
/** See void scheme(const char *name) */
|
|
static const char* scheme() {return scheme_;}
|
|
|
|
/** Returns whether the current scheme is the given name.
|
|
|
|
This is a fast inline convenience function to support scheme-specific
|
|
code in widgets, e.g. in their draw() methods, if required.
|
|
|
|
Use a valid scheme name, not \p NULL (although \p NULL is allowed,
|
|
this is not a useful argument - see below).
|
|
|
|
If Fl::scheme() has not been set or has been set to the default
|
|
scheme ("none" or "base"), then this will always return 0 regardless
|
|
of the argument, because Fl::scheme() is \p NULL in this case.
|
|
|
|
\note The stored scheme name is always lowercase, and this method will
|
|
do a case-sensitive compare, so you \b must provide a lowercase string to
|
|
return the correct value. This is intentional for performance reasons.
|
|
|
|
Example:
|
|
\code
|
|
if (Fl::is_scheme("gtk+")) { your_code_here(); }
|
|
\endcode
|
|
|
|
\param[in] name \b lowercase string of requested scheme name.
|
|
|
|
\return 1 if the given scheme is active, 0 otherwise.
|
|
|
|
\see Fl::scheme(const char *name)
|
|
*/
|
|
static int is_scheme(const char *name) {
|
|
return (scheme_ && name && !strcmp(name,scheme_));
|
|
}
|
|
/**
|
|
Called by scheme according to scheme name.
|
|
Loads or reloads the current scheme selection.
|
|
See void scheme(const char *name)
|
|
*/
|
|
static int reload_scheme(); // platform dependent
|
|
static int scrollbar_size();
|
|
static void scrollbar_size(int W);
|
|
|
|
// execution:
|
|
static int wait();
|
|
static double wait(double time);
|
|
static int check();
|
|
static int ready();
|
|
static int run();
|
|
static Fl_Widget* readqueue();
|
|
/**
|
|
Adds a one-shot timeout callback. The function will be called by
|
|
Fl::wait() at <i>t</i> seconds after this function is called.
|
|
The optional void* argument is passed to the callback.
|
|
|
|
You can have multiple timeout callbacks. To remove a timeout
|
|
callback use Fl::remove_timeout().
|
|
|
|
If you need more accurate, repeated timeouts, use Fl::repeat_timeout() to
|
|
reschedule the subsequent timeouts.
|
|
|
|
The following code will print "TICK" each second on
|
|
stdout with a fair degree of accuracy:
|
|
|
|
\code
|
|
#include <stdio.h>
|
|
#include <FL/Fl.H>
|
|
#include <FL/Fl_Window.H>
|
|
void callback(void*) {
|
|
printf("TICK\n");
|
|
Fl::repeat_timeout(1.0, callback); // retrigger timeout
|
|
}
|
|
int main() {
|
|
Fl_Window win(100,100);
|
|
win.show();
|
|
Fl::add_timeout(1.0, callback); // set up first timeout
|
|
return Fl::run();
|
|
}
|
|
\endcode
|
|
*/
|
|
static void add_timeout(double t, Fl_Timeout_Handler,void* = 0); // platform dependent
|
|
/**
|
|
Repeats a timeout callback from the expiration of the
|
|
previous timeout, allowing for more accurate timing. You may only call
|
|
this method inside a timeout callback.
|
|
|
|
The following code will print "TICK" each second on
|
|
stdout with a fair degree of accuracy:
|
|
|
|
\code
|
|
void callback(void*) {
|
|
puts("TICK");
|
|
Fl::repeat_timeout(1.0, callback);
|
|
}
|
|
|
|
int main() {
|
|
Fl::add_timeout(1.0, callback);
|
|
return Fl::run();
|
|
}
|
|
\endcode
|
|
*/
|
|
static void repeat_timeout(double t, Fl_Timeout_Handler, void* = 0); // platform dependent
|
|
static int has_timeout(Fl_Timeout_Handler, void* = 0);
|
|
static void remove_timeout(Fl_Timeout_Handler, void* = 0);
|
|
static void add_check(Fl_Timeout_Handler, void* = 0);
|
|
static int has_check(Fl_Timeout_Handler, void* = 0);
|
|
static void remove_check(Fl_Timeout_Handler, void* = 0);
|
|
/**
|
|
Adds 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 <I>all</I> the callbacks for a given
|
|
file descriptor.
|
|
|
|
Under UNIX <I>any</I> file descriptor can be monitored (files,
|
|
devices, pipes, sockets, etc.). Due to limitations in Microsoft Windows,
|
|
WIN32 applications can only monitor sockets.
|
|
*/
|
|
static void add_fd(int fd, int when, Fl_FD_Handler cb, void* = 0); // platform dependent
|
|
/** See void add_fd(int fd, int when, Fl_FD_Handler cb, void* = 0) */
|
|
static void add_fd(int fd, Fl_FD_Handler cb, void* = 0); // platform dependent
|
|
/** Removes a file descriptor handler. */
|
|
static void remove_fd(int, int when); // platform dependent
|
|
/** Removes a file descriptor handler. */
|
|
static void remove_fd(int); // platform dependent
|
|
|
|
static void add_idle(Fl_Idle_Handler cb, void* data = 0);
|
|
static int has_idle(Fl_Idle_Handler cb, void* data = 0);
|
|
static void remove_idle(Fl_Idle_Handler cb, void* data = 0);
|
|
/** If true then flush() will do something. */
|
|
static int damage() {return damage_;}
|
|
static void redraw();
|
|
static void flush();
|
|
/** \addtogroup group_comdlg
|
|
@{ */
|
|
/**
|
|
FLTK calls Fl::warning() to output a warning message.
|
|
|
|
The default version on Windows returns \e without printing a warning
|
|
message, because Windows programs normally don't have stderr (a console
|
|
window) enabled.
|
|
|
|
The default version on all other platforms prints the warning message to stderr.
|
|
|
|
You can override the behavior by setting the function pointer to your
|
|
own routine.
|
|
|
|
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, for example. The default implementation returns after
|
|
displaying the message.
|
|
\note \#include <FL/Fl.H>
|
|
*/
|
|
static void (*warning)(const char*, ...);
|
|
/**
|
|
FLTK calls Fl::error() to output a normal error message.
|
|
|
|
The default version on Windows displays the error message in a MessageBox window.
|
|
|
|
The default version on all other platforms prints the error message to stderr.
|
|
|
|
You can override the behavior by setting the function pointer to your
|
|
own routine.
|
|
|
|
Fl::error() means there is a recoverable error such as the inability to read
|
|
an image file. The default implementation returns after displaying the message.
|
|
\note \#include <FL/Fl.H>
|
|
*/
|
|
static void (*error)(const char*, ...);
|
|
/**
|
|
FLTK calls Fl::fatal() to output a fatal error message.
|
|
|
|
The default version on Windows displays the error message in a MessageBox window.
|
|
|
|
The default version on all other platforms prints the error message to stderr.
|
|
|
|
You can override the behavior by setting the function pointer to your
|
|
own routine.
|
|
|
|
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. The default implementation exits with status 1
|
|
after displaying the message.
|
|
\note \#include <FL/Fl.H>
|
|
*/
|
|
static void (*fatal)(const char*, ...);
|
|
/** @} */
|
|
|
|
/** \defgroup fl_windows Windows handling functions
|
|
\brief Windows and standard dialogs handling declared in <FL/Fl.H>
|
|
@{ */
|
|
static Fl_Window* first_window();
|
|
static void first_window(Fl_Window*);
|
|
static Fl_Window* next_window(const Fl_Window*);
|
|
|
|
/**
|
|
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 Fl_Window* modal() {return modal_;}
|
|
/** Returns the window that currently receives all events.
|
|
|
|
\return The window that currently receives all events,
|
|
or NULL if event grabbing is currently OFF.
|
|
*/
|
|
static Fl_Window* grab() {return grab_;}
|
|
/** Selects the window to 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 <I>does not have
|
|
to be shown()</I> , 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
|
|
<I>some</I> 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).
|
|
|
|
<I>Be careful that your program does not enter an infinite loop
|
|
while grab() is on. On X this will lock up your screen!</I>
|
|
To avoid this potential lockup, all newer operating systems seem to
|
|
limit mouse pointer grabbing to the time during which a mouse button
|
|
is held down. Some OS's may not support grabbing at all.
|
|
*/
|
|
static void grab(Fl_Window*); // platform dependent
|
|
/** @} */
|
|
|
|
/** \defgroup fl_events Events handling functions
|
|
Fl class events handling API declared in <FL/Fl.H>
|
|
@{
|
|
*/
|
|
// event information:
|
|
/**
|
|
Returns the last event that was processed. This can be used
|
|
to determine if a callback is being done in response to a
|
|
keypress, mouse click, etc.
|
|
*/
|
|
static int event() {return e_number;}
|
|
/**
|
|
Returns the mouse position of the event relative to the Fl_Window
|
|
it was passed to.
|
|
*/
|
|
static int event_x() {return e_x;}
|
|
/**
|
|
Returns the mouse position of the event relative to the Fl_Window
|
|
it was passed to.
|
|
*/
|
|
static int event_y() {return e_y;}
|
|
/**
|
|
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 int event_x_root() {return e_x_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 int event_y_root() {return e_y_root;}
|
|
/**
|
|
Returns the current horizontal mouse scrolling associated with the
|
|
FL_MOUSEWHEEL event. Right is positive.
|
|
*/
|
|
static int event_dx() {return e_dx;}
|
|
/**
|
|
Returns the current vertical mouse scrolling associated with the
|
|
FL_MOUSEWHEEL event. Down is positive.
|
|
*/
|
|
static int event_dy() {return e_dy;}
|
|
/**
|
|
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 get_mouse(int &,int &); // platform dependent
|
|
/**
|
|
Returns non zero if we had a double click event.
|
|
\retval Non-zero if the most recent FL_PUSH or FL_KEYBOARD was a "double click".
|
|
\retval N-1 for N clicks.
|
|
A double click is counted if the same button is pressed
|
|
again while event_is_click() is true.
|
|
|
|
*/
|
|
static int event_clicks() {return e_clicks;}
|
|
/**
|
|
Manually 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.
|
|
\param[in] i corresponds to no double-click if 0, i+1 mouse clicks otherwise
|
|
\see int event_clicks()
|
|
*/
|
|
static void event_clicks(int i) {e_clicks = i;}
|
|
/**
|
|
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.
|
|
*/
|
|
static int event_is_click() {return e_is_click;}
|
|
/**
|
|
Clears the value returned by Fl::event_is_click().
|
|
Useful to prevent the <I>next</I>
|
|
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.
|
|
*/
|
|
static void event_is_click(int i) {e_is_click = i;}
|
|
/**
|
|
Gets which particular mouse button caused the current event.
|
|
|
|
This returns garbage if the most recent event was not a FL_PUSH or FL_RELEASE event.
|
|
\retval FL_LEFT_MOUSE \retval FL_MIDDLE_MOUSE \retval FL_RIGHT_MOUSE.
|
|
\see Fl::event_buttons()
|
|
*/
|
|
static int event_button() {return e_keysym-FL_Button;}
|
|
/**
|
|
Returns the keyboard and mouse button states of the last event.
|
|
|
|
This is a bitfield of what shift states were on and what mouse buttons
|
|
were held down during the most recent event.
|
|
|
|
The legal event state bits are:
|
|
|
|
- FL_SHIFT
|
|
- FL_CAPS_LOCK
|
|
- FL_CTRL
|
|
- FL_ALT
|
|
- FL_NUM_LOCK
|
|
- FL_META
|
|
- FL_SCROLL_LOCK
|
|
- FL_BUTTON1
|
|
- FL_BUTTON2
|
|
- FL_BUTTON3
|
|
|
|
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
|
|
<I>after</I> the shift key is pressed or released.
|
|
*/
|
|
static int event_state() {return e_state;}
|
|
|
|
/** Returns non-zero if any of the passed event state bits are turned on.
|
|
|
|
Use \p mask to pass the event states you're interested in.
|
|
The legal event state bits are defined in Fl::event_state().
|
|
*/
|
|
static int event_state(int mask) {return e_state&mask;}
|
|
/**
|
|
Gets which key on the keyboard was last pushed.
|
|
|
|
The returned integer 'key code' is not necessarily a text
|
|
equivalent for the keystroke. For instance: if someone presses '5' on the
|
|
numeric keypad with numlock on, Fl::event_key() may return the 'key code'
|
|
for this key, and NOT the character '5'. To always get the '5', use Fl::event_text() instead.
|
|
|
|
\returns an integer 'key code', or 0 if the last event was not a key press or release.
|
|
\see int event_key(int), event_text(), compose(int&).
|
|
*/
|
|
static int event_key() {return e_keysym;}
|
|
/**
|
|
Returns the keycode of the last key event, regardless of the NumLock state.
|
|
|
|
If NumLock is deactivated, FLTK translates events from the
|
|
numeric keypad into the corresponding arrow key events.
|
|
event_key() returns the translated key code, whereas
|
|
event_original_key() returns the keycode before NumLock translation.
|
|
*/
|
|
static int event_original_key(){return e_original_keysym;}
|
|
/**
|
|
Returns true if the given \p key was held
|
|
down (or pressed) <I>during</I> 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 <I>now</I>.
|
|
Under X this requires a round-trip to the server and is <I>much</I>
|
|
slower than Fl::event_key(int).
|
|
|
|
Keys are identified by the <I>unshifted</I> values. FLTK defines a
|
|
set of symbols that should work on most modern machines for every key
|
|
on the keyboard:
|
|
|
|
\li All keys on the main keyboard producing a printable ASCII
|
|
character use the value of that ASCII character (as though shift,
|
|
ctrl, and caps lock were not on). The space bar is 32.
|
|
\li All keys on the numeric keypad producing a printable ASCII
|
|
character use the value of that ASCII character plus FL_KP.
|
|
The highest possible value is FL_KP_Last so you can
|
|
range-check to see if something is on the keypad.
|
|
\li All numbered function keys use the number on the function key plus
|
|
FL_F. The highest possible number is FL_F_Last, so you
|
|
can range-check a value.
|
|
\li Buttons on the mouse are considered keys, and use the button
|
|
number (where the left button is 1) plus FL_Button.
|
|
\li All other keys on the keypad have a symbol: FL_Escape,
|
|
FL_BackSpace, FL_Tab, FL_Enter, FL_Print, FL_Scroll_Lock, FL_Pause,
|
|
FL_Insert, FL_Home, FL_Page_Up, FL_Delete, FL_End, FL_Page_Down,
|
|
FL_Left, FL_Up, FL_Right, FL_Down, FL_Iso_Key, FL_Shift_L, FL_Shift_R,
|
|
FL_Control_L, FL_Control_R, FL_Caps_Lock, FL_Alt_L, FL_Alt_R,
|
|
FL_Meta_L, FL_Meta_R, FL_Menu, FL_Num_Lock, FL_KP_Enter. Be
|
|
careful not to confuse these with the very similar, but all-caps,
|
|
symbols used by Fl::event_state().
|
|
|
|
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.
|
|
*/
|
|
static int event_key(int key);
|
|
/**
|
|
Returns true if the given \p key is held down <I>now</I>.
|
|
Under X this requires a round-trip to the server and is <I>much</I>
|
|
slower than Fl::event_key(int). \see event_key(int)
|
|
*/
|
|
static int get_key(int key); // platform dependent
|
|
/**
|
|
Returns the text associated with the current event, including FL_PASTE or FL_DND_RELEASE events.
|
|
This can be used in response to FL_KEYUP, FL_KEYDOWN, FL_PASTE, and FL_DND_RELEASE.
|
|
|
|
When responding to FL_KEYUP/FL_KEYDOWN, use this function instead of Fl::event_key()
|
|
to get the text equivalent of keystrokes suitable for inserting into strings
|
|
and text widgets.
|
|
|
|
The returned string is guaranteed to be NULL terminated.
|
|
However, see Fl::event_length() for the actual length of the string,
|
|
in case the string itself contains NULLs that are part of the text data.
|
|
|
|
\returns A NULL terminated text string equivalent of the last keystroke.
|
|
*/
|
|
static const char* event_text() {return e_text;}
|
|
/**
|
|
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.
|
|
*/
|
|
static int event_length() {return e_length;}
|
|
|
|
/** During an FL_PASTE event of non-textual data, returns a pointer to the pasted data.
|
|
The returned data is an Fl_Image * when the result of Fl::event_clipboard_type() is Fl::clipboard_image.
|
|
*/
|
|
static void *event_clipboard() { return e_clipboard_data; }
|
|
/** Returns the type of the pasted data during an FL_PASTE event.
|
|
This type can be Fl::clipboard_plain_text or Fl::clipboard_image.
|
|
*/
|
|
static const char *event_clipboard_type() {return e_clipboard_type; }
|
|
|
|
|
|
static int compose(int &del);
|
|
static void compose_reset();
|
|
static int event_inside(int,int,int,int);
|
|
static int event_inside(const Fl_Widget*);
|
|
static int test_shortcut(Fl_Shortcut);
|
|
|
|
/**
|
|
Enables the system input methods facilities. This is the default.
|
|
\see disable_im()
|
|
*/
|
|
static void enable_im();
|
|
/**
|
|
Disables the system input methods facilities.
|
|
\see enable_im()
|
|
*/
|
|
static void disable_im();
|
|
|
|
// event destinations:
|
|
static int handle(int, Fl_Window*);
|
|
static int handle_(int, Fl_Window*);
|
|
/** Gets the widget that is below the mouse.
|
|
\see belowmouse(Fl_Widget*) */
|
|
static Fl_Widget* belowmouse() {return belowmouse_;}
|
|
static void belowmouse(Fl_Widget*);
|
|
/** Gets the widget that is being pushed.
|
|
\see void pushed(Fl_Widget*) */
|
|
static Fl_Widget* pushed() {return pushed_;}
|
|
static void pushed(Fl_Widget*);
|
|
/** Gets the current Fl::focus() widget. \sa Fl::focus(Fl_Widget*) */
|
|
static Fl_Widget* focus() {return focus_;}
|
|
static void focus(Fl_Widget*);
|
|
static void add_handler(Fl_Event_Handler h);
|
|
static void remove_handler(Fl_Event_Handler h);
|
|
static void add_system_handler(Fl_System_Handler h, void *data);
|
|
static void remove_system_handler(Fl_System_Handler h);
|
|
static void event_dispatch(Fl_Event_Dispatch d);
|
|
static Fl_Event_Dispatch event_dispatch();
|
|
/** @} */
|
|
|
|
/** \defgroup fl_clipboard Selection & Clipboard functions
|
|
FLTK global copy/cut/paste functions declared in <FL/Fl.H>
|
|
@{ */
|
|
// cut/paste:
|
|
/**
|
|
Copies the data pointed to by \p stuff to the selection buffer
|
|
(\p destination is 0), the clipboard (\p destination is 1), or
|
|
both (\p destination is 2). Copying to both is only relevant on X11,
|
|
on other platforms it maps to the clipboard (1).
|
|
\p len is the number of relevant bytes in \p stuff.
|
|
\p type is always Fl::clipboard_plain_text.
|
|
The selection buffer is used for
|
|
middle-mouse pastes and for drag-and-drop selections. The
|
|
clipboard is used for traditional copy/cut/paste operations.
|
|
|
|
\note This function is, at present, intended only to copy UTF-8 encoded textual data.
|
|
To copy graphical data, use the Fl_Copy_Surface class. The \p type argument may allow
|
|
in the future to copy other kinds of data.
|
|
*/
|
|
#if FLTK_ABI_VERSION >= 10303 || defined(FL_DOXYGEN)
|
|
static void copy(const char* stuff, int len, int destination = 0, const char *type = Fl::clipboard_plain_text); // platform dependent
|
|
#else
|
|
static void copy(const char* stuff, int len, int destination, const char *type);
|
|
static void copy(const char* stuff, int len, int destination = 0);
|
|
#endif
|
|
|
|
#if !(defined(__APPLE__) || defined(WIN32) || defined(FL_DOXYGEN))
|
|
static void copy_image(const unsigned char* data, int W, int H, int destination = 0); // platform dependent
|
|
#endif
|
|
/**
|
|
Pastes the data from the selection buffer (\p source is 0) or the clipboard
|
|
(\p source is 1) into \p receiver. If \p source is 1,
|
|
the optional \p type argument indicates what type of data is requested from the clipboard
|
|
(at present, Fl::clipboard_plain_text - requesting text data - and
|
|
Fl::clipboard_image - requesting image data - are possible).
|
|
Set things up so the handle function of the \p receiver widget will be called with an FL_PASTE event some
|
|
time in the future if the clipboard does contain data of the requested type. During processing of this event,
|
|
and if \p type is Fl::clipboard_plain_text, the text data from the specified \p source are in Fl::event_text()
|
|
with UTF-8 encoding, and the number of bytes in Fl::event_length();
|
|
if \p type is Fl::clipboard_image, the pointer returned by Fl::event_clipboard() can be safely cast to
|
|
type Fl_Image * to obtain a pointer to the pasted image.
|
|
|
|
The receiver should be prepared to be called \e directly by this, or for
|
|
it to happen \e later, or possibly <i>not at all</i>. 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.
|
|
|
|
If an image is being pasted, and if the handle function of \p receiver returns 1,
|
|
\p receiver gets the ownership of the image which should be deleted after use. Conversely,
|
|
if it returns 0, the image cannot be used. Starting with FLTK 1.3.4, the image is
|
|
of type Fl_RGB_Image across all platforms.
|
|
|
|
The selection buffer (\p source is 0) is used for middle-mouse pastes and for
|
|
drag-and-drop selections. The clipboard (\p source is 1) is used for
|
|
copy/cut/paste operations.
|
|
|
|
\par Platform details for image data:
|
|
\li Unix/Linux platform: Image data in PNG or BMP formats are recognized. Requires linking with the fltk_images library.
|
|
\li MSWindows platform: Both bitmap and vectorial (Enhanced metafile) data from clipboard
|
|
can be pasted as image data.
|
|
\li Mac OS X platform: Both bitmap (TIFF) and vectorial (PDF) data from clipboard
|
|
can be pasted as image data.
|
|
*/
|
|
#if FLTK_ABI_VERSION >= 10303 || defined(FL_DOXYGEN)
|
|
static void paste(Fl_Widget &receiver, int source, const char *type = Fl::clipboard_plain_text); // platform dependent
|
|
#else
|
|
static void paste(Fl_Widget &receiver, int source, const char *type);
|
|
static void paste(Fl_Widget &receiver, int source /*=0*/);
|
|
#endif
|
|
/**
|
|
FLTK will call the registered callback whenever there is a change to the
|
|
selection buffer or the clipboard. The source argument indicates which
|
|
of the two has changed. Only changes by other applications are reported.
|
|
|
|
Example:
|
|
\code
|
|
void clip_callback(int source, void *data) {
|
|
if ( source == 0 ) printf("CLIP CALLBACK: selection buffer changed\n");
|
|
if ( source == 1 ) printf("CLIP CALLBACK: clipboard changed\n");
|
|
}
|
|
[..]
|
|
int main() {
|
|
[..]
|
|
Fl::add_clipboard_notify(clip_callback);
|
|
[..]
|
|
}
|
|
\endcode
|
|
\note Some systems require polling to monitor the clipboard and may
|
|
therefore have some delay in detecting changes.
|
|
*/
|
|
static void add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void *data = 0);
|
|
/**
|
|
Stop calling the specified callback when there are changes to the selection
|
|
buffer or the clipboard.
|
|
*/
|
|
static void remove_clipboard_notify(Fl_Clipboard_Notify_Handler h);
|
|
/** Returns non 0 if the clipboard contains data matching \p type.
|
|
\p type can be Fl::clipboard_plain_text or Fl::clipboard_image.
|
|
*/
|
|
static int clipboard_contains(const char *type);
|
|
/** Denotes plain textual data
|
|
*/
|
|
static char const * const clipboard_plain_text;
|
|
/** Denotes image data
|
|
*/
|
|
static char const * const clipboard_image;
|
|
|
|
/**
|
|
Initiate a Drag And Drop operation. The selection buffer should be
|
|
filled with relevant data before calling this method. FLTK will
|
|
then initiate the system wide drag and drop handling. Dropped data
|
|
will be marked as <i>text</i>.
|
|
|
|
Create a selection first using:
|
|
Fl::copy(const char *stuff, int len, 0)
|
|
*/
|
|
static int dnd(); // platform dependent
|
|
|
|
// These are for back-compatibility only:
|
|
/** back-compatibility only: Gets the widget owning the current selection
|
|
\see Fl_Widget* selection_owner(Fl_Widget*) */
|
|
static Fl_Widget* selection_owner() {return selection_owner_;}
|
|
static void selection_owner(Fl_Widget*);
|
|
static void selection(Fl_Widget &owner, const char*, int len);
|
|
static void paste(Fl_Widget &receiver);
|
|
/** @} */
|
|
/** \defgroup fl_screen Screen functions
|
|
fl global screen functions declared in <FL/Fl.H>
|
|
@{ */
|
|
// screen size:
|
|
/** Returns the leftmost x coordinate of the main screen work area. */
|
|
static int x(); // platform dependent
|
|
/** Returns the topmost y coordinate of the main screen work area. */
|
|
static int y(); // platform dependent
|
|
/** Returns the width in pixels of the main screen work area. */
|
|
static int w(); // platform dependent
|
|
/** Returns the height in pixels of the main screen work area. */
|
|
static int h(); // platform dependent
|
|
|
|
// multi-head support:
|
|
static int screen_count();
|
|
/**
|
|
Gets the bounding box of a screen that contains the mouse pointer.
|
|
\param[out] X,Y,W,H the corresponding screen bounding box
|
|
\see void screen_xywh(int &x, int &y, int &w, int &h, int mx, int my)
|
|
*/
|
|
static void screen_xywh(int &X, int &Y, int &W, int &H) {
|
|
int x, y;
|
|
Fl::get_mouse(x, y);
|
|
screen_xywh(X, Y, W, H, x, y);
|
|
}
|
|
static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my);
|
|
static void screen_xywh(int &X, int &Y, int &W, int &H, int n);
|
|
static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh);
|
|
static int screen_num(int x, int y);
|
|
static int screen_num(int x, int y, int w, int h);
|
|
static void screen_dpi(float &h, float &v, int n=0);
|
|
static void screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my);
|
|
static void screen_work_area(int &X, int &Y, int &W, int &H, int n);
|
|
/**
|
|
Gets the bounding box of the work area of the screen that contains the mouse pointer.
|
|
\param[out] X,Y,W,H the work area bounding box
|
|
\see void screen_work_area(int &x, int &y, int &w, int &h, int mx, int my)
|
|
*/
|
|
static void screen_work_area(int &X, int &Y, int &W, int &H) {
|
|
int x, y;
|
|
Fl::get_mouse(x, y);
|
|
screen_work_area(X, Y, W, H, x, y);
|
|
}
|
|
|
|
/** @} */
|
|
|
|
/** \defgroup fl_attributes Color & Font functions
|
|
fl global color, font functions.
|
|
These functions are declared in <FL/Fl.H> or <FL/fl_draw.H>.
|
|
@{ */
|
|
|
|
// color map:
|
|
static void set_color(Fl_Color, uchar, uchar, uchar);
|
|
/**
|
|
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 void set_color(Fl_Color i, unsigned c); // platform dependent
|
|
static unsigned get_color(Fl_Color i);
|
|
static void get_color(Fl_Color i, uchar &red, uchar &green, uchar &blue);
|
|
/**
|
|
Frees the specified color from the colormap, if applicable.
|
|
If overlay is non-zero then the color is freed from the
|
|
overlay colormap.
|
|
*/
|
|
static void free_color(Fl_Color i, int overlay = 0); // platform dependent
|
|
|
|
// fonts:
|
|
static const char* get_font(Fl_Font);
|
|
/**
|
|
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 \p 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.
|
|
*/
|
|
static const char* get_font_name(Fl_Font, int* attributes = 0);
|
|
/**
|
|
Return an array of sizes in \p 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 int get_font_sizes(Fl_Font, int*& sizep);
|
|
static void set_font(Fl_Font, const char*);
|
|
static void set_font(Fl_Font, Fl_Font);
|
|
/**
|
|
FLTK will open the display, and add every fonts 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 Fl_Font set_fonts(const char* = 0); // platform dependent
|
|
|
|
/** @} */
|
|
/** \defgroup fl_drawings Drawing functions
|
|
FLTK global graphics and GUI drawing functions.
|
|
These functions are declared in <FL/fl_draw.H>,
|
|
and in <FL/x.H> for offscreen buffer-related ones.
|
|
@{ */
|
|
// <Hack to re-order the 'Drawing functions' group>
|
|
/** @} */
|
|
|
|
// labeltypes:
|
|
static void set_labeltype(Fl_Labeltype,Fl_Label_Draw_F*,Fl_Label_Measure_F*);
|
|
/** Sets the functions to call to draw and measure a specific labeltype. */
|
|
static void set_labeltype(Fl_Labeltype, Fl_Labeltype from); // is it defined ?
|
|
|
|
// boxtypes:
|
|
static Fl_Box_Draw_F *get_boxtype(Fl_Boxtype);
|
|
static void set_boxtype(Fl_Boxtype, Fl_Box_Draw_F*,uchar,uchar,uchar,uchar);
|
|
static void set_boxtype(Fl_Boxtype, Fl_Boxtype from);
|
|
static int box_dx(Fl_Boxtype);
|
|
static int box_dy(Fl_Boxtype);
|
|
static int box_dw(Fl_Boxtype);
|
|
static int box_dh(Fl_Boxtype);
|
|
|
|
static int draw_box_active();
|
|
static Fl_Color box_color(Fl_Color);
|
|
static void set_box_color(Fl_Color);
|
|
|
|
// back compatibility:
|
|
/** \addtogroup fl_windows
|
|
@{ */
|
|
/** For back compatibility, sets the void Fl::fatal handler callback */
|
|
static void set_abort(Fl_Abort_Handler f) {fatal = f;}
|
|
static void (*atclose)(Fl_Window*,void*);
|
|
static void default_atclose(Fl_Window*,void*);
|
|
/** For back compatibility, sets the Fl::atclose handler callback. You
|
|
can now simply change the callback for the window instead.
|
|
\see Fl_Window::callback(Fl_Callback*) */
|
|
static void set_atclose(Fl_Atclose_Handler f) {atclose = f;}
|
|
/** @} */
|
|
|
|
/** \addtogroup fl_events
|
|
@{ */
|
|
/** Returns non-zero if the Shift key is pressed. */
|
|
static int event_shift() {return e_state&FL_SHIFT;}
|
|
/** Returns non-zero if the Control key is pressed. */
|
|
static int event_ctrl() {return e_state&FL_CTRL;}
|
|
/** Returns non-zero if the FL_COMMAND key is pressed, either FL_CTRL or on OSX FL_META. */
|
|
static int event_command() {return e_state&FL_COMMAND;}
|
|
/** Returns non-zero if the Alt key is pressed. */
|
|
static int event_alt() {return e_state&FL_ALT;}
|
|
/**
|
|
Returns the mouse buttons state bits; if non-zero, then at least one
|
|
button is pressed now. This function returns the button state at the
|
|
time of the event. During an FL_RELEASE event, the state
|
|
of the released button will be 0. To find out, which button
|
|
caused an FL_RELEASE event, you can use Fl::event_button() instead.
|
|
\return a bit mask value like { [FL_BUTTON1] | [FL_BUTTON2] | [FL_BUTTON3] }
|
|
*/
|
|
static int event_buttons() {return e_state&0x7f000000;}
|
|
/**
|
|
Returns non-zero if mouse button 1 is currently held down.
|
|
For more details, see Fl::event_buttons().
|
|
*/
|
|
static int event_button1() {return e_state&FL_BUTTON1;}
|
|
/**
|
|
Returns non-zero if button 2 is currently held down.
|
|
For more details, see Fl::event_buttons().
|
|
*/
|
|
static int event_button2() {return e_state&FL_BUTTON2;}
|
|
/**
|
|
Returns non-zero if button 3 is currently held down.
|
|
For more details, see Fl::event_buttons().
|
|
*/
|
|
static int event_button3() {return e_state&FL_BUTTON3;}
|
|
/** @} */
|
|
|
|
/**
|
|
Sets an idle callback.
|
|
|
|
\deprecated This method is obsolete - use the add_idle() method instead.
|
|
*/
|
|
static void set_idle(Fl_Old_Idle_Handler cb) {idle = cb;}
|
|
/** See grab(Fl_Window*) */
|
|
static void grab(Fl_Window& win) {grab(&win);}
|
|
/** Releases the current grabbed window, equals grab(0).
|
|
\deprecated Use Fl::grab(0) instead.
|
|
\see grab(Fl_Window*) */
|
|
static void release() {grab(0);}
|
|
|
|
// Visible focus methods...
|
|
/**
|
|
Gets or sets the visible keyboard focus on buttons and other
|
|
non-text widgets. The default mode is to enable keyboard focus
|
|
for all widgets.
|
|
*/
|
|
static void visible_focus(int v) { option(OPTION_VISIBLE_FOCUS, (v!=0)); }
|
|
/**
|
|
Gets or sets the visible keyboard focus on buttons and other
|
|
non-text widgets. The default mode is to enable keyboard focus
|
|
for all widgets.
|
|
*/
|
|
static int visible_focus() { return option(OPTION_VISIBLE_FOCUS); }
|
|
|
|
// Drag-n-drop text operation methods...
|
|
/**
|
|
Gets or sets whether drag and drop text operations are supported.
|
|
This specifically affects whether selected text can
|
|
be dragged from text fields or dragged within a text field as a
|
|
cut/paste shortcut.
|
|
*/
|
|
static void dnd_text_ops(int v) { option(OPTION_DND_TEXT, (v!=0)); }
|
|
/**
|
|
Gets or sets whether drag and drop text operations are
|
|
supported. This specifically affects whether selected text can
|
|
be dragged from text fields or dragged within a text field as a
|
|
cut/paste shortcut.
|
|
*/
|
|
static int dnd_text_ops() { return option(OPTION_DND_TEXT); }
|
|
/** \defgroup fl_multithread Multithreading support functions
|
|
fl multithreading support functions declared in <FL/Fl.H>
|
|
@{ */
|
|
|
|
// Multithreading support:
|
|
static int lock();
|
|
static void unlock();
|
|
static void awake(void* message = 0);
|
|
/** See void awake(void* message=0). */
|
|
static int awake(Fl_Awake_Handler cb, void* message = 0);
|
|
/**
|
|
The thread_message() method returns the last message
|
|
that was sent from a child by the awake() method.
|
|
|
|
See also: \ref advanced_multithreading
|
|
*/
|
|
static void* thread_message(); // platform dependent
|
|
/** @} */
|
|
|
|
/** \defgroup fl_del_widget Safe widget deletion support functions
|
|
|
|
These functions, declared in <FL/Fl.H>, support deletion of widgets inside callbacks.
|
|
|
|
Fl::delete_widget() should be called when deleting widgets
|
|
or complete widget trees (Fl_Group, Fl_Window, ...) inside
|
|
callbacks.
|
|
|
|
The other functions are intended for internal use. The preferred
|
|
way to use them is by using the helper class Fl_Widget_Tracker.
|
|
|
|
The following is to show how it works ...
|
|
|
|
There are three groups of related methods:
|
|
|
|
-# scheduled widget deletion
|
|
- Fl::delete_widget() schedules widgets for deletion
|
|
- Fl::do_widget_deletion() deletes all scheduled widgets
|
|
-# widget watch list ("smart pointers")
|
|
- Fl::watch_widget_pointer() adds a widget pointer to the watch list
|
|
- Fl::release_widget_pointer() removes a widget pointer from the watch list
|
|
- Fl::clear_widget_pointer() clears a widget pointer \e in the watch list
|
|
-# the class Fl_Widget_Tracker:
|
|
- the constructor calls Fl::watch_widget_pointer()
|
|
- the destructor calls Fl::release_widget_pointer()
|
|
- the access methods can be used to test, if a widget has been deleted
|
|
\see Fl_Widget_Tracker.
|
|
|
|
@{ */
|
|
// Widget deletion:
|
|
static void delete_widget(Fl_Widget *w);
|
|
static void do_widget_deletion();
|
|
static void watch_widget_pointer(Fl_Widget *&w);
|
|
static void release_widget_pointer(Fl_Widget *&w);
|
|
static void clear_widget_pointer(Fl_Widget const *w);
|
|
/** @} */
|
|
|
|
/** sets whether GL windows should be drawn at high resolution on Apple
|
|
computers with retina displays
|
|
\version 1.3.4
|
|
*/
|
|
static void use_high_res_GL(int val) { use_high_res_GL_ = val; }
|
|
/** returns whether GL windows should be drawn at high resolution on Apple
|
|
computers with retina displays.
|
|
Default is no.
|
|
\version 1.3.4
|
|
*/
|
|
static int use_high_res_GL() { return use_high_res_GL_; }
|
|
|
|
#ifdef FLTK_HAVE_CAIRO
|
|
/** \defgroup group_cairo Cairo Support Functions and Classes
|
|
@{
|
|
*/
|
|
public:
|
|
// Cairo support API
|
|
static cairo_t * cairo_make_current(Fl_Window* w);
|
|
/** when FLTK_HAVE_CAIRO is defined and cairo_autolink_context() is true,
|
|
any current window dc is linked to a current cairo context.
|
|
This is not the default, because it may not be necessary
|
|
to add cairo support to all fltk supported windows.
|
|
When you wish to associate a cairo context in this mode,
|
|
you need to call explicitly in your draw() overridden method,
|
|
Fl::cairo_make_current(Fl_Window*). This will create a cairo context
|
|
but only for this Window.
|
|
Still in custom cairo application it is possible to handle
|
|
completely this process automatically by setting \p alink to true.
|
|
In this last case, you don't need anymore to call Fl::cairo_make_current().
|
|
You can use Fl::cairo_cc() to get the current cairo context anytime.
|
|
\note Only available when configure has the --enable-cairo option
|
|
*/
|
|
static void cairo_autolink_context(bool alink) {cairo_state_.autolink(alink);}
|
|
/**
|
|
Gets the current autolink mode for cairo support.
|
|
\retval false if no cairo context autolink is made for each window.
|
|
\retval true if any fltk window is attached a cairo context when it
|
|
is current. \see void cairo_autolink_context(bool alink)
|
|
\note Only available when configure has the --enable-cairo option
|
|
*/
|
|
static bool cairo_autolink_context() {return cairo_state_.autolink();}
|
|
/** Gets the current cairo context linked with a fltk window. */
|
|
static cairo_t * cairo_cc() { return cairo_state_.cc(); }
|
|
/** Sets the current cairo context to \p c.
|
|
Set \p own to true if you want fltk to handle this cc deletion.
|
|
\note Only available when configure has the --enable-cairo option
|
|
*/
|
|
static void cairo_cc(cairo_t * c, bool own=false){ cairo_state_.cc(c, own); }
|
|
|
|
private:
|
|
static cairo_t * cairo_make_current(void* gc);
|
|
static cairo_t * cairo_make_current(void* gc, int W, int H);
|
|
static Fl_Cairo_State cairo_state_;
|
|
public:
|
|
/** @} */
|
|
|
|
#endif // FLTK_HAVE_CAIRO
|
|
|
|
};
|
|
|
|
/**
|
|
This class should be used to control safe widget deletion.
|
|
|
|
You can use an Fl_Widget_Tracker object to watch another widget, if you
|
|
need to know, if this widget has been deleted during a callback.
|
|
|
|
This simplifies the use of the "safe widget deletion" methods
|
|
Fl::watch_widget_pointer() and Fl::release_widget_pointer() and
|
|
makes their use more reliable, because the destructor autmatically
|
|
releases the widget pointer from the widget watch list.
|
|
|
|
It is intended to be used as an automatic (local/stack) variable,
|
|
such that the automatic destructor is called when the object's
|
|
scope is left. This ensures that no stale widget pointers are
|
|
left in the widget watch list (see example below).
|
|
|
|
You can also create Fl_Widget_Tracker objects with \c new, but then it
|
|
is your responsibility to delete the object (and thus remove the
|
|
widget pointer from the watch list) when it is not needed any more.
|
|
|
|
Example:
|
|
|
|
\code
|
|
int MyClass::handle (int event) {
|
|
|
|
if (...) {
|
|
Fl_Widget_Tracker wp(this); // watch myself
|
|
do_callback(); // call the callback
|
|
|
|
if (wp.deleted()) return 1; // exit, if deleted
|
|
|
|
// Now we are sure that the widget has not been deleted.
|
|
// It is safe to access the widget
|
|
|
|
clear_changed(); // access the widget
|
|
}
|
|
}
|
|
\endcode
|
|
|
|
*/
|
|
class FL_EXPORT Fl_Widget_Tracker {
|
|
|
|
Fl_Widget* wp_;
|
|
|
|
public:
|
|
|
|
Fl_Widget_Tracker(Fl_Widget *wi);
|
|
~Fl_Widget_Tracker();
|
|
|
|
/**
|
|
Returns a pointer to the watched widget.
|
|
|
|
This pointer is \c NULL, if the widget has been deleted.
|
|
*/
|
|
Fl_Widget *widget() {return wp_;}
|
|
|
|
/**
|
|
Returns 1, if the watched widget has been deleted.
|
|
|
|
This is a convenience method. You can also use something like
|
|
|
|
<tt> if (wp.widget() == 0) // ...</tt>
|
|
|
|
where \p wp is an Fl_Widget_Tracker object.
|
|
*/
|
|
int deleted() {return wp_ == 0;}
|
|
|
|
/**
|
|
Returns 1, if the watched widget exists (has not been deleted).
|
|
|
|
This is a convenience method. You can also use something like
|
|
|
|
<tt> if (wp.widget() != 0) // ...</tt>
|
|
|
|
where \p wp is an Fl_Widget_Tracker object.
|
|
*/
|
|
int exists() {return wp_ != 0;}
|
|
|
|
};
|
|
|
|
/** \defgroup fl_unicode Unicode and UTF-8 functions
|
|
fl global Unicode and UTF-8 handling functions declared in <FL/fl_utf8.h>
|
|
@{ */
|
|
/** @} */
|
|
|
|
#endif // !Fl_H
|
|
|
|
//
|
|
// End of "$Id$".
|
|
//
|