summaryrefslogtreecommitdiffhomepage
path: root/X-Plane-SDK/CHeaders/Widgets
diff options
context:
space:
mode:
Diffstat (limited to 'X-Plane-SDK/CHeaders/Widgets')
-rwxr-xr-xX-Plane-SDK/CHeaders/Widgets/XPStandardWidgets.h580
-rwxr-xr-xX-Plane-SDK/CHeaders/Widgets/XPUIGraphics.h363
-rwxr-xr-xX-Plane-SDK/CHeaders/Widgets/XPWidgetDefs.h486
-rwxr-xr-xX-Plane-SDK/CHeaders/Widgets/XPWidgetUtils.h234
-rwxr-xr-xX-Plane-SDK/CHeaders/Widgets/XPWidgets.h569
5 files changed, 2232 insertions, 0 deletions
diff --git a/X-Plane-SDK/CHeaders/Widgets/XPStandardWidgets.h b/X-Plane-SDK/CHeaders/Widgets/XPStandardWidgets.h
new file mode 100755
index 0000000..fe5b4a8
--- /dev/null
+++ b/X-Plane-SDK/CHeaders/Widgets/XPStandardWidgets.h
@@ -0,0 +1,580 @@
+#ifndef _XPStandardWidgets_h_
+#define _XPStandardWidgets_h_
+
+/*
+ * Copyright 2005-2012 Sandy Barbour and Ben Supnik
+ *
+ * All rights reserved. See license.txt for usage.
+ *
+ * X-Plane SDK Version: 2.1.1
+ *
+ */
+
+/*
+ * XPStandardWidgets - THEORY OF OPERATION
+ *
+ * The standard widgets are widgets built into the widgets library. While you
+ * can gain access to the widget function that drives them, you generally use
+ * them by calling XPCreateWidget and then listening for special messages,
+ * etc.
+ *
+ * The standard widgets often send mesages to themselves when the user
+ * performs an event; these messages are sent up the widget hierarchy until
+ * they are handled. So you can add a widget proc directly to a push button
+ * (for example) to intercept the message when it is clicked, or you can put
+ * one widget proc on a window for all of the push buttons in the window.
+ * Most of these messages contain the original widget ID as a parameter so you
+ * can know which widget is messaging no matter who it is sent to.
+ *
+ */
+
+#include "XPWidgetDefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***************************************************************************
+ * MAIN WINDOW
+ ***************************************************************************/
+/*
+ * The main window widget class provides a "window" as the user knows it.
+ * These windows are dragable and can be selected. Use them to create
+ * floating windows and non-modal dialogs.
+ *
+ */
+
+
+
+#define xpWidgetClass_MainWindow 1
+
+/*
+ * Main Window Type Values
+ *
+ * These type values are used to control the appearance of a main window.
+ *
+ */
+enum {
+ /* The standard main window; pin stripes on XP7, metal frame on XP 6. */
+ xpMainWindowStyle_MainWindow = 0
+
+ /* A translucent dark gray window, like the one ATC messages appear in. */
+ ,xpMainWindowStyle_Translucent = 1
+
+
+};
+
+/*
+ * Main Window Properties
+ *
+ *
+ */
+enum {
+ /* This property specifies the type of window. Set to one of the main window *
+ * types above. */
+ xpProperty_MainWindowType = 1100
+
+ /* This property specifies whether the main window has close boxes in its *
+ * corners. */
+ ,xpProperty_MainWindowHasCloseBoxes = 1200
+
+
+};
+
+/*
+ * MainWindow Messages
+ *
+ *
+ */
+enum {
+ /* This message is sent when the close buttons are pressed for your window. */
+ xpMessage_CloseButtonPushed = 1200
+
+
+};
+
+/***************************************************************************
+ * SUB WINDOW
+ ***************************************************************************/
+/*
+ * X-plane dialogs are divided into separate areas; the sub window widgets
+ * allow you to make these areas. Create one main window and place several
+ * subwindows inside it. Then place your controls inside the subwindows.
+ *
+ */
+
+
+
+#define xpWidgetClass_SubWindow 2
+
+/*
+ * SubWindow Type Values
+ *
+ * These values control the appearance of the subwindow.
+ *
+ */
+enum {
+ /* A panel that sits inside a main window. */
+ xpSubWindowStyle_SubWindow = 0
+
+ /* A screen that sits inside a panel for showing text information. */
+ ,xpSubWindowStyle_Screen = 2
+
+ /* A list view for scrolling lists. */
+ ,xpSubWindowStyle_ListView = 3
+
+
+};
+
+/*
+ * SubWindow Properties
+ *
+ *
+ */
+enum {
+ /* This property specifies the type of window. Set to one of the subwindow *
+ * types above. */
+ xpProperty_SubWindowType = 1200
+
+
+};
+
+/***************************************************************************
+ * BUTTON
+ ***************************************************************************/
+/*
+ * The button class provides a number of different button styles and
+ * behaviors, including push buttons, radio buttons, check boxes, etc. The
+ * button label appears on or next to the button depending on the button's
+ * appearance, or type.
+ *
+ * The button's behavior is a separate property that dictates who it hilights
+ * and what kinds of messages it sends. Since behavior and type are
+ * different, you can do strange things like make check boxes that act as push
+ * buttons or push buttons with radio button behavior.
+ *
+ * In X-Plane 6 there were no check box graphics. The result is the following
+ * behavior: in x-plane 6 all check box and radio buttons are round
+ * (radio-button style) buttons; in X-Plane 7 they are all square (check-box
+ * style) buttons. In a future version of x-plane, the xpButtonBehavior enums
+ * will provide the correct graphic (check box or radio button) giving the
+ * expected result.
+ *
+ */
+
+
+
+#define xpWidgetClass_Button 3
+
+/*
+ * Button Types
+ *
+ * These define the visual appearance of buttons but not how they respond to
+ * the mouse.
+ *
+ */
+enum {
+ /* This is a standard push button, like an "OK" or "Cancel" button in a dialog *
+ * box. */
+ xpPushButton = 0
+
+ /* A check box or radio button. Use this and the button behaviors below to *
+ * get the desired behavior. */
+ ,xpRadioButton = 1
+
+ /* A window close box. */
+ ,xpWindowCloseBox = 3
+
+ /* A small down arrow. */
+ ,xpLittleDownArrow = 5
+
+ /* A small up arrow. */
+ ,xpLittleUpArrow = 6
+
+
+};
+
+/*
+ * Button Behavior Values
+ *
+ * These define how the button responds to mouse clicks.
+ *
+ */
+enum {
+ /* Standard push button behavior. The button hilites while the mouse is *
+ * clicked over it and unhilites when the mouse is moved outside of it or *
+ * released. If the mouse is released over the button, the *
+ * xpMsg_PushButtonPressed message is sent. */
+ xpButtonBehaviorPushButton = 0
+
+ /* Check box behavior. The button immediately toggles its value when the *
+ * mouse is clicked and sends out a xpMsg_ButtonStateChanged message. */
+ ,xpButtonBehaviorCheckBox = 1
+
+ /* Radio button behavior. The button immediately sets its state to one and *
+ * sends out a xpMsg_ButtonStateChanged message if it was not already set to *
+ * one. You must turn off other radio buttons in a group in your code. */
+ ,xpButtonBehaviorRadioButton = 2
+
+
+};
+
+/*
+ * Button Properties
+ *
+ *
+ */
+enum {
+ /* This property sets the visual type of button. Use one of the button types *
+ * above. */
+ xpProperty_ButtonType = 1300
+
+ /* This property sets the button's behavior. Use one of the button behaviors *
+ * above. */
+ ,xpProperty_ButtonBehavior = 1301
+
+ /* This property tells whether a check box or radio button is "checked" or *
+ * not. Not used for push buttons. */
+ ,xpProperty_ButtonState = 1302
+
+
+};
+
+/*
+ * Button Messages
+ *
+ * These messages are sent by the button to itself and then up the widget
+ * chain when the button is clicked. (You may intercept them by providing a
+ * widget handler for the button itself or by providing a handler in a parent
+ * widget.)
+ *
+ */
+enum {
+ /* This message is sent when the user completes a click and release in a *
+ * button with push button behavior. Parameter one of the message is the *
+ * widget ID of the button. This message is dispatched up the widget *
+ * hierarchy. */
+ xpMsg_PushButtonPressed = 1300
+
+ /* This message is sent when a button is clicked that has radio button or *
+ * check box behavior and its value changes. (Note that if the value changes *
+ * by setting a property you do not receive this message!) Parameter one is *
+ * the widget ID of the button, parameter 2 is the new state value, either *
+ * zero or one. This message is dispatched up the widget hierarchy. */
+ ,xpMsg_ButtonStateChanged = 1301
+
+
+};
+
+/***************************************************************************
+ * TEXT FIELD
+ ***************************************************************************/
+/*
+ * The text field widget provides an editable text field including mouse
+ * selection and keyboard navigation. The contents of the text field are its
+ * descriptor. (The descriptor changes as the user types.)
+ *
+ * The text field can have a number of types, that effect the visual layout of
+ * the text field. The text field sends messages to itself so you may control
+ * its behavior.
+ *
+ * If you need to filter keystrokes, add a new handler and intercept the key
+ * press message. Since key presses are passed by pointer, you can modify the
+ * keystroke and pass it through to the text field widget.
+ *
+ * WARNING: in x-plane before 7.10 (including 6.70) null characters could
+ * crash x-plane. To prevent this, wrap this object with a filter function
+ * (more instructions can be found on the SDK website).
+ *
+ */
+
+
+
+#define xpWidgetClass_TextField 4
+
+/*
+ * Text Field Type Values
+ *
+ * These control the look of the text field.
+ *
+ */
+enum {
+ /* A field for text entry. */
+ xpTextEntryField = 0
+
+ /* A transparent text field. The user can type and the text is drawn, but no *
+ * background is drawn. You can draw your own background by adding a widget *
+ * handler and prehandling the draw message. */
+ ,xpTextTransparent = 3
+
+ /* A translucent edit field, dark gray. */
+ ,xpTextTranslucent = 4
+
+
+};
+
+/*
+ * Text Field Properties
+ *
+ *
+ */
+enum {
+ /* This is the character position the selection starts at, zero based. If it *
+ * is the same as the end insertion point, the insertion point is not a *
+ * selection. */
+ xpProperty_EditFieldSelStart = 1400
+
+ /* This is the character position of the end of the selection. */
+ ,xpProperty_EditFieldSelEnd = 1401
+
+ /* This is the character position a drag was started at if the user is *
+ * dragging to select text, or -1 if a drag is not in progress. */
+ ,xpProperty_EditFieldSelDragStart = 1402
+
+ /* This is the type of text field to display, from the above list. */
+ ,xpProperty_TextFieldType = 1403
+
+ /* Set this property to 1 to password protect the field. Characters will be *
+ * drawn as *s even though the descriptor will contain plain-text. */
+ ,xpProperty_PasswordMode = 1404
+
+ /* The max number of characters you can enter, if limited. Zero means *
+ * unlimited. */
+ ,xpProperty_MaxCharacters = 1405
+
+ /* The first visible character on the left. This effectively scrolls the text *
+ * field. */
+ ,xpProperty_ScrollPosition = 1406
+
+ /* The font to draw the field's text with. (An XPLMFontID.) */
+ ,xpProperty_Font = 1407
+
+ /* This is the active side of the insert selection. (Internal) */
+ ,xpProperty_ActiveEditSide = 1408
+
+
+};
+
+/*
+ * Text Field Messages
+ *
+ *
+ */
+enum {
+ /* Text Field Messages *
+ * *
+ * The text field sends this message to itself when its text changes. It *
+ * sends the message up the call chain; param1 is the text field's widget ID. */
+ xpMsg_TextFieldChanged = 1400
+
+
+};
+
+/***************************************************************************
+ * SCROLL BAR
+ ***************************************************************************/
+/*
+ * A standard scroll bar or slider control. The scroll bar has a minimum,
+ * maximum and current value that is updated when the user drags it. The
+ * scroll bar sends continuous messages as it is dragged.
+ *
+ */
+
+
+
+#define xpWidgetClass_ScrollBar 5
+
+/*
+ * Scroll Bar Type Values
+ *
+ * This defines how the scroll bar looks.
+ *
+ */
+enum {
+ /* Scroll bar types. *
+ * *
+ * A standard x-plane scroll bar (with arrows on the ends). */
+ xpScrollBarTypeScrollBar = 0
+
+ /* A slider, no arrows. */
+ ,xpScrollBarTypeSlider = 1
+
+
+};
+
+/*
+ * Scroll Bar Properties
+ *
+ *
+ */
+enum {
+ /* The current position of the thumb (in between the min and max, inclusive) */
+ xpProperty_ScrollBarSliderPosition = 1500
+
+ /* The value the scroll bar has when the thumb is in the lowest position. */
+ ,xpProperty_ScrollBarMin = 1501
+
+ /* The value the scroll bar has when the thumb is in the highest position. */
+ ,xpProperty_ScrollBarMax = 1502
+
+ /* How many units to moev the scroll bar when clicking next to the thumb. The *
+ * scroll bar always moves one unit when the arrows are clicked. */
+ ,xpProperty_ScrollBarPageAmount = 1503
+
+ /* The type of scrollbar from the enums above. */
+ ,xpProperty_ScrollBarType = 1504
+
+ /* Used internally. */
+ ,xpProperty_ScrollBarSlop = 1505
+
+
+};
+
+/*
+ * Scroll Bar Messages
+ *
+ *
+ */
+enum {
+ /* The Scroll Bar sends this message when the slider position changes. It *
+ * sends the message up the call chain; param1 is the Scroll Bar widget ID. */
+ xpMsg_ScrollBarSliderPositionChanged = 1500
+
+
+};
+
+/***************************************************************************
+ * CAPTION
+ ***************************************************************************/
+/*
+ * A caption is a simple widget that shows its descriptor as a string, useful
+ * for labeling parts of a window. It always shows its descriptor as its
+ * string and is otherwise transparent.
+ *
+ */
+
+
+
+#define xpWidgetClass_Caption 6
+
+/*
+ * Caption Properties
+ *
+ *
+ */
+enum {
+ /* This property specifies whether the caption is lit; use lit captions *
+ * against screens. */
+ xpProperty_CaptionLit = 1600
+
+
+};
+
+/***************************************************************************
+ * GENERAL GRAPHICS
+ ***************************************************************************/
+/*
+ * The general graphics widget can show one of many icons available from
+ * x-plane.
+ *
+ */
+
+
+
+#define xpWidgetClass_GeneralGraphics 7
+
+/*
+ * General Graphics Types Values
+ *
+ * These define the icon for the general graphics.
+ *
+ */
+enum {
+ xpShip = 4
+
+ ,xpILSGlideScope = 5
+
+ ,xpMarkerLeft = 6
+
+ ,xp_Airport = 7
+
+ ,xpNDB = 8
+
+ ,xpVOR = 9
+
+ ,xpRadioTower = 10
+
+ ,xpAircraftCarrier = 11
+
+ ,xpFire = 12
+
+ ,xpMarkerRight = 13
+
+ ,xpCustomObject = 14
+
+ ,xpCoolingTower = 15
+
+ ,xpSmokeStack = 16
+
+ ,xpBuilding = 17
+
+ ,xpPowerLine = 18
+
+ ,xpVORWithCompassRose = 19
+
+ ,xpOilPlatform = 21
+
+ ,xpOilPlatformSmall = 22
+
+ ,xpWayPoint = 23
+
+
+};
+
+/*
+ * General Graphics Properties
+ *
+ *
+ */
+enum {
+ /* This property controls the type of icon that is drawn. */
+ xpProperty_GeneralGraphicsType = 1700
+
+
+};
+
+/***************************************************************************
+ * PROGRESS INDICATOR
+ ***************************************************************************/
+/*
+ * This widget implements a progress indicator as seen when x-plane starts up.
+ *
+ */
+
+
+
+#define xpWidgetClass_Progress 8
+
+/*
+ * Progress Indicator Properties
+ *
+ *
+ */
+enum {
+ /* This is the current value of the progress indicator. */
+ xpProperty_ProgressPosition = 1800
+
+ /* This is the minimum value, equivalent to 0% filled. */
+ ,xpProperty_ProgressMin = 1801
+
+ /* This is the maximum value, equivalent to 100% filled. */
+ ,xpProperty_ProgressMax = 1802
+
+
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/X-Plane-SDK/CHeaders/Widgets/XPUIGraphics.h b/X-Plane-SDK/CHeaders/Widgets/XPUIGraphics.h
new file mode 100755
index 0000000..24822c6
--- /dev/null
+++ b/X-Plane-SDK/CHeaders/Widgets/XPUIGraphics.h
@@ -0,0 +1,363 @@
+#ifndef _XPUIGraphics_h_
+#define _XPUIGraphics_h_
+
+/*
+ * Copyright 2005-2012 Sandy Barbour and Ben Supnik
+ *
+ * All rights reserved. See license.txt for usage.
+ *
+ * X-Plane SDK Version: 2.1.1
+ *
+ */
+
+/*
+ *
+ *
+ */
+
+#include "XPWidgetDefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***************************************************************************
+ * UI GRAPHICS
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPWindowStyle
+ *
+ * There are a few built-in window styles in X-Plane that you can use.
+ *
+ * Note that X-Plane 6 does not offer real shadow-compositing; you must make
+ * sure to put a window on top of another window of the right style to the
+ * shadows work, etc. This applies to elements with insets and shadows. The
+ * rules are:
+ *
+ * Sub windows must go on top of main windows, and screens and list views on
+ * top of subwindows. Only help and main windows can be over the main screen.
+ *
+ *
+ * With X-Plane 7 any window or element may be placed over any other element.
+ *
+ * Some windows are scaled by stretching, some by repeating. The drawing
+ * routines know which scaling method to use. The list view cannot be
+ * rescaled in x-plane 6 because it has both a repeating pattern and a
+ * gradient in one element. All other elements can be rescaled.
+ *
+ */
+enum {
+ /* An LCD screen that shows help. */
+ xpWindow_Help = 0
+
+ /* A dialog box window. */
+ ,xpWindow_MainWindow = 1
+
+ /* A panel or frame within a dialog box window. */
+ ,xpWindow_SubWindow = 2
+
+ /* An LCD screen within a panel to hold text displays. */
+ ,xpWindow_Screen = 4
+
+ /* A list view within a panel for scrolling file names, etc. */
+ ,xpWindow_ListView = 5
+
+
+};
+typedef int XPWindowStyle;
+
+/*
+ * XPDrawWindow
+ *
+ * This routine draws a window of the given dimensions at the given offset on
+ * the virtual screen in a given style. The window is automatically scaled as
+ * appropriate using a bitmap scaling technique (scaling or repeating) as
+ * appropriate to the style.
+ *
+ */
+WIDGET_API void XPDrawWindow(
+ int inX1,
+ int inY1,
+ int inX2,
+ int inY2,
+ XPWindowStyle inStyle);
+
+/*
+ * XPGetWindowDefaultDimensions
+ *
+ * This routine returns the default dimensions for a window. Output is either
+ * a minimum or fixed value depending on whether the window is scalable.
+ *
+ */
+WIDGET_API void XPGetWindowDefaultDimensions(
+ XPWindowStyle inStyle,
+ int * outWidth, /* Can be NULL */
+ int * outHeight); /* Can be NULL */
+
+/*
+ * XPElementStyle
+ *
+ * Elements are individually drawable UI things like push buttons, etc. The
+ * style defines what kind of element you are drawing. Elements can be
+ * stretched in one or two dimensions (depending on the element). Some
+ * elements can be lit.
+ *
+ * In x-plane 6 some elements must be drawn over metal. Some are scalable and
+ * some are not. Any element can be drawn anywhere in x-plane 7.
+ *
+ * Scalable Axis Required Background
+ *
+ */
+enum {
+ /* x metal */
+ xpElement_TextField = 6
+
+ /* none metal */
+ ,xpElement_CheckBox = 9
+
+ /* none metal */
+ ,xpElement_CheckBoxLit = 10
+
+ /* none window header */
+ ,xpElement_WindowCloseBox = 14
+
+ /* none window header */
+ ,xpElement_WindowCloseBoxPressed = 15
+
+ /* x metal */
+ ,xpElement_PushButton = 16
+
+ /* x metal */
+ ,xpElement_PushButtonLit = 17
+
+ /* none any */
+ ,xpElement_OilPlatform = 24
+
+ /* none any */
+ ,xpElement_OilPlatformSmall = 25
+
+ /* none any */
+ ,xpElement_Ship = 26
+
+ /* none any */
+ ,xpElement_ILSGlideScope = 27
+
+ /* none any */
+ ,xpElement_MarkerLeft = 28
+
+ /* none any */
+ ,xpElement_Airport = 29
+
+ /* none any */
+ ,xpElement_Waypoint = 30
+
+ /* none any */
+ ,xpElement_NDB = 31
+
+ /* none any */
+ ,xpElement_VOR = 32
+
+ /* none any */
+ ,xpElement_RadioTower = 33
+
+ /* none any */
+ ,xpElement_AircraftCarrier = 34
+
+ /* none any */
+ ,xpElement_Fire = 35
+
+ /* none any */
+ ,xpElement_MarkerRight = 36
+
+ /* none any */
+ ,xpElement_CustomObject = 37
+
+ /* none any */
+ ,xpElement_CoolingTower = 38
+
+ /* none any */
+ ,xpElement_SmokeStack = 39
+
+ /* none any */
+ ,xpElement_Building = 40
+
+ /* none any */
+ ,xpElement_PowerLine = 41
+
+ /* none metal */
+ ,xpElement_CopyButtons = 45
+
+ /* none metal */
+ ,xpElement_CopyButtonsWithEditingGrid = 46
+
+ /* x, y metal */
+ ,xpElement_EditingGrid = 47
+
+ /* THIS CAN PROBABLY BE REMOVED */
+ ,xpElement_ScrollBar = 48
+
+ /* none any */
+ ,xpElement_VORWithCompassRose = 49
+
+ /* none metal */
+ ,xpElement_Zoomer = 51
+
+ /* x, y metal */
+ ,xpElement_TextFieldMiddle = 52
+
+ /* none metal */
+ ,xpElement_LittleDownArrow = 53
+
+ /* none metal */
+ ,xpElement_LittleUpArrow = 54
+
+ /* none metal */
+ ,xpElement_WindowDragBar = 61
+
+ /* none metal */
+ ,xpElement_WindowDragBarSmooth = 62
+
+
+};
+typedef int XPElementStyle;
+
+/*
+ * XPDrawElement
+ *
+ * XPDrawElement draws a given element at an offset on the virtual screen in
+ * set dimensions. EVEN if the element is not scalable, it will be scaled if
+ * the width and height do not match the preferred dimensions; it'll just look
+ * ugly. Pass inLit to see the lit version of the element; if the element
+ * cannot be lit this is ignored.
+ *
+ */
+WIDGET_API void XPDrawElement(
+ int inX1,
+ int inY1,
+ int inX2,
+ int inY2,
+ XPElementStyle inStyle,
+ int inLit);
+
+/*
+ * XPGetElementDefaultDimensions
+ *
+ * This routine returns the recommended or minimum dimensions of a given UI
+ * element. outCanBeLit tells whether the element has both a lit and unlit
+ * state. Pass NULL to not receive any of these parameters.
+ *
+ */
+WIDGET_API void XPGetElementDefaultDimensions(
+ XPElementStyle inStyle,
+ int * outWidth, /* Can be NULL */
+ int * outHeight, /* Can be NULL */
+ int * outCanBeLit); /* Can be NULL */
+
+/*
+ * XPTrackStyle
+ *
+ * A track is a UI element that displays a value vertically or horizontally.
+ * X-Plane has three kinds of tracks: scroll bars, sliders, and progress bars.
+ * Tracks can be displayed either horizontally or vertically; tracks will
+ * choose their own layout based on the larger dimension of their dimensions
+ * (e.g. they know if they are tall or wide). Sliders may be lit or unlit
+ * (showing the user manipulating them).
+ *
+ * ScrollBar - this is a standard scroll bar with arrows and a thumb to drag.
+ * Slider - this is a simple track with a ball in the middle that can be
+ * slid. Progress - this is a progress indicator showing how a long task is
+ * going.
+ *
+ */
+enum {
+ /* not over metal can be lit can be rotated */
+ xpTrack_ScrollBar = 0
+
+ /* over metal can be lit can be rotated */
+ ,xpTrack_Slider = 1
+
+ /* over metal cannot be lit cannot be rotated */
+ ,xpTrack_Progress = 2
+
+
+};
+typedef int XPTrackStyle;
+
+/*
+ * XPDrawTrack
+ *
+ * This routine draws a track. You pass in the track dimensions and size; the
+ * track picks the optimal orientation for these dimensions. Pass in the
+ * track's minimum current and maximum values; the indicator will be
+ * positioned appropriately. You can also specify whether the track is lit or
+ * not.
+ *
+ */
+WIDGET_API void XPDrawTrack(
+ int inX1,
+ int inY1,
+ int inX2,
+ int inY2,
+ int inMin,
+ int inMax,
+ int inValue,
+ XPTrackStyle inTrackStyle,
+ int inLit);
+
+/*
+ * XPGetTrackDefaultDimensions
+ *
+ * This routine returns a track's default smaller dimension; all tracks are
+ * scalable in the larger dimension. It also returns whether a track can be
+ * lit.
+ *
+ */
+WIDGET_API void XPGetTrackDefaultDimensions(
+ XPTrackStyle inStyle,
+ int * outWidth,
+ int * outCanBeLit);
+
+/*
+ * XPGetTrackMetrics
+ *
+ * This routine returns the metrics of a track. If you want to write UI code
+ * to manipulate a track, this routine helps you know where the mouse
+ * locations are. For most other elements, the rectangle the element is drawn
+ * in is enough information. However, the scrollbar drawing routine does some
+ * automatic placement; this routine lets you know where things ended up. You
+ * pass almost everything you would pass to the draw routine. You get out the
+ * orientation, and other useful stuff.
+ *
+ * Besides orientation, you get five dimensions for the five parts of a
+ * scrollbar, which are the down button, down area (area before the thumb),
+ * the thumb, and the up area and button. For horizontal scrollers, the left
+ * button decreases; for vertical scrollers, the top button decreases.
+ *
+ */
+WIDGET_API void XPGetTrackMetrics(
+ int inX1,
+ int inY1,
+ int inX2,
+ int inY2,
+ int inMin,
+ int inMax,
+ int inValue,
+ XPTrackStyle inTrackStyle,
+ int * outIsVertical,
+ int * outDownBtnSize,
+ int * outDownPageSize,
+ int * outThumbSize,
+ int * outUpPageSize,
+ int * outUpBtnSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/X-Plane-SDK/CHeaders/Widgets/XPWidgetDefs.h b/X-Plane-SDK/CHeaders/Widgets/XPWidgetDefs.h
new file mode 100755
index 0000000..18a1bca
--- /dev/null
+++ b/X-Plane-SDK/CHeaders/Widgets/XPWidgetDefs.h
@@ -0,0 +1,486 @@
+#ifndef _XPWidgetDefs_h_
+#define _XPWidgetDefs_h_
+
+/*
+ * Copyright 2005-2012 Sandy Barbour and Ben Supnik
+ *
+ * All rights reserved. See license.txt for usage.
+ *
+ * X-Plane SDK Version: 2.1.1
+ *
+ */
+
+/*
+ *
+ *
+ */
+
+#include "XPLMDefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if APL
+ #if XPWIDGETS
+ #if __GNUC__ >= 4
+ #define WIDGET_API __attribute__((visibility("default")))
+ #elif __MACH__
+ #define WIDGET_API
+ #else
+ #define WIDGET_API __declspec(dllexport)
+ #endif
+ #else
+ #define WIDGET_API
+ #endif
+#elif IBM
+ #if XPWIDGETS
+ #define WIDGET_API __declspec(dllexport)
+ #else
+ #define WIDGET_API __declspec(dllimport)
+ #endif
+#elif LIN
+ #if XPWIDGETS
+ #if __GNUC__ >= 4
+ #define WIDGET_API __attribute__((visibility("default")))
+ #else
+ #define WIDGET_API
+ #endif
+ #else
+ #define WIDGET_API
+ #endif
+#else
+#pragma error "Platform not defined!"
+#endif
+ /***************************************************************************
+ * WIDGET DEFINITIONS
+ ***************************************************************************/
+/*
+ * A widget is a call-back driven screen entity like a push-button, window,
+ * text entry field, etc.
+ *
+ * Use the widget API to create widgets of various classes. You can nest them
+ * into trees of widgets to create complex user interfaces.
+ *
+ */
+
+
+
+/*
+ * XPWidgetID
+ *
+ * A Widget ID is an opaque unique non-zero handle identifying your widget.
+ * Use 0 to specify "no widget". This type is defined as wide enough to hold
+ * a pointer. You receive a widget ID when you create a new widget and then
+ * use that widget ID to further refer to the widget.
+ *
+ */
+typedef void * XPWidgetID;
+
+/*
+ * XPWidgetPropertyID
+ *
+ * Properties are values attached to instances of your widgets. A property is
+ * identified by a 32-bit ID and its value is the width of a pointer.
+ *
+ * Each widget instance may have a property or not have it. When you set a
+ * property on a widget for the first time, the property is added to the
+ * widget; it then stays there for the life of the widget.
+ *
+ * Some property IDs are predefined by the widget package; you can make up
+ * your own property IDs as well.
+ *
+ */
+enum {
+ /* A window's refcon is an opaque value used by client code to find other data *
+ * based on it. */
+ xpProperty_Refcon = 0
+
+ /* These properties are used by the utlities to implement dragging. */
+ ,xpProperty_Dragging = 1
+
+ ,xpProperty_DragXOff = 2
+
+ ,xpProperty_DragYOff = 3
+
+ /* Is the widget hilited? (For widgets that support this kind of thing.) */
+ ,xpProperty_Hilited = 4
+
+ /* Is there a C++ object attached to this widget? */
+ ,xpProperty_Object = 5
+
+ /* If this property is 1, the widget package will use OpenGL to restrict *
+ * drawing to the Wiget's exposed rectangle. */
+ ,xpProperty_Clip = 6
+
+ /* Is this widget enabled (for those that have a disabled state too)? */
+ ,xpProperty_Enabled = 7
+
+ /* NOTE: Property IDs 1 - 999 are reserved for the widget's library. *
+ * *
+ * NOTE: Property IDs 1000 - 9999 are allocated to the standard widget classes *
+ * provided with the library Properties 1000 - 1099 are for widget class 0, *
+ * 1100 - 1199 for widget class 1, etc. */
+ ,xpProperty_UserStart = 10000
+
+
+};
+typedef int XPWidgetPropertyID;
+
+/*
+ * XPMouseState_t
+ *
+ * When the mouse is clicked or dragged, a pointer to this structure is passed
+ * to your widget function.
+ *
+ */
+typedef struct {
+ int x;
+ int y;
+ /* Mouse Button number, left = 0 (right button not yet supported. */
+ int button;
+#if defined(XPLM200)
+ /* Scroll wheel delta (button in this case would be the wheel axis number). */
+ int delta;
+#endif /* XPLM200 */
+} XPMouseState_t;
+
+/*
+ * XPKeyState_t
+ *
+ * When a key is pressed, a pointer to this struct is passed to your widget
+ * function.
+ *
+ */
+typedef struct {
+ /* The ASCII key that was pressed. WARNING: this may be 0 for some non-ASCII *
+ * key sequences. */
+ char key;
+ /* The flags. Make sure to check this if you only want key-downs! */
+ XPLMKeyFlags flags;
+ /* The virtual key code for the key */
+ char vkey;
+} XPKeyState_t;
+
+/*
+ * XPWidgetGeometryChange_t
+ *
+ * This structure contains the deltas for your widget's geometry when it
+ * changes.
+ *
+ */
+typedef struct {
+ int dx;
+ /* +Y = the widget moved up */
+ int dy;
+ int dwidth;
+ int dheight;
+} XPWidgetGeometryChange_t;
+
+/*
+ * XPDispatchMode
+ *
+ * The dispatching modes describe how the widgets library sends out messages.
+ * Currently there are three modes:
+ *
+ */
+enum {
+ /* The message will only be sent to the target widget. */
+ xpMode_Direct = 0
+
+ /* The message is sent to the target widget, then up the chain of parents *
+ * until the message is handled or a parentless widget is reached. */
+ ,xpMode_UpChain = 1
+
+ /* The message is sent to the target widget and then all of its children *
+ * recursively depth-first. */
+ ,xpMode_Recursive = 2
+
+ /* The message is snet just to the target, but goes to every callback, even if *
+ * it is handled. */
+ ,xpMode_DirectAllCallbacks = 3
+
+ /* The message is only sent to the very first handler even if it is not *
+ * accepted. (This is really only useful for some internal Widget Lib *
+ * functions. */
+ ,xpMode_Once = 4
+
+
+};
+typedef int XPDispatchMode;
+
+/*
+ * XPWidgetClass
+ *
+ * Widget classes define predefined widget types. A widget class basically
+ * specifies from a library the widget function to be used for the widget.
+ * Most widgets can be made right from classes.
+ *
+ */
+typedef int XPWidgetClass;
+
+/* An unspecified widget class. Other widget classes are in *
+ * XPStandardWidgets.h */
+#define xpWidgetClass_None 0
+
+/***************************************************************************
+ * WIDGET MESSAGES
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPWidgetMessage
+ *
+ * Widgets receive 32-bit messages indicating what action is to be taken or
+ * notifications of events. The list of messages may be expanded.
+ *
+ */
+enum {
+ /* No message, should not be sent. */
+ xpMsg_None = 0
+
+ /* The create message is sent once per widget that is created with your widget *
+ * function and once for any widget that has your widget function attached. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: 1 if you are being added as a subclass, 0 if the widget is first *
+ * being created. */
+ ,xpMsg_Create = 1
+
+ /* The destroy message is sent once for each message that is destroyed that *
+ * has your widget function. *
+ * *
+ * Dispatching: Direct for all *
+ * *
+ * Param 1: 1 if being deleted by a recursive delete to the parent, 0 for *
+ * explicit deletion. */
+ ,xpMsg_Destroy = 2
+
+ /* The paint message is sent to your widget to draw itself. The paint message *
+ * is the bare-bones message; in response you must draw yourself, draw your *
+ * children, set up clipping and culling, check for visibility, etc. If you *
+ * don't want to do all of this, ignore the paint message and a draw message *
+ * (see below) will be sent to you. *
+ * *
+ * Dispatching: Direct */
+ ,xpMsg_Paint = 3
+
+ /* The draw message is sent to your widget when it is time to draw yourself. *
+ * OpenGL will be set up to draw in 2-d global screen coordinates, but you *
+ * should use the XPLM to set up OpenGL state. *
+ * *
+ * Dispatching: Direct */
+ ,xpMsg_Draw = 4
+
+ /* The key press message is sent once per key that is pressed. The first *
+ * parameter is the type of key code (integer or char) and the second is the *
+ * code itself. By handling this event, you consume the key stroke. *
+ * *
+ * Handling this message 'consumes' the keystroke; not handling it passes it *
+ * to your parent widget. *
+ * *
+ * Dispatching: Up Chain *
+ * *
+ * : Param 1: A pointer to an XPKeyState_t structure with the keystroke. */
+ ,xpMsg_KeyPress = 5
+
+ /* Keyboard focus is being given to you. By handling this message you accept *
+ * keyboard focus. The first parameter will be one if a child of yours gave *
+ * up focus to you, 0 if someone set focus on you explicitly. *
+ * *
+ * : Handling this message accepts focus; not handling refuses focus. *
+ * *
+ * Dispatching: direct *
+ * *
+ * Param 1: 1 if you are gaining focus because your child is giving it up, 0 *
+ * if someone is explicitly giving you focus. */
+ ,xpMsg_KeyTakeFocus = 6
+
+ /* Keyboard focus is being taken away from you. The first parameter will be *
+ * one if you are losing focus because another widget is taking it, or 0 if *
+ * someone called the API to make you lose focus explicitly. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: 1 if focus is being taken by another widget, 0 if code requested *
+ * to remove focus. */
+ ,xpMsg_KeyLoseFocus = 7
+
+ /* You receive one mousedown event per click with a mouse-state structure *
+ * pointed to by parameter 1, by accepting this you eat the click, otherwise *
+ * your parent gets it. You will not receive drag and mouse up messages if *
+ * you do not accept the down message. *
+ * *
+ * Handling this message consumes the mouse click, not handling it passes it *
+ * to the next widget. You can act 'transparent' as a window by never handling *
+ * moues clicks to certain areas. *
+ * *
+ * Dispatching: Up chain NOTE: Technically this is direct dispatched, but the *
+ * widgets library will shop it to each widget until one consumes the click, *
+ * making it effectively "up chain". *
+ * *
+ * Param 1: A pointer to an XPMouseState_t containing the mouse status. */
+ ,xpMsg_MouseDown = 8
+
+ /* You receive a series of mouse drag messages (typically one per frame in the *
+ * sim) as the mouse is moved once you have accepted a mouse down message. *
+ * Parameter one points to a mouse-state structure describing the mouse *
+ * location. You will continue to receive these until the mouse button is *
+ * released. You may receive multiple mouse state messages with the same mouse *
+ * position. You will receive mouse drag events even if the mouse is dragged *
+ * out of your current or original bounds at the time of the mouse down. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: A pointer to an XPMouseState_t containing the mouse status. */
+ ,xpMsg_MouseDrag = 9
+
+ /* The mouseup event is sent once when the mouse button is released after a *
+ * drag or click. You only receive this message if you accept the mouseDown *
+ * message. Parameter one points to a mouse state structure. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: A pointer to an XPMouseState_t containing the mouse status. */
+ ,xpMsg_MouseUp = 10
+
+ /* Your geometry or a child's geometry is being changed. *
+ * *
+ * Dispatching: Up chain *
+ * *
+ * Param 1: The widget ID of the original reshaped target. *
+ * *
+ * Param 2: A pointer to a XPWidgetGeometryChange_t struct describing the *
+ * change. */
+ ,xpMsg_Reshape = 11
+
+ /* Your exposed area has changed. *
+ * *
+ * Dispatching: Direct */
+ ,xpMsg_ExposedChanged = 12
+
+ /* A child has been added to you. The child's ID is passed in parameter one. *
+ * *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: The Widget ID of the child being added. */
+ ,xpMsg_AcceptChild = 13
+
+ /* A child has been removed from to you. The child's ID is passed in *
+ * parameter one. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: The Widget ID of the child being removed. */
+ ,xpMsg_LoseChild = 14
+
+ /* You now have a new parent, or have no parent. The parent's ID is passed *
+ * in, or 0 for no parent. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: The Widget ID of your parent */
+ ,xpMsg_AcceptParent = 15
+
+ /* You or a child has been shown. Note that this does not include you being *
+ * shown because your parent was shown, you were put in a new parent, your *
+ * root was shown, etc. *
+ * *
+ * Dispatching: Up chain *
+ * *
+ * Param 1: The widget ID of the shown widget. */
+ ,xpMsg_Shown = 16
+
+ /* You have been hidden. See limitations above. *
+ * *
+ * Dispatching: Up chain *
+ * *
+ * Param 1: The widget ID of the hidden widget. */
+ ,xpMsg_Hidden = 17
+
+ /* Your descriptor has changed. *
+ * *
+ * Dispatching: Direct */
+ ,xpMsg_DescriptorChanged = 18
+
+ /* A property has changed. Param 1 contains the property ID. *
+ * *
+ * Dispatching: Direct *
+ * *
+ * Param 1: The Property ID being changed. *
+ * *
+ * Param 2: The new property value */
+ ,xpMsg_PropertyChanged = 19
+
+#if defined(XPLM200)
+ /* The mouse wheel has moved. *
+ * *
+ * Return 1 to consume the mouse wheel move, or 0 to pass the message to a *
+ * parent. Dispatching: Up chain *
+ * *
+ * Param 1: A pointer to an XPMouseState_t containing the mouse status. */
+ ,xpMsg_MouseWheel = 20
+
+#endif /* XPLM200 */
+#if defined(XPLM200)
+ /* The cursor is over your widget. If you consume this message, change the *
+ * XPLMCursorStatus value to indicate the desired result, with the same rules *
+ * as in XPLMDisplay.h. *
+ * *
+ * Return 1 to consume this message, 0 to pass it on. *
+ * *
+ * Dispatching: Up chain Param 1: A pointer to an XPMouseState_t struct *
+ * containing the mouse status. *
+ * *
+ * Param 2: A pointer to a XPLMCursorStatus - set this to the cursor result *
+ * you desire. */
+ ,xpMsg_CursorAdjust = 21
+
+#endif /* XPLM200 */
+ /* NOTE: Message IDs 1000 - 9999 are allocated to the standard widget classes *
+ * provided with the library with 1000 - 1099 for widget class 0, 1100 - 1199 *
+ * for widget class 1, etc. Message IDs 10,000 and beyond are for plugin use. */
+ ,xpMsg_UserStart = 10000
+
+
+};
+typedef int XPWidgetMessage;
+
+/***************************************************************************
+ * WIDGET CALLBACK FUNCTION
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPWidgetFunc_t
+ *
+ * This function defines your custom widget's behavior. It will be called by
+ * the widgets library to send messages to your widget. The message and
+ * widget ID are passed in, as well as two ptr-width signed parameters whose
+ * meaning varies with the message. Return 1 to indicate that you have
+ * processed the message, 0 to indicate that you have not. For any message
+ * that is not understood, return 0.
+ *
+ */
+typedef int (* XPWidgetFunc_t)(
+ XPWidgetMessage inMessage,
+ XPWidgetID inWidget,
+ intptr_t inParam1,
+ intptr_t inParam2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/X-Plane-SDK/CHeaders/Widgets/XPWidgetUtils.h b/X-Plane-SDK/CHeaders/Widgets/XPWidgetUtils.h
new file mode 100755
index 0000000..e61d272
--- /dev/null
+++ b/X-Plane-SDK/CHeaders/Widgets/XPWidgetUtils.h
@@ -0,0 +1,234 @@
+#ifndef _XPWidgetUtils_h_
+#define _XPWidgetUtils_h_
+
+/*
+ * Copyright 2005-2012 Sandy Barbour and Ben Supnik
+ *
+ * All rights reserved. See license.txt for usage.
+ *
+ * X-Plane SDK Version: 2.1.1
+ *
+ */
+
+/*
+ * XPWidgetUtils - USAGE NOTES
+ *
+ * The XPWidgetUtils library contains useful functions that make writing and
+ * using widgets less of a pain.
+ *
+ * One set of functions are the widget behavior functions. These functions
+ * each add specific useful behaviors to widgets. They can be used in two
+ * manners:
+ *
+ * 1. You can add a widget behavior function to a widget as a callback proc
+ * using the XPAddWidgetCallback function. The widget will gain that
+ * behavior. Remember that the last function you add has highest priority.
+ * You can use this to change or augment the behavior of an existing finished
+ * widget.
+ *
+ * 2. You can call a widget function from inside your own widget function.
+ * This allows you to include useful behaviors in custom-built widgets. A
+ * number of the standard widgets get their behavior from this library. To do
+ * this, call the behavior function from your function first. If it returns
+ * 1, that means it handled the event and you don't need to; simply return 1.
+ *
+ */
+
+#include "XPWidgetDefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***************************************************************************
+ * GENERAL UTILITIES
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+
+
+/*
+ * Convenience accessors
+ *
+ * It can be clumsy accessing the variables passed in by pointer to a struct
+ * for mouse and reshape messages; these accessors let you simply pass in the param
+ * right from the arguments of your widget proc and get back the value you want.
+ *
+ */
+#define MOUSE_X(param) (((XPMouseState_t *) (param))->x)
+#define MOUSE_Y(param) (((XPMouseState_t *) (param))->y)
+
+#define DELTA_X(param) (((XPWidgetGeometryChange_t *) (param))->dx)
+#define DELTA_Y(param) (((XPWidgetGeometryChange_t *) (param))->dy)
+#define DELTA_W(param) (((XPWidgetGeometryChange_t *) (param))->dwidth)
+#define DELTA_H(param) (((XPWidgetGeometryChange_t *) (param))->dheight)
+
+#define KEY_CHAR(param) (((XPKeyState_t *) (param))->key)
+#define KEY_FLAGS(param) (((XPKeyState_t *) (param))->flags)
+#define KEY_VKEY(param) (((XPKeyState_t *) (param))->vkey)
+
+#define IN_RECT(x, y, l, t, r, b) \
+ (((x) >= (l)) && ((x) <= (r)) && ((y) >= (b)) && ((y) <= (t)))
+
+/*
+ * XPWidgetCreate_t
+ *
+ * This structure contains all of the parameters needed to create a wiget. It
+ * is used with XPUCreateWidgets to create widgets in bulk from an array. All
+ * parameters correspond to those of XPCreateWidget except for the container
+ * index. If the container index is equal to the index of a widget in the
+ * array, the widget in the array passed to XPUCreateWidgets is used as the
+ * parent of this widget. Note that if you pass an index greater than your
+ * own position in the array, the parent you are requesting will not exist
+ * yet. If the container index is NO_PARENT, the parent widget is specified as
+ * NULL. If the container index is PARAM_PARENT, the widget passed into
+ * XPUCreateWidgets is used.
+ *
+ */
+typedef struct {
+ int left;
+ int top;
+ int right;
+ int bottom;
+ int visible;
+ const char * descriptor;
+ int isRoot;
+ int containerIndex;
+ XPWidgetClass widgetClass;
+} XPWidgetCreate_t;
+
+#define NO_PARENT -1
+
+#define PARAM_PARENT -2
+
+#define WIDGET_COUNT(x) ((sizeof(x) / sizeof(XPWidgetCreate_t)))
+
+/*
+ * XPUCreateWidgets
+ *
+ * This function creates a series of widgets from a table...see
+ * XPCreateWidget_t above. Pass in an array of widget creation structures and
+ * an array of widget IDs that will receive each widget.
+ *
+ * Widget parents are specified by index into the created widget table,
+ * allowing you to create nested widget structures. You can create multiple
+ * widget trees in one table. Generally you should create widget trees from
+ * the top down.
+ *
+ * You can also pass in a widget ID that will be used when the widget's parent
+ * is listed as PARAM_PARENT; this allows you to embed widgets created with
+ * XPUCreateWidgets in a widget created previously.
+ *
+ */
+WIDGET_API void XPUCreateWidgets(
+ const XPWidgetCreate_t * inWidgetDefs,
+ int inCount,
+ XPWidgetID inParamParent,
+ XPWidgetID * ioWidgets);
+
+/*
+ * XPUMoveWidgetBy
+ *
+ * Simply moves a widget by an amount, +x = right, +y=up, without resizing the
+ * widget.
+ *
+ */
+WIDGET_API void XPUMoveWidgetBy(
+ XPWidgetID inWidget,
+ int inDeltaX,
+ int inDeltaY);
+
+/***************************************************************************
+ * LAYOUT MANAGERS
+ ***************************************************************************/
+/*
+ * The layout managers are widget behavior functions for handling where
+ * widgets move. Layout managers can be called from a widget function or
+ * attached to a widget later.
+ *
+ */
+
+
+
+/*
+ * XPUFixedLayout
+ *
+ * This function causes the widget to maintain its children in fixed position
+ * relative to itself as it is resized. Use this on the top level 'window'
+ * widget for your window.
+ *
+ */
+WIDGET_API int XPUFixedLayout(
+ XPWidgetMessage inMessage,
+ XPWidgetID inWidget,
+ intptr_t inParam1,
+ intptr_t inParam2);
+
+/***************************************************************************
+ * WIDGET PROC BEHAVIORS
+ ***************************************************************************/
+/*
+ * These widget behavior functions add other useful behaviors to widgets.
+ * These functions cannot be attached to a widget; they must be called from
+ * your widget function.
+ *
+ */
+
+
+
+/*
+ * XPUSelectIfNeeded
+ *
+ * This causes the widget to bring its window to the foreground if it is not
+ * already. inEatClick specifies whether clicks in the background should be
+ * consumed by bringin the window to the foreground.
+ *
+ */
+WIDGET_API int XPUSelectIfNeeded(
+ XPWidgetMessage inMessage,
+ XPWidgetID inWidget,
+ intptr_t inParam1,
+ intptr_t inParam2,
+ int inEatClick);
+
+/*
+ * XPUDefocusKeyboard
+ *
+ * This causes a click in the widget to send keyboard focus back to X-Plane.
+ * This stops editing of any text fields, etc.
+ *
+ */
+WIDGET_API int XPUDefocusKeyboard(
+ XPWidgetMessage inMessage,
+ XPWidgetID inWidget,
+ intptr_t inParam1,
+ intptr_t inParam2,
+ int inEatClick);
+
+/*
+ * XPUDragWidget
+ *
+ * XPUDragWidget drags the widget in response to mouse clicks. Pass in not
+ * only the event, but the global coordinates of the drag region, which might
+ * be a sub-region of your widget (for example, a title bar).
+ *
+ */
+WIDGET_API int XPUDragWidget(
+ XPWidgetMessage inMessage,
+ XPWidgetID inWidget,
+ intptr_t inParam1,
+ intptr_t inParam2,
+ int inLeft,
+ int inTop,
+ int inRight,
+ int inBottom);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/X-Plane-SDK/CHeaders/Widgets/XPWidgets.h b/X-Plane-SDK/CHeaders/Widgets/XPWidgets.h
new file mode 100755
index 0000000..13ca62e
--- /dev/null
+++ b/X-Plane-SDK/CHeaders/Widgets/XPWidgets.h
@@ -0,0 +1,569 @@
+#ifndef _XPWidgets_h_
+#define _XPWidgets_h_
+
+/*
+ * Copyright 2005-2012 Sandy Barbour and Ben Supnik
+ *
+ * All rights reserved. See license.txt for usage.
+ *
+ * X-Plane SDK Version: 2.1.1
+ *
+ */
+
+/*
+ * WIDGETS - THEORY OF OPERATION AND NOTES
+ *
+ * Widgets are persistent view 'objects' for X-Plane. A widget is an object
+ * referenced by its opaque handle (widget ID) and the APIs in this file. You
+ * cannot access the widget's guts directly. Every Widget has the following
+ * intrinsic data:
+ *
+ * - A bounding box defined in global screen coordinates with 0,0 in the
+ * bottom left and +y = up, +x = right.
+ *
+ * - A visible box, which is the intersection of the bounding box with the
+ * widget's parents visible box.
+ *
+ * - Zero or one parent widgets. (Always zero if the widget is a root widget.
+ *
+ *
+ * - Zero or more child widgets.
+ *
+ * - Whether the widget is a root. Root widgets are the top level plugin
+ * windows.
+ *
+ * - Whether the widget is visible.
+ *
+ * - A text string descriptor, whose meaning varies from widget to widget.
+ *
+ * - An arbitrary set of 32 bit integral properties defined by 32-bit integral
+ * keys. This is how specific widgets
+ *
+ * store specific data.
+ *
+ * - A list of widget callbacks proc that implements the widgets behaviors.
+ *
+ * The Widgets library sends messages to widgets to request specific behaviors
+ * or notify the widget of things.
+ *
+ * Widgets may have more than one callback function, in which case messages
+ * are sent to the most recently added callback function until the message is
+ * handled. Messages may also be sent to parents or children; see the
+ * XPWidgetDefs.h header file for the different widget message dispatching
+ * functions. By adding a callback function to a window you can 'subclass'
+ * its behavior.
+ *
+ * A set of standard widgets are provided that serve common UI purposes. You
+ * can also customize or implement entirely custom widgets.
+ *
+ * Widgets are different than other view hierarchies (most notably Win32,
+ * which they bear a striking resemblance to) in the following ways:
+ *
+ * - Not all behavior can be patched. State that is managed by the XPWidgets
+ * DLL and not by individual widgets cannot be customized.
+ *
+ * - All coordinates are in global screen coordinates. Coordinates are not
+ * relative to an enclosing widget, nor are they relative to a display window.
+ *
+ *
+ * - Widget messages are always dispatched synchronously, and there is no
+ * concept of scheduling an update or a dirty region. Messages originate from
+ * X-Plane as the sim cycle goes by. Since x-plane is constantly redrawing,
+ * so are widgets; there is no need to mark a part of a widget as 'needing
+ * redrawing' because redrawing happens frequently whether the widget needs it
+ * or not.
+ *
+ * - Any widget may be a 'root' widget, causing it to be drawn; there is no
+ * relationship between widget class and rootness. Root widgets are
+ * imlemented as XPLMDisply windows.
+ *
+ */
+
+#include "XPWidgetDefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***************************************************************************
+ * WIDGET CREATION AND MANAGEMENT
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPCreateWidget
+ *
+ * This function creates a new widget and returns the new widget's ID to you.
+ * If the widget creation fails for some reason, it returns NULL. Widget
+ * creation will fail either if you pass a bad class ID or if there is not
+ * adequate memory.
+ *
+ * Input Parameters:
+ *
+ * - Top, left, bottom, and right in global screen coordinates defining the
+ * widget's location on the screen.
+ *
+ * - inVisible is 1 if the widget should be drawn, 0 to start the widget as
+ * hidden.
+ *
+ * - inDescriptor is a null terminated string that will become the widget's
+ * descriptor.
+ *
+ * - inIsRoot is 1 if this is going to be a root widget, 0 if it will not be.
+ *
+ * - inContainer is the ID of this widget's container. It must be 0 for a
+ * root widget. for a non-root widget, pass the widget ID of the widget to
+ * place this widget within. If this widget is not going to start inside
+ * another widget, pass 0; this new widget will then just be floating off in
+ * space (and will not be drawn until it is placed in a widget.
+ *
+ * - inClass is the class of the widget to draw. Use one of the predefined
+ * class-IDs to create a standard widget.
+ *
+ * A note on widget embedding: a widget is only called (and will be drawn,
+ * etc.) if it is placed within a widget that will be called. Root widgets
+ * are always called. So it is possible to have whole chains of widgets that
+ * are simply not called. You can preconstruct widget trees and then place
+ * them into root widgets later to activate them if you wish.
+ *
+ */
+WIDGET_API XPWidgetID XPCreateWidget(
+ int inLeft,
+ int inTop,
+ int inRight,
+ int inBottom,
+ int inVisible,
+ const char * inDescriptor,
+ int inIsRoot,
+ XPWidgetID inContainer,
+ XPWidgetClass inClass);
+
+/*
+ * XPCreateCustomWidget
+ *
+ * This function is the same as XPCreateWidget except that instead of passing
+ * a class ID, you pass your widget callback function pointer defining the
+ * widget. Use this function to define a custom widget. All parameters are
+ * the same as XPCreateWidget, except that the widget class has been replaced
+ * with the widget function.
+ *
+ */
+WIDGET_API XPWidgetID XPCreateCustomWidget(
+ int inLeft,
+ int inTop,
+ int inRight,
+ int inBottom,
+ int inVisible,
+ const char * inDescriptor,
+ int inIsRoot,
+ XPWidgetID inContainer,
+ XPWidgetFunc_t inCallback);
+
+/*
+ * XPDestroyWidget
+ *
+ * This class destroys a widget. Pass in the ID of the widget to kill. If
+ * you pass 1 for inDestroyChilren, the widget's children will be destroyed
+ * first, then this widget will be destroyed. (Furthermore, the widget's
+ * children will be destroyed with the inDestroyChildren flag set to 1, so the
+ * destruction will recurse down the widget tree.) If you pass 0 for this
+ * flag, the child widgets will simply end up with their parent set to 0.
+ *
+ */
+WIDGET_API void XPDestroyWidget(
+ XPWidgetID inWidget,
+ int inDestroyChildren);
+
+/*
+ * XPSendMessageToWidget
+ *
+ * This sends any message to a widget. You should probably not go around
+ * simulating the predefined messages that the widgets library defines for
+ * you. You may however define custom messages for your widgets and send them
+ * with this method.
+ *
+ * This method supports several dispatching patterns; see XPDispatchMode for
+ * more info. The function returns 1 if the message was handled, 0 if it was
+ * not.
+ *
+ * For each widget that receives the message (see the dispatching modes), each
+ * widget function from the most recently installed to the oldest one
+ * receives the message in order until it is handled.
+ *
+ */
+WIDGET_API int XPSendMessageToWidget(
+ XPWidgetID inWidget,
+ XPWidgetMessage inMessage,
+ XPDispatchMode inMode,
+ intptr_t inParam1,
+ intptr_t inParam2);
+
+/***************************************************************************
+ * WIDGET POSITIONING AND VISIBILITY
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPPlaceWidgetWithin
+ *
+ * This function changes which container a widget resides in. You may NOT use
+ * this function on a root widget! inSubWidget is the widget that will be
+ * moved. Pass a widget ID in inContainer to make inSubWidget be a child of
+ * inContainer. It will become the last/closest widget in the container.
+ * Pass 0 to remove the widget from any container. Any call to this other
+ * than passing the widget ID of the old parent of the affected widget will
+ * cause the widget to be removed from its old parent. Placing a widget within
+ * its own parent simply makes it the last widget.
+ *
+ * NOTE: this routine does not reposition the sub widget in global
+ * coordinates. If the container has layout management code, it will
+ * reposition the subwidget for you, otherwise you must do it with
+ * SetWidgetGeometry.
+ *
+ */
+WIDGET_API void XPPlaceWidgetWithin(
+ XPWidgetID inSubWidget,
+ XPWidgetID inContainer);
+
+/*
+ * XPCountChildWidgets
+ *
+ * This routine returns the number of widgets another widget contains.
+ *
+ */
+WIDGET_API int XPCountChildWidgets(
+ XPWidgetID inWidget);
+
+/*
+ * XPGetNthChildWidget
+ *
+ * This routine returns the widget ID of a child widget by index. Indexes are
+ * 0 based, from 0 to one minus the number of widgets in the parent,
+ * inclusive. If the index is invalid, 0 is returned.
+ *
+ */
+WIDGET_API XPWidgetID XPGetNthChildWidget(
+ XPWidgetID inWidget,
+ int inIndex);
+
+/*
+ * XPGetParentWidget
+ *
+ * This routine returns the parent of a widget, or 0 if the widget has no
+ * parent. Root widgets never have parents and therefore always return 0.
+ *
+ */
+WIDGET_API XPWidgetID XPGetParentWidget(
+ XPWidgetID inWidget);
+
+/*
+ * XPShowWidget
+ *
+ * This routine makes a widget visible if it is not already. Note that if a
+ * widget is not in a rooted widget hierarchy or one of its parents is not
+ * visible, it will still not be visible to the user.
+ *
+ */
+WIDGET_API void XPShowWidget(
+ XPWidgetID inWidget);
+
+/*
+ * XPHideWidget
+ *
+ * Makes a widget invisible. See XPShowWidget for considerations of when a
+ * widget might not be visible despite its own visibility state.
+ *
+ */
+WIDGET_API void XPHideWidget(
+ XPWidgetID inWidget);
+
+/*
+ * XPIsWidgetVisible
+ *
+ * This returns 1 if a widget is visible, 0 if it is not. Note that this
+ * routine takes into consideration whether a parent is invisible. Use this
+ * routine to tell if the user can see the widget.
+ *
+ */
+WIDGET_API int XPIsWidgetVisible(
+ XPWidgetID inWidget);
+
+/*
+ * XPFindRootWidget
+ *
+ * XPFindRootWidget returns the Widget ID of the root widget that contains the
+ * passed in widget or NULL if the passed in widget is not in a rooted
+ * hierarchy.
+ *
+ */
+WIDGET_API XPWidgetID XPFindRootWidget(
+ XPWidgetID inWidget);
+
+/*
+ * XPBringRootWidgetToFront
+ *
+ * This routine makes the specified widget be in the front most widget
+ * hierarchy. If this widget is a root widget, its widget hierarchy comes to
+ * front, otherwise the widget's root is brought to the front. If this widget
+ * is not in an active widget hiearchy (e.g. there is no root widget at the
+ * top of the tree), this routine does nothing.
+ *
+ */
+WIDGET_API void XPBringRootWidgetToFront(
+ XPWidgetID inWidget);
+
+/*
+ * XPIsWidgetInFront
+ *
+ * This routine returns true if this widget's hierarchy is the front most
+ * hierarchy. It returns false if the widget's hierarchy is not in front, or
+ * if the widget is not in a rooted hierarchy.
+ *
+ */
+WIDGET_API int XPIsWidgetInFront(
+ XPWidgetID inWidget);
+
+/*
+ * XPGetWidgetGeometry
+ *
+ * This routine returns the bounding box of a widget in global coordinates.
+ * Pass NULL for any parameter you are not interested in.
+ *
+ */
+WIDGET_API void XPGetWidgetGeometry(
+ XPWidgetID inWidget,
+ int * outLeft, /* Can be NULL */
+ int * outTop, /* Can be NULL */
+ int * outRight, /* Can be NULL */
+ int * outBottom); /* Can be NULL */
+
+/*
+ * XPSetWidgetGeometry
+ *
+ * This function changes the bounding box of a widget.
+ *
+ */
+WIDGET_API void XPSetWidgetGeometry(
+ XPWidgetID inWidget,
+ int inLeft,
+ int inTop,
+ int inRight,
+ int inBottom);
+
+/*
+ * XPGetWidgetForLocation
+ *
+ * Given a widget and a location, this routine returns the widget ID of the
+ * child of that widget that owns that location. If inRecursive is true then
+ * this will return a child of a child of a widget as it tries to find the
+ * deepest widget at that location. If inVisibleOnly is true, then only
+ * visible widgets are considered, otherwise all widgets are considered. The
+ * widget ID passed for inContainer will be returned if the location is in
+ * that widget but not in a child widget. 0 is returned if the location is
+ * not in the container.
+ *
+ * NOTE: if a widget's geometry extends outside its parents geometry, it will
+ * not be returned by this call for mouse locations outside the parent
+ * geometry. The parent geometry limits the child's eligibility for mouse
+ * location.
+ *
+ */
+WIDGET_API XPWidgetID XPGetWidgetForLocation(
+ XPWidgetID inContainer,
+ int inXOffset,
+ int inYOffset,
+ int inRecursive,
+ int inVisibleOnly);
+
+/*
+ * XPGetWidgetExposedGeometry
+ *
+ * This routine returns the bounds of the area of a widget that is completely
+ * within its parent widgets. Since a widget's bounding box can be outside
+ * its parent, part of its area will not be elligible for mouse clicks and
+ * should not draw. Use XPGetWidgetGeometry to find out what area defines
+ * your widget's shape, but use this routine to find out what area to actually
+ * draw into. Note that the widget library does not use OpenGL clipping to
+ * keep frame rates up, although you could use it internally.
+ *
+ */
+WIDGET_API void XPGetWidgetExposedGeometry(
+ XPWidgetID inWidgetID,
+ int * outLeft, /* Can be NULL */
+ int * outTop, /* Can be NULL */
+ int * outRight, /* Can be NULL */
+ int * outBottom); /* Can be NULL */
+
+/***************************************************************************
+ * ACCESSING WIDGET DATA
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPSetWidgetDescriptor
+ *
+ * Every widget has a descriptor, which is a text string. What the text
+ * string is used for varies from widget to widget; for example, a push
+ * button's text is its descriptor, a caption shows its descriptor, and a text
+ * field's descriptor is the text being edited. In other words, the usage for
+ * the text varies from widget to widget, but this API provides a universal
+ * and convenient way to get at it. While not all UI widgets need their
+ * descriptor, many do.
+ *
+ */
+WIDGET_API void XPSetWidgetDescriptor(
+ XPWidgetID inWidget,
+ const char * inDescriptor);
+
+/*
+ * XPGetWidgetDescriptor
+ *
+ * This routine returns the widget's descriptor. Pass in the length of the
+ * buffer you are going to receive the descriptor in. The descriptor will be
+ * null terminated for you. This routine returns the length of the actual
+ * descriptor; if you pass NULL for outDescriptor, you can get the
+ * descriptor's length without getting its text. If the length of the
+ * descriptor exceeds your buffer length, the buffer will not be null
+ * terminated (this routine has 'strncpy' semantics).
+ *
+ */
+WIDGET_API int XPGetWidgetDescriptor(
+ XPWidgetID inWidget,
+ char * outDescriptor,
+ int inMaxDescLength);
+
+/*
+ * XPSetWidgetProperty
+ *
+ * This function sets a widget's property. Properties are arbitrary values
+ * associated by a widget by ID.
+ *
+ */
+WIDGET_API void XPSetWidgetProperty(
+ XPWidgetID inWidget,
+ XPWidgetPropertyID inProperty,
+ intptr_t inValue);
+
+/*
+ * XPGetWidgetProperty
+ *
+ * This routine returns the value of a widget's property, or 0 if the property
+ * is not defined. If you need to know whether the property is defined, pass
+ * a pointer to an int for inExists; the existence of that property will be
+ * returned in the int. Pass NULL for inExists if you do not need this
+ * information.
+ *
+ */
+WIDGET_API intptr_t XPGetWidgetProperty(
+ XPWidgetID inWidget,
+ XPWidgetPropertyID inProperty,
+ int * inExists); /* Can be NULL */
+
+/***************************************************************************
+ * KEYBOARD MANAGEMENT
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPSetKeyboardFocus
+ *
+ * XPSetKeyboardFocus controls which widget will receive keystrokes. Pass the
+ * Widget ID of the widget to get the keys. Note that if the widget does not
+ * care about keystrokes, they will go to the parent widget, and if no widget
+ * cares about them, they go to X-Plane.
+ *
+ * If you set the keyboard focus to Widget ID 0, X-Plane gets keyboard focus.
+ *
+ * This routine returns the widget ID that ended up with keyboard focus, or 0
+ * for x-plane.
+ *
+ * Keyboard focus is not changed if the new widget will not accept it. For
+ * setting to x-plane, keyboard focus is always accepted.
+ *
+ * *
+ */
+WIDGET_API XPWidgetID XPSetKeyboardFocus(
+ XPWidgetID inWidget);
+
+/*
+ * XPLoseKeyboardFocus
+ *
+ * This causes the specified widget to lose focus; focus is passed to its
+ * parent, or the next parent that will accept it. This routine does nothing
+ * if this widget does not have focus.
+ *
+ */
+WIDGET_API void XPLoseKeyboardFocus(
+ XPWidgetID inWidget);
+
+/*
+ * XPGetWidgetWithFocus
+ *
+ * This routine returns the widget that has keyboard focus, or 0 if X-Plane
+ * has keyboard focus or some other plugin window that does not have widgets
+ * has focus.
+ *
+ */
+WIDGET_API XPWidgetID XPGetWidgetWithFocus(void);
+
+/***************************************************************************
+ * CREATING CUSTOM WIDGETS
+ ***************************************************************************/
+/*
+ *
+ *
+ */
+
+
+/*
+ * XPAddWidgetCallback
+ *
+ * This function adds a new widget callback to a widget. This widget callback
+ * supercedes any existing ones and will receive messages first; if it does
+ * not handle messages they will go on to be handled by pre-existing widgets.
+ *
+ * The widget function will remain on the widget for the life of the widget.
+ * The creation message will be sent to the new callback immediately with the
+ * widget ID, and the destruction message will be sent before the other widget
+ * function receives a destruction message.
+ *
+ * This provides a way to 'subclass' an existing widget. By providing a
+ * second hook that only handles certain widget messages, you can customize or
+ * extend widget behavior.
+ *
+ */
+WIDGET_API void XPAddWidgetCallback(
+ XPWidgetID inWidget,
+ XPWidgetFunc_t inNewCallback);
+
+/*
+ * XPGetWidgetClassFunc
+ *
+ * Given a widget class, this function returns the callbacks that power that
+ * widget class.
+ *
+ */
+WIDGET_API XPWidgetFunc_t XPGetWidgetClassFunc(
+ XPWidgetClass inWidgetClass);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-28 11:28:17 +0000