// // Enumerations for the Fast Light Tool Kit (FLTK). // // Copyright 1998-2024 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 This file contains type definitions and general enumerations. */ #ifndef Fl_Enumerations_H #define Fl_Enumerations_H /* ****************************************************************************** * FL_ABI_VERSION is defined by configure or CMake since FLTK 1.3.4. * It is written to FL/fl_config.h and #included here. ****************************************************************************** * For more informations on FL_ABI_VERSION see README.abi-version.txt. ****************************************************************************** */ #include # include "Fl_Export.H" # include "fl_types.h" # include // for FL_COMMAND and FL_CONTROL /** \name Version Numbers FLTK defines some constants to help the programmer to find out, for which FLTK version a program is compiled. The following constants are defined: */ /**@{*/ /** The major release version of this FLTK library. \see FL_VERSION */ #define FL_MAJOR_VERSION 1 /** The minor release version for this library. FLTK remains mostly source-code compatible between minor version changes. */ #define FL_MINOR_VERSION 4 /** The patch version for this library. FLTK remains binary compatible between patches. */ #define FL_PATCH_VERSION 0 /** The FLTK version number as a \em double. FL_VERSION is a \em double that describes the major, minor, and patch version numbers. Version 1.2.3 is actually stored as 1.0203 to allow for more than 9 minor and patch releases. \deprecated This \p double version number is retained for compatibility with existing program code. New code should use \em int FL_API_VERSION instead. FL_VERSION is deprecated because comparisons of floating point values may fail due to rounding errors. However, there are currently no plans to remove this deprecated constant. FL_VERSION is equivalent to (double)FL_API_VERSION / 10000. \see Fl::version() (deprecated as well) \see FL_API_VERSION \see Fl::api_version() */ #define FL_VERSION ( (double)FL_MAJOR_VERSION + \ (double)FL_MINOR_VERSION * 0.01 + \ (double)FL_PATCH_VERSION * 0.0001 ) /** The FLTK API version number as an \em int. FL_API_VERSION is an \em int that describes the major, minor, and patch version numbers. Version 1.2.3 is actually stored as 10203 to allow for more than 9 minor and patch releases. The FL_MAJOR_VERSION, FL_MINOR_VERSION, and FL_PATCH_VERSION constants give the integral values for the major, minor, and patch releases respectively. \note FL_API_VERSION is intended to replace the deprecated \em double FL_VERSION. \see Fl::api_version() */ #define FL_API_VERSION (FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100 + FL_PATCH_VERSION) /** The FLTK ABI (Application Binary Interface) version number as an \em int. FL_ABI_VERSION is an \em int that describes the major, minor, and patch ABI version numbers in the same format as FL_API_VERSION. The ABI version number \p FL_ABI_VERSION is usually the same as the API version \p FL_API_VERSION with the last two digits set to '00'. FLTK retains the ABI (Application Binary Interface) during patch releases of the same major and minor versions. Examples: \verbatim FLTK Version FL_API_VERSION FL_ABI_VERSION FL_VERSION (deprecated) 1.3.0 10300 10300 1.0300 1.3.4 10304 10300 1.0304 \endverbatim Version 1.2.3 is actually stored as 10203 to allow for more than 9 minor and patch releases. The FL_MAJOR_VERSION, FL_MINOR_VERSION, and FL_PATCH_VERSION constants give the integral values for the major, minor, and patch releases respectively. To enable new ABI-breaking features in patch releases you can configure FLTK to use a higher FL_ABI_VERSION. \see README.abi-version.txt */ #ifndef FL_ABI_VERSION #define FL_ABI_VERSION (FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100) #endif /* Check if FL_ABI_VERSION is out of allowed range; redefine if necessary. This is done to prevent users from defining an illegal ABI version. Rule: FL_MAJOR_VERSION * 10000 + FL_MINOR_VERSION * 100 <= FL_ABI_VERSION <= FL_API_VERSION. Example (FLTK 1.3.4): 10300 <= FL_ABI_VERSION <= 10304 Note: configure + CMake can be used to define FL_ABI_VERSION, but they do not check validity. This is done here. */ #if FL_ABI_VERSION < FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100 # undef FL_ABI_VERSION # define FL_ABI_VERSION (FL_MAJOR_VERSION*10000 + FL_MINOR_VERSION*100) #elif FL_ABI_VERSION > FL_API_VERSION # undef FL_ABI_VERSION # define FL_ABI_VERSION FL_API_VERSION #endif /**@}*/ // group: Version Numbers /** Every time a user moves the mouse pointer, clicks a button, or presses a key, an event is generated and sent to your application. Events can also come from other programs like the window manager. Events are identified by the integer argument passed to the Fl_Widget::handle() virtual method. Other information about the most recent event is stored in static locations and acquired by calling the Fl::event_*() methods. This static information remains valid until the next event is read from the window system, so it is ok to look at it outside of the handle() method. Event numbers can be converted to their actual names using the \ref fl_eventnames[] array defined in \#include <FL/names.h> \see Fl::event_text(), Fl::event_key(), class Fl:: */ // DEV NOTE: Keep this list in sync with FL/names.h enum Fl_Event { // events /** No event. */ FL_NO_EVENT = 0, /** A mouse button has gone down with the mouse pointing at this widget. You can find out what button by calling Fl::event_button(). You find out the mouse position by calling Fl::event_x() and Fl::event_y(). A widget indicates that it "wants" the mouse click by returning non-zero from its Fl_Widget::handle() method. It will then become the Fl::pushed() widget and will get FL_DRAG and the matching FL_RELEASE events. If Fl_Widget::handle() returns zero then FLTK will try sending the FL_PUSH to another widget. */ FL_PUSH = 1, /** A mouse button has been released. You can find out what button by calling Fl::event_button(). In order to receive the FL_RELEASE event, the widget must return non-zero when handling FL_PUSH. */ FL_RELEASE = 2, /** The mouse has been moved to point at this widget. This can be used for highlighting feedback. If a widget wants to highlight or otherwise track the mouse, it indicates this by returning non-zero from its handle() method. It then becomes the Fl::belowmouse() widget and will receive FL_MOVE and FL_LEAVE events. */ FL_ENTER = 3, /** The mouse has moved out of the widget. In order to receive the FL_LEAVE event, the widget must return non-zero when handling FL_ENTER. */ FL_LEAVE = 4, /** The mouse has moved with a button held down. The current button state is in Fl::event_state(). The mouse position is in Fl::event_x() and Fl::event_y(). In order to receive FL_DRAG events, the widget must return non-zero when handling FL_PUSH. */ FL_DRAG = 5, /** This indicates an attempt to give a widget the keyboard focus. If a widget wants the focus, it should change itself to display the fact that it has the focus, and return non-zero from its handle() method. It then becomes the Fl::focus() widget and gets FL_KEYDOWN, FL_KEYUP, and FL_UNFOCUS events. The focus will change either because the window manager changed which window gets the focus, or because the user tried to navigate using tab, arrows, or other keys. You can check Fl::event_key() to figure out why it moved. For navigation it will be the key pressed and for interaction with the window manager it will be zero. */ FL_FOCUS = 6, /** This event is sent to the previous Fl::focus() widget when another widget gets the focus or the window loses focus. */ FL_UNFOCUS = 7, /** A key was pressed (FL_KEYDOWN) or released (FL_KEYUP). Fl_KEYBOARD is a synonym for FL_KEYDOWN. The key can be found in Fl::event_key(). The text that the key should insert can be found with Fl::event_text() and its length is in Fl::event_length(). If you use the key handle() should return 1. If you return zero then FLTK assumes you ignored the key and will then attempt to send it to a parent widget. If none of them want it, it will change the event into a FL_SHORTCUT event. To receive FL_KEYBOARD events you must also respond to the FL_FOCUS and FL_UNFOCUS events. If you are writing a text-editing widget you may also want to call the Fl::compose() function to translate individual keystrokes into non-ASCII characters. FL_KEYUP events are sent to the widget that currently has focus. This is not necessarily the same widget that received the corresponding FL_KEYDOWN event because focus may have changed between events. */ FL_KEYDOWN = 8, /** Equivalent to FL_KEYDOWN. \see FL_KEYDOWN */ FL_KEYBOARD = 8, /** Key release event. \see FL_KEYDOWN */ FL_KEYUP = 9, /** The user clicked the close button of a window. This event is used internally only to trigger the callback of Fl_Window derived classed. The default callback closes the window calling Fl_Window::hide(). */ FL_CLOSE = 10, /** The mouse has moved without any mouse buttons held down. This event is sent to the Fl::belowmouse() widget. In order to receive FL_MOVE events, the widget must return non-zero when handling FL_ENTER. */ FL_MOVE = 11, /** If the Fl::focus() widget is zero or ignores an FL_KEYBOARD event then FLTK tries sending this event to every widget it can, until one of them returns non-zero. FL_SHORTCUT is first sent to the Fl::belowmouse() widget, then its parents and siblings, and eventually to every widget in the window, trying to find an object that returns non-zero. FLTK tries really hard to not to ignore any keystrokes! You can also make "global" shortcuts by using Fl::add_handler(). A global shortcut will work no matter what windows are displayed or which one has the focus. */ FL_SHORTCUT = 12, /** This widget is no longer active, due to Fl_Widget::deactivate() being called on it or one of its parents. Fl_Widget::active() may still be true after this, the widget is only active if Fl_Widget::active() is true on it and all its parents (use Fl_Widget::active_r() to check this). */ FL_DEACTIVATE = 13, /** This widget is now active, due to Fl_Widget::activate() being called on it or one of its parents. */ FL_ACTIVATE = 14, /** This widget is no longer visible, due to Fl_Widget::hide() being called on it or one of its parents, or due to a parent window being minimized. Fl_Widget::visible() may still be true after this, but the widget is visible only if visible() is true for it and all its parents (use Fl_Widget::visible_r() to check this). */ FL_HIDE = 15, /** This widget is visible again, due to Fl_Widget::show() being called on it or one of its parents, or due to a parent window being restored. Child Fl_Windows respond to this by actually creating the window if not done already, so if you subclass a window, be sure to pass FL_SHOW to the base class Fl_Widget::handle() method! */ FL_SHOW = 16, /** You should get this event some time after you call Fl::paste(). The contents of Fl::event_text() is the text to insert and the number of characters is in Fl::event_length(). */ FL_PASTE = 17, /** The Fl::selection_owner() will get this event before the selection is moved to another widget. This indicates that some other widget or program has claimed the selection. Motif programs used this to clear the selection indication. Most modern programs ignore this. */ FL_SELECTIONCLEAR = 18, /** The user has moved the mouse wheel. The Fl::event_dx() and Fl::event_dy() methods can be used to find the amount to scroll horizontally and vertically. */ FL_MOUSEWHEEL = 19, /** The mouse has been moved to point at this widget. A widget that is interested in receiving drag'n'drop data must return 1 to receive FL_DND_DRAG, FL_DND_LEAVE and FL_DND_RELEASE events. */ FL_DND_ENTER = 20, /** The mouse has been moved inside a widget while dragging data. A widget that is interested in receiving drag'n'drop data should indicate the possible drop position. */ FL_DND_DRAG = 21, /** The mouse has moved out of the widget. */ FL_DND_LEAVE = 22, /** The user has released the mouse button dropping data into the widget. If the widget returns 1, it will receive the data in the immediately following FL_PASTE event. */ FL_DND_RELEASE = 23, /** The screen configuration (number, positions) was changed. Use Fl::add_handler() to be notified of this event. */ FL_SCREEN_CONFIGURATION_CHANGED = 24, /** The fullscreen state of the window has changed. This event is sent to the window's handle method. */ FL_FULLSCREEN = 25, /** The user has made a zoom/pinch/magnification gesture (Mac OS platform only). The Fl::event_dy() method can be used to find magnification amount, Fl::event_x() and Fl::event_y() are set as well. This event is sent to the window's handle method. */ FL_ZOOM_GESTURE = 26, /** A zoom event (ctrl/+/-/0/ or cmd/+/-/0/) was processed. Use Fl::add_handler() to be notified of this event. */ FL_ZOOM_EVENT = 27 // DEV NOTE: Keep this list in sync with FL/names.h }; /** \name When Conditions */ /**@{*/ /** These constants determine when a callback is performed. Fl_When is a bit field. Some values are merely shortcuts for common bit combinations. New flags may be added in the future, so it's important to mask the required bit when reading via \p when(). \note Some widgets may not fully support \p FL_WHEN_... flags. \see Fl_Widget::when(), Fl::callback_reason(), Fl_Callback_Reason, Fl_Widget::do_callback() */ enum Fl_When { // Fl_Widget::when(): FL_WHEN_NEVER = 0, ///< Never call the callback FL_WHEN_CHANGED = 1, ///< Do the callback only when the widget value changes FL_WHEN_NOT_CHANGED = 2, ///< Do the callback whenever the user interacts with the widget FL_WHEN_RELEASE = 4, ///< Do the callback when the button or key is released and the value changes FL_WHEN_RELEASE_ALWAYS = 6, ///< Do the callback when the button or key is released, even if the value doesn't change FL_WHEN_ENTER_KEY = 8, ///< Do the callback when the user presses the ENTER key and the value changes FL_WHEN_ENTER_KEY_ALWAYS = 10, ///< Do the callback when the user presses the ENTER key, even if the value doesn't change FL_WHEN_ENTER_KEY_CHANGED = 11, ///< Do callbacks whether the value changed or not, and when the ENTER key is pressed FL_WHEN_CLOSED = 16 ///< Do the callback when a child of Fl_Tabs is closed }; /**@}*/ // group: When Conditions /** \name Callback Reasons */ /**@{*/ /** These constants describe why a callback is performed. \see Fl::callback_reason(), Fl_Widget::when(), Fl_When */ enum Fl_Callback_Reason { FL_REASON_UNKNOWN=0, ///< unknown or unset reason FL_REASON_SELECTED, ///< an item was selected FL_REASON_DESELECTED, ///< an item was de-selected FL_REASON_RESELECTED, ///< an item was re-selected (double-clicked). FL_REASON_OPENED, ///< an item was opened FL_REASON_CLOSED, ///< an item was closed FL_REASON_DRAGGED, ///< an item was dragged into a new place FL_REASON_CANCELLED, ///< a dialog was cancelled FL_REASON_CHANGED, ///< the value of the widget was modified FL_REASON_GOT_FOCUS, ///< a widget received focus FL_REASON_LOST_FOCUS, ///< a widget lost focus FL_REASON_RELEASED, ///< the mouse button was released FL_REASON_ENTER_KEY, ///< user finished input pressing Enter FL_REASON_USER = 32 ///< user defined callback reasons }; /**@}*/ // group: Callback Reasons /** \name Names of Non-ASCII keys and mouse buttons The following constants define the names of non-ASCII keys on the keyboard and of mouse buttons for FL_KEYBOARD and FL_SHORTCUT events. \see Fl::event_key() and Fl::get_key(int) (use ASCII letters for all other keys): */ /**@{*/ // FIXME: These codes collide with valid Unicode keys #define FL_Button 0xfee8 ///< A mouse button; use FL_Button + n for mouse button \c n. #define FL_BackSpace 0xff08 ///< The backspace key. #define FL_Tab 0xff09 ///< The tab key. #define FL_Iso_Key 0xff0c ///< The additional key of ISO keyboards. #define FL_Enter 0xff0d ///< The enter key. #define FL_Pause 0xff13 ///< The pause key. #define FL_Scroll_Lock 0xff14 ///< The scroll lock key. #define FL_Escape 0xff1b ///< The escape key. #define FL_Kana 0xff2e ///< The Kana key of JIS keyboards. #define FL_Eisu 0xff2f ///< The Eisu key of JIS keyboards. #define FL_Yen 0xff30 ///< The Yen key of JIS keyboards. #define FL_JIS_Underscore 0xff31 ///< The underscore key of JIS keyboards. #define FL_Home 0xff50 ///< The home key. #define FL_Left 0xff51 ///< The left arrow key. #define FL_Up 0xff52 ///< The up arrow key. #define FL_Right 0xff53 ///< The right arrow key. #define FL_Down 0xff54 ///< The down arrow key. #define FL_Page_Up 0xff55 ///< The page-up key. #define FL_Page_Down 0xff56 ///< The page-down key. #define FL_End 0xff57 ///< The end key. #define FL_Print 0xff61 ///< The print (or print-screen) key. #define FL_Insert 0xff63 ///< The insert key. #define FL_Menu 0xff67 ///< The menu key. #define FL_Help 0xff68 ///< The 'help' key on Mac keyboards #define FL_Num_Lock 0xff7f ///< The num lock key. #define FL_KP 0xff80 ///< One of the keypad numbers; use FL_KP + 'n' for digit n. #define FL_KP_Enter 0xff8d ///< The enter key on the keypad, same as Fl_KP+'\\r'. #define FL_KP_Last 0xffbd ///< The last keypad key; use to range-check keypad. #define FL_F 0xffbd ///< One of the function keys; use FL_F + n for function key n. #define FL_F_Last 0xffe0 ///< The last function key; use to range-check function keys. #define FL_Shift_L 0xffe1 ///< The lefthand shift key. #define FL_Shift_R 0xffe2 ///< The righthand shift key. #define FL_Control_L 0xffe3 ///< The lefthand control key. #define FL_Control_R 0xffe4 ///< The righthand control key. #define FL_Caps_Lock 0xffe5 ///< The caps lock key. #define FL_Meta_L 0xffe7 ///< The left meta/Windows key. #define FL_Meta_R 0xffe8 ///< The right meta/Windows key. #define FL_Alt_L 0xffe9 ///< The left alt key. #define FL_Alt_R 0xffea ///< The right alt key. #define FL_Delete 0xffff ///< The delete key. #define FL_Alt_Gr 0xfe03 ///< The AltGr key on some international keyboards. // These use the Private Use Area (PUA) of the Basic Multilingual Plane // of Unicode. Guaranteed not to conflict with a proper Unicode character. // These primarily map to the XFree86 keysym range #define FL_Volume_Down 0xEF11 ///< Volume control down #define FL_Volume_Mute 0xEF12 ///< Mute sound from the system #define FL_Volume_Up 0xEF13 ///< Volume control up #define FL_Media_Play 0xEF14 ///< Start playing of audio #define FL_Media_Stop 0xEF15 ///< Stop playing audio #define FL_Media_Prev 0xEF16 ///< Previous track #define FL_Media_Next 0xEF17 ///< Next track #define FL_Home_Page 0xEF18 ///< Display user's home page #define FL_Mail 0xEF19 ///< Invoke user's mail program #define FL_Search 0xEF1B ///< Search #define FL_Back 0xEF26 ///< Like back on a browser #define FL_Forward 0xEF27 ///< Like forward on a browser #define FL_Stop 0xEF28 ///< Stop current operation #define FL_Refresh 0xEF29 ///< Refresh the page #define FL_Sleep 0xEF2F ///< Put system to sleep #define FL_Favorites 0xEF30 ///< Show favorite locations /**@}*/ // group: Non-ASCII key names /** \name Mouse Buttons These constants define the button numbers for FL_PUSH and FL_RELEASE events. \see Fl::event_button() */ /**@{*/ #define FL_LEFT_MOUSE 1 ///< The left mouse button #define FL_MIDDLE_MOUSE 2 ///< The middle mouse button #define FL_RIGHT_MOUSE 3 ///< The right mouse button /**@}*/ // group: Mouse Buttons /** \name Event States The following constants define bits in the Fl::event_state() value. */ /**@{*/ // group: Event States // FIXME: it would be nice to have the modifiers in the upper 8 bit so that // a unicode key (24bit) can be sent as an unsigned with the modifiers. #define FL_SHIFT 0x00010000 ///< One of the shift keys is down #define FL_CAPS_LOCK 0x00020000 ///< The caps lock is on #define FL_CTRL 0x00040000 ///< One of the ctrl keys is down #define FL_ALT 0x00080000 ///< One of the alt keys is down #define FL_NUM_LOCK 0x00100000 ///< The num lock is on // most X servers do this? #define FL_META 0x00400000 ///< One of the meta/Windows keys is down // correct for XFree86 #define FL_SCROLL_LOCK 0x00800000 ///< The scroll lock is on // correct for XFree86 #define FL_BUTTON1 0x01000000 ///< Mouse button 1 is pushed #define FL_BUTTON2 0x02000000 ///< Mouse button 2 is pushed #define FL_BUTTON3 0x04000000 ///< Mouse button 3 is pushed #define FL_BUTTONS 0x7f000000 ///< Any mouse button is pushed #define FL_BUTTON(n) (0x00800000<<(n)) ///< Mouse button n (n > 0) is pushed #define FL_KEY_MASK 0x0000ffff ///< All keys are 16 bit for now // FIXME: Unicode needs 24 bits! /**@}*/ // group: Event States /** \name Box Types \brief FLTK standard box types This enum defines the standard box types included with FLTK. \note The documented \p enum \p Fl_Boxtype contains some values (names) with leading underscores, e.g. \p \b _FL_SHADOW_BOX. This is due to technical reasons - please use the same values (names) without the leading underscore in your code! Enum values with leading underscores are reserved for internal use and subject to change without notice! FL_NO_BOX means nothing is drawn at all, so whatever is already on the screen remains. The FL_..._FRAME types only draw their edges, leaving the interior unchanged. The blue color in the image below is the area that is not drawn by the frame types. \anchor boxTypesImage \image html boxtypes.png "FLTK Standard Box Types" \image latex boxtypes.png "FLTK Standard Box Types" width=12cm \note Not all box types are depicted in the figure above. See enum \ref Fl_Boxtype below for the complete list of box types. \see Fl::get_system_colors() */ /**@{*/ // group: Box Types /** \brief FLTK standard box types This enum defines the standard box types included with FLTK. \note The documented \p enum \p Fl_Boxtype contains some values (names) with leading underscores, e.g. \p \b _FL_SHADOW_BOX. This is due to technical reasons - please use the same values (names) without the leading underscore in your code! Enum values with leading underscores are reserved for internal use and subject to change without notice! */ enum Fl_Boxtype { // boxtypes (if you change these you must also change fl_boxtype.cxx): FL_NO_BOX = 0, ///< nothing is drawn at all, this box is invisible FL_FLAT_BOX, ///< a flat box FL_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_UP_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_DOWN_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_THIN_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_THIN_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_THIN_UP_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_THIN_DOWN_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_ENGRAVED_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_EMBOSSED_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_ENGRAVED_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_EMBOSSED_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) FL_BORDER_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage) _FL_SHADOW_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_SHADOW_BOX FL_BORDER_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage) _FL_SHADOW_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_SHADOW_FRAME _FL_ROUNDED_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUNDED_BOX _FL_RSHADOW_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_RSHADOW_BOX _FL_ROUNDED_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUNDED_FRAME _FL_RFLAT_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_RFLAT_BOX _FL_ROUND_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUND_UP_BOX _FL_ROUND_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_ROUND_DOWN_BOX _FL_DIAMOND_UP_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_DIAMOND_UP_BOX _FL_DIAMOND_DOWN_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_DIAMOND_DOWN_BOX _FL_OVAL_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OVAL_BOX _FL_OSHADOW_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OSHADOW_BOX _FL_OVAL_FRAME, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OVAL_FRAME _FL_OFLAT_BOX, ///< see figure [Standard Box Types](@ref boxTypesImage), use FL_OFLAT_BOX _FL_PLASTIC_UP_BOX, ///< plastic version of FL_UP_BOX, use FL_PLASTIC_UP_BOX _FL_PLASTIC_DOWN_BOX, ///< plastic version of FL_DOWN_BOX, use FL_PLASTIC_DOWN_BOX _FL_PLASTIC_UP_FRAME, ///< plastic version of FL_UP_FRAME, use FL_PLASTIC_UP_FRAME _FL_PLASTIC_DOWN_FRAME, ///< plastic version of FL_DOWN_FRAME, use FL_PLASTIC_DOWN_FRAME _FL_PLASTIC_THIN_UP_BOX, ///< plastic version of FL_THIN_UP_BOX, use FL_PLASTIC_THIN_UP_BOX _FL_PLASTIC_THIN_DOWN_BOX, ///< plastic version of FL_THIN_DOWN_BOX, use FL_PLASTIC_THIN_DOWN_BOX _FL_PLASTIC_ROUND_UP_BOX, ///< plastic version of FL_ROUND_UP_BOX, use FL_PLASTIC_ROUND_UP_BOX _FL_PLASTIC_ROUND_DOWN_BOX, ///< plastic version of FL_ROUND_DOWN_BOX, use FL_PLASTIC_ROUND_DOWN_BOX _FL_GTK_UP_BOX, ///< gtk+ version of FL_UP_BOX, use FL_GTK_UP_BOX _FL_GTK_DOWN_BOX, ///< gtk+ version of FL_DOWN_BOX, use FL_GTK_DOWN_BOX _FL_GTK_UP_FRAME, ///< gtk+ version of FL_UP_FRAME, use FL_GTK_UP_FRAME _FL_GTK_DOWN_FRAME, ///< gtk+ version of FL_DOWN_FRAME, use FL_GTK_DOWN_FRAME _FL_GTK_THIN_UP_BOX, ///< gtk+ version of FL_THIN_UP_BOX, use FL_GTK_THIN_UP_BOX _FL_GTK_THIN_DOWN_BOX, ///< gtk+ version of FL_THIN_DOWN_BOX, use FL_GTK_THIN_DOWN_BOX _FL_GTK_THIN_UP_FRAME, ///< gtk+ version of FL_THIN_UP_FRAME, use FL_GTK_THIN_UP_FRAME _FL_GTK_THIN_DOWN_FRAME, ///< gtk+ version of FL_THIN_DOWN_FRAME, use FL_GTK_THIN_DOWN_FRAME _FL_GTK_ROUND_UP_BOX, ///< gtk+ version of FL_ROUND_UP_BOX, use FL_GTK_ROUND_UP_BOX _FL_GTK_ROUND_DOWN_BOX, ///< gtk+ version of FL_ROUND_DOWN_BOX, use FL_GTK_ROUND_DOWN_BOX _FL_GLEAM_UP_BOX, ///< gleam version of FL_UP_BOX, use FL_GLEAM_UP_BOX _FL_GLEAM_DOWN_BOX, ///< gleam version of FL_DOWN_BOX, use FL_GLEAM_DOWN_BOX _FL_GLEAM_UP_FRAME, ///< gleam version of FL_UP_FRAME, use FL_GLEAM_UP_FRAME _FL_GLEAM_DOWN_FRAME, ///< gleam version of FL_DOWN_FRAME, use FL_GLEAM_DOWN_FRAME _FL_GLEAM_THIN_UP_BOX, ///< gleam version of FL_THIN_UP_BOX, use FL_GLEAM_THIN_UP_BOX _FL_GLEAM_THIN_DOWN_BOX, ///< gleam version of FL_THIN_DOWN_BOX, use FL_GLEAM_THIN_DOWN_BOX _FL_GLEAM_ROUND_UP_BOX, ///< gleam version of FL_ROUND_UP_BOX, use FL_GLEAM_ROUND_UP_BOX _FL_GLEAM_ROUND_DOWN_BOX, ///< gleam version of FL_ROUND_DOWN_BOX, use FL_GLEAM_ROUND_DOWN_BOX _FL_OXY_UP_BOX, ///< oxy version of FL_UP_BOX, use FL_OXY_UP_BOX _FL_OXY_DOWN_BOX, ///< oxy version of FL_DOWN_BOX, use FL_OXY_DOWN_BOX _FL_OXY_UP_FRAME, ///< oxy version of FL_UP_FRAME, use FL_OXY_UP_FRAME _FL_OXY_DOWN_FRAME, ///< oxy version of FL_DOWN_FRAME, use FL_OXY_DOWN_FRAME _FL_OXY_THIN_UP_BOX, ///< oxy version of FL_THIN_UP_BOX, use FL_OXY_THIN_UP_BOX _FL_OXY_THIN_DOWN_BOX, ///< oxy version of FL_THIN_DOWN_BOX, use FL_OXY_THIN_DOWN_BOX _FL_OXY_THIN_UP_FRAME, ///< oxy version of FL_THIN_UP_FRAME, use FL_OXY_THIN_UP_FRAME _FL_OXY_THIN_DOWN_FRAME, ///< oxy version of FL_THIN_DOWN_FRAME, use FL_OXY_THIN_DOWN_FRAME _FL_OXY_ROUND_UP_BOX, ///< oxy version of FL_ROUND_UP_BOX, use FL_OXY_ROUND_UP_BOX _FL_OXY_ROUND_DOWN_BOX, ///< oxy version of FL_ROUND_DOWN_BOX, use FL_OXY_ROUND_DOWN_BOX _FL_OXY_BUTTON_UP_BOX, ///< FL_OXY_BUTTON_UP_BOX (new boxtype ?), use FL_OXY_BUTTON_UP_BOX _FL_OXY_BUTTON_DOWN_BOX, ///< FL_OXY_BUTTON_DOWN_BOX (new boxtype ?), use FL_OXY_BUTTON_DOWN_BOX FL_FREE_BOXTYPE, ///< the first free box type for creation of new box types FL_MAX_BOXTYPE = 255 ///< highest legal index for a box type }; #ifndef FL_DOXYGEN extern FL_EXPORT Fl_Boxtype fl_define_FL_ROUND_UP_BOX(); #define FL_ROUND_UP_BOX fl_define_FL_ROUND_UP_BOX() #define FL_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_ROUND_UP_BOX()+1) extern FL_EXPORT Fl_Boxtype fl_define_FL_SHADOW_BOX(); #define FL_SHADOW_BOX fl_define_FL_SHADOW_BOX() #define FL_SHADOW_FRAME (Fl_Boxtype)(fl_define_FL_SHADOW_BOX()+2) extern FL_EXPORT Fl_Boxtype fl_define_FL_ROUNDED_BOX(); #define FL_ROUNDED_BOX fl_define_FL_ROUNDED_BOX() #define FL_ROUNDED_FRAME (Fl_Boxtype)(fl_define_FL_ROUNDED_BOX()+2) extern FL_EXPORT Fl_Boxtype fl_define_FL_RFLAT_BOX(); #define FL_RFLAT_BOX fl_define_FL_RFLAT_BOX() extern FL_EXPORT Fl_Boxtype fl_define_FL_RSHADOW_BOX(); #define FL_RSHADOW_BOX fl_define_FL_RSHADOW_BOX() extern FL_EXPORT Fl_Boxtype fl_define_FL_DIAMOND_BOX(); #define FL_DIAMOND_UP_BOX fl_define_FL_DIAMOND_BOX() #define FL_DIAMOND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_DIAMOND_BOX()+1) extern FL_EXPORT Fl_Boxtype fl_define_FL_OVAL_BOX(); #define FL_OVAL_BOX fl_define_FL_OVAL_BOX() #define FL_OSHADOW_BOX (Fl_Boxtype)(fl_define_FL_OVAL_BOX()+1) #define FL_OVAL_FRAME (Fl_Boxtype)(fl_define_FL_OVAL_BOX()+2) #define FL_OFLAT_BOX (Fl_Boxtype)(fl_define_FL_OVAL_BOX()+3) extern FL_EXPORT Fl_Boxtype fl_define_FL_PLASTIC_UP_BOX(); #define FL_PLASTIC_UP_BOX fl_define_FL_PLASTIC_UP_BOX() #define FL_PLASTIC_DOWN_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+1) #define FL_PLASTIC_UP_FRAME (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+2) #define FL_PLASTIC_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+3) #define FL_PLASTIC_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+4) #define FL_PLASTIC_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+5) #define FL_PLASTIC_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+6) #define FL_PLASTIC_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_PLASTIC_UP_BOX()+7) extern FL_EXPORT Fl_Boxtype fl_define_FL_GTK_UP_BOX(); #define FL_GTK_UP_BOX fl_define_FL_GTK_UP_BOX() #define FL_GTK_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+1) #define FL_GTK_UP_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+2) #define FL_GTK_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+3) #define FL_GTK_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+4) #define FL_GTK_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+5) #define FL_GTK_THIN_UP_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+6) #define FL_GTK_THIN_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+7) #define FL_GTK_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+8) #define FL_GTK_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GTK_UP_BOX()+9) extern FL_EXPORT Fl_Boxtype fl_define_FL_GLEAM_UP_BOX(); #define FL_GLEAM_UP_BOX fl_define_FL_GLEAM_UP_BOX() #define FL_GLEAM_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+1) #define FL_GLEAM_UP_FRAME (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+2) #define FL_GLEAM_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+3) #define FL_GLEAM_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+4) #define FL_GLEAM_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+5) #define FL_GLEAM_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+6) #define FL_GLEAM_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_GLEAM_UP_BOX()+7) extern FL_EXPORT Fl_Boxtype fl_define_FL_OXY_UP_BOX(); #define FL_OXY_UP_BOX fl_define_FL_OXY_UP_BOX() #define FL_OXY_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+1) #define FL_OXY_UP_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+2) #define FL_OXY_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+3) #define FL_OXY_THIN_UP_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+4) #define FL_OXY_THIN_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+5) #define FL_OXY_THIN_UP_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+6) #define FL_OXY_THIN_DOWN_FRAME (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+7) #define FL_OXY_ROUND_UP_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+8) #define FL_OXY_ROUND_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+9) #define FL_OXY_BUTTON_UP_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+10) #define FL_OXY_BUTTON_DOWN_BOX (Fl_Boxtype)(fl_define_FL_OXY_UP_BOX()+11) #endif // ! FL_DOXYGEN // conversions of box types to other boxtypes: /** Get the filled version of a frame. If no filled version of a given frame exists, the behavior of this function is undefined and some random box or frame is returned. */ inline Fl_Boxtype fl_box(Fl_Boxtype b) { return (Fl_Boxtype)((b1)?b:(b-2)); } /** Get the "pressed" or "down" version of a box. If no "down" version of a given box exists, the behavior of this function is undefined and some random box or frame is returned. */ inline Fl_Boxtype fl_down(Fl_Boxtype b) { return (Fl_Boxtype)((bvirtual colormap or 24-bit RGB color values. (See \ref drawing_colors for the default FLTK colormap) Color indices occupy the lower 8 bits of the value, while RGB colors occupy the upper 24 bits, for a byte organization of RGBI.
 Fl_Color => 0xrrggbbii
                | | | |
                | | | +--- \ref drawing_colors "index" between 0 and 255
                | | +----- blue color component (8 bit)
                | +------- green component (8 bit)
                +--------- red component (8 bit)
 
A color can have either an index or an rgb value. Colors with rgb set and an index >0 are reserved for special use. */ /**@{*/ /** An FLTK color value; see also \ref drawing_colors */ typedef unsigned int Fl_Color; // Standard colors. These are used as default colors in widgets and altered as necessary const Fl_Color FL_FOREGROUND_COLOR = 0; ///< the default foreground color (0) used for labels and text const Fl_Color FL_BACKGROUND2_COLOR = 7; ///< the default background color for text, list, and valuator widgets const Fl_Color FL_INACTIVE_COLOR = 8; ///< the inactive foreground color const Fl_Color FL_SELECTION_COLOR = 15; ///< the default selection/highlight color // boxtypes generally limit themselves to these colors so // the whole ramp is not allocated: const Fl_Color FL_GRAY0 = 32; // 'A' const Fl_Color FL_DARK3 = 39; // 'H' const Fl_Color FL_DARK2 = 45; // 'N' const Fl_Color FL_DARK1 = 47; // 'P' /** Default background color */ const Fl_Color FL_BACKGROUND_COLOR = 49; // 'R' default background color const Fl_Color FL_LIGHT1 = 50; // 'S' const Fl_Color FL_LIGHT2 = 52; // 'U' const Fl_Color FL_LIGHT3 = 54; // 'W' // FLTK provides a 5x8x5 color cube that is used with colormap visuals const Fl_Color FL_BLACK = 56; const Fl_Color FL_RED = 88; const Fl_Color FL_GREEN = 63; const Fl_Color FL_YELLOW = 95; const Fl_Color FL_BLUE = 216; const Fl_Color FL_MAGENTA = 248; const Fl_Color FL_CYAN = 223; const Fl_Color FL_DARK_RED = 72; const Fl_Color FL_DARK_GREEN = 60; const Fl_Color FL_DARK_YELLOW = 76; const Fl_Color FL_DARK_BLUE = 136; const Fl_Color FL_DARK_MAGENTA = 152; const Fl_Color FL_DARK_CYAN = 140; const Fl_Color FL_WHITE = 255; /** Colors numbered between FL_FREE_COLOR and FL_FREE_COLOR + FL_NUM_FREE_COLOR - 1 are free for the user to be given any value using Fl::set_color(). */ #define FL_FREE_COLOR (Fl_Color)16 #define FL_NUM_FREE_COLOR 16 #define FL_GRAY_RAMP (Fl_Color)32 #define FL_NUM_GRAY 24 #define FL_GRAY FL_BACKGROUND_COLOR #define FL_COLOR_CUBE (Fl_Color)56 #define FL_NUM_RED 5 #define FL_NUM_GREEN 8 #define FL_NUM_BLUE 5 FL_EXPORT Fl_Color fl_inactive(Fl_Color c); /** Type of a custom fl_contrast() function. Use this signature to define your own custom fl_contrast() function together with fl_contrast_mode(FL_CONTRAST_CUSTOM). Example: \code Fl_Color my_contrast(Fl_Color fg, Fl_Color bg, int context, int size) { // calculate contrast and ... return color; } // call this early in your main() program: fl_contrast_function(my_contrast); fl_contrast_mode(FL_CONTRAST_CUSTOM); fl_contrast_level(50); // optional, must be called after fl_contrast_mode() \endcode For parameters and types see fl_contrast(Fl_Color, Fl_Color, int, int). \see fl_contrast(Fl_Color, Fl_Color, int, int) \see fl_contrast_mode(int) */ typedef Fl_Color (Fl_Contrast_Function)(Fl_Color, Fl_Color, int, int); FL_EXPORT void fl_contrast_function(Fl_Contrast_Function *f); /** Define the possible modes to calculate fl_contrast(). */ enum Fl_Contrast_Mode { FL_CONTRAST_NONE = 0, ///< always return foreground color FL_CONTRAST_LEGACY, ///< legacy (FLTK 1.3.x) contrast function FL_CONTRAST_CIELAB, ///< new (FLTK 1.4.0) default function FL_CONTRAST_CUSTOM, ///< optional custom contrast function FL_CONTRAST_LAST ///< internal use only (invalid contrast mode) }; // The following functions are defined and documented in src/fl_contrast.cxx FL_EXPORT void fl_contrast_level(int level); FL_EXPORT int fl_contrast_level(); FL_EXPORT void fl_contrast_mode(int mode); FL_EXPORT int fl_contrast_mode(); FL_EXPORT Fl_Color fl_contrast(Fl_Color fg, Fl_Color bg, int context = 0, int size = 0); FL_EXPORT double fl_lightness(Fl_Color color); FL_EXPORT double fl_luminance(Fl_Color color); // Other color functions are defined and documented in src/fl_color.cxx FL_EXPORT Fl_Color fl_color_average(Fl_Color c1, Fl_Color c2, float weight); /** Returns a lighter version of the specified color. */ inline Fl_Color fl_lighter(Fl_Color c) { return fl_color_average(c, FL_WHITE, .67f); } /** Returns a darker version of the specified color. */ inline Fl_Color fl_darker(Fl_Color c) { return fl_color_average(c, FL_BLACK, .67f); } /** Returns the 24-bit color value closest to \p r, \p g, \p b. */ inline Fl_Color fl_rgb_color(uchar r, uchar g, uchar b) { if (!r && !g && !b) return FL_BLACK; else return (Fl_Color)(((((r << 8) | g) << 8) | b) << 8); } /** Returns the 24-bit color value closest to \p g (grayscale). */ inline Fl_Color fl_rgb_color(uchar g) { if (!g) return FL_BLACK; else return (Fl_Color)(((((g << 8) | g) << 8) | g) << 8); } /** Returns a gray color value from black (i == 0) to white (i == FL_NUM_GRAY - 1). FL_NUM_GRAY is defined to be 24 in the current FLTK release. To get the closest FLTK gray value to an 8-bit grayscale color 'I' use: \code fl_gray_ramp(I * (FL_NUM_GRAY - 1) / 255) \endcode */ inline Fl_Color fl_gray_ramp(int i) {return (Fl_Color)(i+FL_GRAY_RAMP);} /** Returns a color out of the color cube. \p r must be in the range 0 to FL_NUM_RED (5) minus 1, \p g must be in the range 0 to FL_NUM_GREEN (8) minus 1, \p b must be in the range 0 to FL_NUM_BLUE (5) minus 1. To get the closest color to a 8-bit set of R,G,B values use: \code fl_color_cube(R * (FL_NUM_RED - 1) / 255, G * (FL_NUM_GREEN - 1) / 255, B * (FL_NUM_BLUE - 1) / 255); \endcode */ inline Fl_Color fl_color_cube(int r, int g, int b) { return (Fl_Color)((b*FL_NUM_RED + r) * FL_NUM_GREEN + g + FL_COLOR_CUBE);} /**@}*/ // group: Colors /** \name Cursors */ /**@{*/ /** The following constants define the mouse cursors that are available in FLTK. Cursors are provided by the system when available, or bitmaps built into FLTK as a fallback. */ /* FIXME: We should renumber these, but that will break the ABI */ enum Fl_Cursor { FL_CURSOR_DEFAULT = 0, /**< the default cursor, usually an arrow: ↖*/ // U+2196 FL_CURSOR_ARROW = 35, /**< an arrow pointer: ↖*/ // U+2196 FL_CURSOR_CROSS = 66, /**< crosshair: +*/ // U+FF0B FL_CURSOR_WAIT = 76, /**< busy indicator (for instance hourglass): ⌚,⌛*/ // U+231A, U+231B FL_CURSOR_INSERT = 77, /**< I-beam: ⌶*/ // U+2336 FL_CURSOR_HAND = 31, /**< pointing hand: ☜*/ // U+261C FL_CURSOR_HELP = 47, /**< question mark pointer: ?*/ FL_CURSOR_MOVE = 27, /**< 4-pointed arrow or hand: ✥, ✋*/ // U+2725, U+270B /* Resize indicators */ FL_CURSOR_NS = 78, /**< up/down resize: ⇕ */ // U+21D5 FL_CURSOR_WE = 79, /**< left/right resize: ⇔*/ // U+21D4 FL_CURSOR_NWSE = 80, /**< diagonal resize: ⤡*/ // U+2921 FL_CURSOR_NESW = 81, /**< diagonal resize: ⤢*/ // U+2922 FL_CURSOR_N = 70, /**< upwards resize: ⤒*/ // U+2912 FL_CURSOR_NE = 69, /**< upwards, right resize: ↗*/ // U+2197 FL_CURSOR_E = 49, /**< rightwards resize: ⇥*/ // U+21E5 FL_CURSOR_SE = 8, /**< downwards, right resize: ⇲*/ // U+21F2 FL_CURSOR_S = 9, /**< downwards resize: ⤓*/ // U+2913 FL_CURSOR_SW = 7, /**< downwards, left resize: ↙*/ // U+2199 FL_CURSOR_W = 36, /**< leftwards resize: ⇤*/ // U+21E4 FL_CURSOR_NW = 68, /**< upwards, left resize: ⇱*/ // U+21F1 FL_CURSOR_NONE =255 /**< invisible. */ }; /**@}*/ // group: Cursors /** FD "when" conditions */ enum { // values for "when" passed to Fl::add_fd() FL_READ = 1, /**< Call the callback when there is data to be read. */ FL_WRITE = 4, /**< Call the callback when data can be written without blocking. */ FL_EXCEPT = 8 /**< Call the callback if an exception occurs on the file. */ }; /** visual types and Fl_Gl_Window::mode() (values match Glut) */ enum Fl_Mode { FL_RGB = 0, FL_INDEX = 1, FL_SINGLE = 0, FL_DOUBLE = 2, FL_ACCUM = 4, FL_ALPHA = 8, FL_DEPTH = 16, FL_STENCIL = 32, FL_RGB8 = 64, FL_MULTISAMPLE= 128, FL_STEREO = 256, FL_FAKE_SINGLE = 512, // Fake single buffered windows using double-buffer FL_OPENGL3 = 1024 }; // image alpha blending #define FL_IMAGE_WITH_ALPHA 0x40000000 /** Damage masks */ enum Fl_Damage { FL_DAMAGE_CHILD = 0x01, /**< A child needs to be redrawn. */ FL_DAMAGE_EXPOSE = 0x02, /**< The window was exposed. */ FL_DAMAGE_SCROLL = 0x04, /**< The Fl_Scroll widget was scrolled. Used by other widgets for other widget specific damages. */ FL_DAMAGE_OVERLAY = 0x08, /**< The overlay planes need to be redrawn. */ FL_DAMAGE_USER1 = 0x10, /**< First user-defined damage bit. */ FL_DAMAGE_USER2 = 0x20, /**< Second user-defined damage bit. */ FL_DAMAGE_ALL = 0x80 /**< Everything needs to be redrawn. */ }; // FLTK 1.0.x compatibility definitions (FLTK_1_0_COMPAT) dropped in 1.4.0 /** Arrow types define the type of arrow drawing function. FLTK schemes can draw several graphical elements in their particular way. One of these elements is an arrow type that can be in different GUI elements like scrollbars, choice buttons, and FLTK's Fl_Return_Button. \note This enum is not yet stable (as of FLTK 1.4.0) and may be changed without notice as necessary. \since 1.4.0 */ enum Fl_Arrow_Type { FL_ARROW_SINGLE = 0x01, ///< Single arrow, e.g. in Fl_Scrollbar FL_ARROW_DOUBLE = 0x02, ///< Double arrow, e.g. in Fl_Counter FL_ARROW_CHOICE = 0x03, ///< Dropdown box, e.g. in Fl_Choice FL_ARROW_RETURN = 0x04 ///< Return arrow, e.g. in Fl_Return_Button }; /** Fl_Orientation describes the orientation of a GUI element. FLTK schemes can draw several graphical elements, for instance arrows, pointing at different directions. This enum defines the direction to use for drawing a particular GUI element. The definition of this enum was chosen such that the enum value can be multiplied by 45 to get a rotation angle in degrees starting at the horizontal axis (0 = right, 1 = NE, 2 = up, ...) that can be used with fl_rotate(). Note: angle is counter-clockwise in degrees. The 'unspecified' value \b FL_ORIENT_NONE shall be used for elements that would usually not be rotated, like the return arrow of the Fl_Return_Button. It can still be used as an angle though since it is the same value as \p FL_ORIENT_RIGHT (0 degrees). \note This enum is not yet stable (as of FLTK 1.4.0) and may be changed without notice as necessary. \since 1.4.0 */ enum Fl_Orientation { FL_ORIENT_NONE = 0x00, ///< GUI element direction is unspecified FL_ORIENT_RIGHT = 0x00, ///< GUI element pointing right ( 0°) FL_ORIENT_NE = 0x01, ///< GUI element pointing NE ( 45°) FL_ORIENT_UP = 0x02, ///< GUI element pointing up ( 90°) FL_ORIENT_NW = 0x03, ///< GUI element pointing NW (135°) FL_ORIENT_LEFT = 0x04, ///< GUI element pointing left (180°) FL_ORIENT_SW = 0x05, ///< GUI element pointing SW (225°) FL_ORIENT_DOWN = 0x06, ///< GUI element pointing down (270°) FL_ORIENT_SE = 0x07 ///< GUI element pointing SE (315°) }; #endif