mirror of
https://github.com/fltk/fltk.git
synced 2026-02-06 00:01:57 +08:00
Refactor large static class Fl into an expandable namespace Fl (#1325)
* Change class Fl into namespace Fl. * Untangle Fl namespace into themed headers. * cut line count of FL/Fl.H in half * FL/core subdirectory now holds short headers grouped by functionality.
This commit is contained in:
Matthias Melcher
GitHub
144
FL/Fl_Widget_Tracker.H
Normal file
144
FL/Fl_Widget_Tracker.H
Normal file
@@ -0,0 +1,144 @@
|
||||
//
|
||||
// Widget Tracker header file for the Fast Light Tool Kit (FLTK).
|
||||
//
|
||||
// Copyright 2025 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:
|
||||
//
|
||||
// https://www.fltk.org/COPYING.php
|
||||
//
|
||||
// Please see the following page on how to report bugs and issues:
|
||||
//
|
||||
// https://www.fltk.org/bugs.php
|
||||
//
|
||||
|
||||
/** \file FL/Fl_Widget_Tracker.H
|
||||
\brief Track widget deletion.
|
||||
*/
|
||||
|
||||
#ifndef Fl_Widget_Tracker_H
|
||||
#define Fl_Widget_Tracker_H
|
||||
|
||||
#include <FL/fl_config.h> // build configuration
|
||||
#include <FL/Fl_Export.H>
|
||||
|
||||
class Fl_Widget;
|
||||
|
||||
|
||||
/**
|
||||
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 whether 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 automatically
|
||||
releases the widget pointer from the widget watch list.
|
||||
|
||||
Fl_Widget_Tracker is intended to be used as an automatic (local/stack)
|
||||
variable, such that its 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 no longer needed.
|
||||
|
||||
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,
|
||||
// and it is safe to access the widget:
|
||||
|
||||
box(FL_FLAT_BOX);
|
||||
color(FL_WHITE);
|
||||
redraw();
|
||||
}
|
||||
}
|
||||
\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.
|
||||
\return nullptr if the widget was deleted.
|
||||
*/
|
||||
Fl_Widget *widget() { return wp_; }
|
||||
|
||||
/**
|
||||
Check if the widget was deleted since the tracker was created.
|
||||
\return 1 if the watched widget has been deleted, otherwise 0
|
||||
*/
|
||||
int deleted() {return wp_ == 0;}
|
||||
|
||||
/**
|
||||
Check if the widget exists and was not deleted since the tracker was created.
|
||||
\return 1 if the watched widget exists, otherwise 0
|
||||
*/
|
||||
int exists() { return wp_ != 0; }
|
||||
|
||||
};
|
||||
|
||||
namespace Fl {
|
||||
|
||||
/** \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:
|
||||
FL_EXPORT extern void delete_widget(Fl_Widget *w);
|
||||
FL_EXPORT extern void do_widget_deletion();
|
||||
FL_EXPORT extern void watch_widget_pointer(Fl_Widget *&w);
|
||||
FL_EXPORT extern void release_widget_pointer(Fl_Widget *&w);
|
||||
FL_EXPORT extern void clear_widget_pointer(Fl_Widget const *w);
|
||||
|
||||
/** @} */
|
||||
|
||||
} // namespace Fl
|
||||
|
||||
#endif // !Fl_Widget_Tracker_H
|
||||
495
FL/core/events.H
Normal file
495
FL/core/events.H
Normal file
@@ -0,0 +1,495 @@
|
||||
//
|
||||
// Global event header file for the Fast Light Tool Kit (FLTK).
|
||||
//
|
||||
// Copyright 2025 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:
|
||||
//
|
||||
// https://www.fltk.org/COPYING.php
|
||||
//
|
||||
// Please see the following page on how to report bugs and issues:
|
||||
//
|
||||
// https://www.fltk.org/bugs.php
|
||||
//
|
||||
|
||||
/** \file FL/core/events.H
|
||||
\brief Global event handling variables and functions.
|
||||
*/
|
||||
|
||||
#ifndef Fl_core_events_H
|
||||
#define Fl_core_events_H
|
||||
|
||||
#include <FL/fl_config.h> // build configuration
|
||||
#include <FL/Fl_Export.H> // for FL_EXPORT
|
||||
#include <FL/core/function_types.H> // widget callbacks and services
|
||||
|
||||
class Fl_Widget;
|
||||
|
||||
namespace Fl {
|
||||
|
||||
//
|
||||
// Event Variables (Internal)
|
||||
// Note: These variables should be private, but would harm back compatibility.
|
||||
//
|
||||
|
||||
#ifndef FL_DOXYGEN
|
||||
|
||||
// Core event information
|
||||
FL_EXPORT extern int e_number; ///< Current event type
|
||||
FL_EXPORT extern int e_state; ///< Keyboard/mouse button states
|
||||
|
||||
// Mouse position and movement
|
||||
FL_EXPORT extern int e_x; ///< Mouse X position (window relative)
|
||||
FL_EXPORT extern int e_y; ///< Mouse Y position (window relative)
|
||||
FL_EXPORT extern int e_x_root; ///< Mouse X position (screen absolute)
|
||||
FL_EXPORT extern int e_y_root; ///< Mouse Y position (screen absolute)
|
||||
FL_EXPORT extern int e_dx; ///< Mouse wheel horizontal delta
|
||||
FL_EXPORT extern int e_dy; ///< Mouse wheel vertical delta
|
||||
|
||||
// Mouse click handling
|
||||
FL_EXPORT extern int e_clicks; ///< Number of consecutive clicks
|
||||
FL_EXPORT extern int e_is_click; ///< True if event qualifies as click
|
||||
|
||||
// Keyboard event data
|
||||
FL_EXPORT extern int e_keysym; ///< Key symbol for current event
|
||||
FL_EXPORT extern int e_original_keysym; ///< Original key before NumLock translation
|
||||
FL_EXPORT extern char* e_text; ///< Text associated with key event
|
||||
FL_EXPORT extern int e_length; ///< Length of text in e_text
|
||||
|
||||
// Clipboard data (for paste events)
|
||||
FL_EXPORT extern void* e_clipboard_data; ///< Pasted data pointer
|
||||
FL_EXPORT extern const char* e_clipboard_type; ///< Type of pasted data
|
||||
|
||||
// Event handling infrastructure
|
||||
FL_EXPORT extern Fl_Event_Dispatch e_dispatch; ///< Custom event dispatcher
|
||||
FL_EXPORT extern Fl_Callback_Reason callback_reason_; ///< Reason for current callback
|
||||
|
||||
// Widget state tracking
|
||||
FL_EXPORT extern Fl_Widget* belowmouse_; ///< Widget under mouse cursor
|
||||
FL_EXPORT extern Fl_Widget* pushed_; ///< Widget receiving drag events
|
||||
FL_EXPORT extern Fl_Widget* focus_; ///< Widget with keyboard focus
|
||||
|
||||
#endif // FL_DOXYGEN
|
||||
|
||||
|
||||
/** \defgroup fl_events Events handling functions
|
||||
Fl class events handling API declared in <FL/Fl.H>
|
||||
@{
|
||||
*/
|
||||
|
||||
//
|
||||
// Event Information Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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.
|
||||
*/
|
||||
FL_EXPORT inline int event() { return e_number; }
|
||||
|
||||
//
|
||||
// Mouse Position Functions
|
||||
//
|
||||
|
||||
/**
|
||||
Returns the mouse position of the event relative to the Fl_Window
|
||||
it was passed to.
|
||||
*/
|
||||
FL_EXPORT inline int event_x() { return e_x; }
|
||||
|
||||
/**
|
||||
Returns the mouse position of the event relative to the Fl_Window
|
||||
it was passed to.
|
||||
*/
|
||||
FL_EXPORT inline 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().
|
||||
*/
|
||||
FL_EXPORT inline 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().
|
||||
*/
|
||||
FL_EXPORT inline int event_y_root() { return e_y_root; }
|
||||
|
||||
//
|
||||
// Mouse Wheel Functions
|
||||
//
|
||||
|
||||
/**
|
||||
Returns the current horizontal mouse scrolling associated with the
|
||||
FL_MOUSEWHEEL event. Right is positive.
|
||||
*/
|
||||
FL_EXPORT inline int event_dx() { return e_dx; }
|
||||
|
||||
/**
|
||||
Returns the current vertical mouse scrolling associated with the
|
||||
FL_MOUSEWHEEL event. Down is positive.
|
||||
*/
|
||||
FL_EXPORT inline int event_dy() { return e_dy; }
|
||||
|
||||
//
|
||||
// Mouse Query Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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.
|
||||
*/
|
||||
FL_EXPORT extern void get_mouse(int &,int &);
|
||||
|
||||
//
|
||||
// Mouse Click Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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.
|
||||
|
||||
*/
|
||||
FL_EXPORT inline 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()
|
||||
*/
|
||||
FL_EXPORT inline 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.
|
||||
*/
|
||||
FL_EXPORT inline 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.
|
||||
*/
|
||||
FL_EXPORT inline void event_is_click(int i) { e_is_click = i; }
|
||||
|
||||
//
|
||||
// Mouse Button Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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
|
||||
\retval FL_BACK_MOUSE
|
||||
\retval FL_FORWARD_MOUSE
|
||||
\see Fl::event_buttons(), Fl::event_state()
|
||||
*/
|
||||
FL_EXPORT inline int event_button() { return e_keysym - FL_Button; }
|
||||
|
||||
//
|
||||
// Event State Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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.
|
||||
|
||||
\note FLTK platforms differ in what Fl::event_state() returns when it is called
|
||||
while a modifier key or mouse button is being pressed or released.
|
||||
|
||||
- Under X11 and Wayland, Fl::event_state() indicates the state of the modifier keys and
|
||||
mouse buttons just \b prior to the event. Thus, during the \c FL_KEYDOWN event generated
|
||||
when pressing the shift key, for example, the \c FL_SHIFT bit of event_state() is 0 and
|
||||
becomes 1 only at the next event which can be any other event, including e.g. \c FL_MOVE.
|
||||
- Under other platforms the reported state of modifier keys or mouse buttons includes that
|
||||
of the key or button being pressed or released.
|
||||
- Fl::event_state() returns the same value under all platforms when it's called while a
|
||||
non-modifier key (e.g. a letter or function key) is being pressed or released.
|
||||
- X servers do not agree on shift states, and \c FL_NUM_LOCK, \c FL_META, and \c FL_SCROLL_LOCK
|
||||
may not work.
|
||||
- The values were selected to match the XFree86 server on Linux.
|
||||
|
||||
\note This inconsistency \b may be fixed (on X11 and Wayland) in a later release.
|
||||
|
||||
The legal event state bits are:
|
||||
|
||||
| Device | State Bit | Key or Button | Since |
|
||||
|----------|----------------|-------------------------|--------|
|
||||
| Keyboard | FL_SHIFT | Shift | |
|
||||
| Keyboard | FL_CAPS_LOCK | Caps Lock | |
|
||||
| Keyboard | FL_CTRL | Ctrl | |
|
||||
| Keyboard | FL_ALT | Alt | |
|
||||
| Keyboard | FL_NUM_LOCK | Num Lock | |
|
||||
| Keyboard | FL_META | Meta, e.g. "Windows" | |
|
||||
| Keyboard | FL_SCROLL_LOCK | Scroll Lock | |
|
||||
| Mouse | FL_BUTTON1 | left button | |
|
||||
| Mouse | FL_BUTTON2 | middle button | |
|
||||
| Mouse | FL_BUTTON3 | right button | |
|
||||
| Mouse | FL_BUTTON4 | side button 1 (back) | 1.3.10 |
|
||||
| Mouse | FL_BUTTON5 | side button 2 (forward) | 1.3.10 |
|
||||
*/
|
||||
FL_EXPORT inline 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().
|
||||
*/
|
||||
FL_EXPORT inline int event_state(int mask) { return e_state & mask; }
|
||||
|
||||
//
|
||||
// Keyboard Event Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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&).
|
||||
*/
|
||||
FL_EXPORT inline 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.
|
||||
*/
|
||||
FL_EXPORT inline 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
|
||||
(e.g., FL_KP + '4', 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 Windows Fl::get_key(FL_KP_Enter) and Fl::event_key(FL_KP_Enter) do not work.
|
||||
*/
|
||||
FL_EXPORT extern 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)
|
||||
*/
|
||||
FL_EXPORT extern int get_key(int key); // platform dependent
|
||||
|
||||
//
|
||||
// Text and Clipboard Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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.
|
||||
*/
|
||||
FL_EXPORT inline 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.
|
||||
*/
|
||||
FL_EXPORT inline int event_length() { return e_length; }
|
||||
|
||||
/** Denotes plain textual data
|
||||
*/
|
||||
FL_EXPORT extern char const * const clipboard_plain_text;
|
||||
|
||||
/** Denotes image data
|
||||
*/
|
||||
FL_EXPORT extern char const * const clipboard_image;
|
||||
|
||||
/** During an FL_PASTE event of non-textual data, returns a pointer to the pasted data.
|
||||
The returned data is an Fl_RGB_Image * when the result of Fl::event_clipboard_type() is Fl::clipboard_image.
|
||||
*/
|
||||
FL_EXPORT inline 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.
|
||||
*/
|
||||
FL_EXPORT inline const char *event_clipboard_type() { return e_clipboard_type; }
|
||||
|
||||
|
||||
//
|
||||
// Advanced Event Functions
|
||||
//
|
||||
|
||||
FL_EXPORT extern int compose(int &del);
|
||||
FL_EXPORT extern void compose_reset();
|
||||
FL_EXPORT extern int event_inside(int,int,int,int);
|
||||
FL_EXPORT extern int event_inside(const Fl_Widget*);
|
||||
FL_EXPORT extern int test_shortcut(Fl_Shortcut);
|
||||
|
||||
FL_EXPORT extern void enable_im();
|
||||
FL_EXPORT extern void disable_im();
|
||||
|
||||
//
|
||||
// Event Handling and Widget Management
|
||||
//
|
||||
|
||||
FL_EXPORT extern int handle(int, Fl_Window*);
|
||||
FL_EXPORT extern int handle_(int, Fl_Window*);
|
||||
|
||||
/** Gets the widget that is below the mouse.
|
||||
\see belowmouse(Fl_Widget*) */
|
||||
FL_EXPORT inline Fl_Widget* belowmouse() { return belowmouse_; }
|
||||
FL_EXPORT extern void belowmouse(Fl_Widget*);
|
||||
|
||||
/** Gets the widget that is being pushed.
|
||||
\see void pushed(Fl_Widget*) */
|
||||
FL_EXPORT inline Fl_Widget* pushed() { return pushed_; }
|
||||
FL_EXPORT extern void pushed(Fl_Widget*);
|
||||
|
||||
/** Gets the current Fl::focus() widget. \sa Fl::focus(Fl_Widget*) */
|
||||
FL_EXPORT inline Fl_Widget* focus() { return focus_; }
|
||||
FL_EXPORT extern void focus(Fl_Widget*);
|
||||
|
||||
FL_EXPORT extern void add_handler(Fl_Event_Handler ha);
|
||||
FL_EXPORT extern void add_handler(Fl_Event_Handler ha, Fl_Event_Handler before);
|
||||
FL_EXPORT extern Fl_Event_Handler last_handler();
|
||||
FL_EXPORT extern void remove_handler(Fl_Event_Handler h);
|
||||
FL_EXPORT extern void add_system_handler(Fl_System_Handler h, void *data);
|
||||
FL_EXPORT extern void remove_system_handler(Fl_System_Handler h);
|
||||
FL_EXPORT extern void event_dispatch(Fl_Event_Dispatch d);
|
||||
FL_EXPORT extern Fl_Event_Dispatch event_dispatch();
|
||||
FL_EXPORT extern Fl_Callback_Reason callback_reason();
|
||||
|
||||
//
|
||||
// Convenience State Check Functions
|
||||
//
|
||||
|
||||
/** Returns non-zero if the Shift key is pressed. */
|
||||
FL_EXPORT inline int event_shift() { return e_state & FL_SHIFT; }
|
||||
|
||||
/** Returns non-zero if the Control key is pressed. */
|
||||
FL_EXPORT inline 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. */
|
||||
FL_EXPORT inline int event_command() { return e_state & FL_COMMAND; }
|
||||
|
||||
/** Returns non-zero if the Alt key is pressed. */
|
||||
FL_EXPORT inline int event_alt() { return e_state & FL_ALT; }
|
||||
|
||||
//
|
||||
// Mouse Button State Functions
|
||||
//
|
||||
|
||||
/**
|
||||
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_BUTTON5] }
|
||||
*/
|
||||
FL_EXPORT inline int event_buttons() { return e_state & FL_BUTTONS; }
|
||||
|
||||
/**
|
||||
Returns non-zero if mouse button 1 is currently held down.
|
||||
For more details, see Fl::event_buttons().
|
||||
*/
|
||||
FL_EXPORT inline int event_button1() { return e_state & FL_BUTTON1; }
|
||||
|
||||
/**
|
||||
Returns non-zero if mouse button 2 is currently held down.
|
||||
For more details, see Fl::event_buttons().
|
||||
*/
|
||||
FL_EXPORT inline int event_button2() { return e_state & FL_BUTTON2; }
|
||||
|
||||
/**
|
||||
Returns non-zero if mouse button 3 is currently held down.
|
||||
For more details, see Fl::event_buttons().
|
||||
*/
|
||||
FL_EXPORT inline int event_button3() { return e_state & FL_BUTTON3; }
|
||||
|
||||
/**
|
||||
Returns non-zero if mouse button 4 is currently held down.
|
||||
For more details, see Fl::event_buttons().
|
||||
*/
|
||||
FL_EXPORT inline int event_button4() { return e_state & FL_BUTTON4; }
|
||||
|
||||
/**
|
||||
Returns non-zero if mouse button 5 is currently held down.
|
||||
For more details, see Fl::event_buttons().
|
||||
*/
|
||||
FL_EXPORT inline int event_button5() { return e_state & FL_BUTTON5; }
|
||||
|
||||
/** @} */
|
||||
|
||||
} // namespace Fl
|
||||
|
||||
#endif // !Fl_core_events_H
|
||||
141
FL/core/function_types.H
Normal file
141
FL/core/function_types.H
Normal file
@@ -0,0 +1,141 @@
|
||||
//
|
||||
// Function types for the Fast Light Tool Kit (FLTK).
|
||||
//
|
||||
// Copyright 2025 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:
|
||||
//
|
||||
// https://www.fltk.org/COPYING.php
|
||||
//
|
||||
// Please see the following page on how to report bugs and issues:
|
||||
//
|
||||
// https://www.fltk.org/bugs.php
|
||||
//
|
||||
|
||||
/** \file FL/core/function_types.H
|
||||
\brief FLTK typedefs for service and widget callbacks.
|
||||
*/
|
||||
|
||||
#ifndef Fl_core_function_types_H
|
||||
#define Fl_core_function_types_H
|
||||
|
||||
|
||||
#include <FL/fl_config.h> // build configuration
|
||||
#include <FL/Fl_Export.H> // for FL_EXPORT
|
||||
#include <FL/platform_types.h> // for FL_SOCKET
|
||||
#include <FL/Enumerations.H> // for Fl_Align, Fl_Color, etc.
|
||||
|
||||
class Fl_Window;
|
||||
struct Fl_Label;
|
||||
|
||||
|
||||
/** \defgroup callback_functions Callback Function Typedefs
|
||||
|
||||
\brief Typedefs defined in <FL/core/function_types.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
|
||||
|
||||
@{
|
||||
*/
|
||||
|
||||
//
|
||||
// Drawing and Rendering Function Types
|
||||
//
|
||||
|
||||
/** 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 box focus frame drawing functions */
|
||||
typedef void (Fl_Box_Draw_Focus_F)(Fl_Boxtype bt, int x, int y, int w, int h, Fl_Color fg, Fl_Color bg);
|
||||
|
||||
//
|
||||
// Timer and Scheduling Function Types
|
||||
//
|
||||
|
||||
/** Signature of timeout callback functions passed as parameters.
|
||||
Please see Fl::add_timeout() for details.
|
||||
*/
|
||||
typedef void (*Fl_Timeout_Handler)(void *data);
|
||||
|
||||
/** Signature of some wakeup callback functions passed as parameters */
|
||||
typedef void (*Fl_Awake_Handler)(void *data);
|
||||
|
||||
//
|
||||
// Idle Processing Function Types
|
||||
//
|
||||
|
||||
/** Signature of add_idle callback function passed as parameter.
|
||||
This signature allows an idle callback to use one parameter as an
|
||||
arbitrary `data` value.
|
||||
*/
|
||||
typedef void (*Fl_Idle_Handler)(void *data);
|
||||
|
||||
/** Signature of add_idle callback function passed as parameter.
|
||||
This signature allows an idle callback without parameters.
|
||||
When the callback is called it is called with an additional
|
||||
parameter (set to nullptr) which is not used by the callback.
|
||||
*/
|
||||
typedef void (*Fl_Old_Idle_Handler)();
|
||||
|
||||
//
|
||||
// File Descriptor and I/O Function Types
|
||||
//
|
||||
|
||||
/** Signature of add_fd functions passed as parameters */
|
||||
typedef void (*Fl_FD_Handler)(FL_SOCKET fd, void *data);
|
||||
|
||||
//
|
||||
// Event Handling Function Types
|
||||
//
|
||||
|
||||
/** 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 event_dispatch functions passed as parameters.
|
||||
\see Fl::event_dispatch(Fl_Event_Dispatch) */
|
||||
typedef int (*Fl_Event_Dispatch)(int event, Fl_Window *w);
|
||||
|
||||
//
|
||||
// Application Lifecycle Function Types
|
||||
//
|
||||
|
||||
/** 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);
|
||||
|
||||
//
|
||||
// Clipboard and Data Transfer Function Types
|
||||
//
|
||||
|
||||
/** Signature of add_clipboard_notify functions passed as parameters */
|
||||
typedef void (*Fl_Clipboard_Notify_Handler)(int source, void *data);
|
||||
|
||||
/** @} */ /* group callback_functions */
|
||||
|
||||
|
||||
#endif // !Fl_core_function_types_H
|
||||
162
FL/core/options.H
Normal file
162
FL/core/options.H
Normal file
@@ -0,0 +1,162 @@
|
||||
//
|
||||
// Core options header file for the Fast Light Tool Kit (FLTK).
|
||||
//
|
||||
// Copyright 2025 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:
|
||||
//
|
||||
// https://www.fltk.org/COPYING.php
|
||||
//
|
||||
// Please see the following page on how to report bugs and issues:
|
||||
//
|
||||
// https://www.fltk.org/bugs.php
|
||||
//
|
||||
|
||||
/** \file FL/core/options.H
|
||||
\brief Application and system wide options management.
|
||||
*/
|
||||
|
||||
#ifndef Fl_core_options_H
|
||||
#define Fl_core_options_H
|
||||
|
||||
#include <FL/fl_config.h> // build configuration
|
||||
#include <FL/Fl_Export.H> // for FL_EXPORT
|
||||
|
||||
|
||||
namespace Fl {
|
||||
|
||||
/** 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,
|
||||
|
||||
/// Meaningful for the Wayland/X11 platform only. When switched on, the library uses a Zenity-based file dialog.
|
||||
/// When switched off (default), no zenity-based file dialog is used.
|
||||
OPTION_FNFC_USES_ZENITY,
|
||||
|
||||
/// Meaningful for the Wayland/X11 platform only.
|
||||
/// When switched on, the library uses a kdialog-based file dialog if command 'kdialog' is available on the running system.
|
||||
/// When switched off (default), no kdialog-based file dialog is used.
|
||||
OPTION_FNFC_USES_KDIALOG,
|
||||
|
||||
/// When switched on (default), Fl_Printer runs the GTK printer dialog
|
||||
/// if the GTK library is available on the platform (linux/unix only).
|
||||
/// When switched off, the GTK printer dialog isn't used even if the GTK library is available.
|
||||
OPTION_PRINTER_USES_GTK,
|
||||
|
||||
/// When switched on (default), the library shows in a transient yellow window the zoom factor
|
||||
/// value.
|
||||
/// When switched off, no such window gets displayed.
|
||||
OPTION_SHOW_SCALING,
|
||||
|
||||
/// When switched on and when the keyboard in use has '+' in the shifted position of its key,
|
||||
/// pressing that key and ctrl triggers the zoom-in operation.
|
||||
/// When switched off (default), the zoom-in operation requires that also the shift key is pressed.
|
||||
/// Under macOS, this option has no effect because the OS itself generates ⌘= followed
|
||||
/// by ⌘+ when pressing ⌘ and the '=|+' key without pressing shift.
|
||||
OPTION_SIMPLE_ZOOM_SHORTCUT,
|
||||
|
||||
// don't change this, leave it always as the last element
|
||||
/// For internal use only.
|
||||
OPTION_LAST
|
||||
} Fl_Option;
|
||||
|
||||
/*
|
||||
Return a global setting for all FLTK applications, possibly overridden
|
||||
by a setting specifically for this application.
|
||||
*/
|
||||
FL_EXPORT extern bool option(Fl_Option opt);
|
||||
|
||||
/*
|
||||
Override an option while the application is running.
|
||||
*/
|
||||
FL_EXPORT extern void option(Fl_Option opt, bool val);
|
||||
|
||||
// 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.
|
||||
*/
|
||||
FL_EXPORT inline 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.
|
||||
*/
|
||||
FL_EXPORT inline int visible_focus() { return option(OPTION_VISIBLE_FOCUS); }
|
||||
|
||||
// Drag-n-drop text operation methods...
|
||||
|
||||
/**
|
||||
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.
|
||||
*/
|
||||
FL_EXPORT inline void dnd_text_ops(int v) { option(OPTION_DND_TEXT, (v!=0)); }
|
||||
|
||||
/**
|
||||
Gets whether drag and drop text operations are
|
||||
supported. This returns whether selected text can
|
||||
be dragged from text fields or dragged within a text field as a
|
||||
cut/paste shortcut.
|
||||
*/
|
||||
FL_EXPORT inline int dnd_text_ops() { return option(OPTION_DND_TEXT); }
|
||||
|
||||
} // namespace Fl
|
||||
|
||||
|
||||
#endif // !Fl_core_options_H
|
||||
@@ -189,10 +189,17 @@ if(FLTK_HAVE_CAIRO) # FLTK_OPTION_CAIRO_WINDOW or FLTK_OPTION_CAIRO_EXT
|
||||
list(APPEND CPPFILES Fl_Cairo.cxx)
|
||||
endif()
|
||||
|
||||
# find all header files in source directory <FL/...>
|
||||
# find all header files in includes directory <FL/...>
|
||||
file(GLOB
|
||||
HEADER_FILES
|
||||
"../FL/*.[hH]"
|
||||
"../FL/core/*.[hH]"
|
||||
)
|
||||
|
||||
# find all private header files in source directory "src/..."
|
||||
file(GLOB
|
||||
PRIVATE_HEADER_FILES
|
||||
"*.[hH]"
|
||||
)
|
||||
|
||||
# add generated header files in build directory
|
||||
@@ -409,6 +416,7 @@ else()
|
||||
endif(FLTK_USE_X11 AND NOT FLTK_USE_WAYLAND)
|
||||
|
||||
source_group("Header Files" FILES ${HEADER_FILES})
|
||||
source_group("Private Header Files" FILES ${PRIVATE_HEADER_FILES})
|
||||
source_group("Driver Source Files" FILES ${DRIVER_FILES})
|
||||
source_group("Driver Header Files" FILES ${DRIVER_HEADER_FILES})
|
||||
|
||||
@@ -622,7 +630,7 @@ endif()
|
||||
# prepare source files for shared and static FLTK libraries
|
||||
|
||||
set(SHARED_FILES ${CPPFILES} ${MMFILES} ${CFILES} ${PSFILES})
|
||||
list(APPEND SHARED_FILES ${HEADER_FILES} ${DRIVER_HEADER_FILES})
|
||||
list(APPEND SHARED_FILES ${HEADER_FILES} ${PRIVATE_HEADER_FILES} ${DRIVER_HEADER_FILES})
|
||||
|
||||
set(STATIC_FILES ${SHARED_FILES})
|
||||
|
||||
|
||||
200
src/Fl.cxx
200
src/Fl.cxx
@@ -18,7 +18,7 @@
|
||||
Implementation of the member functions of class Fl.
|
||||
*/
|
||||
|
||||
#include <FL/Fl.H>
|
||||
#include "Fl_Private.H"
|
||||
#include <FL/platform.H>
|
||||
#include "Fl_Screen_Driver.H"
|
||||
#include "Fl_Window_Driver.H"
|
||||
@@ -71,10 +71,10 @@ void *Fl::e_clipboard_data = NULL;
|
||||
Fl_Event_Dispatch Fl::e_dispatch = 0;
|
||||
Fl_Callback_Reason Fl::callback_reason_ = FL_REASON_UNKNOWN;
|
||||
|
||||
unsigned char Fl::options_[] = { 0, 0 };
|
||||
unsigned char Fl::options_read_ = 0;
|
||||
unsigned char Fl::Private::options_[] = { 0, 0 };
|
||||
unsigned char Fl::Private::options_read_ = 0;
|
||||
|
||||
int Fl::selection_to_clipboard_ = 0;
|
||||
int Fl::Private::selection_to_clipboard_ = 0;
|
||||
|
||||
Fl_Window *fl_xfocus = NULL; // which window X thinks has focus
|
||||
Fl_Window *fl_xmousewin; // which window X thinks has FL_ENTER
|
||||
@@ -86,6 +86,45 @@ Fl_Window *Fl::modal_; // topmost modal() window
|
||||
char const * const Fl::clipboard_plain_text = "text/plain";
|
||||
char const * const Fl::clipboard_image = "image";
|
||||
|
||||
/**
|
||||
Copies selections on X11 directly to the clipboard if enabled.
|
||||
|
||||
This method can be called on all platforms. Other platforms than X11 are
|
||||
not affected by this feature.
|
||||
|
||||
If this is switched on (\p mode = 1), Fl::copy() copies all data to the
|
||||
clipboard regardless of its \p destination argument. If the destination is 0
|
||||
(selection buffer) data is copied to both the selection buffer and the clipboard.
|
||||
|
||||
Drag and drop is also affected since drag-and-drop data is copied to the selection
|
||||
buffer.
|
||||
|
||||
You can use this to make the experience of data selection and copying more like
|
||||
that on other platforms (Windows, macOS, and even Wayland).
|
||||
|
||||
The default operation mode is the standard X11 behavior (disabled).
|
||||
|
||||
\note This feature is experimental and enabling it may have unexpected side effects.
|
||||
It is your own responsibility if you enable it.
|
||||
|
||||
\since 1.4.0
|
||||
|
||||
\param[in] mode 1 = enable selection_to_clipboard, 0 = disable selection_to_clipboard
|
||||
|
||||
\see copy(const char *, int, int, const char *)
|
||||
*/
|
||||
void Fl::selection_to_clipboard(int mode) {
|
||||
Private::selection_to_clipboard_ = mode ? 1 : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Returns the current selection_to_clipboard mode.
|
||||
|
||||
\see void selection_to_clipboard(int)
|
||||
*/
|
||||
int Fl::selection_to_clipboard() {
|
||||
return Private::selection_to_clipboard_;
|
||||
}
|
||||
|
||||
//
|
||||
// Drivers
|
||||
@@ -500,7 +539,7 @@ int Fl::has_check(Fl_Timeout_Handler cb, void *argp) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Fl::run_checks()
|
||||
void Fl::Private::run_checks()
|
||||
{
|
||||
// checks are a bit messy so that add/remove and wait may be called
|
||||
// from inside them without causing an infinite loop:
|
||||
@@ -580,7 +619,23 @@ void fl_trigger_clipboard_notify(int source) {
|
||||
////////////////////////////////////////////////////////////////
|
||||
// idle/wait/run/check/ready:
|
||||
|
||||
void (*Fl::idle_)(); // see Fl::add_idle.cxx for the add/remove functions
|
||||
void (*Fl::Private::idle_)(); // see Fl::add_idle.cxx for the add/remove functions
|
||||
|
||||
/**
|
||||
Returns whether at least one idle callback is currently set.
|
||||
|
||||
\c true means that at least one callback is currently queued, but
|
||||
not necessarily active. While a callback is being executed, it is
|
||||
also counted as "set" unless (i.e. before) it removes itself from
|
||||
the idle callback queue (ring).
|
||||
|
||||
\return whether an idle callback is currently set
|
||||
\retval true At least one idle callback is currently set.
|
||||
\retval false No idle callback is currently set.
|
||||
*/
|
||||
bool Fl::idle() {
|
||||
return (Private::idle_ != nullptr);
|
||||
}
|
||||
|
||||
/*
|
||||
Private, undocumented method to run idle callbacks.
|
||||
@@ -598,7 +653,7 @@ void (*Fl::idle_)(); // see Fl::add_idle.cxx for the add/remove functions
|
||||
the first idle callback and appends it to the end of the list of idle
|
||||
callbacks. For details see static function call_idle() in Fl_add_idle.cxx.
|
||||
|
||||
If it is NULL then no idle callbacks are active and Fl::run_idle() returns
|
||||
If it is NULL then no idle callbacks are active and Fl::Private::run_idle() returns
|
||||
immediately.
|
||||
|
||||
Note: idle callbacks can be queued in nested FLTK event loops like
|
||||
@@ -609,11 +664,11 @@ void (*Fl::idle_)(); // see Fl::add_idle.cxx for the add/remove functions
|
||||
if an event (timeout or button click etc.) handler calls Fl::add_idle()
|
||||
or even in Fl::flush() if a draw() method calls Fl::add_idle().
|
||||
*/
|
||||
void Fl::run_idle() {
|
||||
void Fl::Private::run_idle() {
|
||||
static char in_idle;
|
||||
if (Fl::idle_ && !in_idle) {
|
||||
if (Fl::Private::idle_ && !in_idle) {
|
||||
in_idle = 1;
|
||||
Fl::idle_(); // call the idle callback stored in Fl::idle_ == Fl::idle()
|
||||
Fl::Private::idle_(); // call the idle callback stored in Fl::Private::idle_ == Fl::idle()
|
||||
in_idle = 0;
|
||||
}
|
||||
}
|
||||
@@ -733,7 +788,27 @@ void Fl::hide_all_windows() {
|
||||
}
|
||||
}
|
||||
|
||||
int Fl::program_should_quit_ = 0;
|
||||
int Fl::Private::program_should_quit_ = 0;
|
||||
|
||||
/** Returns non-zero when a request for program termination was received and accepted.
|
||||
On the MacOS platform, the "Quit xxx" item of the application menu is such a request,
|
||||
that is considered accepted when all windows are closed. On other platforms, this function
|
||||
returns 0 until \p Fl::program_should_quit(1) is called.
|
||||
\version 1.4.0
|
||||
*/
|
||||
int Fl::program_should_quit() {
|
||||
return Private::program_should_quit_;
|
||||
}
|
||||
|
||||
/** Indicate to the FLTK library whether a program termination request was received and accepted.
|
||||
A program may set this to 1, for example, while performing a platform-independent command asking the program to cleanly
|
||||
terminate, similarly to the "Quit xxx" item of the application menu under MacOS.
|
||||
\version 1.4.0
|
||||
*/
|
||||
void Fl::program_should_quit(int should_i) {
|
||||
Private::program_should_quit_ = should_i;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Window list management:
|
||||
@@ -2046,74 +2121,74 @@ void Fl::clear_widget_pointer(Fl_Widget const *w)
|
||||
*/
|
||||
bool Fl::option(Fl_Option opt)
|
||||
{
|
||||
if (!options_read_) {
|
||||
if (!Private::options_read_) {
|
||||
int tmp;
|
||||
{ // first, read the system wide preferences
|
||||
Fl_Preferences prefs(Fl_Preferences::CORE_SYSTEM, "fltk.org", "fltk");
|
||||
Fl_Preferences opt_prefs(prefs, "options");
|
||||
opt_prefs.get("ArrowFocus", tmp, 0); // default: off
|
||||
options_[OPTION_ARROW_FOCUS] = tmp;
|
||||
Private::options_[OPTION_ARROW_FOCUS] = tmp;
|
||||
//opt_prefs.get("NativeFilechooser", tmp, 1); // default: on
|
||||
//options_[OPTION_NATIVE_FILECHOOSER] = tmp;
|
||||
//Private::options_[OPTION_NATIVE_FILECHOOSER] = tmp;
|
||||
//opt_prefs.get("FilechooserPreview", tmp, 1); // default: on
|
||||
//options_[OPTION_FILECHOOSER_PREVIEW] = tmp;
|
||||
//Private::options_[OPTION_FILECHOOSER_PREVIEW] = tmp;
|
||||
opt_prefs.get("VisibleFocus", tmp, 1); // default: on
|
||||
options_[OPTION_VISIBLE_FOCUS] = tmp;
|
||||
Private::options_[OPTION_VISIBLE_FOCUS] = tmp;
|
||||
opt_prefs.get("DNDText", tmp, 1); // default: on
|
||||
options_[OPTION_DND_TEXT] = tmp;
|
||||
Private::options_[OPTION_DND_TEXT] = tmp;
|
||||
opt_prefs.get("ShowTooltips", tmp, 1); // default: on
|
||||
options_[OPTION_SHOW_TOOLTIPS] = tmp;
|
||||
Private::options_[OPTION_SHOW_TOOLTIPS] = tmp;
|
||||
opt_prefs.get("FNFCUsesGTK", tmp, 1); // default: on
|
||||
options_[OPTION_FNFC_USES_GTK] = tmp;
|
||||
Private::options_[OPTION_FNFC_USES_GTK] = tmp;
|
||||
opt_prefs.get("PrintUsesGTK", tmp, 1); // default: on
|
||||
options_[OPTION_PRINTER_USES_GTK] = tmp;
|
||||
Private::options_[OPTION_PRINTER_USES_GTK] = tmp;
|
||||
|
||||
opt_prefs.get("ShowZoomFactor", tmp, 1); // default: on
|
||||
options_[OPTION_SHOW_SCALING] = tmp;
|
||||
Private::options_[OPTION_SHOW_SCALING] = tmp;
|
||||
opt_prefs.get("UseZenity", tmp, 0); // default: off
|
||||
options_[OPTION_FNFC_USES_ZENITY] = tmp;
|
||||
Private::options_[OPTION_FNFC_USES_ZENITY] = tmp;
|
||||
opt_prefs.get("UseKdialog", tmp, 0); // default: off
|
||||
options_[OPTION_FNFC_USES_KDIALOG] = tmp;
|
||||
Private::options_[OPTION_FNFC_USES_KDIALOG] = tmp;
|
||||
opt_prefs.get("SimpleZoomShortcut", tmp, 0); // default: off
|
||||
options_[OPTION_SIMPLE_ZOOM_SHORTCUT] = tmp;
|
||||
Private::options_[OPTION_SIMPLE_ZOOM_SHORTCUT] = tmp;
|
||||
}
|
||||
{ // next, check the user preferences
|
||||
// override system options only, if the option is set ( >= 0 )
|
||||
Fl_Preferences prefs(Fl_Preferences::CORE_USER, "fltk.org", "fltk");
|
||||
Fl_Preferences opt_prefs(prefs, "options");
|
||||
opt_prefs.get("ArrowFocus", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_ARROW_FOCUS] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_ARROW_FOCUS] = tmp;
|
||||
//opt_prefs.get("NativeFilechooser", tmp, -1);
|
||||
//if (tmp >= 0) options_[OPTION_NATIVE_FILECHOOSER] = tmp;
|
||||
//if (tmp >= 0) Private::options_[OPTION_NATIVE_FILECHOOSER] = tmp;
|
||||
//opt_prefs.get("FilechooserPreview", tmp, -1);
|
||||
//if (tmp >= 0) options_[OPTION_FILECHOOSER_PREVIEW] = tmp;
|
||||
//if (tmp >= 0) Private::options_[OPTION_FILECHOOSER_PREVIEW] = tmp;
|
||||
opt_prefs.get("VisibleFocus", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_VISIBLE_FOCUS] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_VISIBLE_FOCUS] = tmp;
|
||||
opt_prefs.get("DNDText", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_DND_TEXT] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_DND_TEXT] = tmp;
|
||||
opt_prefs.get("ShowTooltips", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_SHOW_TOOLTIPS] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_SHOW_TOOLTIPS] = tmp;
|
||||
opt_prefs.get("FNFCUsesGTK", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_FNFC_USES_GTK] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_FNFC_USES_GTK] = tmp;
|
||||
opt_prefs.get("PrintUsesGTK", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_PRINTER_USES_GTK] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_PRINTER_USES_GTK] = tmp;
|
||||
|
||||
opt_prefs.get("ShowZoomFactor", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_SHOW_SCALING] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_SHOW_SCALING] = tmp;
|
||||
opt_prefs.get("UseZenity", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_FNFC_USES_ZENITY] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_FNFC_USES_ZENITY] = tmp;
|
||||
opt_prefs.get("UseKdialog", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_FNFC_USES_KDIALOG] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_FNFC_USES_KDIALOG] = tmp;
|
||||
opt_prefs.get("SimpleZoomShortcut", tmp, -1);
|
||||
if (tmp >= 0) options_[OPTION_SIMPLE_ZOOM_SHORTCUT] = tmp;
|
||||
if (tmp >= 0) Private::options_[OPTION_SIMPLE_ZOOM_SHORTCUT] = tmp;
|
||||
}
|
||||
{ // now, if the developer has registered this app, we could ask for per-application preferences
|
||||
}
|
||||
options_read_ = 1;
|
||||
Private::options_read_ = 1;
|
||||
}
|
||||
if (opt<0 || opt>=OPTION_LAST)
|
||||
return false;
|
||||
return (bool)(options_[opt]!=0);
|
||||
return (bool)(Private::options_[opt]!=0);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -2142,11 +2217,11 @@ void Fl::option(Fl_Option opt, bool val)
|
||||
{
|
||||
if (opt<0 || opt>=OPTION_LAST)
|
||||
return;
|
||||
if (!options_read_) {
|
||||
if (!Private::options_read_) {
|
||||
// make sure that the options_ array is filled in
|
||||
option(opt);
|
||||
}
|
||||
options_[opt] = val;
|
||||
Private::options_[opt] = val;
|
||||
}
|
||||
|
||||
|
||||
@@ -2169,9 +2244,50 @@ Fl_Widget_Tracker::~Fl_Widget_Tracker()
|
||||
Fl::release_widget_pointer(wp_); // remove pointer from watch list
|
||||
}
|
||||
|
||||
int Fl::use_high_res_GL_ = 0;
|
||||
int Fl::Private::use_high_res_GL_ = 0;
|
||||
|
||||
int Fl::draw_GL_text_with_textures_ = 1;
|
||||
/** sets whether GL windows should be drawn at high resolution on Apple
|
||||
computers with retina displays
|
||||
\version 1.3.4
|
||||
*/
|
||||
void Fl::use_high_res_GL(int val) {
|
||||
Private::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
|
||||
*/
|
||||
int Fl::use_high_res_GL() {
|
||||
return Private::use_high_res_GL_;
|
||||
}
|
||||
|
||||
int Fl::Private::draw_GL_text_with_textures_ = 1;
|
||||
|
||||
/** sets whether OpenGL uses textures to draw all text.
|
||||
By default, FLTK draws OpenGL text using textures, if the necessary
|
||||
hardware support is available. Call \p Fl::draw_GL_text_with_textures(0)
|
||||
once in your program before the first call to gl_font() to have FLTK
|
||||
draw instead OpenGL text using a legacy, platform-dependent procedure.
|
||||
It's recommended not to deactivate textures under the MacOS platform
|
||||
because the MacOS legacy procedure is extremely rudimentary.
|
||||
\param val use 0 to prevent FLTK from drawing GL text with textures
|
||||
\see gl_texture_pile_height(int max)
|
||||
\version 1.4.0
|
||||
*/
|
||||
void Fl::draw_GL_text_with_textures(int val) {
|
||||
Private::draw_GL_text_with_textures_ = val;
|
||||
}
|
||||
|
||||
/** returns whether whether OpenGL uses textures to draw all text.
|
||||
Default is yes.
|
||||
\see draw_GL_text_with_textures(int val)
|
||||
\version 1.4.0
|
||||
*/
|
||||
int Fl::draw_GL_text_with_textures() {
|
||||
return Private::draw_GL_text_with_textures_;
|
||||
}
|
||||
|
||||
int Fl::dnd()
|
||||
{
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
// Preprocessor macro FLTK_HAVE_CAIRO_EXT is defined only for "CAIRO_EXT".
|
||||
// Both macros are defined in 'FL/fl_config.h'.
|
||||
|
||||
#include <FL/Fl.H> // includes <FL/fl_config.h>
|
||||
#include "Fl_Private.H" // includes <FL/fl_config.h>
|
||||
|
||||
#ifdef FLTK_HAVE_CAIRO
|
||||
|
||||
@@ -61,7 +61,53 @@
|
||||
|
||||
// static initialization
|
||||
|
||||
Fl_Cairo_State Fl::cairo_state_; ///< current Cairo context information
|
||||
Fl_Cairo_State Fl::Private::cairo_state_; ///< current Cairo context information
|
||||
|
||||
/** 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
|
||||
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 if built with CMake option FLTK_OPTION_CAIRO_WINDOW=ON.
|
||||
*/
|
||||
void Fl::cairo_autolink_context(bool alink) {
|
||||
Private::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 if built with CMake option FLTK_OPTION_CAIRO_EXT=ON.
|
||||
*/
|
||||
bool Fl::cairo_autolink_context() {
|
||||
return Private::cairo_state_.autolink();
|
||||
}
|
||||
|
||||
/** Gets the current Cairo context linked with a fltk window. */
|
||||
cairo_t *Fl::cairo_cc() {
|
||||
return Private::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 if built with CMake option FLTK_OPTION_CAIRO_WINDOW=ON.
|
||||
*/
|
||||
void Fl::cairo_cc(cairo_t *c, bool own=false) {
|
||||
Private::cairo_state_.cc(c, own);
|
||||
}
|
||||
|
||||
|
||||
// Fl_Cairo_State
|
||||
|
||||
@@ -131,10 +177,10 @@ cairo_t *Fl::cairo_make_current(Fl_Window *wi) {
|
||||
#endif
|
||||
|
||||
#if defined(FLTK_USE_X11)
|
||||
cairo_ctxt = Fl::cairo_make_current(0, wi->w() * scale, wi->h() * scale);
|
||||
cairo_ctxt = Fl::Private::cairo_make_current(0, wi->w() * scale, wi->h() * scale);
|
||||
#else
|
||||
// on macOS, scaling is done before by Fl_Window::make_current(), on Windows, the size is not used
|
||||
cairo_ctxt = Fl::cairo_make_current(fl_gc, wi->w(), wi->h());
|
||||
cairo_ctxt = Fl::Private::cairo_make_current(fl_gc, wi->w(), wi->h());
|
||||
#endif
|
||||
|
||||
#if !defined(USE_MAC_OS)
|
||||
@@ -169,7 +215,7 @@ static cairo_surface_t *cairo_create_surface(void *gc, int W, int H) {
|
||||
|
||||
\note Only available if CMake FLTK_OPTION_CAIRO_WINDOW is enabled.
|
||||
*/
|
||||
cairo_t *Fl::cairo_make_current(void *gc) {
|
||||
cairo_t *Fl::Private::cairo_make_current(void *gc) {
|
||||
int W = 0, H = 0;
|
||||
#if defined(FLTK_USE_X11) || defined(FLTK_USE_WAYLAND)
|
||||
// FIXME X11 get W,H
|
||||
@@ -211,7 +257,7 @@ cairo_t *Fl::cairo_make_current(void *gc) {
|
||||
|
||||
\note Only available if CMake FLTK_OPTION_CAIRO_WINDOW is enabled.
|
||||
*/
|
||||
cairo_t *Fl::cairo_make_current(void *gc, int W, int H) {
|
||||
cairo_t *Fl::Private::cairo_make_current(void *gc, int W, int H) {
|
||||
if (gc == Fl::cairo_state_.gc() &&
|
||||
fl_window == (Window)Fl::cairo_state_.window() &&
|
||||
cairo_state_.cc() != 0) // no need to create a cc, just return that one
|
||||
|
||||
77
src/Fl_Private.H
Normal file
77
src/Fl_Private.H
Normal file
@@ -0,0 +1,77 @@
|
||||
//
|
||||
// Private header file for the Fast Light Tool Kit (FLTK).
|
||||
//
|
||||
// Copyright 2025 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:
|
||||
//
|
||||
// https://www.fltk.org/COPYING.php
|
||||
//
|
||||
// Please see the following page on how to report bugs and issues:
|
||||
//
|
||||
// https://www.fltk.org/bugs.php
|
||||
//
|
||||
|
||||
/** \file src/Fl_Private.H
|
||||
\brief Fl::Private namespace.
|
||||
*/
|
||||
|
||||
#ifndef Fl_Private_H
|
||||
#define Fl_Private_H
|
||||
|
||||
#include <FL/fl_config.h> // build configuration
|
||||
#include <FL/Fl.H>
|
||||
|
||||
/**
|
||||
FLTK private global variables and functions.
|
||||
*/
|
||||
namespace Fl {
|
||||
namespace Private {
|
||||
|
||||
FL_EXPORT extern int use_high_res_GL_;
|
||||
FL_EXPORT extern int draw_GL_text_with_textures_;
|
||||
FL_EXPORT extern int box_shadow_width_;
|
||||
FL_EXPORT extern int box_border_radius_max_;
|
||||
FL_EXPORT extern int selection_to_clipboard_;
|
||||
|
||||
FL_EXPORT extern unsigned char options_[OPTION_LAST];
|
||||
FL_EXPORT extern unsigned char options_read_;
|
||||
FL_EXPORT extern int program_should_quit_; // non-zero means the program was asked to cleanly terminate
|
||||
|
||||
/**
|
||||
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()
|
||||
*/
|
||||
FL_EXPORT extern void (*idle_)();
|
||||
|
||||
FL_EXPORT extern void run_idle();
|
||||
FL_EXPORT extern void run_checks();
|
||||
|
||||
/**
|
||||
Sets an idle callback (internal use only).
|
||||
|
||||
This method is now private and is used to store the idle callback.
|
||||
The old, public set_idle() method was deprecated since 1.3.x and
|
||||
is no longer available in FLTK 1.5.
|
||||
|
||||
See documentation: use Fl::add_idle() instead.
|
||||
*/
|
||||
FL_EXPORT inline void set_idle_(Fl_Old_Idle_Handler cb) { idle_ = cb; }
|
||||
|
||||
#ifdef FLTK_HAVE_CAIRO
|
||||
|
||||
FL_EXPORT extern cairo_t *cairo_make_current(void *gc);
|
||||
FL_EXPORT extern cairo_t *cairo_make_current(void *gc, int W, int H);
|
||||
FL_EXPORT extern Fl_Cairo_State cairo_state_;
|
||||
|
||||
#endif // FLTK_HAVE_CAIRO
|
||||
|
||||
} // namespace Private
|
||||
} // namespace Fl
|
||||
|
||||
#endif // !Fl_Private_H
|
||||
@@ -58,7 +58,7 @@ class Fl_Sys_Menu_Bar_Driver;
|
||||
Each supported platform implements several of the virtual methods of this class.
|
||||
*/
|
||||
class Fl_System_Driver {
|
||||
friend class Fl;
|
||||
friend Fl_System_Driver *Fl::system_driver();
|
||||
protected:
|
||||
// implement once for each platform
|
||||
static Fl_System_Driver *newSystemDriver();
|
||||
|
||||
@@ -21,7 +21,7 @@
|
||||
*/
|
||||
|
||||
#include "Fl_System_Driver.H"
|
||||
#include <FL/Fl.H>
|
||||
#include "Fl_Private.H"
|
||||
#include "Fl_Timeout.h"
|
||||
#include <FL/Fl_File_Icon.H>
|
||||
#include <FL/fl_utf8.h>
|
||||
@@ -357,8 +357,8 @@ double Fl_System_Driver::wait(double time_to_wait) {
|
||||
Fl::do_widget_deletion();
|
||||
|
||||
Fl_Timeout::do_timeouts();
|
||||
Fl::run_checks();
|
||||
Fl::run_idle();
|
||||
Fl::Private::run_checks();
|
||||
Fl::Private::run_idle();
|
||||
|
||||
// The idle function may turn off idle() if *all* idle callbacks
|
||||
// are removed from the callback queue (ring), we can then wait.
|
||||
|
||||
@@ -173,8 +173,10 @@ void Fl::default_atclose(Fl_Window* window, void* v) {
|
||||
window->hide();
|
||||
Fl_Widget::default_callback(window, v); // put on Fl::read_queue()
|
||||
}
|
||||
|
||||
/** Back compatibility: default window callback handler \see Fl::set_atclose() */
|
||||
void (*Fl::atclose)(Fl_Window*, void*) = default_atclose;
|
||||
void (*Fl::atclose)(Fl_Window*, void*) = Fl::default_atclose;
|
||||
|
||||
/** Back compatibility: Sets the default callback v for win to call on close event */
|
||||
void Fl_Window::default_callback(Fl_Window* win, void* v) {
|
||||
Fl::atclose(win, v);
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
// Replaces the older set_idle() call which has been renamed to set_idle_(),
|
||||
// is now private in class Fl::, and is used to implement this.
|
||||
|
||||
#include <FL/Fl.H>
|
||||
#include "Fl_Private.H"
|
||||
|
||||
struct idle_cb {
|
||||
void (*cb)(void*);
|
||||
@@ -83,7 +83,7 @@ void Fl::add_idle(Fl_Idle_Handler cb, void* data) {
|
||||
} else {
|
||||
first = last = p;
|
||||
p->next = p;
|
||||
set_idle_(call_idle);
|
||||
Private::set_idle_(call_idle);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -161,7 +161,7 @@ void Fl::remove_idle(Fl_Idle_Handler cb, void* data) {
|
||||
}
|
||||
if (l == p) { // only one
|
||||
first = last = 0;
|
||||
set_idle_(0);
|
||||
Private::set_idle_(0);
|
||||
} else {
|
||||
last = l;
|
||||
first = l->next = p->next;
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
// boxtypes. Other box types are in separate files so they are not
|
||||
// linked in if not used.
|
||||
|
||||
#include <FL/Fl.H>
|
||||
#include "src/Fl_Private.H"
|
||||
#include <FL/Fl_Widget.H>
|
||||
#include <FL/fl_draw.H>
|
||||
#include <config.h>
|
||||
@@ -46,8 +46,47 @@ static const uchar inactive_ramp[24] = {
|
||||
51, 51, 52, 52};
|
||||
static int draw_it_active = 1;
|
||||
|
||||
int Fl::box_border_radius_max_ = 15;
|
||||
int Fl::box_shadow_width_ = 3;
|
||||
int Fl::Private::box_border_radius_max_ = 15;
|
||||
|
||||
/** Get the maximum border radius of all "rounded" boxtypes in pixels.
|
||||
\since 1.4.0
|
||||
*/
|
||||
int Fl::box_border_radius_max() {
|
||||
return Private::box_border_radius_max_;
|
||||
}
|
||||
|
||||
/** Set the maximum border radius of all "rounded" boxtypes in pixels.
|
||||
Must be at least 5, default = 15.
|
||||
|
||||
\note This does \b not apply to the "round" boxtypes which have really round sides
|
||||
(i.e. composed of half circles) as opposed to "rounded" boxtypes that have only
|
||||
rounded corners with a straight border between corners.
|
||||
|
||||
The box border radius of "rounded" boxtypes is typically calculated as about 2/5 of
|
||||
the box height or width, whichever is smaller. The upper limit can be set by this
|
||||
method for all "rounded" boxtypes.
|
||||
\since 1.4.0
|
||||
*/
|
||||
void Fl::box_border_radius_max(int R) {
|
||||
Private::box_border_radius_max_ = R < 5 ? 5 : R;
|
||||
}
|
||||
|
||||
int Fl::Private::box_shadow_width_ = 3;
|
||||
|
||||
/** Get the box shadow width of all "shadow" boxtypes in pixels.
|
||||
\since 1.4.0
|
||||
*/
|
||||
int Fl::box_shadow_width() {
|
||||
return Private::box_shadow_width_;
|
||||
}
|
||||
|
||||
/** Set the box shadow width of all "shadow" boxtypes in pixels.
|
||||
Must be at least 1, default = 3. There is no upper limit.
|
||||
\since 1.4.0
|
||||
*/
|
||||
void Fl::box_shadow_width(int W) {
|
||||
Private::box_shadow_width_ = W < 1 ? 1 : W;
|
||||
}
|
||||
|
||||
/**
|
||||
Determines if the currently drawn box is active or inactive.
|
||||
|
||||
Reference in New Issue
Block a user