GermanAirlines/GermanAirlinesVA-GAConnector
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Real Name

Browse Source
This commit is contained in:
Kilian Hofmann
2022-01-01 23:50:23 +01:00
parent 94a31b7608
commit 0adf122d1d
553 changed files with 155034 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
XPSDK/CHeaders/Widgets/XPStandardWidgets.h
+628
View File
@@ -0,0 +1,628 @@
#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
XPSDK/CHeaders/Widgets/XPUIGraphics.h
+395
View File
@@ -0,0 +1,395 @@
#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
XPSDK/CHeaders/Widgets/XPWidgetDefs.h
+525
View File
@@ -0,0 +1,525 @@
#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
XPSDK/CHeaders/Widgets/XPWidgetUtils.h
+224
View File
@@ -0,0 +1,224 @@
#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
XPSDK/CHeaders/Widgets/XPWidgets.h
+541
View File
@@ -0,0 +1,541 @@
#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