From 5aa3fc9655560c68ab43573e4afb2d40833d01bf Mon Sep 17 00:00:00 2001 From: Matthias Melcher Date: Wed, 10 Feb 2016 22:43:45 +0000 Subject: Moving fl_beep into screen driver. git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3-porting@11152 ea41ed52-d2ee-0310-a9c1-e6b18d33e121 --- FL/Fl_Screen_Driver.H | 1436 +----------------------- src/Fl_Image.cxx | 6 - src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.cxx | 19 + src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.h | 2 + src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.cxx | 28 + src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.h | 14 +- src/drivers/X11/Fl_X11_Screen_Driver.cxx | 16 + src/drivers/X11/Fl_X11_Screen_Driver.h | 2 + src/fl_ask.cxx | 55 +- 9 files changed, 95 insertions(+), 1483 deletions(-) diff --git a/FL/Fl_Screen_Driver.H b/FL/Fl_Screen_Driver.H index a36934e32..8532ffbc2 100644 --- a/FL/Fl_Screen_Driver.H +++ b/FL/Fl_Screen_Driver.H @@ -21,6 +21,17 @@ #include +// TODO: add text composition? +// TODO: add Fl::display +// TODO: add copy/paste, drag/drop? +// TODO: get key/get mouse? +// TODO: system colors/colormaps +// TODO: system menu? +// TODO: native filechooser +// TODO: native message boxes +// TODO: read screen to image +// TODO: application shortcuts + class FL_EXPORT Fl_Screen_Driver : public Fl_Device { @@ -33,6 +44,7 @@ protected: public: static Fl_Screen_Driver *newScreenDriver(); + // --- screen configuration virtual void init() = 0; virtual int x() = 0; virtual int y() = 0; @@ -49,1431 +61,11 @@ public: virtual void screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my); virtual void screen_work_area(int &X, int &Y, int &W, int &H, int n) = 0; virtual void screen_work_area(int &X, int &Y, int &W, int &H); + // --- audible output + virtual void beep(int type) = 0; }; - - - - - - -#if 0 - -#ifdef FLTK_HAVE_CAIRO -# include -#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 - -# ifdef BSD -# undef BSD -# 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 -#elif defined(__APPLE__) -# define FL_SOCKET int -#elif defined(FL_PORTING) -# pragma message "FL_PORTING: define a type for FL_SOCKET" -# define FL_SOCKET int // default if not ported -# undef check -#else -# define FL_SOCKET int -#endif - -/** \defgroup callback_functions Callback function typedefs - \brief Typedefs defined in 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: // run time information about compile time configuration - /** \defgroup cfg_gfx runtime graphics driver configuration */ - /** @{ */ - static bool cfg_gfx_xlib; ///< X11 Xlib rendering available, usually on Linux systems - static bool cfg_gfx_quartz; ///< Quartz rendering available, usually on OS X systems - static bool cfg_gfx_gdi; ///< GDI redering available, usually on MSWindows systems - static bool cfg_gfx_opengl; ///< OpenGL redering available, available on many platforms - static bool cfg_gfx_cairo; ///< Cairo redering available, available on many platforms - static bool cfg_gfx_directx;///< DirectX redering available, usually on MSWindows systems - /** @} */ - /** \defgroup cfg_prn runtime printer driver configuration */ - /** @{ */ - static bool cfg_prn_ps; ///< PostScript rendering available, usually on Linux systems - static bool cfg_prn_quartz; ///< Quartz rendering available, usually on OS X systems - static bool cfg_prn_gdi; ///< GDI redering available, usually on MSWindows systems - /** @} */ - /** \defgroup cfg_win runtime window and event manager configuration */ - /** @{ */ - static bool cfg_win_x11; ///< X11 window management available, usually on Linux systems - static bool cfg_win_cocoa; ///< Cocoa window management available, usually on OS X systems - static bool cfg_win_win32; ///< WIN32 window management available, on low level MSWindows - /** @} */ - /** \defgroup cfg_sys runtime system configuration */ - /** @{ */ - static bool cfg_sys_posix; ///< Posix system available, usually on Linux and OS X systems, but also Cygwin - static bool cfg_sys_win32; ///< WIN32 system available, on MSWindows - /** @} */ - -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 -#elif defined(WIN32) - // not needed in WIN32 -#elif defined(FL_PORTING) -# pragma message "FL_PORTING: define a type for FL_SOCKET" - // no default implementation -#else - // not needed in X11 -#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 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 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 t 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 -#include -#include -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 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 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 - */ - 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 - */ - 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 - */ - static void (*fatal)(const char*, ...); - /** @} */ - - /** \defgroup fl_windows Windows handling functions - \brief Windows and standard dialogs handling declared in - @{ */ - 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 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! - 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 - @{ - */ - // 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 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. - */ - 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 - after 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) 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: - - \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 now. - Under X this requires a round-trip to the server and is much - 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 - @{ */ - // 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. - */ - static void copy(const char* stuff, int len, int destination = 0, const char *type = Fl::clipboard_plain_text); // platform dependent - -#if defined(__APPLE__) - // not needed -#elif defined(WIN32) - // not needed -#elif defined(FL_DOXYGEN) - // don't show in documentation -#elif defined(FL_PORTING) -# pragma message "FL_PORTING: do you need to implement copy_image() ?" - // not implemented by default -#else - static void copy_image(const unsigned char* data, int W, int H, int destination = 0); // X11 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, Fl::event_clipboard() returns a pointer to the - image data, as an Fl_Image *. - The receiver - should be prepared to be called \e directly by this, or for - it to happen \e 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. - - 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. - - \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. - - */ - static void paste(Fl_Widget &receiver, int source, const char *type = Fl::clipboard_plain_text); // platform dependent - /** - 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 text. - - 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 - @{ */ - // 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 or . - @{ */ - - // 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 , - and in for offscreen buffer-related ones. - @{ */ - // - /** @} */ - - // 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 - @{ */ - - // 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 , 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 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 - - if (wp.widget() == 0) // ... - - 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 - - if (wp.widget() != 0) // ... - - where \p wp is an Fl_Widget_Tracker object. - */ - int exists() {return wp_ != 0;} - -}; -#endif // 0 - - #endif // !FL_SCREEN_DRIVER_H // diff --git a/src/Fl_Image.cxx b/src/Fl_Image.cxx index 35871765c..32d05fe02 100644 --- a/src/Fl_Image.cxx +++ b/src/Fl_Image.cxx @@ -26,12 +26,6 @@ #include #include "flstring.h" -#if defined(WIN32) || defined(__APPLE__) -#elif defined(FL_PORTING) -# pragma message "FL_PORTING: implement RGB image handling here" -#else -#endif - void fl_restore_clip(); // from fl_rect.cxx // diff --git a/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.cxx b/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.cxx index 94dedb813..704c3dc72 100644 --- a/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.cxx +++ b/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.cxx @@ -19,8 +19,11 @@ #include "../../config_lib.h" #include "Fl_Cocoa_Screen_Driver.h" +#include +extern "C" void NSBeep(void); + /** Creates a driver that manages all screen and display related calls. @@ -93,6 +96,22 @@ void Fl_Cocoa_Screen_Driver::screen_dpi(float &h, float &v, int n) } +/** + Emits a system beep message. + \param[in] type The beep type from the \ref Fl_Beep enumeration. + \note \#include + */ +void Fl_Cocoa_Screen_Driver::beep(int type) { + switch (type) { + case FL_BEEP_DEFAULT : + case FL_BEEP_ERROR : + NSBeep(); + break; + default : + break; + } +} + // // End of "$Id$". diff --git a/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.h b/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.h index 4023e8706..4c5cf8a7e 100644 --- a/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.h +++ b/src/drivers/Cocoa/Fl_Cocoa_Screen_Driver.h @@ -55,6 +55,8 @@ public: virtual void screen_xywh(int &X, int &Y, int &W, int &H, int n); virtual void screen_dpi(float &h, float &v, int n=0); virtual void screen_work_area(int &X, int &Y, int &W, int &H, int n); + // --- audible output + virtual void beep(int type); }; diff --git a/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.cxx b/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.cxx index 0531e093f..ddf9deaac 100644 --- a/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.cxx +++ b/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.cxx @@ -19,6 +19,7 @@ #include "../../config_lib.h" #include "Fl_WinAPI_Screen_Driver.h" +#include # if !defined(HMONITOR_DECLARED) && (_WIN32_WINNT < 0x0500) # define COMPILE_MULTIMON_STUBS @@ -172,6 +173,7 @@ void Fl_WinAPI_Screen_Driver::screen_dpi(float &h, float &v, int n) } } + int Fl_WinAPI_Screen_Driver::x() { RECT r; @@ -180,6 +182,7 @@ int Fl_WinAPI_Screen_Driver::x() return r.left; } + int Fl_WinAPI_Screen_Driver::y() { RECT r; @@ -188,6 +191,7 @@ int Fl_WinAPI_Screen_Driver::y() return r.top; } + int Fl_WinAPI_Screen_Driver::h() { RECT r; @@ -196,6 +200,7 @@ int Fl_WinAPI_Screen_Driver::h() return r.bottom - r.top; } + int Fl_WinAPI_Screen_Driver::w() { RECT r; @@ -205,6 +210,29 @@ int Fl_WinAPI_Screen_Driver::w() } +void Fl_WinAPI_Screen_Driver::beep(int type) +{ + switch (type) { + case FL_BEEP_QUESTION : + case FL_BEEP_PASSWORD : + MessageBeep(MB_ICONQUESTION); + break; + case FL_BEEP_MESSAGE : + MessageBeep(MB_ICONASTERISK); + break; + case FL_BEEP_NOTIFICATION : + MessageBeep(MB_ICONASTERISK); + break; + case FL_BEEP_ERROR : + MessageBeep(MB_ICONERROR); + break; + default : + MessageBeep(0xFFFFFFFF); + break; + } +} + + // // End of "$Id$". diff --git a/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.h b/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.h index be0ee2caf..f0f5c823c 100644 --- a/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.h +++ b/src/drivers/WinAPI/Fl_WinAPI_Screen_Driver.h @@ -32,12 +32,12 @@ class FL_EXPORT Fl_WinAPI_Screen_Driver : public Fl_Screen_Driver { protected: - RECT screens[MAX_SCREENS]; - RECT work_area[MAX_SCREENS]; - float dpi[MAX_SCREENS][2]; - - static BOOL CALLBACK screen_cb(HMONITOR mon, HDC, LPRECT r, LPARAM); - BOOL screen_cb(HMONITOR mon, HDC, LPRECT r); + RECT screens[MAX_SCREENS]; + RECT work_area[MAX_SCREENS]; + float dpi[MAX_SCREENS][2]; + + static BOOL CALLBACK screen_cb(HMONITOR mon, HDC, LPRECT r, LPARAM); + BOOL screen_cb(HMONITOR mon, HDC, LPRECT r); public: virtual void init(); @@ -48,6 +48,8 @@ public: virtual void screen_xywh(int &X, int &Y, int &W, int &H, int n); virtual void screen_dpi(float &h, float &v, int n=0); virtual void screen_work_area(int &X, int &Y, int &W, int &H, int n); + // --- audible output + virtual void beep(int type); }; diff --git a/src/drivers/X11/Fl_X11_Screen_Driver.cxx b/src/drivers/X11/Fl_X11_Screen_Driver.cxx index 6ae8458a1..6a53f65f6 100644 --- a/src/drivers/X11/Fl_X11_Screen_Driver.cxx +++ b/src/drivers/X11/Fl_X11_Screen_Driver.cxx @@ -21,6 +21,7 @@ #include "Fl_X11_Screen_Driver.h" #include #include +#include #if HAVE_XINERAMA # include @@ -186,6 +187,21 @@ void Fl_X11_Screen_Driver::screen_dpi(float &h, float &v, int n) } +void Fl_X11_Screen_Driver::beep(int type) { + switch (type) { + case FL_BEEP_DEFAULT : + case FL_BEEP_ERROR : + if (!fl_display) fl_open_display(); + XBell(fl_display, 100); + break; + default : + if (!fl_display) fl_open_display(); + XBell(fl_display, 50); + break; + } +} + + // // End of "$Id$". diff --git a/src/drivers/X11/Fl_X11_Screen_Driver.h b/src/drivers/X11/Fl_X11_Screen_Driver.h index 23e57fd52..635e975dc 100644 --- a/src/drivers/X11/Fl_X11_Screen_Driver.h +++ b/src/drivers/X11/Fl_X11_Screen_Driver.h @@ -50,6 +50,8 @@ public: virtual void screen_xywh(int &X, int &Y, int &W, int &H, int n); virtual void screen_dpi(float &h, float &v, int n=0); virtual void screen_work_area(int &X, int &Y, int &W, int &H, int n); + // --- audible output + virtual void beep(int type); }; diff --git a/src/fl_ask.cxx b/src/fl_ask.cxx index ce61a2796..127339535 100644 --- a/src/fl_ask.cxx +++ b/src/fl_ask.cxx @@ -41,6 +41,7 @@ #include #include #include +#include #include static Fl_Window *message_form; @@ -54,9 +55,6 @@ static const char *message_title_default; Fl_Font fl_message_font_ = FL_HELVETICA; Fl_Fontsize fl_message_size_ = -1; static int enableHotspot = 1; -#ifdef __APPLE__ -extern "C" void NSBeep(void); -#endif static char avoidRecursion = 0; @@ -275,59 +273,18 @@ const char* fl_cancel= "Cancel"; ///< string pointer used in common dialogs, you const char* fl_close= "Close"; ///< string pointer used in common dialogs, you can change it to another language // fltk functions: + /** Emits a system beep message. \param[in] type The beep type from the \ref Fl_Beep enumeration. \note \#include */ -void fl_beep(int type) { -#ifdef WIN32 - switch (type) { - case FL_BEEP_QUESTION : - case FL_BEEP_PASSWORD : - MessageBeep(MB_ICONQUESTION); - break; - case FL_BEEP_MESSAGE : - MessageBeep(MB_ICONASTERISK); - break; - case FL_BEEP_NOTIFICATION : - MessageBeep(MB_ICONASTERISK); - break; - case FL_BEEP_ERROR : - MessageBeep(MB_ICONERROR); - break; - default : - MessageBeep(0xFFFFFFFF); - break; - } -#elif defined(__APPLE__) - switch (type) { - case FL_BEEP_DEFAULT : - case FL_BEEP_ERROR : - NSBeep(); - break; - default : - break; - } -#elif defined(FL_PORTING) -# pragma message "FL_PORTING: implement beeping or other noise generating functions" -#else - switch (type) { - case FL_BEEP_DEFAULT : - case FL_BEEP_ERROR : - if (!fl_display) fl_open_display(); - - XBell(fl_display, 100); - break; - default : - if (!fl_display) fl_open_display(); - - XBell(fl_display, 50); - break; - } -#endif // WIN32 +void fl_beep(int type) +{ + Fl::screen_driver()->beep(type); } + /** Shows an information message dialog box. \note Common dialog boxes are application modal. No more than one common dialog box -- cgit v1.2.3