Include a stripped-down version of FLTK in tree and add a USE_INCLUDED_FLTK option to build against it.
git-svn-id: svn://svn.code.sf.net/p/tigervnc/code/trunk@4603 3789f03b-4d11-0410-bbf8-ca57d06f2519
diff --git a/common/fltk/FL/Enumerations.H b/common/fltk/FL/Enumerations.H
new file mode 100644
index 0000000..093422b
--- /dev/null
+++ b/common/fltk/FL/Enumerations.H
@@ -0,0 +1,959 @@
+//
+// "$Id: Enumerations.H 8710 2011-05-21 21:55:59Z manolo $"
+//
+// Enumerations for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2011 by Bill Spitzak and others.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+//
+// Please report all bugs and problems on the following page:
+//
+// http://www.fltk.org/str.php
+//
+
+/** \file
+ This file contains type definitions and general enumerations.
+ */
+
+#ifndef Fl_Enumerations_H
+#define Fl_Enumerations_H
+
+# include "Fl_Export.H"
+# include "fl_types.h"
+
+/** \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.
+ \sa 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 3
+
+/**
+ 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 double that describes the major and minor version numbers.
+ Version 1.1 is actually stored as 1.01 to allow for more than 9 minor
+ 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.
+ */
+#define FL_VERSION ((double)FL_MAJOR_VERSION + \
+ (double)FL_MINOR_VERSION * 0.01 + \
+ (double)FL_PATCH_VERSION * 0.0001)
+
+/*@}*/ // 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.
+
+ \sa Fl::event_text(), Fl::event_key(), class Fl::
+ */
+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 <I>attempt</I> 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
+};
+
+/** \name When Conditions */
+/*@{*/
+/** These constants determine when a callback is performed.
+
+ \sa Fl_Widget::when();
+ \todo doxygen comments for values are incomplete and maybe wrong or unclear
+ */
+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 ///< ?
+};
+
+/*@}*/ // group: When Conditions
+
+/** \name Mouse and Keyboard Events
+
+ This and the following constants define the non-ASCII keys on the
+ keyboard for FL_KEYBOARD and FL_SHORTCUT events.
+
+ \todo FL_Button and FL_key... constants could be structured better
+ (use an enum or some doxygen grouping ?)
+
+ \sa 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 n.
+#define FL_BackSpace 0xff08 ///< The backspace key.
+#define FL_Tab 0xff09 ///< The tab key.
+#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_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 number 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.
+
+// 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: Mouse and Keyboard Events
+
+/** \name Mouse Buttons
+
+ These constants define the button numbers for FL_PUSH and FL_RELEASE events.
+
+ \sa 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 ke (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!
+
+#ifdef __APPLE__
+# define FL_COMMAND FL_META ///< An alias for FL_CTRL on WIN32 and X11, or FL_META on MacOS X
+# define FL_CONTROL FL_CTRL ///< An alias for FL_META on WIN32 and X11, or FL_CTRL on MacOS X
+#else
+# define FL_COMMAND FL_CTRL ///< An alias for FL_CTRL on WIN32 and X11, or FL_META on MacOS X
+# define FL_CONTROL FL_META ///< An alias for FL_META on WIN32 and X11, or FL_CTRL on MacOS X
+#endif // __APPLE__
+
+/*@}*/ // group: Event States
+
+/** \name Box Types
+ \brief FLTK standard box types
+
+ This enum defines the standard box types included with FLTK.
+
+ 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 Figure 1
+ is the area that is not drawn by the frame types.
+
+ \image html boxtypes.png "Figure 1: FLTK standard box types"
+ \image latex boxtypes.png "FLTK standard box types" width=10cm
+ \todo Description of boxtypes is incomplete.
+ See below for the defined enum Fl_Boxtype.
+ \see src/Fl_get_system_colors.cxx
+*/
+/*@{*/
+enum Fl_Boxtype { // boxtypes (if you change these you must fix fl_boxtype.C):
+
+ FL_NO_BOX = 0, ///< nothing is drawn at all, this box is invisible
+ FL_FLAT_BOX, ///< a flat box
+ FL_UP_BOX, ///< see figure 1
+ FL_DOWN_BOX, ///< see figure 1
+ FL_UP_FRAME, ///< see figure 1
+ FL_DOWN_FRAME, ///< see figure 1
+ FL_THIN_UP_BOX, ///< see figure 1
+ FL_THIN_DOWN_BOX, ///< see figure 1
+ FL_THIN_UP_FRAME, ///< see figure 1
+ FL_THIN_DOWN_FRAME, ///< see figure 1
+ FL_ENGRAVED_BOX, ///< see figure 1
+ FL_EMBOSSED_BOX, ///< see figure 1
+ FL_ENGRAVED_FRAME, ///< see figure 1
+ FL_EMBOSSED_FRAME, ///< see figure 1
+ FL_BORDER_BOX, ///< see figure 1
+ _FL_SHADOW_BOX, ///< see figure 1
+ FL_BORDER_FRAME, ///< see figure 1
+ _FL_SHADOW_FRAME, ///< see figure 1
+ _FL_ROUNDED_BOX, ///< see figure 1
+ _FL_RSHADOW_BOX, ///< see figure 1
+ _FL_ROUNDED_FRAME, ///< see figure 1
+ _FL_RFLAT_BOX, ///< see figure 1
+ _FL_ROUND_UP_BOX, ///< see figure 1
+ _FL_ROUND_DOWN_BOX, ///< see figure 1
+ _FL_DIAMOND_UP_BOX, ///< see figure 1
+ _FL_DIAMOND_DOWN_BOX, ///< see figure 1
+ _FL_OVAL_BOX, ///< see figure 1
+ _FL_OSHADOW_BOX, ///< see figure 1
+ _FL_OVAL_FRAME, ///< see figure 1
+ _FL_OFLAT_BOX, ///< see figure 1
+ _FL_PLASTIC_UP_BOX, ///< plastic version of FL_UP_BOX
+ _FL_PLASTIC_DOWN_BOX, ///< plastic version of FL_DOWN_BOX
+ _FL_PLASTIC_UP_FRAME, ///< plastic version of FL_UP_FRAME
+ _FL_PLASTIC_DOWN_FRAME, ///< plastic version of FL_DOWN_FRAME
+ _FL_PLASTIC_THIN_UP_BOX, ///< plastic version of FL_THIN_UP_BOX
+ _FL_PLASTIC_THIN_DOWN_BOX, ///< plastic version of FL_THIN_DOWN_BOX
+ _FL_PLASTIC_ROUND_UP_BOX, ///< plastic version of FL_ROUND_UP_BOX
+ _FL_PLASTIC_ROUND_DOWN_BOX, ///< plastic version of FL_ROUND_DOWN_BOX
+ _FL_GTK_UP_BOX, ///< gtk+ version of FL_UP_BOX
+ _FL_GTK_DOWN_BOX, ///< gtk+ version of FL_DOWN_BOX
+ _FL_GTK_UP_FRAME, ///< gtk+ version of FL_UP_FRAME
+ _FL_GTK_DOWN_FRAME, ///< gtk+ version of FL_DOWN_RAME
+ _FL_GTK_THIN_UP_BOX, ///< gtk+ version of FL_THIN_UP_BOX
+ _FL_GTK_THIN_DOWN_BOX, ///< gtk+ version of FL_THIN_DOWN_BOX
+ _FL_GTK_THIN_UP_FRAME, ///< gtk+ version of FL_UP_FRAME
+ _FL_GTK_THIN_DOWN_FRAME, ///< gtk+ version of FL_THIN_DOWN_FRAME
+ _FL_GTK_ROUND_UP_BOX, ///< gtk+ version of FL_ROUND_UP_BOX
+ _FL_GTK_ROUND_DOWN_BOX, ///< gtk+ version of FL_ROUND_DOWN_BOX
+ FL_FREE_BOXTYPE ///< the first free box type for creation of new box types
+};
+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)
+
+// 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)((b<FL_UP_BOX||b%4>1)?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)((b<FL_UP_BOX)?b:(b|1));
+}
+/**
+ Get the unfilled, frame only version of a box.
+ If no frame 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_frame(Fl_Boxtype b) {
+ return (Fl_Boxtype)((b%4<2)?b:(b+2));
+}
+
+// back-compatibility box types:
+#define FL_FRAME FL_ENGRAVED_FRAME
+#define FL_FRAME_BOX FL_ENGRAVED_BOX
+#define FL_CIRCLE_BOX FL_ROUND_DOWN_BOX
+#define FL_DIAMOND_BOX FL_DIAMOND_DOWN_BOX
+
+/*@}*/ // group: Box Types
+
+/**
+ The labeltype() method sets the type of the label.
+
+ The following standard label types are included:
+
+ \todo The doxygen comments are incomplete, and some labeltypes
+ are starting with an underscore. Also, there are three
+ external functions undocumented (yet):
+ - fl_define_FL_SHADOW_LABEL()
+ - fl_define_FL_ENGRAVED_LABEL()
+ - fl_define_FL_EMBOSSED_LABEL()
+*/
+enum Fl_Labeltype { // labeltypes:
+ FL_NORMAL_LABEL = 0, ///< draws the text (0)
+ FL_NO_LABEL, ///< does nothing
+ _FL_SHADOW_LABEL, ///< draws a drop shadow under the text
+ _FL_ENGRAVED_LABEL, ///< draws edges as though the text is engraved
+ _FL_EMBOSSED_LABEL, ///< draws edges as though the text is raised
+ _FL_MULTI_LABEL, ///< ?
+ _FL_ICON_LABEL, ///< draws the icon associated with the text
+ _FL_IMAGE_LABEL, ///< ?
+
+ FL_FREE_LABELTYPE ///< first free labeltype to use for creating own labeltypes
+};
+
+/**
+ Sets the current label type and return its corresponding Fl_Labeltype value.
+ @{
+*/
+#define FL_SYMBOL_LABEL FL_NORMAL_LABEL
+extern Fl_Labeltype FL_EXPORT fl_define_FL_SHADOW_LABEL();
+#define FL_SHADOW_LABEL fl_define_FL_SHADOW_LABEL()
+extern Fl_Labeltype FL_EXPORT fl_define_FL_ENGRAVED_LABEL();
+#define FL_ENGRAVED_LABEL fl_define_FL_ENGRAVED_LABEL()
+extern Fl_Labeltype FL_EXPORT fl_define_FL_EMBOSSED_LABEL();
+#define FL_EMBOSSED_LABEL fl_define_FL_EMBOSSED_LABEL()
+/** @} */
+
+/** \name Alignment Flags
+ Flags to control the label alignment.
+ This controls how the label is displayed next to or inside the widget.
+ The default value is FL_ALIGN_CENTER for most widgets, which centers the label
+ inside the widget.
+
+ Flags can be or'd to achieve a combination of alignments.
+
+ \code
+ Outside alignments:
+ TOP_LEFT TOP TOP_RIGHT
+ LEFT_TOP+---------------------------------+RIGHT_TOP
+ | |
+ LEFT| |RIGHT
+ | |
+ LEFT_BOTTOM+---------------------------------+RIGHT_BOTTOM
+ BOTTOM_RIGHT BOTTOM BOTTOM_LEFT
+
+ Inside alignments:
+ +---------------------------------+
+ |TOP_LEFT TOP TOP_RIGHT|
+ | |
+ |LEFT RIGHT|
+ | |
+ |BOTTOM_RIGHT BOTTOM BOTTOM_LEFT|
+ +---------------------------------+
+ \endcode
+ \see #FL_ALIGN_CENTER, etc.
+ */
+/*@{*/
+/** FLTK type for alignment control */
+typedef unsigned Fl_Align;
+ /** Align the label horizontally in the middle. */
+const Fl_Align FL_ALIGN_CENTER = (Fl_Align)0;
+ /** Align the label at the top of the widget. Inside labels appear below the top,
+ outside labels are drawn on top of the widget. */
+const Fl_Align FL_ALIGN_TOP = (Fl_Align)1;
+ /** Align the label at the bottom of the widget. */
+const Fl_Align FL_ALIGN_BOTTOM = (Fl_Align)2;
+ /** Align the label at the left of the widget. Inside labels appear left-justified
+ starting at the left side of the widget, outside labels are right-justified and
+ drawn to the left of the widget. */
+const Fl_Align FL_ALIGN_LEFT = (Fl_Align)4;
+ /** Align the label to the right of the widget. */
+const Fl_Align FL_ALIGN_RIGHT = (Fl_Align)8;
+ /** Draw the label inside of the widget. */
+const Fl_Align FL_ALIGN_INSIDE = (Fl_Align)16;
+ /** If the label contains an image, draw the text on top of the image. */
+const Fl_Align FL_ALIGN_TEXT_OVER_IMAGE = (Fl_Align)0x0020;
+ /** If the label contains an image, draw the text below the image. */
+const Fl_Align FL_ALIGN_IMAGE_OVER_TEXT = (Fl_Align)0x0000;
+ /** All parts of the label that are lager than the widget will not be drawn . */
+const Fl_Align FL_ALIGN_CLIP = (Fl_Align)64;
+ /** Wrap text that does not fit the width of the widget. */
+const Fl_Align FL_ALIGN_WRAP = (Fl_Align)128;
+ /** If the label contains an image, draw the text to the right of the image. */
+const Fl_Align FL_ALIGN_IMAGE_NEXT_TO_TEXT = (Fl_Align)0x0100;
+ /** If the label contains an image, draw the text to the left of the image. */
+const Fl_Align FL_ALIGN_TEXT_NEXT_TO_IMAGE = (Fl_Align)0x0120;
+/** If the label contains an image, draw the image or deimage in the background. */
+const Fl_Align FL_ALIGN_IMAGE_BACKDROP = (Fl_Align)0x0200;
+const Fl_Align FL_ALIGN_TOP_LEFT = FL_ALIGN_TOP | FL_ALIGN_LEFT;
+const Fl_Align FL_ALIGN_TOP_RIGHT = FL_ALIGN_TOP | FL_ALIGN_RIGHT;
+const Fl_Align FL_ALIGN_BOTTOM_LEFT = FL_ALIGN_BOTTOM | FL_ALIGN_LEFT;
+const Fl_Align FL_ALIGN_BOTTOM_RIGHT = FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT;
+const Fl_Align FL_ALIGN_LEFT_TOP = 0x0007; // magic value
+const Fl_Align FL_ALIGN_RIGHT_TOP = 0x000b; // magic value
+const Fl_Align FL_ALIGN_LEFT_BOTTOM = 0x000d; // magic value
+const Fl_Align FL_ALIGN_RIGHT_BOTTOM = 0x000e; // magic value
+const Fl_Align FL_ALIGN_NOWRAP = (Fl_Align)0; // for back compatibility
+const Fl_Align FL_ALIGN_POSITION_MASK = 0x000f; // left, right, top, bottom
+const Fl_Align FL_ALIGN_IMAGE_MASK = 0x0320; // l/r, t/b, backdrop
+/*@}*/
+
+
+/** \name Font Numbers
+ The following constants define the standard FLTK fonts:
+ */
+/*@{*/
+/** A font number is an index into the internal font table. */
+typedef int Fl_Font;
+
+const Fl_Font FL_HELVETICA = 0; ///< Helvetica (or Arial) normal (0)
+const Fl_Font FL_HELVETICA_BOLD = 1; ///< Helvetica (or Arial) bold
+const Fl_Font FL_HELVETICA_ITALIC = 2; ///< Helvetica (or Arial) oblique
+const Fl_Font FL_HELVETICA_BOLD_ITALIC = 3; ///< Helvetica (or Arial) bold-oblique
+const Fl_Font FL_COURIER = 4; ///< Courier normal
+const Fl_Font FL_COURIER_BOLD = 5; ///< Courier bold
+const Fl_Font FL_COURIER_ITALIC = 6; ///< Courier italic
+const Fl_Font FL_COURIER_BOLD_ITALIC = 7; ///< Courier bold-italic
+const Fl_Font FL_TIMES = 8; ///< Times roman
+const Fl_Font FL_TIMES_BOLD = 9; ///< Times roman bold
+const Fl_Font FL_TIMES_ITALIC = 10; ///< Times roman italic
+const Fl_Font FL_TIMES_BOLD_ITALIC = 11; ///< Times roman bold-italic
+const Fl_Font FL_SYMBOL = 12; ///< Standard symbol font
+const Fl_Font FL_SCREEN = 13; ///< Default monospaced screen font
+const Fl_Font FL_SCREEN_BOLD = 14; ///< Default monospaced bold screen font
+const Fl_Font FL_ZAPF_DINGBATS = 15; ///< Zapf-dingbats font
+
+const Fl_Font FL_FREE_FONT = 16; ///< first one to allocate
+const Fl_Font FL_BOLD = 1; ///< add this to helvetica, courier, or times
+const Fl_Font FL_ITALIC = 2; ///< add this to helvetica, courier, or times
+const Fl_Font FL_BOLD_ITALIC = 3; ///< add this to helvetica, courier, or times
+
+/*@}*/
+
+/** Size of a font in pixels.
+ This is the approximate height of a font in pixels.
+ */
+typedef int Fl_Fontsize;
+
+extern FL_EXPORT Fl_Fontsize FL_NORMAL_SIZE; ///< normal font size
+
+/** \name Colors
+ The Fl_Color type holds an FLTK color value.
+
+ Colors are either 8-bit indexes into a virtual colormap
+ or 24-bit RGB color values.
+
+ Color indices occupy the lower 8 bits of the value, while
+ RGB colors occupy the upper 24 bits, for a byte organization of RGBI.
+
+<pre>
+ Fl_Color => 0xrrggbbii
+ | | | |
+ | | | +--- index between 0 and 255
+ | | +----- blue color component (8 bit)
+ | +------- green component (8 bit)
+ +--------- red component (8 bit)
+ </pre>
+
+ 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 */
+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'
+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;
+
+
+#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);
+
+FL_EXPORT Fl_Color fl_contrast(Fl_Color fg, Fl_Color bg);
+
+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.
+
+ The double-headed arrows are bitmaps provided by FLTK on X, the others
+ are provided by system-defined cursors.
+
+ \todo enum Fl_Cursor needs maybe an image.
+*/
+enum Fl_Cursor {
+ FL_CURSOR_DEFAULT = 0, /**< the default cursor, usually an arrow. */
+ FL_CURSOR_ARROW = 35, /**< an arrow pointer. */
+ FL_CURSOR_CROSS = 66, /**< crosshair. */
+ FL_CURSOR_WAIT = 76, /**< watch or hourglass. */
+ FL_CURSOR_INSERT = 77, /**< I-beam. */
+ FL_CURSOR_HAND = 31, /**< hand (uparrow on MSWindows). */
+ FL_CURSOR_HELP = 47, /**< question mark. */
+ FL_CURSOR_MOVE = 27, /**< 4-pointed arrow. */
+ // fltk provides bitmaps for these:
+ FL_CURSOR_NS = 78, /**< up/down arrow. */
+ FL_CURSOR_WE = 79, /**< left/right arrow. */
+ FL_CURSOR_NWSE = 80, /**< diagonal arrow. */
+ FL_CURSOR_NESW = 81, /**< diagonal arrow. */
+ FL_CURSOR_NONE =255, /**< invisible. */
+ // for back compatibility (non MSWindows ones):
+ FL_CURSOR_N = 70, /**< for back compatibility. */
+ FL_CURSOR_NE = 69, /**< for back compatibility. */
+ FL_CURSOR_E = 49, /**< for back compatibility. */
+ FL_CURSOR_SE = 8, /**< for back compatibility. */
+ FL_CURSOR_S = 9, /**< for back compatibility. */
+ FL_CURSOR_SW = 7, /**< for back compatibility. */
+ FL_CURSOR_W = 36, /**< for back compatibility. */
+ FL_CURSOR_NW = 68 /**< for back compatibility. */
+};
+/*@}*/ // 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
+};
+
+// 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. */
+ 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...
+# ifdef FLTK_1_0_COMPAT
+# define contrast fl_contrast
+# define down fl_down
+# define frame fl_frame
+# define inactive fl_inactive
+# endif // FLTK_1_0_COMPAT
+
+#endif
+
+//
+// End of "$Id: Enumerations.H 8710 2011-05-21 21:55:59Z manolo $".
+//