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

Update XPLM for ARM64

Browse Source
This commit is contained in:
Kilian Hofmann
2022-09-27 15:34:46 +02:00
parent 40067a606d
commit 174c20bd8f
59 changed files with 12475 additions and 9196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TODO.md
-2
View File
@@ -1,3 +1 @@
- Update OSXCross Docker image to SDK 11
- Implement ARM64 arch for Plugin
- Implement Logbook PHP
XPSDK/CHeaders/Widgets/XPStandardWidgets.h
+186 -258
View File
@@ -2,29 +2,29 @@
#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
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPStandardWidgets
***************************************************************************/
/*
* XPStandardWidgets - THEORY OF OPERATION
* ## THEORY OF OPERATION
*
* The standard widgets are widgets built into the widgets library. While you
* 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
* 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.
* 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.
*
*/
@@ -39,8 +39,8 @@ extern "C" {
***************************************************************************/
/*
* 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.
* These windows are dragable and can be selected. Use them to create floating
* windows and non-modal dialogs.
*
*/
@@ -54,12 +54,11 @@ extern "C" {
*
*/
enum {
/* The standard main window; pin stripes on XP7, metal frame on XP 6. */
xpMainWindowStyle_MainWindow = 0
/* 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
/* A translucent dark gray window, like the one ATC messages appear in. */
xpMainWindowStyle_Translucent = 1,
};
@@ -67,17 +66,15 @@ enum {
/*
* 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 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
/* This property specifies whether the main window has close boxes in its *
* corners. */
xpProperty_MainWindowHasCloseBoxes = 1200,
};
@@ -85,12 +82,10 @@ enum {
/*
* MainWindow Messages
*
*
*/
enum {
/* This message is sent when the close buttons are pressed for your window.
*/
xpMessage_CloseButtonPushed = 1200
/* This message is sent when the close buttons are pressed for your window. */
xpMessage_CloseButtonPushed = 1200,
};
@@ -99,9 +94,9 @@ enum {
* SUB WINDOW
***************************************************************************/
/*
* X-plane dialogs are divided into separate areas; the sub window widgets
* 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.
* subwindows inside it. Then place your controls inside the subwindows.
*
*/
@@ -115,16 +110,14 @@ enum {
*
*/
enum {
/* A panel that sits inside a main window. */
xpSubWindowStyle_SubWindow = 0
/* 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 screen that sits inside a panel for showing text information. */
xpSubWindowStyle_Screen = 2,
/* A list view for scrolling lists. */
,
xpSubWindowStyle_ListView = 3
/* A list view for scrolling lists. */
xpSubWindowStyle_ListView = 3,
};
@@ -132,12 +125,11 @@ enum {
/*
* SubWindow Properties
*
*
*/
enum {
/* This property specifies the type of window. Set to one of the subwindow
* * types above. */
xpProperty_SubWindowType = 1200
/* This property specifies the type of window. Set to one of the subwindow *
* types above. */
xpProperty_SubWindowType = 1200,
};
@@ -147,21 +139,21 @@ enum {
***************************************************************************/
/*
* The button class provides a number of different button styles and
* behaviors, including push buttons, radio buttons, check boxes, etc. The
* 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.
* 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.
* 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.
*
*/
@@ -176,26 +168,22 @@ enum {
*
*/
enum {
/* This is a standard push button, like an "OK" or "Cancel" button in a
* dialog * box. */
xpPushButton = 0
/* 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 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 window close box. */
xpWindowCloseBox = 3,
/* A small down arrow. */
,
xpLittleDownArrow = 5
/* A small down arrow. */
xpLittleDownArrow = 5,
/* A small up arrow. */
,
xpLittleUpArrow = 6
/* A small up arrow. */
xpLittleUpArrow = 6,
};
@@ -207,23 +195,20 @@ enum {
*
*/
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
/* 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
/* 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
/* 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,
};
@@ -231,22 +216,19 @@ enum {
/*
* 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 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 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
/* This property tells whether a check box or radio button is "checked" or *
* not. Not used for push buttons. */
xpProperty_ButtonState = 1302,
};
@@ -255,26 +237,24 @@ enum {
* 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
* 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 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
/* 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,
};
@@ -284,19 +264,19 @@ enum {
***************************************************************************/
/*
* 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.)
* 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
* 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
* 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).
*
*/
@@ -311,18 +291,16 @@ enum {
*
*/
enum {
/* A field for text entry. */
xpTextEntryField = 0
/* 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 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
/* A translucent edit field, dark gray. */
xpTextTranslucent = 4,
};
@@ -330,49 +308,40 @@ enum {
/*
* 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 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 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 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
/* 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
/* 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 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 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
/* 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
/* This is the active side of the insert selection. (Internal) */
xpProperty_ActiveEditSide = 1408,
};
@@ -380,15 +349,11 @@ enum {
/*
* 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
/* 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,
};
@@ -397,8 +362,8 @@ enum {
* 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
* 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.
*
*/
@@ -413,14 +378,11 @@ enum {
*
*/
enum {
/* Scroll bar types. *
* *
* A standard x-plane scroll bar (with arrows on the ends). */
xpScrollBarTypeScrollBar = 0
/* A standard X-Plane scroll bar (with arrows on the ends). */
xpScrollBarTypeScrollBar = 0,
/* A slider, no arrows. */
,
xpScrollBarTypeSlider = 1
/* A slider, no arrows. */
xpScrollBarTypeSlider = 1,
};
@@ -428,34 +390,26 @@ enum {
/*
* Scroll Bar Properties
*
*
*/
enum {
/* The current position of the thumb (in between the min and max, inclusive)
*/
xpProperty_ScrollBarSliderPosition = 1500
/* 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 lowest position. */
xpProperty_ScrollBarMin = 1501,
/* The value the scroll bar has when the thumb is in the highest position.
*/
,
xpProperty_ScrollBarMax = 1502
/* 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
/* How many units to move 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
/* The type of scrollbar from the enums above. */
xpProperty_ScrollBarType = 1504,
/* Used internally. */
,
xpProperty_ScrollBarSlop = 1505
/* Used internally. */
xpProperty_ScrollBarSlop = 1505,
};
@@ -463,13 +417,11 @@ enum {
/*
* 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
/* 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,
};
@@ -479,7 +431,7 @@ enum {
***************************************************************************/
/*
* 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
* for labeling parts of a window. It always shows its descriptor as its
* string and is otherwise transparent.
*
*/
@@ -490,12 +442,11 @@ enum {
/*
* Caption Properties
*
*
*/
enum {
/* This property specifies whether the caption is lit; use lit captions *
* against screens. */
xpProperty_CaptionLit = 1600
/* This property specifies whether the caption is lit; use lit captions *
* against screens. */
xpProperty_CaptionLit = 1600,
};
@@ -505,7 +456,7 @@ enum {
***************************************************************************/
/*
* The general graphics widget can show one of many icons available from
* x-plane.
* X-Plane.
*
*/
@@ -519,61 +470,43 @@ enum {
*
*/
enum {
xpShip = 4
xpShip = 4,
,
xpILSGlideScope = 5
xpILSGlideScope = 5,
,
xpMarkerLeft = 6
xpMarkerLeft = 6,
,
xp_Airport = 7
xp_Airport = 7,
,
xpNDB = 8
xpNDB = 8,
,
xpVOR = 9
xpVOR = 9,
,
xpRadioTower = 10
xpRadioTower = 10,
,
xpAircraftCarrier = 11
xpAircraftCarrier = 11,
,
xpFire = 12
xpFire = 12,
,
xpMarkerRight = 13
xpMarkerRight = 13,
,
xpCustomObject = 14
xpCustomObject = 14,
,
xpCoolingTower = 15
xpCoolingTower = 15,
,
xpSmokeStack = 16
xpSmokeStack = 16,
,
xpBuilding = 17
xpBuilding = 17,
,
xpPowerLine = 18
xpPowerLine = 18,
,
xpVORWithCompassRose = 19
xpVORWithCompassRose = 19,
,
xpOilPlatform = 21
xpOilPlatform = 21,
,
xpOilPlatformSmall = 22
xpOilPlatformSmall = 22,
,
xpWayPoint = 23
xpWayPoint = 23,
};
@@ -581,11 +514,10 @@ enum {
/*
* General Graphics Properties
*
*
*/
enum {
/* This property controls the type of icon that is drawn. */
xpProperty_GeneralGraphicsType = 1700
/* This property controls the type of icon that is drawn. */
xpProperty_GeneralGraphicsType = 1700,
};
@@ -594,29 +526,25 @@ enum {
* PROGRESS INDICATOR
***************************************************************************/
/*
* This widget implements a progress indicator as seen when x-plane starts up.
* 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 current value of the progress indicator. */
xpProperty_ProgressPosition = 1800,
/* This is the minimum value, equivalent to 0% filled. */
,
xpProperty_ProgressMin = 1801
/* This is the minimum value, equivalent to 0% filled. */
xpProperty_ProgressMin = 1801,
/* This is the maximum value, equivalent to 100% filled. */
,
xpProperty_ProgressMax = 1802
/* This is the maximum value, equivalent to 100% filled. */
xpProperty_ProgressMax = 1802,
};
XPSDK/CHeaders/Widgets/XPUIGraphics.h
+178 -219
View File
@@ -2,18 +2,14 @@
#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
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/*
*
*
*/
/***************************************************************************
* XPUIGraphics
***************************************************************************/
#include "XPWidgetDefs.h"
@@ -24,11 +20,6 @@ extern "C" {
/***************************************************************************
* UI GRAPHICS
***************************************************************************/
/*
*
*
*/
/*
* XPWindowStyle
@@ -37,40 +28,35 @@ extern "C" {
*
* 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
* 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.
*
* 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.
* 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
/* An LCD screen that shows help. */
xpWindow_Help = 0,
/* A dialog box window. */
,
xpWindow_MainWindow = 1
/* A dialog box window. */
xpWindow_MainWindow = 1,
/* A panel or frame within a dialog box window. */
,
xpWindow_SubWindow = 2
/* 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
/* 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
/* A list view within a panel for scrolling file names, etc. */
xpWindow_ListView = 5,
};
@@ -80,182 +66,152 @@ 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
* 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);
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
* 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 */
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 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.
* 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
* Scalable Axis Required Background
*
*/
enum {
/* x metal */
xpElement_TextField = 6
/* x metal */
xpElement_TextField = 6,
/* none metal */
,
xpElement_CheckBox = 9
/* none metal */
xpElement_CheckBox = 9,
/* none metal */
,
xpElement_CheckBoxLit = 10
/* none metal */
xpElement_CheckBoxLit = 10,
/* none window header */
,
xpElement_WindowCloseBox = 14
/* none window header */
xpElement_WindowCloseBox = 14,
/* none window header */
,
xpElement_WindowCloseBoxPressed = 15
/* none window header */
xpElement_WindowCloseBoxPressed = 15,
/* x metal */
,
xpElement_PushButton = 16
/* x metal */
xpElement_PushButton = 16,
/* x metal */
,
xpElement_PushButtonLit = 17
/* x metal */
xpElement_PushButtonLit = 17,
/* none any */
,
xpElement_OilPlatform = 24
/* none any */
xpElement_OilPlatform = 24,
/* none any */
,
xpElement_OilPlatformSmall = 25
/* none any */
xpElement_OilPlatformSmall = 25,
/* none any */
,
xpElement_Ship = 26
/* none any */
xpElement_Ship = 26,
/* none any */
,
xpElement_ILSGlideScope = 27
/* none any */
xpElement_ILSGlideScope = 27,
/* none any */
,
xpElement_MarkerLeft = 28
/* none any */
xpElement_MarkerLeft = 28,
/* none any */
,
xpElement_Airport = 29
/* none any */
xpElement_Airport = 29,
/* none any */
,
xpElement_Waypoint = 30
/* none any */
xpElement_Waypoint = 30,
/* none any */
,
xpElement_NDB = 31
/* none any */
xpElement_NDB = 31,
/* none any */
,
xpElement_VOR = 32
/* none any */
xpElement_VOR = 32,
/* none any */
,
xpElement_RadioTower = 33
/* none any */
xpElement_RadioTower = 33,
/* none any */
,
xpElement_AircraftCarrier = 34
/* none any */
xpElement_AircraftCarrier = 34,
/* none any */
,
xpElement_Fire = 35
/* none any */
xpElement_Fire = 35,
/* none any */
,
xpElement_MarkerRight = 36
/* none any */
xpElement_MarkerRight = 36,
/* none any */
,
xpElement_CustomObject = 37
/* none any */
xpElement_CustomObject = 37,
/* none any */
,
xpElement_CoolingTower = 38
/* none any */
xpElement_CoolingTower = 38,
/* none any */
,
xpElement_SmokeStack = 39
/* none any */
xpElement_SmokeStack = 39,
/* none any */
,
xpElement_Building = 40
/* none any */
xpElement_Building = 40,
/* none any */
,
xpElement_PowerLine = 41
/* none any */
xpElement_PowerLine = 41,
/* none metal */
,
xpElement_CopyButtons = 45
/* none metal */
xpElement_CopyButtons = 45,
/* none metal */
,
xpElement_CopyButtonsWithEditingGrid = 46
/* none metal */
xpElement_CopyButtonsWithEditingGrid = 46,
/* x, y metal */
,
xpElement_EditingGrid = 47
/* x, y metal */
xpElement_EditingGrid = 47,
/* THIS CAN PROBABLY BE REMOVED */
,
xpElement_ScrollBar = 48
/* THIS CAN PROBABLY BE REMOVED */
xpElement_ScrollBar = 48,
/* none any */
,
xpElement_VORWithCompassRose = 49
/* none any */
xpElement_VORWithCompassRose = 49,
/* none metal */
,
xpElement_Zoomer = 51
/* none metal */
xpElement_Zoomer = 51,
/* x, y metal */
,
xpElement_TextFieldMiddle = 52
/* x, y metal */
xpElement_TextFieldMiddle = 52,
/* none metal */
,
xpElement_LittleDownArrow = 53
/* none metal */
xpElement_LittleDownArrow = 53,
/* none metal */
,
xpElement_LittleUpArrow = 54
/* none metal */
xpElement_LittleUpArrow = 54,
/* none metal */
,
xpElement_WindowDragBar = 61
/* none metal */
xpElement_WindowDragBar = 61,
/* none metal */
,
xpElement_WindowDragBarSmooth = 62
/* none metal */
xpElement_WindowDragBarSmooth = 62,
};
@@ -265,32 +221,34 @@ 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.
* 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);
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.
* 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 */
WIDGET_API void XPGetElementDefaultDimensions(
XPElementStyle inStyle,
int * outWidth, /* Can be NULL */
int * outHeight, /* Can be NULL */
int * outCanBeLit); /* Can be NULL */
/*
* XPTrackStyle
@@ -299,26 +257,24 @@ WIDGET_API void
* 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
* (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.
* - 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
/* 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 can be lit can be rotated */
xpTrack_Slider = 1,
/* over metal cannot be lit cannot be rotated */
,
xpTrack_Progress = 2
/* over metal cannot be lit cannot be rotated */
xpTrack_Progress = 2,
};
@@ -327,66 +283,69 @@ 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
* 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
* 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);
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
* scalable in the larger dimension. It also returns whether a track can be
* lit.
*
*/
WIDGET_API void XPGetTrackDefaultDimensions(XPTrackStyle inStyle,
int *outWidth,
int *outCanBeLit);
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
* 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
* 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
* 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);
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
}
XPSDK/CHeaders/Widgets/XPWidgetDefs.h
+291 -344
View File
@@ -2,18 +2,14 @@
#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
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/*
*
*
*/
/***************************************************************************
* XPWidgetDefs
***************************************************************************/
#include "XPLMDefs.h"
@@ -23,44 +19,44 @@ extern "C" {
#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
#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
#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
#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
* Use the widget API to create widgets of various classes. You can nest them
* into trees of widgets to create complex user interfaces.
*
*/
@@ -70,20 +66,20 @@ extern "C" {
* 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.
* 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;
typedef void * XPWidgetID;
/*
* XPWidgetPropertyID
*
* Properties are values attached to instances of your widgets. A property is
* 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
* 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.
*
@@ -92,44 +88,38 @@ typedef void *XPWidgetID;
*
*/
enum {
/* A window's refcon is an opaque value used by client code to find other
* data * based on it. */
xpProperty_Refcon = 0
/* 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
/* These properties are used by the utlities to implement dragging. */
xpProperty_Dragging = 1,
,
xpProperty_DragXOff = 2
xpProperty_DragXOff = 2,
,
xpProperty_DragYOff = 3
xpProperty_DragYOff = 3,
/* Is the widget hilited? (For widgets that support this kind of thing.) */
,
xpProperty_Hilited = 4
/* 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
/* 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
/* 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
/* 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
/* NOTE: Property IDs 1 - 999 are reserved for the widgets 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,
};
@@ -143,14 +133,13 @@ typedef int XPWidgetPropertyID;
*
*/
typedef struct {
int x;
int y;
/* Mouse Button number, left = 0 (right button not yet supported. */
int button;
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;
/* Scroll wheel delta (button in this case would be the wheel axis number). */
int delta;
#endif /* XPLM200 */
} XPMouseState_t;
@@ -162,13 +151,13 @@ typedef struct {
*
*/
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;
/* 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;
/*
@@ -179,11 +168,11 @@ typedef struct {
*
*/
typedef struct {
int dx;
/* +Y = the widget moved up */
int dy;
int dwidth;
int dheight;
int dx;
/* +Y = the widget moved up */
int dy;
int dwidth;
int dheight;
} XPWidgetGeometryChange_t;
/*
@@ -194,29 +183,25 @@ typedef struct {
*
*/
enum {
/* The message will only be sent to the target widget. */
xpMode_Direct = 0
/* 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, 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 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 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
/* 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 library *
* functions.) */
xpMode_Once = 4,
};
@@ -225,269 +210,235 @@ typedef int XPDispatchMode;
/*
* XPWidgetClass
*
* Widget classes define predefined widget types. A widget class basically
* 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
/* 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.
* notifications of events. The list of messages may be expanded.
*
*/
enum {
/* No message, should not be sent. */
xpMsg_None = 0
/* 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 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 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 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 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
/* 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 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
/* 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 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
/* 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
/* 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 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
/* 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 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
/* 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 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 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
/* 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
/* 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
/* 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
/* 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
/* 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
/* 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,
};
@@ -496,27 +447,23 @@ 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.
* 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);
typedef int (* XPWidgetFunc_t)(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
#ifdef __cplusplus
}
XPSDK/CHeaders/Widgets/XPWidgetUtils.h
+96 -88
View File
@@ -2,35 +2,35 @@
#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
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPWidgetUtils
***************************************************************************/
/*
* XPWidgetUtils - USAGE NOTES
* ## USAGE NOTES
*
* The XPWidgetUtils library contains useful functions that make writing and
* using widgets less of a pain.
* 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
* 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.
*
* 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.
* 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.
*
*/
@@ -43,79 +43,80 @@ extern "C" {
/***************************************************************************
* 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.
* 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 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 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 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)))
#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
* 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
* 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;
int left;
int top;
int right;
int bottom;
int visible;
const char * descriptor;
/* Whether ethis widget is a root wiget */
int isRoot;
/* The index of the widget to contain within, or a constant */
int containerIndex;
XPWidgetClass widgetClass;
} XPWidgetCreate_t;
#define NO_PARENT -1
#define NO_PARENT -1
#define PARAM_PARENT -2
#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
* 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
* 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
@@ -123,10 +124,11 @@ typedef struct {
* XPUCreateWidgets in a widget created previously.
*
*/
WIDGET_API void XPUCreateWidgets(const XPWidgetCreate_t *inWidgetDefs,
int inCount,
XPWidgetID inParamParent,
XPWidgetID *ioWidgets);
WIDGET_API void XPUCreateWidgets(
const XPWidgetCreate_t * inWidgetDefs,
int inCount,
XPWidgetID inParamParent,
XPWidgetID * ioWidgets);
/*
* XPUMoveWidgetBy
@@ -135,8 +137,10 @@ WIDGET_API void XPUCreateWidgets(const XPWidgetCreate_t *inWidgetDefs,
* widget.
*
*/
WIDGET_API void
XPUMoveWidgetBy(XPWidgetID inWidget, int inDeltaX, int inDeltaY);
WIDGET_API void XPUMoveWidgetBy(
XPWidgetID inWidget,
int inDeltaX,
int inDeltaY);
/***************************************************************************
* LAYOUT MANAGERS
@@ -153,14 +157,15 @@ WIDGET_API void
* 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'
* 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_API int XPUFixedLayout(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
/***************************************************************************
* WIDGET PROC BEHAVIORS
@@ -177,15 +182,16 @@ WIDGET_API int XPUFixedLayout(XPWidgetMessage inMessage,
* 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
* 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);
WIDGET_API int XPUSelectIfNeeded(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2,
int inEatClick);
/*
* XPUDefocusKeyboard
@@ -194,28 +200,30 @@ WIDGET_API int XPUSelectIfNeeded(XPWidgetMessage inMessage,
* This stops editing of any text fields, etc.
*
*/
WIDGET_API int XPUDefocusKeyboard(XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2,
int inEatClick);
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
* 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);
WIDGET_API int XPUDragWidget(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2,
int inLeft,
int inTop,
int inRight,
int inBottom);
#ifdef __cplusplus
}
XPSDK/CHeaders/Widgets/XPWidgets.h
+232 -235
View File
@@ -2,45 +2,34 @@
#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
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPWidgets
***************************************************************************/
/*
* WIDGETS - THEORY OF OPERATION AND NOTES
* ## 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
* 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.
*
* 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.
*
*
* 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 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.
*
* 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
@@ -48,38 +37,36 @@
*
* 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
* 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.
* 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
* 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.
*
*
* - 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.
*
* 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.
* relationship between widget class and rootness. Root widgets are
* imlemented as XPLMDisply windows.
*
*/
#include "XPWidgetDefs.h"
#include "XPLMDisplay.h"
#ifdef __cplusplus
extern "C" {
@@ -88,98 +75,92 @@ extern "C" {
/***************************************************************************
* 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
* 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.
*
* widget's location on the screen.
* - inVisible is 1 if the widget should be drawn, 0 to start the widget as
* hidden.
*
* hidden.
* - inDescriptor is a null terminated string that will become the widget's
* descriptor.
*
* 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.
* - 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.
* 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);
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. 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);
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
* 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);
WIDGET_API void XPDestroyWidget(
XPWidgetID inWidget,
int inDestroyChildren);
/*
* XPSendMessageToWidget
*
* This sends any message to a widget. You should probably not go around
* 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
* 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
@@ -187,45 +168,42 @@ WIDGET_API void XPDestroyWidget(XPWidgetID inWidget, int inDestroyChildren);
* 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 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_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.
* 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
* 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);
WIDGET_API void XPPlaceWidgetWithin(
XPWidgetID inSubWidget,
XPWidgetID inContainer);
/*
* XPCountChildWidgets
@@ -233,77 +211,85 @@ WIDGET_API void XPPlaceWidgetWithin(XPWidgetID inSubWidget,
* This routine returns the number of widgets another widget contains.
*
*/
WIDGET_API int XPCountChildWidgets(XPWidgetID inWidget);
WIDGET_API int XPCountChildWidgets(
XPWidgetID inWidget);
/*
* XPGetNthChildWidget
*
* This routine returns the widget ID of a child widget by index. Indexes are
* 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.
* inclusive. If the index is invalid, 0 is returned.
*
*/
WIDGET_API XPWidgetID XPGetNthChildWidget(XPWidgetID inWidget, int inIndex);
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.
* 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);
WIDGET_API XPWidgetID XPGetParentWidget(
XPWidgetID inWidget);
/*
* XPShowWidget
*
* This routine makes a widget visible if it is not already. Note that if a
* 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.
* visible, it will still not be visible to the user.
*
*/
WIDGET_API void XPShowWidget(XPWidgetID inWidget);
WIDGET_API void XPShowWidget(
XPWidgetID inWidget);
/*
* XPHideWidget
*
* Makes a widget invisible. See XPShowWidget for considerations of when a
* 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);
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
* 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);
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.
* 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);
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
* 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);
WIDGET_API void XPBringRootWidgetToFront(
XPWidgetID inWidget);
/*
* XPIsWidgetInFront
@@ -313,7 +299,8 @@ WIDGET_API void XPBringRootWidgetToFront(XPWidgetID inWidget);
* if the widget is not in a rooted hierarchy.
*
*/
WIDGET_API int XPIsWidgetInFront(XPWidgetID inWidget);
WIDGET_API int XPIsWidgetInFront(
XPWidgetID inWidget);
/*
* XPGetWidgetGeometry
@@ -322,11 +309,12 @@ WIDGET_API int XPIsWidgetInFront(XPWidgetID inWidget);
* 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 */
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
@@ -334,157 +322,169 @@ WIDGET_API void XPGetWidgetGeometry(XPWidgetID inWidget,
* This function changes the bounding box of a widget.
*
*/
WIDGET_API void XPSetWidgetGeometry(XPWidgetID inWidget,
int inLeft,
int inTop,
int inRight,
int inBottom);
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
* 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
* 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.
* 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
* 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);
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.
* 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 */
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
* 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);
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
* 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);
WIDGET_API int XPGetWidgetDescriptor(
XPWidgetID inWidget,
char * outDescriptor,
int inMaxDescLength);
/*
* XPGetWidgetUnderlyingWindow
*
* Returns the window (from the XPLMDisplay API) that backs your widget
* window. If you have opted in to modern windows, via a call to
* XPLMEnableFeature("XPLM_USE_NATIVE_WIDGET_WINDOWS", 1), you can use the
* returned window ID for display APIs like XPLMSetWindowPositioningMode(),
* allowing you to pop the widget window out into a real OS window, or move it
* into VR.
*
*/
WIDGET_API XPLMWindowID XPGetWidgetUnderlyingWindow(
XPWidgetID inWidget);
/*
* XPSetWidgetProperty
*
* This function sets a widget's property. Properties are arbitrary values
* 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);
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
* 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 */
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.
* 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.
* 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.
* 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.
* 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);
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
* 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);
WIDGET_API void XPLoseKeyboardFocus(
XPWidgetID inWidget);
/*
* XPGetWidgetWithFocus
@@ -499,31 +499,27 @@ WIDGET_API XPWidgetID XPGetWidgetWithFocus(void);
/***************************************************************************
* CREATING CUSTOM WIDGETS
***************************************************************************/
/*
*
*
*/
/*
* XPAddWidgetCallback
*
* This function adds a new widget callback to a widget. This widget callback
* 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
* 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.
* 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);
WIDGET_API void XPAddWidgetCallback(
XPWidgetID inWidget,
XPWidgetFunc_t inNewCallback);
/*
* XPGetWidgetClassFunc
@@ -532,7 +528,8 @@ WIDGET_API void XPAddWidgetCallback(XPWidgetID inWidget,
* widget class.
*
*/
WIDGET_API XPWidgetFunc_t XPGetWidgetClassFunc(XPWidgetClass inWidgetClass);
WIDGET_API XPWidgetFunc_t XPGetWidgetClassFunc(
XPWidgetClass inWidgetClass);
#ifdef __cplusplus
}
XPSDK/CHeaders/Wrappers/XPCBroadcaster.cpp
+38 -27
View File
@@ -1,45 +1,56 @@
#include "XPCBroadcaster.h"
#include "XPCListener.h"
XPCBroadcaster::XPCBroadcaster() : mIterator(NULL) {}
XPCBroadcaster::XPCBroadcaster() :
mIterator(NULL)
{
}
XPCBroadcaster::~XPCBroadcaster()
{
ListenerVector::iterator iter;
mIterator = &iter;
for (iter = mListeners.begin(); iter != mListeners.end(); ++iter) {
(*iter)->BroadcasterRemoved(this);
}
ListenerVector::iterator iter;
mIterator = &iter;
for (iter = mListeners.begin(); iter != mListeners.end(); ++iter)
{
(*iter)->BroadcasterRemoved(this);
}
}
void XPCBroadcaster::AddListener(XPCListener *inListener)
void XPCBroadcaster::AddListener(
XPCListener * inListener)
{
mListeners.push_back(inListener);
inListener->BroadcasterAdded(this);
mListeners.push_back(inListener);
inListener->BroadcasterAdded(this);
}
void XPCBroadcaster::RemoveListener(XPCListener *inListener)
void XPCBroadcaster::RemoveListener(
XPCListener * inListener)
{
ListenerVector::iterator iter =
std::find(mListeners.begin(), mListeners.end(), inListener);
if (iter == mListeners.end())
return;
ListenerVector::iterator iter = std::find
(mListeners.begin(), mListeners.end(), inListener);
if (iter == mListeners.end())
return;
if (mIterator != NULL) {
if (*mIterator >= iter)
(*mIterator)--;
}
if (mIterator != NULL)
{
if (*mIterator >= iter)
(*mIterator)--;
}
mListeners.erase(iter);
inListener->BroadcasterRemoved(this);
mListeners.erase(iter);
inListener->BroadcasterRemoved(this);
}
void XPCBroadcaster::BroadcastMessage(int inMessage, void *inParam)
void XPCBroadcaster::BroadcastMessage(
int inMessage,
void * inParam)
{
ListenerVector::iterator iter;
mIterator = &iter;
for (iter = mListeners.begin(); iter != mListeners.end(); ++iter) {
(*iter)->ListenToMessage(inMessage, inParam);
}
mIterator = NULL;
ListenerVector::iterator iter;
mIterator = &iter;
for (iter = mListeners.begin(); iter != mListeners.end(); ++iter)
{
(*iter)->ListenToMessage(inMessage, inParam);
}
mIterator = NULL;
}
XPSDK/CHeaders/Wrappers/XPCBroadcaster.h
+20 -13
View File
@@ -1,31 +1,38 @@
#ifndef _XPCBroadcaster_h_
#define _XPCBroadcaster_h_
#include <algorithm>
#include <vector>
#include <algorithm>
class XPCListener;
class XPCListener;
class XPCBroadcaster
{
class XPCBroadcaster {
public:
XPCBroadcaster();
virtual ~XPCBroadcaster();
void AddListener(XPCListener *inListener);
void RemoveListener(XPCListener *inListener);
XPCBroadcaster();
virtual ~XPCBroadcaster();
void AddListener(
XPCListener * inListener);
void RemoveListener(
XPCListener * inListener);
protected:
void BroadcastMessage(int inMessage, void *inParam = 0);
void BroadcastMessage(
int inMessage,
void * inParam=0);
private:
typedef std::vector<XPCListener *> ListenerVector;
ListenerVector mListeners;
typedef std::vector<XPCListener *> ListenerVector;
// Reentrancy support
ListenerVector mListeners;
// Reentrancy support
ListenerVector::iterator * mIterator;
ListenerVector::iterator *mIterator;
};
#endif
XPSDK/CHeaders/Wrappers/XPCDisplay.cpp
+68 -71
View File
@@ -1,107 +1,104 @@
#include "XPCDisplay.h"
XPCKeySniffer::XPCKeySniffer(int inBeforeWindows)
: mBeforeWindows(inBeforeWindows)
XPCKeySniffer::XPCKeySniffer(int inBeforeWindows) : mBeforeWindows(inBeforeWindows)
{
XPLMRegisterKeySniffer(KeySnifferCB,
mBeforeWindows,
reinterpret_cast<void *>(this));
XPLMRegisterKeySniffer(KeySnifferCB, mBeforeWindows, reinterpret_cast<void *>(this));
}
XPCKeySniffer::~XPCKeySniffer()
{
XPLMUnregisterKeySniffer(KeySnifferCB,
mBeforeWindows,
reinterpret_cast<void *>(this));
XPLMUnregisterKeySniffer(KeySnifferCB, mBeforeWindows, reinterpret_cast<void *>(this));
}
int XPCKeySniffer::KeySnifferCB(char inCharKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void *inRefCon)
int XPCKeySniffer::KeySnifferCB(
char inCharKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void * inRefCon)
{
XPCKeySniffer *me = reinterpret_cast<XPCKeySniffer *>(inRefCon);
return me->HandleKeyStroke(inCharKey, inFlags, inVirtualKey);
XPCKeySniffer * me = reinterpret_cast<XPCKeySniffer *>(inRefCon);
return me->HandleKeyStroke(inCharKey, inFlags, inVirtualKey);
}
XPCWindow::XPCWindow(int inLeft,
int inTop,
int inRight,
int inBottom,
int inIsVisible)
XPCWindow::XPCWindow(
int inLeft,
int inTop,
int inRight,
int inBottom,
int inIsVisible)
{
mWindow = XPLMCreateWindow(inLeft,
inTop,
inRight,
inBottom,
inIsVisible,
DrawCB,
HandleKeyCB,
MouseClickCB,
reinterpret_cast<void *>(this));
mWindow = XPLMCreateWindow(inLeft, inTop, inRight, inBottom, inIsVisible,
DrawCB, HandleKeyCB, MouseClickCB,
reinterpret_cast<void *>(this));
}
XPCWindow::~XPCWindow() { XPLMDestroyWindow(mWindow); }
void XPCWindow::GetWindowGeometry(int *outLeft,
int *outTop,
int *outRight,
int *outBottom)
XPCWindow::~XPCWindow()
{
XPLMGetWindowGeometry(mWindow, outLeft, outTop, outRight, outBottom);
XPLMDestroyWindow(mWindow);
}
void XPCWindow::SetWindowGeometry(int inLeft,
int inTop,
int inRight,
int inBottom)
void XPCWindow::GetWindowGeometry(
int * outLeft,
int * outTop,
int * outRight,
int * outBottom)
{
XPLMSetWindowGeometry(mWindow, inLeft, inTop, inRight, inBottom);
XPLMGetWindowGeometry(mWindow, outLeft, outTop, outRight, outBottom);
}
int XPCWindow::GetWindowIsVisible(void)
void XPCWindow::SetWindowGeometry(
int inLeft,
int inTop,
int inRight,
int inBottom)
{
return XPLMGetWindowIsVisible(mWindow);
XPLMSetWindowGeometry(mWindow, inLeft, inTop, inRight, inBottom);
}
void XPCWindow::SetWindowIsVisible(int inIsVisible)
int XPCWindow::GetWindowIsVisible(void)
{
XPLMSetWindowIsVisible(mWindow, inIsVisible);
return XPLMGetWindowIsVisible(mWindow);
}
void XPCWindow::TakeKeyboardFocus(void) { XPLMTakeKeyboardFocus(mWindow); }
void XPCWindow::BringWindowToFront(void) { XPLMBringWindowToFront(mWindow); }
int XPCWindow::IsWindowInFront(void) { return XPLMIsWindowInFront(mWindow); }
void XPCWindow::DrawCB(XPLMWindowID inWindowID, void *inRefcon)
void XPCWindow::SetWindowIsVisible(
int inIsVisible)
{
XPCWindow *me = reinterpret_cast<XPCWindow *>(inRefcon);
me->DoDraw();
XPLMSetWindowIsVisible(mWindow, inIsVisible);
}
void XPCWindow::HandleKeyCB(XPLMWindowID inWindowID,
char inKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void *inRefcon,
int losingFocus)
void XPCWindow::TakeKeyboardFocus(void)
{
XPCWindow *me = reinterpret_cast<XPCWindow *>(inRefcon);
if (losingFocus)
me->LoseFocus();
else
me->HandleKey(inKey, inFlags, inVirtualKey);
XPLMTakeKeyboardFocus(mWindow);
}
int XPCWindow::MouseClickCB(XPLMWindowID inWindowID,
int x,
int y,
XPLMMouseStatus inMouse,
void *inRefcon)
void XPCWindow::BringWindowToFront(void)
{
XPCWindow *me = reinterpret_cast<XPCWindow *>(inRefcon);
return me->HandleClick(x, y, inMouse);
XPLMBringWindowToFront(mWindow);
}
int XPCWindow::IsWindowInFront(void)
{
return XPLMIsWindowInFront(mWindow);
}
void XPCWindow::DrawCB(XPLMWindowID inWindowID, void * inRefcon)
{
XPCWindow * me = reinterpret_cast<XPCWindow *>(inRefcon);
me->DoDraw();
}
void XPCWindow::HandleKeyCB(XPLMWindowID inWindowID, char inKey, XPLMKeyFlags inFlags, char inVirtualKey, void * inRefcon, int losingFocus)
{
XPCWindow * me = reinterpret_cast<XPCWindow *>(inRefcon);
if (losingFocus)
me->LoseFocus();
else
me->HandleKey(inKey, inFlags, inVirtualKey);
}
int XPCWindow::MouseClickCB(XPLMWindowID inWindowID, int x, int y, XPLMMouseStatus inMouse, void * inRefcon)
{
XPCWindow * me = reinterpret_cast<XPCWindow *>(inRefcon);
return me->HandleClick(x, y, inMouse);
}
XPSDK/CHeaders/Wrappers/XPCDisplay.h
+51 -48
View File
@@ -3,68 +3,71 @@
#include "XPLMDisplay.h"
class XPCKeySniffer
{
class XPCKeySniffer {
public:
XPCKeySniffer(int inBeforeWindows);
virtual ~XPCKeySniffer();
virtual int HandleKeyStroke(char inCharKey,
XPLMKeyFlags inFlags,
char inVirtualKey) = 0;
XPCKeySniffer(int inBeforeWindows);
virtual ~XPCKeySniffer();
virtual int HandleKeyStroke(
char inCharKey,
XPLMKeyFlags inFlags,
char inVirtualKey)=0;
private:
int mBeforeWindows;
static int KeySnifferCB(char inCharKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void *inRefCon);
int mBeforeWindows;
static int KeySnifferCB(
char inCharKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void * inRefCon);
};
class XPCWindow
{
class XPCWindow {
public:
XPCWindow(int inLeft,
int inTop,
int inRight,
int inBottom,
int inIsVisible);
virtual ~XPCWindow();
virtual void DoDraw(void) = 0;
virtual void
HandleKey(char inKey, XPLMKeyFlags inFlags, char inVirtualKey) = 0;
virtual void LoseFocus(void) = 0;
virtual int HandleClick(int x, int y, XPLMMouseStatus inMouse) = 0;
XPCWindow(
int inLeft,
int inTop,
int inRight,
int inBottom,
int inIsVisible);
virtual ~XPCWindow();
void GetWindowGeometry(int *outLeft,
int *outTop,
int *outRight,
int *outBottom);
void SetWindowGeometry(int inLeft, int inTop, int inRight, int inBottom);
int GetWindowIsVisible(void);
void SetWindowIsVisible(int inIsVisible);
void TakeKeyboardFocus(void);
void BringWindowToFront(void);
int IsWindowInFront(void);
virtual void DoDraw(void)=0;
virtual void HandleKey(char inKey, XPLMKeyFlags inFlags, char inVirtualKey)=0;
virtual void LoseFocus(void)=0;
virtual int HandleClick(int x, int y, XPLMMouseStatus inMouse)=0;
void GetWindowGeometry(
int * outLeft,
int * outTop,
int * outRight,
int * outBottom);
void SetWindowGeometry(
int inLeft,
int inTop,
int inRight,
int inBottom);
int GetWindowIsVisible(void);
void SetWindowIsVisible(
int inIsVisible);
void TakeKeyboardFocus(void);
void BringWindowToFront(void);
int IsWindowInFront(void);
private:
XPLMWindowID mWindow;
static void DrawCB(XPLMWindowID inWindowID, void *inRefcon);
static void HandleKeyCB(XPLMWindowID inWindowID,
char inKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void *inRefcon,
int losingFocus);
static int MouseClickCB(XPLMWindowID inWindowID,
int x,
int y,
XPLMMouseStatus inMouse,
void *inRefcon);
XPLMWindowID mWindow;
static void DrawCB(XPLMWindowID inWindowID, void * inRefcon);
static void HandleKeyCB(XPLMWindowID inWindowID, char inKey, XPLMKeyFlags inFlags, char inVirtualKey, void * inRefcon, int losingFocus);
static int MouseClickCB(XPLMWindowID inWindowID, int x, int y, XPLMMouseStatus inMouse, void * inRefcon);
};
#endif
XPSDK/CHeaders/Wrappers/XPCListener.cpp
+14 -10
View File
@@ -1,23 +1,27 @@
#include "XPCListener.h"
#include "XPCBroadcaster.h"
XPCListener::XPCListener() {}
XPCListener::XPCListener()
{
}
XPCListener::~XPCListener()
{
while (!mBroadcasters.empty())
mBroadcasters.front()->RemoveListener(this);
while (!mBroadcasters.empty())
mBroadcasters.front()->RemoveListener(this);
}
void XPCListener::BroadcasterAdded(XPCBroadcaster *inBroadcaster)
void XPCListener::BroadcasterAdded(
XPCBroadcaster * inBroadcaster)
{
mBroadcasters.push_back(inBroadcaster);
mBroadcasters.push_back(inBroadcaster);
}
void XPCListener::BroadcasterRemoved(XPCBroadcaster *inBroadcaster)
void XPCListener::BroadcasterRemoved(
XPCBroadcaster * inBroadcaster)
{
BroadcastVector::iterator iter =
std::find(mBroadcasters.begin(), mBroadcasters.end(), inBroadcaster);
if (iter != mBroadcasters.end())
mBroadcasters.erase(iter);
BroadcastVector::iterator iter = std::find(mBroadcasters.begin(),
mBroadcasters.end(), inBroadcaster);
if (iter != mBroadcasters.end())
mBroadcasters.erase(iter);
}
XPSDK/CHeaders/Wrappers/XPCListener.h
+18 -12
View File
@@ -1,30 +1,36 @@
#ifndef _XPCListener_h_
#define _XPCListener_h_
#include <algorithm>
#include <vector>
#include <algorithm>
class XPCBroadcaster;
class XPCBroadcaster;
class XPCListener
{
class XPCListener {
public:
XPCListener();
virtual ~XPCListener();
virtual void ListenToMessage(int inMessage, void *inParam) = 0;
XPCListener();
virtual ~XPCListener();
virtual void ListenToMessage(
int inMessage,
void * inParam)=0;
private:
typedef std::vector<XPCBroadcaster *> BroadcastVector;
BroadcastVector mBroadcasters;
typedef std::vector<XPCBroadcaster *> BroadcastVector;
friend class XPCBroadcaster;
BroadcastVector mBroadcasters;
void BroadcasterAdded(XPCBroadcaster *inBroadcaster);
friend class XPCBroadcaster;
void BroadcasterAdded(
XPCBroadcaster * inBroadcaster);
void BroadcasterRemoved(
XPCBroadcaster * inBroadcaster);
void BroadcasterRemoved(XPCBroadcaster *inBroadcaster);
};
#endif
XPSDK/CHeaders/Wrappers/XPCProcessing.cpp
+30 -38
View File
@@ -1,60 +1,52 @@
#include "XPCProcessing.h"
#include "XPLMUtilities.h"
XPCProcess::XPCProcess() : mInCallback(false), mCallbackTime(0)
XPCProcess::XPCProcess() :
mInCallback(false),
mCallbackTime(0)
{
XPLMRegisterFlightLoopCallback(FlightLoopCB,
0,
reinterpret_cast<void *>(this));
XPLMRegisterFlightLoopCallback(FlightLoopCB, 0, reinterpret_cast<void *>(this));
}
XPCProcess::~XPCProcess()
{
XPLMUnregisterFlightLoopCallback(FlightLoopCB,
reinterpret_cast<void *>(this));
XPLMUnregisterFlightLoopCallback(FlightLoopCB, reinterpret_cast<void *>(this));
}
void XPCProcess::StartProcessTime(float inSeconds)
void XPCProcess::StartProcessTime(float inSeconds)
{
mCallbackTime = inSeconds;
if (!mInCallback)
XPLMSetFlightLoopCallbackInterval(FlightLoopCB,
mCallbackTime,
1 /*relative to now*/,
reinterpret_cast<void *>(this));
mCallbackTime = inSeconds;
if (!mInCallback)
XPLMSetFlightLoopCallbackInterval(
FlightLoopCB, mCallbackTime, 1/*relative to now*/, reinterpret_cast<void *>(this));
}
void XPCProcess::StartProcessCycles(int inCycles)
void XPCProcess::StartProcessCycles(int inCycles)
{
mCallbackTime = -inCycles;
if (!mInCallback)
XPLMSetFlightLoopCallbackInterval(FlightLoopCB,
mCallbackTime,
1 /*relative to now*/,
reinterpret_cast<void *>(this));
mCallbackTime = -inCycles;
if (!mInCallback)
XPLMSetFlightLoopCallbackInterval(
FlightLoopCB, mCallbackTime, 1/*relative to now*/, reinterpret_cast<void *>(this));
}
void XPCProcess::StopProcess(void)
void XPCProcess::StopProcess(void)
{
mCallbackTime = 0;
if (!mInCallback)
XPLMSetFlightLoopCallbackInterval(FlightLoopCB,
mCallbackTime,
1 /*relative to now*/,
reinterpret_cast<void *>(this));
mCallbackTime = 0;
if (!mInCallback)
XPLMSetFlightLoopCallbackInterval(
FlightLoopCB, mCallbackTime, 1/*relative to now*/, reinterpret_cast<void *>(this));
}
float XPCProcess::FlightLoopCB(float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter,
void *inRefcon)
float XPCProcess::FlightLoopCB(
float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter,
void * inRefcon)
{
XPCProcess *me = reinterpret_cast<XPCProcess *>(inRefcon);
me->mInCallback = true;
me->DoProcessing(inElapsedSinceLastCall,
inElapsedTimeSinceLastFlightLoop,
inCounter);
me->mInCallback = false;
return me->mCallbackTime;
XPCProcess * me = reinterpret_cast<XPCProcess *>(inRefcon);
me->mInCallback = true;
me->DoProcessing(inElapsedSinceLastCall, inElapsedTimeSinceLastFlightLoop, inCounter);
me->mInCallback = false;
return me->mCallbackTime;
}
XPSDK/CHeaders/Wrappers/XPCProcessing.h
+22 -18
View File
@@ -3,31 +3,35 @@
#include "XPLMProcessing.h"
class XPCProcess
{
class XPCProcess {
public:
XPCProcess();
virtual ~XPCProcess();
void StartProcessTime(float inSeconds);
void StartProcessCycles(int inCycles);
void StopProcess(void);
XPCProcess();
virtual ~XPCProcess();
virtual void DoProcessing(float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter) = 0;
void StartProcessTime(float inSeconds);
void StartProcessCycles(int inCycles);
void StopProcess(void);
virtual void DoProcessing(
float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter)=0;
private:
static float FlightLoopCB(float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter,
void *inRefcon);
bool mInCallback;
float mCallbackTime;
static float FlightLoopCB(
float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter,
void * inRefcon);
bool mInCallback;
float mCallbackTime;
XPCProcess(const XPCProcess&);
XPCProcess& operator=(const XPCProcess&);
XPCProcess(const XPCProcess &);
XPCProcess &operator=(const XPCProcess &);
};
#endif
XPSDK/CHeaders/Wrappers/XPCWidget.cpp
+96 -84
View File
@@ -1,111 +1,123 @@
#include "XPCWidget.h"
XPCWidget::XPCWidget(int inLeft,
int inTop,
int inRight,
int inBottom,
bool inVisible,
const char *inDescriptor,
bool inIsRoot,
XPWidgetID inParent,
XPWidgetClass inClass)
: mWidget(NULL), mOwnsChildren(false), mOwnsWidget(true)
XPCWidget::XPCWidget(
int inLeft,
int inTop,
int inRight,
int inBottom,
bool inVisible,
const char * inDescriptor,
bool inIsRoot,
XPWidgetID inParent,
XPWidgetClass inClass) :
mWidget(NULL),
mOwnsChildren(false),
mOwnsWidget(true)
{
mWidget = XPCreateWidget(inLeft,
inTop,
inRight,
inBottom,
inVisible ? 1 : 0,
inDescriptor,
inIsRoot ? 1 : 0,
inIsRoot ? NULL : inParent,
inClass);
mWidget = XPCreateWidget(
inLeft, inTop, inRight, inBottom,
inVisible ? 1 : 0,
inDescriptor,
inIsRoot ? 1 : 0,
inIsRoot ? NULL : inParent,
inClass);
XPSetWidgetProperty(mWidget,
xpProperty_Object,
reinterpret_cast<intptr_t>(this));
XPAddWidgetCallback(mWidget, WidgetCallback);
XPSetWidgetProperty(mWidget, xpProperty_Object, reinterpret_cast<intptr_t>(this));
XPAddWidgetCallback(mWidget, WidgetCallback);
}
XPCWidget::XPCWidget(XPWidgetID inWidget, bool inOwnsWidget)
: mWidget(inWidget), mOwnsChildren(false), mOwnsWidget(inOwnsWidget)
XPCWidget::XPCWidget(
XPWidgetID inWidget,
bool inOwnsWidget) :
mWidget(inWidget),
mOwnsChildren(false),
mOwnsWidget(inOwnsWidget)
{
XPSetWidgetProperty(mWidget,
xpProperty_Object,
reinterpret_cast<intptr_t>(this));
XPAddWidgetCallback(mWidget, WidgetCallback);
XPSetWidgetProperty(mWidget, xpProperty_Object, reinterpret_cast<intptr_t>(this));
XPAddWidgetCallback(mWidget, WidgetCallback);
}
XPCWidget::~XPCWidget()
{
if (mOwnsWidget)
XPDestroyWidget(mWidget, mOwnsChildren ? 1 : 0);
if (mOwnsWidget)
XPDestroyWidget(mWidget, mOwnsChildren ? 1 : 0);
}
void XPCWidget::SetOwnsWidget(bool inOwnsWidget) { mOwnsWidget = inOwnsWidget; }
void XPCWidget::SetOwnsChildren(bool inOwnsChildren)
void XPCWidget::SetOwnsWidget(
bool inOwnsWidget)
{
mOwnsChildren = inOwnsChildren;
mOwnsWidget = inOwnsWidget;
}
XPCWidget::operator XPWidgetID() const { return mWidget; }
XPWidgetID XPCWidget::Get(void) const { return mWidget; }
void XPCWidget::AddAttachment(XPCWidgetAttachment *inAttachment,
bool inOwnsAttachment,
bool inPrefilter)
void XPCWidget::SetOwnsChildren(
bool inOwnsChildren)
{
if (inPrefilter) {
mAttachments.insert(mAttachments.begin(),
AttachmentInfo(inAttachment, inOwnsAttachment));
} else {
mAttachments.push_back(AttachmentInfo(inAttachment, inOwnsAttachment));
}
mOwnsChildren = inOwnsChildren;
}
void XPCWidget::RemoveAttachment(XPCWidgetAttachment *inAttachment)
XPCWidget::operator XPWidgetID () const
{
for (AttachmentVector::iterator iter = mAttachments.begin();
iter != mAttachments.end();
++iter) {
if (iter->first == inAttachment) {
mAttachments.erase(iter);
return;
}
}
return mWidget;
}
int XPCWidget::HandleWidgetMessage(XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
XPWidgetID XPCWidget::Get(void) const
{
return 0;
return mWidget;
}
int XPCWidget::WidgetCallback(XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
void XPCWidget::AddAttachment(
XPCWidgetAttachment * inAttachment,
bool inOwnsAttachment,
bool inPrefilter)
{
XPCWidget *me = reinterpret_cast<XPCWidget *>(
XPGetWidgetProperty(inWidget, xpProperty_Object, NULL));
if (me == NULL)
return 0;
for (AttachmentVector::iterator iter = me->mAttachments.begin();
iter != me->mAttachments.end();
++iter) {
int result = iter->first->HandleWidgetMessage(me,
inMessage,
inWidget,
inParam1,
inParam2);
if (result != 0)
return result;
}
return me->HandleWidgetMessage(inMessage, inWidget, inParam1, inParam2);
if (inPrefilter)
{
mAttachments.insert(mAttachments.begin(), AttachmentInfo(inAttachment, inOwnsAttachment));
} else {
mAttachments.push_back(AttachmentInfo(inAttachment, inOwnsAttachment));
}
}
void XPCWidget::RemoveAttachment(
XPCWidgetAttachment * inAttachment)
{
for (AttachmentVector::iterator iter = mAttachments.begin();
iter != mAttachments.end(); ++iter)
{
if (iter->first == inAttachment)
{
mAttachments.erase(iter);
return;
}
}
}
int XPCWidget::HandleWidgetMessage(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
return 0;
}
int XPCWidget::WidgetCallback(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
XPCWidget * me = reinterpret_cast<XPCWidget *>(XPGetWidgetProperty(inWidget, xpProperty_Object, NULL));
if (me == NULL)
return 0;
for (AttachmentVector::iterator iter = me->mAttachments.begin(); iter !=
me->mAttachments.end(); ++iter)
{
int result = iter->first->HandleWidgetMessage(me, inMessage, inWidget, inParam1, inParam2);
if (result != 0)
return result;
}
return me->HandleWidgetMessage(inMessage, inWidget, inParam1, inParam2);
}
XPSDK/CHeaders/Wrappers/XPCWidget.h
+61 -48
View File
@@ -1,71 +1,84 @@
#ifndef _XPCWidget_h_
#define _XPCWidget_h_
#include "XPWidgets.h"
#include <algorithm>
#include <vector>
#include <algorithm>
#include "XPWidgets.h"
class XPCWidget;
class XPCWidget;
class XPCWidgetAttachment
{
class XPCWidgetAttachment {
public:
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2) = 0;
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)=0;
};
class XPCWidget
{
class XPCWidget {
public:
XPCWidget(int inLeft,
int inTop,
int inRight,
int inBottom,
bool inVisible,
const char *inDescriptor,
bool inIsRoot,
XPWidgetID inParent,
XPWidgetClass inClass);
XPCWidget(XPWidgetID inWidget, bool inOwnsWidget);
virtual ~XPCWidget();
void SetOwnsWidget(bool inOwnsWidget);
void SetOwnsChildren(bool inOwnsChildren);
XPCWidget(
int inLeft,
int inTop,
int inRight,
int inBottom,
bool inVisible,
const char * inDescriptor,
bool inIsRoot,
XPWidgetID inParent,
XPWidgetClass inClass);
XPCWidget(
XPWidgetID inWidget,
bool inOwnsWidget);
virtual ~XPCWidget();
operator XPWidgetID() const;
void SetOwnsWidget(
bool inOwnsWidget);
void SetOwnsChildren(
bool inOwnsChildren);
XPWidgetID Get(void) const;
operator XPWidgetID () const;
void AddAttachment(XPCWidgetAttachment *inAttachment,
bool inOwnsAttachment,
bool inPrefilter);
void RemoveAttachment(XPCWidgetAttachment *inAttachment);
XPWidgetID Get(void) const;
virtual int HandleWidgetMessage(XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
void AddAttachment(
XPCWidgetAttachment * inAttachment,
bool inOwnsAttachment,
bool inPrefilter);
void RemoveAttachment(
XPCWidgetAttachment * inAttachment);
virtual int HandleWidgetMessage(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
private:
static int WidgetCallback(XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
typedef std::pair<XPCWidgetAttachment *, bool> AttachmentInfo;
typedef std::vector<AttachmentInfo> AttachmentVector;
static int WidgetCallback(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
AttachmentVector mAttachments;
XPWidgetID mWidget;
bool mOwnsChildren;
bool mOwnsWidget;
typedef std::pair<XPCWidgetAttachment *, bool> AttachmentInfo;
typedef std::vector<AttachmentInfo> AttachmentVector;
AttachmentVector mAttachments;
XPWidgetID mWidget;
bool mOwnsChildren;
bool mOwnsWidget;
XPCWidget();
XPCWidget(const XPCWidget&);
XPCWidget& operator=(const XPCWidget&);
XPCWidget();
XPCWidget(const XPCWidget &);
XPCWidget &operator=(const XPCWidget &);
};
#endif
XPSDK/CHeaders/Wrappers/XPCWidgetAttachments.cpp
+219 -187
View File
@@ -2,234 +2,266 @@
#include "XPStandardWidgets.h"
#include "XPWidgetUtils.h"
static void XPCGetOrderedSubWidgets(XPWidgetID inWidget,
std::vector<XPWidgetID> &outChildren);
static void XPCGetOrderedSubWidgets(
XPWidgetID inWidget,
std::vector<XPWidgetID>& outChildren);
XPCKeyFilterAttachment::XPCKeyFilterAttachment(const char *inValidKeys,
const char *outValidKeys)
: mInput(inValidKeys), mOutput(outValidKeys)
XPCKeyFilterAttachment::XPCKeyFilterAttachment(
const char * inValidKeys,
const char * outValidKeys) :
mInput(inValidKeys),
mOutput(outValidKeys)
{
}
XPCKeyFilterAttachment::~XPCKeyFilterAttachment() {}
int XPCKeyFilterAttachment::HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
XPCKeyFilterAttachment::~XPCKeyFilterAttachment()
{
if (inMessage == xpMsg_KeyPress) {
char &theKey = KEY_CHAR(inParam1);
std::string::size_type pos = mInput.find(theKey);
if (pos == std::string::npos)
return 1; // Not found; eat the key!
else {
theKey = mOutput[pos];
return 0;
} // Let it live.
}
return 0;
}
int XPCKeyFilterAttachment::HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
if (inMessage == xpMsg_KeyPress)
{
char& theKey = KEY_CHAR(inParam1);
std::string::size_type pos = mInput.find(theKey);
if (pos == std::string::npos)
return 1; // Not found; eat the key!
else {
theKey = mOutput[pos];
return 0;
} // Let it live.
}
return 0;
}
XPCKeyMessageAttachment::XPCKeyMessageAttachment(char inKey,
int inMessage,
void *inParam,
bool inConsume,
bool inVkey,
XPCListener *inListener)
: mKey(inKey), mMsg(inMessage), mParam(inParam), mConsume(inConsume),
mVkey(inVkey)
XPCKeyMessageAttachment::XPCKeyMessageAttachment(
char inKey,
int inMessage,
void * inParam,
bool inConsume,
bool inVkey,
XPCListener * inListener) :
mKey(inKey), mMsg(inMessage), mParam(inParam), mConsume(inConsume),
mVkey(inVkey)
{
if (inListener != NULL)
this->AddListener(inListener);
if (inListener != NULL)
this->AddListener(inListener);
}
XPCKeyMessageAttachment::~XPCKeyMessageAttachment() {}
int XPCKeyMessageAttachment::HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
XPCKeyMessageAttachment::~XPCKeyMessageAttachment()
{
if (inMessage == xpMsg_KeyPress) {
char theKey = mVkey ? KEY_VKEY(inParam1) : KEY_CHAR(inParam1);
if (theKey != mKey)
return 0;
if (!(KEY_FLAGS(inParam1) & xplm_DownFlag))
return 0;
}
BroadcastMessage(mMsg, mParam);
return mConsume ? 1 : 0;
}
return 0;
int XPCKeyMessageAttachment::HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
if (inMessage == xpMsg_KeyPress)
{
char theKey = mVkey ? KEY_VKEY(inParam1) : KEY_CHAR(inParam1);
if (theKey != mKey)
return 0;
if (!(KEY_FLAGS(inParam1) & xplm_DownFlag))
return 0;
BroadcastMessage(mMsg, mParam);
return mConsume ? 1 : 0;
}
return 0;
}
XPCPushButtonMessageAttachment::XPCPushButtonMessageAttachment(
XPWidgetID inWidget,
int inMessage,
void *inParam,
XPCListener *inListener)
: mMsg(inMessage), mParam(inParam), mWidget(inWidget)
XPWidgetID inWidget,
int inMessage,
void * inParam,
XPCListener * inListener) :
mMsg(inMessage), mParam(inParam), mWidget(inWidget)
{
if (inListener != NULL)
this->AddListener(inListener);
if (inListener != NULL)
this->AddListener(inListener);
}
XPCPushButtonMessageAttachment::~XPCPushButtonMessageAttachment() {}
int XPCPushButtonMessageAttachment::HandleWidgetMessage(
XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
XPCPushButtonMessageAttachment::~XPCPushButtonMessageAttachment()
{
if ((inMessage == xpMsg_PushButtonPressed) &&
((XPWidgetID)inParam1 == mWidget)) {
BroadcastMessage(mMsg, mParam);
return 1;
}
if ((inMessage == xpMsg_ButtonStateChanged) &&
((XPWidgetID)inParam1 == mWidget)) {
BroadcastMessage(mMsg, mParam);
return 1;
}
return 0;
}
XPCSliderMessageAttachment::XPCSliderMessageAttachment(XPWidgetID inWidget,
int inMessage,
void *inParam,
XPCListener *inListener)
: mMsg(inMessage), mParam(inParam), mWidget(inWidget)
int XPCPushButtonMessageAttachment::HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
if (inListener != NULL)
this->AddListener(inListener);
if ((inMessage == xpMsg_PushButtonPressed) && ((XPWidgetID) inParam1 == mWidget))
{
BroadcastMessage(mMsg, mParam);
return 1;
}
if ((inMessage == xpMsg_ButtonStateChanged) && ((XPWidgetID) inParam1 == mWidget))
{
BroadcastMessage(mMsg, mParam);
return 1;
}
return 0;
}
XPCSliderMessageAttachment::~XPCSliderMessageAttachment() {}
int XPCSliderMessageAttachment::HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
XPCSliderMessageAttachment::XPCSliderMessageAttachment(
XPWidgetID inWidget,
int inMessage,
void * inParam,
XPCListener * inListener) :
mMsg(inMessage), mParam(inParam), mWidget(inWidget)
{
if ((inMessage == xpMsg_ScrollBarSliderPositionChanged) &&
((XPWidgetID)inParam1 == mWidget)) {
BroadcastMessage(mMsg, mParam);
return 1;
}
if (inListener != NULL)
this->AddListener(inListener);
}
return 0;
XPCSliderMessageAttachment::~XPCSliderMessageAttachment()
{
}
int XPCSliderMessageAttachment::HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
if ((inMessage == xpMsg_ScrollBarSliderPositionChanged) && ((XPWidgetID) inParam1 == mWidget))
{
BroadcastMessage(mMsg, mParam);
return 1;
}
return 0;
}
XPCCloseButtonMessageAttachment::XPCCloseButtonMessageAttachment(
XPWidgetID inWidget,
int inMessage,
void *inParam,
XPCListener *inListener)
: mMsg(inMessage), mParam(inParam), mWidget(inWidget)
XPWidgetID inWidget,
int inMessage,
void * inParam,
XPCListener * inListener) :
mMsg(inMessage), mParam(inParam), mWidget(inWidget)
{
if (inListener != NULL)
this->AddListener(inListener);
if (inListener != NULL)
this->AddListener(inListener);
}
XPCCloseButtonMessageAttachment::~XPCCloseButtonMessageAttachment() {}
int XPCCloseButtonMessageAttachment::HandleWidgetMessage(
XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
XPCCloseButtonMessageAttachment::~XPCCloseButtonMessageAttachment()
{
if ((inMessage == xpMessage_CloseButtonPushed) &&
((XPWidgetID)inParam1 == mWidget)) {
BroadcastMessage(mMsg, mParam);
return 1;
}
return 0;
}
XPCTabGroupAttachment::XPCTabGroupAttachment() {}
XPCTabGroupAttachment::~XPCTabGroupAttachment() {}
int XPCTabGroupAttachment::HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
int XPCCloseButtonMessageAttachment::HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
if ((inMessage == xpMsg_KeyPress) && (KEY_CHAR(inParam1) == XPLM_KEY_TAB) &&
((KEY_FLAGS(inParam1) & xplm_UpFlag) == 0)) {
bool backwards = (KEY_FLAGS(inParam1) & xplm_ShiftFlag) != 0;
std::vector<XPWidgetID> widgets;
XPCGetOrderedSubWidgets(inWidget, widgets);
int n, index = 0;
XPWidgetID focusWidget = XPGetWidgetWithFocus();
std::vector<XPWidgetID>::iterator iter =
std::find(widgets.begin(), widgets.end(), focusWidget);
if (iter != widgets.end()) {
index = std::distance(widgets.begin(), iter);
if (backwards)
index--;
else
index++;
if (index < 0)
index = widgets.size() - 1;
if (index >= widgets.size())
index = 0;
}
if ((inMessage == xpMessage_CloseButtonPushed) && ((XPWidgetID) inParam1 == mWidget))
{
BroadcastMessage(mMsg, mParam);
return 1;
}
if (backwards) {
for (n = index; n >= 0; --n) {
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
for (n = widgets.size() - 1; n > index; --n) {
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
} else {
for (n = index; n < widgets.size(); ++n) {
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
for (n = 0; n < index; ++n) {
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
}
}
return 0;
return 0;
}
XPCTabGroupAttachment::XPCTabGroupAttachment()
{
}
XPCTabGroupAttachment::~XPCTabGroupAttachment()
{
}
int XPCTabGroupAttachment::HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
if ((inMessage == xpMsg_KeyPress) && (KEY_CHAR(inParam1) == XPLM_KEY_TAB) &&
((KEY_FLAGS(inParam1) & xplm_UpFlag) == 0))
{
bool backwards = (KEY_FLAGS(inParam1) & xplm_ShiftFlag) != 0;
std::vector<XPWidgetID> widgets;
XPCGetOrderedSubWidgets(inWidget, widgets);
int n, index = 0;
XPWidgetID focusWidget = XPGetWidgetWithFocus();
std::vector<XPWidgetID>::iterator iter = std::find(widgets.begin(), widgets.end(), focusWidget);
if (iter != widgets.end())
{
index = std::distance(widgets.begin(), iter);
if (backwards)
index--;
else
index++;
if (index < 0)
index = widgets.size() - 1;
if (index >= widgets.size())
index = 0;
}
if (backwards)
{
for (n = index; n >= 0; --n)
{
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
for (n = widgets.size() - 1; n > index; --n)
{
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
} else {
for (n = index; n < widgets.size(); ++n)
{
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
for (n = 0; n < index; ++n)
{
if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL))
if (XPSetKeyboardFocus(widgets[n]) != NULL)
return 1;
}
}
}
return 0;
}
static void XPCGetOrderedSubWidgets(XPWidgetID inWidget,
std::vector<XPWidgetID> &outChildren)
{
outChildren.clear();
int count = XPCountChildWidgets(inWidget);
for (int n = 0; n < count; ++n) {
XPWidgetID child = XPGetNthChildWidget(inWidget, n);
outChildren.push_back(child);
std::vector<XPWidgetID> grandChildren;
XPCGetOrderedSubWidgets(child, grandChildren);
outChildren.insert(outChildren.end(),
grandChildren.begin(),
grandChildren.end());
}
static void XPCGetOrderedSubWidgets(
XPWidgetID inWidget,
std::vector<XPWidgetID>& outChildren)
{
outChildren.clear();
int count = XPCountChildWidgets(inWidget);
for (int n = 0; n < count; ++n)
{
XPWidgetID child = XPGetNthChildWidget(inWidget, n);
outChildren.push_back(child);
std::vector<XPWidgetID> grandChildren;
XPCGetOrderedSubWidgets(child, grandChildren);
outChildren.insert(outChildren.end(), grandChildren.begin(), grandChildren.end());
}
}
XPSDK/CHeaders/Wrappers/XPCWidgetAttachments.h
+102 -88
View File
@@ -3,130 +3,144 @@
#include <string>
#include "XPCBroadcaster.h"
#include "XPCWidget.h"
#include "XPCBroadcaster.h"
class XPCKeyFilterAttachment : public XPCWidgetAttachment
{
class XPCKeyFilterAttachment : public XPCWidgetAttachment {
public:
XPCKeyFilterAttachment(const char *inValidKeys, const char *outValidKeys);
virtual ~XPCKeyFilterAttachment();
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
XPCKeyFilterAttachment(
const char * inValidKeys,
const char * outValidKeys);
virtual ~XPCKeyFilterAttachment();
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
private:
std::string mInput;
std::string mOutput;
std::string mInput;
std::string mOutput;
};
class XPCKeyMessageAttachment : public XPCWidgetAttachment,
public XPCBroadcaster
{
class XPCKeyMessageAttachment : public XPCWidgetAttachment, public XPCBroadcaster {
public:
XPCKeyMessageAttachment(char inKey,
int inMessage,
void *inParam,
bool inConsume,
bool inVkey,
XPCListener *inListener);
virtual ~XPCKeyMessageAttachment();
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
XPCKeyMessageAttachment(
char inKey,
int inMessage,
void * inParam,
bool inConsume,
bool inVkey,
XPCListener * inListener);
virtual ~XPCKeyMessageAttachment();
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
private:
char mKey;
bool mVkey;
int mMsg;
void *mParam;
bool mConsume;
char mKey;
bool mVkey;
int mMsg;
void * mParam;
bool mConsume;
};
class XPCPushButtonMessageAttachment : public XPCWidgetAttachment,
XPCBroadcaster
{
class XPCPushButtonMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster {
public:
XPCPushButtonMessageAttachment(XPWidgetID inWidget,
int inMessage,
void *inParam,
XPCListener *inListener);
virtual ~XPCPushButtonMessageAttachment();
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
XPCPushButtonMessageAttachment(
XPWidgetID inWidget,
int inMessage,
void * inParam,
XPCListener * inListener);
virtual ~XPCPushButtonMessageAttachment();
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
private:
XPWidgetID mWidget;
int mMsg;
void *mParam;
XPWidgetID mWidget;
int mMsg;
void * mParam;
};
class XPCSliderMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster
{
class XPCSliderMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster {
public:
XPCSliderMessageAttachment(XPWidgetID inWidget,
int inMessage,
void *inParam,
XPCListener *inListener);
virtual ~XPCSliderMessageAttachment();
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
XPCSliderMessageAttachment(
XPWidgetID inWidget,
int inMessage,
void * inParam,
XPCListener * inListener);
virtual ~XPCSliderMessageAttachment();
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
private:
XPWidgetID mWidget;
int mMsg;
void *mParam;
XPWidgetID mWidget;
int mMsg;
void * mParam;
};
class XPCCloseButtonMessageAttachment : public XPCWidgetAttachment,
XPCBroadcaster
{
class XPCCloseButtonMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster {
public:
XPCCloseButtonMessageAttachment(XPWidgetID inWidget,
int inMessage,
void *inParam,
XPCListener *inListener);
virtual ~XPCCloseButtonMessageAttachment();
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
XPCCloseButtonMessageAttachment(
XPWidgetID inWidget,
int inMessage,
void * inParam,
XPCListener * inListener);
virtual ~XPCCloseButtonMessageAttachment();
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
private:
XPWidgetID mWidget;
int mMsg;
void *mParam;
XPWidgetID mWidget;
int mMsg;
void * mParam;
};
class XPCTabGroupAttachment : public XPCWidgetAttachment
{
class XPCTabGroupAttachment : public XPCWidgetAttachment {
public:
XPCTabGroupAttachment();
virtual ~XPCTabGroupAttachment();
virtual int HandleWidgetMessage(XPCWidget *inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
XPCTabGroupAttachment();
virtual ~XPCTabGroupAttachment();
virtual int HandleWidgetMessage(
XPCWidget * inObject,
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
};
#endif
XPSDK/CHeaders/XPLM/XPLMCamera.h
+57 -57
View File
@@ -2,43 +2,47 @@
#define _XPLMCamera_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMCamera
***************************************************************************/
/*
* XPLMCamera - THEORY OF OPERATION The XPLMCamera APIs allow plug-ins to
* control the camera angle in X-Plane. This has a number of applications,
* including but not limited to:
* The XPLMCamera APIs allow plug-ins to control the camera angle in X-Plane.
* This has a number of applications, including but not limited to:
*
* - Creating new views (including dynamic/user-controllable views) for the
* user.
*
* user.
* - Creating applications that use X-Plane as a renderer of scenery,
* aircrafts, or both.
* aircrafts, or both.
*
* The camera is controlled via six parameters: a location in OpenGL
* coordinates and pitch, roll and yaw, similar to an airplane's position.
* OpenGL coordinate info is described in detail in the XPLMGraphics
* documentation; generally you should use the XPLMGraphics routines to
* convert from world to local coordinates. The camera's orientation starts
* facing level with the ground directly up the negative-Z axis
* (approximately north) with the horizon horizontal. It is then rotated
* clockwise for yaw, pitched up for positive pitch, and rolled clockwise
* around the vector it is looking along for roll.
* convert from world to local coordinates. The camera's orientation starts
* facing level with the ground directly up the negative-Z axis (approximately
* north) with the horizon horizontal. It is then rotated clockwise for yaw,
* pitched up for positive pitch, and rolled clockwise around the vector it is
* looking along for roll.
*
* You control the camera either either until the user selects a new view or
* permanently (the later being similar to how UDP camera control works). You
* permanently (the later being similar to how UDP camera control works). You
* control the camera by registering a callback per frame from which you
* calculate the new camera positions. This guarantees smooth camera motion.
* calculate the new camera positions. This guarantees smooth camera motion.
*
* Use the XPLMDataAccess APIs to get information like the position of the
* aircraft, etc. for complex camera positioning.
*
* Note: if your goal is to move the virtual pilot in the cockpit, this API is
* not needed; simply update the datarefs for the pilot's head position.
*
* For custom exterior cameras, set the camera's mode to an external view
* first to get correct sound and 2-d panel behavior.
*
*/
#include "XPLMDefs.h"
@@ -50,11 +54,6 @@ extern "C" {
/***************************************************************************
* CAMERA CONTROL
***************************************************************************/
/*
*
*
*/
/*
* XPLMCameraControlDuration
@@ -64,13 +63,12 @@ extern "C" {
*
*/
enum {
/* Control the camera until the user picks a new view. */
xplm_ControlCameraUntilViewChanges = 1
/* Control the camera until the user picks a new view. */
xplm_ControlCameraUntilViewChanges = 1,
/* Control the camera until your plugin is disabled or another plugin
* forcably * takes control. */
,
xplm_ControlCameraForever = 2
/* Control the camera until your plugin is disabled or another plugin forcably*
* takes control. */
xplm_ControlCameraForever = 2,
};
@@ -79,30 +77,30 @@ typedef int XPLMCameraControlDuration;
/*
* XPLMCameraPosition_t
*
* This structure contains a full specification of the camera. X, Y, and Z
* are the camera's position in OpenGL coordiantes; pitch, roll, and yaw are
* rotations from a camera facing flat north in degrees. Positive pitch means
* This structure contains a full specification of the camera. X, Y, and Z are
* the camera's position in OpenGL coordiantes; pitch, roll, and yaw are
* rotations from a camera facing flat north in degrees. Positive pitch means
* nose up, positive roll means roll right, and positive yaw means yaw right,
* all in degrees. Zoom is a zoom factor, with 1.0 meaning normal zoom and 2.0
* magnifying by 2x (objects appear larger).
*
*/
typedef struct {
float x;
float y;
float z;
float pitch;
float heading;
float roll;
float zoom;
float x;
float y;
float z;
float pitch;
float heading;
float roll;
float zoom;
} XPLMCameraPosition_t;
/*
* XPLMCameraControl_f
*
* You use an XPLMCameraControl function to provide continuous control over
* the camera. You are passed in a structure in which to put the new camera
* position; modify it and return 1 to reposition the camera. Return 0 to
* the camera. You are passed in a structure in which to put the new camera
* position; modify it and return 1 to reposition the camera. Return 0 to
* surrender control of the camera; camera control will be handled by X-Plane
* on this draw loop. The contents of the structure as you are called are
* undefined.
@@ -111,27 +109,28 @@ typedef struct {
* called with inIsLosingControl set to 1 and ioCameraPosition NULL.
*
*/
typedef int (*XPLMCameraControl_f)(
XPLMCameraPosition_t *outCameraPosition, /* Can be NULL */
int inIsLosingControl,
void *inRefcon);
typedef int (* XPLMCameraControl_f)(
XPLMCameraPosition_t * outCameraPosition, /* Can be NULL */
int inIsLosingControl,
void * inRefcon);
/*
* XPLMControlCamera
*
* This function repositions the camera on the next drawing cycle. You must
* pass a non-null control function. Specify in inHowLong how long you'd like
* control (indefinitely or until a key is pressed).
* This function repositions the camera on the next drawing cycle. You must
* pass a non-null control function. Specify in inHowLong how long you'd like
* control (indefinitely or until a new view mode is set by the user).
*
*/
XPLM_API void XPLMControlCamera(XPLMCameraControlDuration inHowLong,
XPLMCameraControl_f inControlFunc,
void *inRefcon);
XPLM_API void XPLMControlCamera(
XPLMCameraControlDuration inHowLong,
XPLMCameraControl_f inControlFunc,
void * inRefcon);
/*
* XPLMDontControlCamera
*
* This function stops you from controlling the camera. If you have a camera
* This function stops you from controlling the camera. If you have a camera
* control function, it will not be called with an inIsLosingControl flag.
* X-Plane will control the camera on the next cycle.
*
@@ -139,18 +138,18 @@ XPLM_API void XPLMControlCamera(XPLMCameraControlDuration inHowLong,
* posession of the camera.
*
*/
XPLM_API void XPLMDontControlCamera(void);
XPLM_API void XPLMDontControlCamera(void);
/*
* XPLMIsCameraBeingControlled
*
* This routine returns 1 if the camera is being controlled, zero if it is
* not. If it is and you pass in a pointer to a camera control duration, the
* not. If it is and you pass in a pointer to a camera control duration, the
* current control duration will be returned.
*
*/
XPLM_API int XPLMIsCameraBeingControlled(
XPLMCameraControlDuration *outCameraControlDuration); /* Can be NULL */
XPLM_API int XPLMIsCameraBeingControlled(
XPLMCameraControlDuration * outCameraControlDuration); /* Can be NULL */
/*
* XPLMReadCameraPosition
@@ -158,7 +157,8 @@ XPLM_API int XPLMIsCameraBeingControlled(
* This function reads the current camera position.
*
*/
XPLM_API void XPLMReadCameraPosition(XPLMCameraPosition_t *outCameraPosition);
XPLM_API void XPLMReadCameraPosition(
XPLMCameraPosition_t * outCameraPosition);
#ifdef __cplusplus
}
XPSDK/CHeaders/XPLM/XPLMDataAccess.h
+300 -254
View File
@@ -2,61 +2,82 @@
#define _XPLMDataAccess_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMDataAccess
***************************************************************************/
/*
* XPLM Data Access API - Theory of Operation
*
* The data access API gives you a generic, flexible, high performance way to
* read and write data to and from X-Plane and other plug-ins. For example,
* read and write data to and from X-Plane and other plug-ins. For example,
* this API allows you to read and set the nav radios, get the plane location,
* determine the current effective graphics frame rate, etc.
*
* The data access APIs are the way that you read and write data from the sim
* as well as other plugins.
*
* The API works using opaque data references. A data reference is a source
* of data; you do not know where it comes from, but once you have it you can
* read the data quickly and possibly write it. To get a data reference, you
* look it up.
* The API works using opaque data references. A data reference is a source of
* data; you do not know where it comes from, but once you have it you can
* read the data quickly and possibly write it.
*
* Data references are identified by verbose string names
* (sim/cockpit/radios/nav1_freq_hz). The actual numeric value of the data
* reference is implementation defined and is likely to change each time the
* simulator is run (or the plugin that provides the datareference is
* reloaded).
* Dataref Lookup
* --------------
*
* Data references are identified by verbose, permanent string names; by
* convention these names use path separates to form a hierarchy of datarefs,
* e.g. (sim/cockpit/radios/nav1_freq_hz). The actual opaque numeric value of
* the data reference, as returned by the XPLM API, is implementation defined
* and changes each time X-Plane is launched; therefore you need to look up
* the dataref by path every time your plugin runs.
*
* The task of looking up a data reference is relatively expensive; look up
* your data references once based on verbose strings, and save the opaque
* data reference value for the duration of your plugin's operation. Reading
* and writing data references is relatively fast (the cost is equivalent to
* two function calls through function pointers).
* your data references once based on the verbose path strings, and save the
* opaque data reference value for the duration of your plugin's operation.
* Reading and writing data references is relatively fast (the cost is
* equivalent to two function calls through function pointers).
*
* This allows data access to be high performance, while leaving in
* abstraction; since data references are opaque and are searched for, the
* underlying data access system can be rebuilt.
* X-Plane publishes over 4000 datarefs; a complete list may be found in the
* reference section of the SDK online documentation (from the SDK home page,
* choose Documentation).
*
* Dataref Types
* -------------
*
* A note on typing: you must know the correct data type to read and write.
* APIs are provided for reading and writing data in a number of ways. You
* can also double check the data type for a data ref. Note that automatic
* conversion is not done for you.
* APIs are provided for reading and writing data in a number of ways. You can
* also double check the data type for a data ref. Automatic type conversion
* is not done for you.
*
* Dataref types are a set, e.g. a dataref can be more than one type. When
* this happens, you can choose which API you want to use to read. For
* example, it is not uncommon for a dataref to be of type float and double.
* This means you can use either XPLMGetDatad or XPLMGetDataf to read it.
*
* Creating New Datarefs
* ---------------------
*
* X-Plane provides datarefs that come with the sim, but plugins can also
* create their own datarefs. A plugin creates a dataref by registering
* function callbacks to read and write the dataref. The XPLM will call your
* plugin each time some other plugin (or X-Plane) tries to read or write the
* dataref. You must provide a read (and optional write) callback for each
* data type you support.
*
* A note for plugins sharing data with other plugins: the load order of
* plugins is not guaranteed. To make sure that every plugin publishing data
* plugins is not guaranteed. To make sure that every plugin publishing data
* has published their data references before other plugins try to subscribe,
* publish your data references in your start routine but resolve them the
* first time your 'enable' routine is called, or the first time they are
* needed in code.
*
* X-Plane publishes well over 1000 datarefs; a complete list may be found in
* the reference section of the SDK online documentation (from the SDK home
* page, choose Documentation).
* When a plugin that created a dataref is unloaded, it becomes "orphaned".
* The dataref handle continues to be usable, but the dataref is not writable,
* and reading it will always return 0 (or 0 items for arrays). If the plugin
* is reloaded and re-registers the dataref, the handle becomes un-orphaned
* and works again.
*
*/
@@ -70,8 +91,8 @@ extern "C" {
* READING AND WRITING DATA
***************************************************************************/
/*
* These routines allow you to access a wide variety of data from within
* x-plane and modify some of it.
* These routines allow you to access data from within X-Plane and sometimes
* modify it.
*
*/
@@ -80,12 +101,12 @@ extern "C" {
* XPLMDataRef
*
* A data ref is an opaque handle to data provided by the simulator or another
* plugin. It uniquely identifies one variable (or array of variables) over
* the lifetime of your plugin. You never hard code these values; you always
* plugin. It uniquely identifies one variable (or array of variables) over
* the lifetime of your plugin. You never hard code these values; you always
* get them from XPLMFindDataRef.
*
*/
typedef void *XPLMDataRef;
typedef void * XPLMDataRef;
/*
* XPLMDataTypeID
@@ -95,36 +116,32 @@ typedef void *XPLMDataRef;
* you expect. But for the most part, you will know the type of data you are
* expecting from the online documentation.
*
* Data types each take a bit field, so sets of data types may be formed.
* Data types each take a bit field; it is legal to have a single dataref be
* more than one type of data. Whe this happens, you can pick any matching
* get/set API.
*
*/
enum {
/* Data of a type the current XPLM doesn't do. */
xplmType_Unknown = 0
/* Data of a type the current XPLM doesn't do. */
xplmType_Unknown = 0,
/* A single 4-byte integer, native endian. */
,
xplmType_Int = 1
/* A single 4-byte integer, native endian. */
xplmType_Int = 1,
/* A single 4-byte float, native endian. */
,
xplmType_Float = 2
/* A single 4-byte float, native endian. */
xplmType_Float = 2,
/* A single 8-byte double, native endian. */
,
xplmType_Double = 4
/* A single 8-byte double, native endian. */
xplmType_Double = 4,
/* An array of 4-byte floats, native endian. */
,
xplmType_FloatArray = 8
/* An array of 4-byte floats, native endian. */
xplmType_FloatArray = 8,
/* An array of 4-byte integers, native endian. */
,
xplmType_IntArray = 16
/* An array of 4-byte integers, native endian. */
xplmType_IntArray = 16,
/* A variable block of data. */
,
xplmType_Data = 32
/* A variable block of data. */
xplmType_Data = 32,
};
@@ -135,70 +152,82 @@ typedef int XPLMDataTypeID;
*
* Given a c-style string that names the data ref, this routine looks up the
* actual opaque XPLMDataRef that you use to read and write the data. The
* string names for datarefs are published on the x-plane SDK web site.
* string names for datarefs are published on the X-Plane SDK web site.
*
* This function returns NULL if the data ref cannot be found.
*
* NOTE: this function is relatively expensive; save the XPLMDataRef this
* function returns for future use. Do not look up your data ref by string
* function returns for future use. Do not look up your data ref by string
* every time you need to read or write it.
*
*/
XPLM_API XPLMDataRef XPLMFindDataRef(const char *inDataRefName);
XPLM_API XPLMDataRef XPLMFindDataRef(
const char * inDataRefName);
/*
* XPLMCanWriteDataRef
*
* Given a data ref, this routine returns true if you can successfully set
* the data, false otherwise. Some datarefs are read-only.
* Given a data ref, this routine returns true if you can successfully set the
* data, false otherwise. Some datarefs are read-only.
*
* NOTE: even if a dataref is marked writable, it may not act writable. This
* can happen for datarefs that X-Plane writes to on every frame of
* simulation. In some cases, the dataref is writable but you have to set a
* separate "override" dataref to 1 to stop X-Plane from writing it.
*
*/
XPLM_API int XPLMCanWriteDataRef(XPLMDataRef inDataRef);
XPLM_API int XPLMCanWriteDataRef(
XPLMDataRef inDataRef);
/*
* XPLMIsDataRefGood
*
* WARNING: This function is deprecated and should not be used. Datarefs are
* valid until plugins are reloaded or the sim quits. Plugins sharing
* datarefs should support these semantics by not unregistering datarefs
* during operation. (You should however unregister datarefs when your plugin
* is unloaded, as part of general resource cleanup.)
* This function returns true if the passed in handle is a valid dataref that
* is not orphaned.
*
* This function returns whether a data ref is still valid. If it returns
* false, you should refind the data ref from its original string. Calling an
* accessor function on a bad data ref will return a default value, typically
* 0 or 0-length data.
* Note: there is normally no need to call this function; datarefs returned by
* XPLMFindDataRef remain valid (but possibly orphaned) unless there is a
* complete plugin reload (in which case your plugin is reloaded anyway).
* Orphaned datarefs can be safely read and return 0. Therefore you never need
* to call XPLMIsDataRefGood to 'check' the safety of a dataref.
* (XPLMIsDatarefGood performs some slow checking of the handle validity, so
* it has a perormance cost.)
*
*/
XPLM_API int XPLMIsDataRefGood(XPLMDataRef inDataRef);
XPLM_API int XPLMIsDataRefGood(
XPLMDataRef inDataRef);
/*
* XPLMGetDataRefTypes
*
* This routine returns the types of the data ref for accessor use. If a data
* ref is available in multiple data types, they will all be returned.
* This routine returns the types of the data ref for accessor use. If a data
* ref is available in multiple data types, the bit-wise OR of these types
* will be returned.
*
*/
XPLM_API XPLMDataTypeID XPLMGetDataRefTypes(XPLMDataRef inDataRef);
XPLM_API XPLMDataTypeID XPLMGetDataRefTypes(
XPLMDataRef inDataRef);
/***************************************************************************
* DATA ACCESSORS
***************************************************************************/
/*
* These routines read and write the data references. For each supported data
* type there is a reader and a writer.
* These routines read and write the data references. For each supported data
* type there is a reader and a writer.
*
* If the data ref is invalid or the plugin that provides it is disabled or
* If the data ref is orphaned or the plugin that provides it is disabled or
* there is a type mismatch, the functions that read data will return 0 as a
* default value or not modify the passed in memory. The plugins that write
* data will not write under these circumstances or if the data ref is
* read-only. NOTE: to keep the overhead of reading datarefs low, these
* routines do not do full validation of a dataref; passing a junk value for
* a dataref can result in crashing the sim.
* read-only.
*
* NOTE: to keep the overhead of reading datarefs low, these routines do not
* do full validation of a dataref; passing a junk value for a dataref can
* result in crashing the sim. The get/set APIs do check for NULL.
*
* For array-style datarefs, you specify the number of items to read/write and
* the offset into the array; the actual number of items read or written is
* returned. This may be less to prevent an array-out-of-bounds error.
* returned. This may be less to prevent an array-out-of-bounds error.
*
*/
@@ -207,73 +236,80 @@ XPLM_API XPLMDataTypeID XPLMGetDataRefTypes(XPLMDataRef inDataRef);
* XPLMGetDatai
*
* Read an integer data ref and return its value. The return value is the
* dataref value or 0 if the dataref is invalid/NULL or the plugin is
* disabled.
* dataref value or 0 if the dataref is NULL or the plugin is disabled.
*
*/
XPLM_API int XPLMGetDatai(XPLMDataRef inDataRef);
XPLM_API int XPLMGetDatai(
XPLMDataRef inDataRef);
/*
* XPLMSetDatai
*
* Write a new value to an integer data ref. This routine is a no-op if the
* plugin publishing the dataref is disabled, the dataref is invalid, or the
* Write a new value to an integer data ref. This routine is a no-op if the
* plugin publishing the dataref is disabled, the dataref is NULL, or the
* dataref is not writable.
*
*/
XPLM_API void XPLMSetDatai(XPLMDataRef inDataRef, int inValue);
XPLM_API void XPLMSetDatai(
XPLMDataRef inDataRef,
int inValue);
/*
* XPLMGetDataf
*
* Read a single precision floating point dataref and return its value. The
* return value is the dataref value or 0.0 if the dataref is invalid/NULL or
* the plugin is disabled.
* return value is the dataref value or 0.0 if the dataref is NULL or the
* plugin is disabled.
*
*/
XPLM_API float XPLMGetDataf(XPLMDataRef inDataRef);
XPLM_API float XPLMGetDataf(
XPLMDataRef inDataRef);
/*
* XPLMSetDataf
*
* Write a new value to a single precision floating point data ref. This
* Write a new value to a single precision floating point data ref. This
* routine is a no-op if the plugin publishing the dataref is disabled, the
* dataref is invalid, or the dataref is not writable.
* dataref is NULL, or the dataref is not writable.
*
*/
XPLM_API void XPLMSetDataf(XPLMDataRef inDataRef, float inValue);
XPLM_API void XPLMSetDataf(
XPLMDataRef inDataRef,
float inValue);
/*
* XPLMGetDatad
*
* Read a double precision floating point dataref and return its value. The
* return value is the dataref value or 0.0 if the dataref is invalid/NULL or
* the plugin is disabled.
* return value is the dataref value or 0.0 if the dataref is NULL or the
* plugin is disabled.
*
*/
XPLM_API double XPLMGetDatad(XPLMDataRef inDataRef);
XPLM_API double XPLMGetDatad(
XPLMDataRef inDataRef);
/*
* XPLMSetDatad
*
* Write a new value to a double precision floating point data ref. This
* Write a new value to a double precision floating point data ref. This
* routine is a no-op if the plugin publishing the dataref is disabled, the
* dataref is invalid, or the dataref is not writable.
* dataref is NULL, or the dataref is not writable.
*
*/
XPLM_API void XPLMSetDatad(XPLMDataRef inDataRef, double inValue);
XPLM_API void XPLMSetDatad(
XPLMDataRef inDataRef,
double inValue);
/*
* XPLMGetDatavi
*
* Read a part of an integer array dataref. If you pass NULL for outVaules,
* Read a part of an integer array dataref. If you pass NULL for outValues,
* the routine will return the size of the array, ignoring inOffset and inMax.
*
*
* If outValues is not NULL, then up to inMax values are copied from the
* dataref into outValues, starting at inOffset in the dataref. If inMax +
* inOffset is larger than the size of the dataref, less than inMax values
* will be copied. The number of values copied is returned.
* will be copied. The number of values copied is returned.
*
* Note: the semantics of array datarefs are entirely implemented by the
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
@@ -281,16 +317,17 @@ XPLM_API void XPLMSetDatad(XPLMDataRef inDataRef, double inValue);
* plugin may have different behavior.
*
*/
XPLM_API int XPLMGetDatavi(XPLMDataRef inDataRef,
int *outValues, /* Can be NULL */
int inOffset,
int inMax);
XPLM_API int XPLMGetDatavi(
XPLMDataRef inDataRef,
int * outValues, /* Can be NULL */
int inOffset,
int inMax);
/*
* XPLMSetDatavi
*
* Write part or all of an integer array dataref. The values passed by
* inValues are written into the dataref starting at inOffset. Up to inCount
* Write part or all of an integer array dataref. The values passed by
* inValues are written into the dataref starting at inOffset. Up to inCount
* values are written; however if the values would write "off the end" of the
* dataref array, then fewer values are written.
*
@@ -300,22 +337,23 @@ XPLM_API int XPLMGetDatavi(XPLMDataRef inDataRef,
* plugin may have different behavior.
*
*/
XPLM_API void XPLMSetDatavi(XPLMDataRef inDataRef,
int *inValues,
int inoffset,
int inCount);
XPLM_API void XPLMSetDatavi(
XPLMDataRef inDataRef,
int * inValues,
int inoffset,
int inCount);
/*
* XPLMGetDatavf
*
* Read a part of a single precision floating point array dataref. If you
* pass NULL for outVaules, the routine will return the size of the array,
* ignoring inOffset and inMax.
* Read a part of a single precision floating point array dataref. If you pass
* NULL for outVaules, the routine will return the size of the array, ignoring
* inOffset and inMax.
*
* If outValues is not NULL, then up to inMax values are copied from the
* dataref into outValues, starting at inOffset in the dataref. If inMax +
* inOffset is larger than the size of the dataref, less than inMax values
* will be copied. The number of values copied is returned.
* will be copied. The number of values copied is returned.
*
* Note: the semantics of array datarefs are entirely implemented by the
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
@@ -323,17 +361,18 @@ XPLM_API void XPLMSetDatavi(XPLMDataRef inDataRef,
* plugin may have different behavior.
*
*/
XPLM_API int XPLMGetDatavf(XPLMDataRef inDataRef,
float *outValues, /* Can be NULL */
int inOffset,
int inMax);
XPLM_API int XPLMGetDatavf(
XPLMDataRef inDataRef,
float * outValues, /* Can be NULL */
int inOffset,
int inMax);
/*
* XPLMSetDatavf
*
* Write part or all of a single precision floating point array dataref. The
* Write part or all of a single precision floating point array dataref. The
* values passed by inValues are written into the dataref starting at
* inOffset. Up to inCount values are written; however if the values would
* inOffset. Up to inCount values are written; however if the values would
* write "off the end" of the dataref array, then fewer values are written.
*
* Note: the semantics of array datarefs are entirely implemented by the
@@ -342,21 +381,22 @@ XPLM_API int XPLMGetDatavf(XPLMDataRef inDataRef,
* plugin may have different behavior.
*
*/
XPLM_API void XPLMSetDatavf(XPLMDataRef inDataRef,
float *inValues,
int inoffset,
int inCount);
XPLM_API void XPLMSetDatavf(
XPLMDataRef inDataRef,
float * inValues,
int inoffset,
int inCount);
/*
* XPLMGetDatab
*
* Read a part of a byte array dataref. If you pass NULL for outVaules, the
* Read a part of a byte array dataref. If you pass NULL for outVaules, the
* routine will return the size of the array, ignoring inOffset and inMax.
*
* If outValues is not NULL, then up to inMax values are copied from the
* dataref into outValues, starting at inOffset in the dataref. If inMax +
* inOffset is larger than the size of the dataref, less than inMax values
* will be copied. The number of values copied is returned.
* will be copied. The number of values copied is returned.
*
* Note: the semantics of array datarefs are entirely implemented by the
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
@@ -364,17 +404,18 @@ XPLM_API void XPLMSetDatavf(XPLMDataRef inDataRef,
* plugin may have different behavior.
*
*/
XPLM_API int XPLMGetDatab(XPLMDataRef inDataRef,
void *outValue, /* Can be NULL */
int inOffset,
int inMaxBytes);
XPLM_API int XPLMGetDatab(
XPLMDataRef inDataRef,
void * outValue, /* Can be NULL */
int inOffset,
int inMaxBytes);
/*
* XPLMSetDatab
*
* Write part or all of a byte array dataref. The values passed by inValues
* are written into the dataref starting at inOffset. Up to inCount values
* are written; however if the values would write "off the end" of the dataref
* Write part or all of a byte array dataref. The values passed by inValues
* are written into the dataref starting at inOffset. Up to inCount values are
* written; however if the values would write "off the end" of the dataref
* array, then fewer values are written.
*
* Note: the semantics of array datarefs are entirely implemented by the
@@ -383,28 +424,29 @@ XPLM_API int XPLMGetDatab(XPLMDataRef inDataRef,
* plugin may have different behavior.
*
*/
XPLM_API void XPLMSetDatab(XPLMDataRef inDataRef,
void *inValue,
int inOffset,
int inLength);
XPLM_API void XPLMSetDatab(
XPLMDataRef inDataRef,
void * inValue,
int inOffset,
int inLength);
/***************************************************************************
* PUBLISHING YOUR PLUGINS DATA
* PUBLISHING YOUR PLUGIN'S DATA
***************************************************************************/
/*
* These functions allow you to create data references that other plug-ins can
* access via the above data access APIs. Data references published by other
* plugins operate the same as ones published by x-plane in all manners except
* that your data reference will not be available to other plugins if/when
* your plugin is disabled.
* These functions allow you to create data references that other plug-ins and
* X-Plane can access via the above data access APIs. Data references
* published by other plugins operate the same as ones published by X-Plane in
* all manners except that your data reference will not be available to other
* plugins if/when your plugin is disabled.
*
* You share data by registering data provider callback functions. When a
* plug-in requests your data, these callbacks are then called. You provide
* You share data by registering data provider callback functions. When a
* plug-in requests your data, these callbacks are then called. You provide
* one callback to return the value when a plugin 'reads' it and another to
* change the value when a plugin 'writes' it.
*
* Important: you must pick a prefix for your datarefs other than "sim/" -
* this prefix is reserved for X-Plane. The X-Plane SDK website contains a
* this prefix is reserved for X-Plane. The X-Plane SDK website contains a
* registry where authors can select a unique first word for dataref names, to
* prevent dataref collisions between plugins.
*
@@ -416,146 +458,151 @@ XPLM_API void XPLMSetDatab(XPLMDataRef inDataRef,
*
* Data provider function pointers.
*
* These define the function pointers you provide to get or set data. Note
* that you are passed a generic pointer for each one. This is the same
* pointer you pass in your register routine; you can use it to find global
* These define the function pointers you provide to get or set data. Note
* that you are passed a generic pointer for each one. This is the same
* pointer you pass in your register routine; you can use it to locate plugin
* variables, etc.
*
* The semantics of your callbacks are the same as the dataref accessor above
* - basically routines like XPLMGetDatai are just pass-throughs from a caller
* to your plugin. Be particularly mindful in implementing array dataref
* to your plugin. Be particularly mindful in implementing array dataref
* read-write accessors; you are responsible for avoiding overruns, supporting
* offset read/writes, and handling a read with a NULL buffer.
*
*/
typedef int (*XPLMGetDatai_f)(void *inRefcon);
typedef int (* XPLMGetDatai_f)(
void * inRefcon);
/*
* XPLMSetDatai_f
*
*
*/
typedef void (*XPLMSetDatai_f)(void *inRefcon, int inValue);
typedef void (* XPLMSetDatai_f)(
void * inRefcon,
int inValue);
/*
* XPLMGetDataf_f
*
*
*/
typedef float (*XPLMGetDataf_f)(void *inRefcon);
typedef float (* XPLMGetDataf_f)(
void * inRefcon);
/*
* XPLMSetDataf_f
*
*
*/
typedef void (*XPLMSetDataf_f)(void *inRefcon, float inValue);
typedef void (* XPLMSetDataf_f)(
void * inRefcon,
float inValue);
/*
* XPLMGetDatad_f
*
*
*/
typedef double (*XPLMGetDatad_f)(void *inRefcon);
typedef double (* XPLMGetDatad_f)(
void * inRefcon);
/*
* XPLMSetDatad_f
*
*
*/
typedef void (*XPLMSetDatad_f)(void *inRefcon, double inValue);
typedef void (* XPLMSetDatad_f)(
void * inRefcon,
double inValue);
/*
* XPLMGetDatavi_f
*
*
*/
typedef int (*XPLMGetDatavi_f)(void *inRefcon,
int *outValues, /* Can be NULL */
int inOffset,
int inMax);
typedef int (* XPLMGetDatavi_f)(
void * inRefcon,
int * outValues, /* Can be NULL */
int inOffset,
int inMax);
/*
* XPLMSetDatavi_f
*
*
*/
typedef void (*XPLMSetDatavi_f)(void *inRefcon,
int *inValues,
int inOffset,
int inCount);
typedef void (* XPLMSetDatavi_f)(
void * inRefcon,
int * inValues,
int inOffset,
int inCount);
/*
* XPLMGetDatavf_f
*
*
*/
typedef int (*XPLMGetDatavf_f)(void *inRefcon,
float *outValues, /* Can be NULL */
int inOffset,
int inMax);
typedef int (* XPLMGetDatavf_f)(
void * inRefcon,
float * outValues, /* Can be NULL */
int inOffset,
int inMax);
/*
* XPLMSetDatavf_f
*
*
*/
typedef void (*XPLMSetDatavf_f)(void *inRefcon,
float *inValues,
int inOffset,
int inCount);
typedef void (* XPLMSetDatavf_f)(
void * inRefcon,
float * inValues,
int inOffset,
int inCount);
/*
* XPLMGetDatab_f
*
*
*/
typedef int (*XPLMGetDatab_f)(void *inRefcon,
void *outValue, /* Can be NULL */
int inOffset,
int inMaxLength);
typedef int (* XPLMGetDatab_f)(
void * inRefcon,
void * outValue, /* Can be NULL */
int inOffset,
int inMaxLength);
/*
* XPLMSetDatab_f
*
*
*/
typedef void (*XPLMSetDatab_f)(void *inRefcon,
void *inValue,
int inOffset,
int inLength);
typedef void (* XPLMSetDatab_f)(
void * inRefcon,
void * inValue,
int inOffset,
int inLength);
/*
* XPLMRegisterDataAccessor
*
* This routine creates a new item of data that can be read and written. Pass
* This routine creates a new item of data that can be read and written. Pass
* in the data's full name for searching, the type(s) of the data for
* accessing, and whether the data can be written to. For each data type you
* accessing, and whether the data can be written to. For each data type you
* support, pass in a read accessor function and a write accessor function if
* necessary. Pass NULL for data types you do not support or write accessors
* necessary. Pass NULL for data types you do not support or write accessors
* if you are read-only.
*
* You are returned a data ref for the new item of data created. You can use
* this data ref to unregister your data later or read or write from it.
* You are returned a data ref for the new item of data created. You can use
* this data ref to unregister your data later or read or write from it.
*
*/
XPLM_API XPLMDataRef XPLMRegisterDataAccessor(const char *inDataName,
XPLMDataTypeID inDataType,
int inIsWritable,
XPLMGetDatai_f inReadInt,
XPLMSetDatai_f inWriteInt,
XPLMGetDataf_f inReadFloat,
XPLMSetDataf_f inWriteFloat,
XPLMGetDatad_f inReadDouble,
XPLMSetDatad_f inWriteDouble,
XPLMGetDatavi_f inReadIntArray,
XPLMSetDatavi_f inWriteIntArray,
XPLMGetDatavf_f inReadFloatArray,
XPLMSetDatavf_f inWriteFloatArray,
XPLMGetDatab_f inReadData,
XPLMSetDatab_f inWriteData,
void *inReadRefcon,
void *inWriteRefcon);
XPLM_API XPLMDataRef XPLMRegisterDataAccessor(
const char * inDataName,
XPLMDataTypeID inDataType,
int inIsWritable,
XPLMGetDatai_f inReadInt,
XPLMSetDatai_f inWriteInt,
XPLMGetDataf_f inReadFloat,
XPLMSetDataf_f inWriteFloat,
XPLMGetDatad_f inReadDouble,
XPLMSetDatad_f inWriteDouble,
XPLMGetDatavi_f inReadIntArray,
XPLMSetDatavi_f inWriteIntArray,
XPLMGetDatavf_f inReadFloatArray,
XPLMSetDatavf_f inWriteFloatArray,
XPLMGetDatab_f inReadData,
XPLMSetDatab_f inWriteData,
void * inReadRefcon,
void * inWriteRefcon);
/*
* XPLMUnregisterDataAccessor
@@ -565,13 +612,9 @@ XPLM_API XPLMDataRef XPLMRegisterDataAccessor(const char *inDataName,
* registration. Once you unregister a data ref, your function pointer will
* not be called anymore.
*
* For maximum compatibility, do not unregister your data accessors until
* final shutdown (when your XPluginStop routine is called). This allows
* other plugins to find your data reference once and use it for their entire
* time of operation.
*
*/
XPLM_API void XPLMUnregisterDataAccessor(XPLMDataRef inDataRef);
XPLM_API void XPLMUnregisterDataAccessor(
XPLMDataRef inDataRef);
/***************************************************************************
* SHARING DATA BETWEEN MULTIPLE PLUGINS
@@ -579,34 +622,34 @@ XPLM_API void XPLMUnregisterDataAccessor(XPLMDataRef inDataRef);
/*
* The data reference registration APIs from the previous section allow a
* plugin to publish data in a one-owner manner; the plugin that publishes the
* data reference owns the real memory that the data ref uses. This is
* data reference owns the real memory that the data ref uses. This is
* satisfactory for most cases, but there are also cases where plugnis need to
* share actual data.
*
* With a shared data reference, no one plugin owns the actual memory for the
* data reference; the plugin SDK allocates that for you. When the first
* plugin asks to 'share' the data, the memory is allocated. When the data is
* data reference; the plugin SDK allocates that for you. When the first
* plugin asks to 'share' the data, the memory is allocated. When the data is
* changed, every plugin that is sharing the data is notified.
*
* Shared data references differ from the 'owned' data references from the
* previous section in a few ways:
*
* - With shared data references, any plugin can create the data reference;
* with owned plugins one plugin must create the data reference and others
* subscribe. (This can be a problem if you don't know which set of plugins
* will be present).
* * With shared data references, any plugin can create the data reference;
* with owned plugins one plugin must create the data reference and others
* subscribe. (This can be a problem if you don't know which set of plugins
* will be present).
*
* - With shared data references, every plugin that is sharing the data is
* notified when the data is changed. With owned data references, only the
* one owner is notified when the data is changed.
* * With shared data references, every plugin that is sharing the data is
* notified when the data is changed. With owned data references, only the
* one owner is notified when the data is changed.
*
* - With shared data references, you cannot access the physical memory of the
* data reference; you must use the XPLMGet... and XPLMSet... APIs. With an
* owned data reference, the one owning data reference can manipulate the
* data reference's memory in any way it sees fit.
* * With shared data references, you cannot access the physical memory of the
* data reference; you must use the XPLMGet... and XPLMSet... APIs. With an
* owned data reference, the one owning data reference can manipulate the
* data reference's memory in any way it sees fit.
*
* Shared data references solve two problems: if you need to have a data
* reference used by several plugins but do not know which plugins will be
* reference used by several plugins but do not know which plugins will be
* installed, or if all plugins sharing data need to be notified when that
* data is changed, use shared data references.
*
@@ -617,12 +660,13 @@ XPLM_API void XPLMUnregisterDataAccessor(XPLMDataRef inDataRef);
* XPLMDataChanged_f
*
* An XPLMDataChanged_f is a callback that the XPLM calls whenever any other
* plug-in modifies shared data. A refcon you provide is passed back to help
* plug-in modifies shared data. A refcon you provide is passed back to help
* identify which data is being changed. In response, you may want to call one
* of the XPLMGetDataxxx routines to find the new value of the data.
*
*/
typedef void (*XPLMDataChanged_f)(void *inRefcon);
typedef void (* XPLMDataChanged_f)(
void * inRefcon);
/*
* XPLMShareData
@@ -630,38 +674,40 @@ typedef void (*XPLMDataChanged_f)(void *inRefcon);
* This routine connects a plug-in to shared data, creating the shared data if
* necessary. inDataName is a standard path for the data ref, and inDataType
* specifies the type. This function will create the data if it does not
* exist. If the data already exists but the type does not match, an error is
* returned, so it is important that plug-in authors collaborate to establish
* exist. If the data already exists but the type does not match, an error is
* returned, so it is important that plug-in authors collaborate to establish
* public standards for shared data.
*
* If a notificationFunc is passed in and is not NULL, that notification
* function will be called whenever the data is modified. The notification
* function will be called whenever the data is modified. The notification
* refcon will be passed to it. This allows your plug-in to know which shared
* data was changed if multiple shared data are handled by one callback, or if
* the plug-in does not use global variables.
*
* A one is returned for successfully creating or finding the shared data; a
* zero if the data already exists but is of the wrong type.
* zero if the data already exists but is of the wrong type.
*
*/
XPLM_API int XPLMShareData(const char *inDataName,
XPLMDataTypeID inDataType,
XPLMDataChanged_f inNotificationFunc,
void *inNotificationRefcon);
XPLM_API int XPLMShareData(
const char * inDataName,
XPLMDataTypeID inDataType,
XPLMDataChanged_f inNotificationFunc,
void * inNotificationRefcon);
/*
* XPLMUnshareData
*
* This routine removes your notification function for shared data. Call it
* when done with the data to stop receiving change notifications. Arguments
* This routine removes your notification function for shared data. Call it
* when done with the data to stop receiving change notifications. Arguments
* must match XPLMShareData. The actual memory will not necessarily be freed,
* since other plug-ins could be using it.
*
*/
XPLM_API int XPLMUnshareData(const char *inDataName,
XPLMDataTypeID inDataType,
XPLMDataChanged_f inNotificationFunc,
void *inNotificationRefcon);
XPLM_API int XPLMUnshareData(
const char * inDataName,
XPLMDataTypeID inDataType,
XPLMDataChanged_f inNotificationFunc,
void * inNotificationRefcon);
#ifdef __cplusplus
}
XPSDK/CHeaders/XPLM/XPLMDefs.h
+236 -240
View File
@@ -2,14 +2,14 @@
#define _XPLMDefs_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMDefs
***************************************************************************/
/*
* This file is contains the cross-platform and basic definitions for the
* X-Plane SDK.
@@ -40,7 +40,7 @@ extern "C" {
* the DLL.
*
* You can prefix your five required callbacks with the PLUGIN_API macro to
* declare them as exported C functions. The XPLM_API macro identifies
* declare them as exported C functions. The XPLM_API macro identifies
* functions that are provided to you via the plugin SDK. (Link against
* XPLM.lib to use these functions.)
*
@@ -48,77 +48,77 @@ extern "C" {
#ifdef __cplusplus
#if APL
#if __GNUC__ >= 4
#define PLUGIN_API extern "C" __attribute__((visibility("default")))
#elif __MACH__
#define PLUGIN_API extern "C"
#if APL
#if __GNUC__ >= 4
#define PLUGIN_API extern "C" __attribute__((visibility("default")))
#elif __MACH__
#define PLUGIN_API extern "C"
#else
#define PLUGIN_API extern "C" __declspec(dllexport)
#endif
#elif IBM
#define PLUGIN_API extern "C" __declspec(dllexport)
#elif LIN
#if __GNUC__ >= 4
#define PLUGIN_API extern "C" __attribute__((visibility("default")))
#else
#define PLUGIN_API extern "C"
#endif
#else
#error "Platform not defined!"
#endif
#else
#define PLUGIN_API extern "C" __declspec(dllexport)
#endif
#elif IBM
#define PLUGIN_API extern "C" __declspec(dllexport)
#elif LIN
#if __GNUC__ >= 4
#define PLUGIN_API extern "C" __attribute__((visibility("default")))
#else
#define PLUGIN_API extern "C"
#endif
#else
#error "Platform not defined!"
#endif
#else
#if APL
#if __GNUC__ >= 4
#define PLUGIN_API __attribute__((visibility("default")))
#elif __MACH__
#define PLUGIN_API
#else
#define PLUGIN_API __declspec(dllexport)
#endif
#elif IBM
#define PLUGIN_API __declspec(dllexport)
#elif LIN
#if __GNUC__ >= 4
#define PLUGIN_API __attribute__((visibility("default")))
#else
#define PLUGIN_API
#endif
#else
#error "Platform not defined!"
#endif
#if APL
#if __GNUC__ >= 4
#define PLUGIN_API __attribute__((visibility("default")))
#elif __MACH__
#define PLUGIN_API
#else
#define PLUGIN_API __declspec(dllexport)
#endif
#elif IBM
#define PLUGIN_API __declspec(dllexport)
#elif LIN
#if __GNUC__ >= 4
#define PLUGIN_API __attribute__((visibility("default")))
#else
#define PLUGIN_API
#endif
#else
#error "Platform not defined!"
#endif
#endif
#if APL
#if XPLM
#if __GNUC__ >= 4
#define XPLM_API __attribute__((visibility("default")))
#elif __MACH__
#define XPLM_API
#else
#define XPLM_API __declspec(dllexport)
#endif
#else
#define XPLM_API
#endif
#if XPLM
#if __GNUC__ >= 4
#define XPLM_API __attribute__((visibility("default")))
#elif __MACH__
#define XPLM_API
#else
#define XPLM_API __declspec(dllexport)
#endif
#else
#define XPLM_API
#endif
#elif IBM
#if XPLM
#define XPLM_API __declspec(dllexport)
#else
#define XPLM_API __declspec(dllimport)
#endif
#if XPLM
#define XPLM_API __declspec(dllexport)
#else
#define XPLM_API __declspec(dllimport)
#endif
#elif LIN
#if XPLM
#if __GNUC__ >= 4
#define XPLM_API __attribute__((visibility("default")))
#if XPLM
#if __GNUC__ >= 4
#define XPLM_API __attribute__((visibility("default")))
#else
#define XPLM_API
#endif
#else
#define XPLM_API
#endif
#else
#define XPLM_API
#endif
#else
#define XPLM_API
#endif
#else
#error "Platform not defined!"
#error "Platform not defined!"
#endif
/***************************************************************************
@@ -137,7 +137,8 @@ extern "C" {
* disable or enable a plug-in, or discover what plug-in is 'running' at the
* time. A plug-in ID is unique within the currently running instance of
* X-Plane unless plug-ins are reloaded. Plug-ins may receive a different
* unique ID each time they are loaded.
* unique ID each time they are loaded. This includes the unloading and
* reloading of plugins that are part of the user's aircraft.
*
* For persistent identification of plug-ins, use XPLMFindPluginBySignature in
* XPLMUtiltiies.h
@@ -147,14 +148,14 @@ extern "C" {
*/
typedef int XPLMPluginID;
/* No plugin. */
#define XPLM_NO_PLUGIN_ID (-1)
/* No plugin. */
#define XPLM_NO_PLUGIN_ID (-1)
/* X-Plane itself */
#define XPLM_PLUGIN_XPLANE (0)
/* X-Plane itself */
#define XPLM_PLUGIN_XPLANE (0)
/* The current XPLM revision is 2.10 (210). */
#define kXPLM_Version (210)
/* The current XPLM revision is 4.00 (400). */
#define kXPLM_Version (400)
/*
* XPLMKeyFlags
@@ -174,24 +175,20 @@ typedef int XPLMPluginID;
*
*/
enum {
/* The shift key is down */
xplm_ShiftFlag = 1
/* The shift key is down */
xplm_ShiftFlag = 1,
/* The option or alt key is down */
,
xplm_OptionAltFlag = 2
/* The option or alt key is down */
xplm_OptionAltFlag = 2,
/* The control key is down* */
,
xplm_ControlFlag = 4
/* The control key is down* */
xplm_ControlFlag = 4,
/* The key is being pressed down */
,
xplm_DownFlag = 8
/* The key is being pressed down */
xplm_DownFlag = 8,
/* The key is being released */
,
xplm_UpFlag = 16
/* The key is being released */
xplm_UpFlag = 16,
};
@@ -205,52 +202,53 @@ typedef int XPLMKeyFlags;
* codes. Not all key presses generate an ASCII value, so plugin code should
* be prepared to see null characters come from the keyboard...this usually
* represents a key stroke that has no equivalent ASCII, like a page-down
* press. Use virtual key codes to find these key strokes. ASCII key codes
* take into account modifier keys; shift keys will affect capitals and
* punctuation; control key combinations may have no vaild ASCII and produce
* NULL. To detect control-key combinations, use virtual key codes, not ASCII
* keys.
* press. Use virtual key codes to find these key strokes.
*
* ASCII key codes take into account modifier keys; shift keys will affect
* capitals and punctuation; control key combinations may have no vaild ASCII
* and produce NULL. To detect control-key combinations, use virtual key
* codes, not ASCII keys.
*
*/
#define XPLM_KEY_RETURN 13
#define XPLM_KEY_RETURN 13
#define XPLM_KEY_ESCAPE 27
#define XPLM_KEY_ESCAPE 27
#define XPLM_KEY_TAB 9
#define XPLM_KEY_TAB 9
#define XPLM_KEY_DELETE 8
#define XPLM_KEY_DELETE 8
#define XPLM_KEY_LEFT 28
#define XPLM_KEY_LEFT 28
#define XPLM_KEY_RIGHT 29
#define XPLM_KEY_RIGHT 29
#define XPLM_KEY_UP 30
#define XPLM_KEY_UP 30
#define XPLM_KEY_DOWN 31
#define XPLM_KEY_DOWN 31
#define XPLM_KEY_0 48
#define XPLM_KEY_0 48
#define XPLM_KEY_1 49
#define XPLM_KEY_1 49
#define XPLM_KEY_2 50
#define XPLM_KEY_2 50
#define XPLM_KEY_3 51
#define XPLM_KEY_3 51
#define XPLM_KEY_4 52
#define XPLM_KEY_4 52
#define XPLM_KEY_5 53
#define XPLM_KEY_5 53
#define XPLM_KEY_6 54
#define XPLM_KEY_6 54
#define XPLM_KEY_7 55
#define XPLM_KEY_7 55
#define XPLM_KEY_8 56
#define XPLM_KEY_8 56
#define XPLM_KEY_9 57
#define XPLM_KEY_9 57
#define XPLM_KEY_DECIMAL 46
#define XPLM_KEY_DECIMAL 46
/***************************************************************************
* VIRTUAL KEY CODES
@@ -258,10 +256,10 @@ typedef int XPLMKeyFlags;
/*
* These are cross-platform defines for every distinct keyboard press on the
* computer. Every physical key on the keyboard has a virtual key code. So
* the "two" key on the top row of the main keyboard has a different code
* from the "two" key on the numeric key pad. But the 'w' and 'W' character
* are indistinguishable by virtual key code because they are the same
* physical key (one with and one without the shift key).
* the "two" key on the top row of the main keyboard has a different code from
* the "two" key on the numeric key pad. But the 'w' and 'W' character are
* indistinguishable by virtual key code because they are the same physical
* key (one with and one without the shift key).
*
* Use virtual key codes to detect keystrokes that do not have ASCII
* equivalents, allow the user to map the numeric keypad separately from the
@@ -273,243 +271,241 @@ typedef int XPLMKeyFlags;
* additions and changes. A few differences:
*
* 1. Modifier keys are not available as virtual key codes. You cannot get
* distinct modifier press and release messages. Please do not try to use
* modifier keys as regular keys; doing so will almost certainly interfere
* with users' abilities to use the native x-plane key bindings.
*
* distinct modifier press and release messages. Please do not try to use
* modifier keys as regular keys; doing so will almost certainly interfere
* with users' abilities to use the native X-Plane key bindings.
* 2. Some keys that do not exist on both Mac and PC keyboards are removed.
*
* 3. Do not assume that the values of these keystrokes are interchangeable
* with MS v-keys.
* with MS v-keys.
*
*/
#define XPLM_VK_BACK 0x08
#define XPLM_VK_BACK 0x08
#define XPLM_VK_TAB 0x09
#define XPLM_VK_TAB 0x09
#define XPLM_VK_CLEAR 0x0C
#define XPLM_VK_CLEAR 0x0C
#define XPLM_VK_RETURN 0x0D
#define XPLM_VK_RETURN 0x0D
#define XPLM_VK_ESCAPE 0x1B
#define XPLM_VK_ESCAPE 0x1B
#define XPLM_VK_SPACE 0x20
#define XPLM_VK_SPACE 0x20
#define XPLM_VK_PRIOR 0x21
#define XPLM_VK_PRIOR 0x21
#define XPLM_VK_NEXT 0x22
#define XPLM_VK_NEXT 0x22
#define XPLM_VK_END 0x23
#define XPLM_VK_END 0x23
#define XPLM_VK_HOME 0x24
#define XPLM_VK_HOME 0x24
#define XPLM_VK_LEFT 0x25
#define XPLM_VK_LEFT 0x25
#define XPLM_VK_UP 0x26
#define XPLM_VK_UP 0x26
#define XPLM_VK_RIGHT 0x27
#define XPLM_VK_RIGHT 0x27
#define XPLM_VK_DOWN 0x28
#define XPLM_VK_DOWN 0x28
#define XPLM_VK_SELECT 0x29
#define XPLM_VK_SELECT 0x29
#define XPLM_VK_PRINT 0x2A
#define XPLM_VK_PRINT 0x2A
#define XPLM_VK_EXECUTE 0x2B
#define XPLM_VK_EXECUTE 0x2B
#define XPLM_VK_SNAPSHOT 0x2C
#define XPLM_VK_SNAPSHOT 0x2C
#define XPLM_VK_INSERT 0x2D
#define XPLM_VK_INSERT 0x2D
#define XPLM_VK_DELETE 0x2E
#define XPLM_VK_DELETE 0x2E
#define XPLM_VK_HELP 0x2F
#define XPLM_VK_HELP 0x2F
/* XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
#define XPLM_VK_0 0x30
/* XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
#define XPLM_VK_0 0x30
#define XPLM_VK_1 0x31
#define XPLM_VK_1 0x31
#define XPLM_VK_2 0x32
#define XPLM_VK_2 0x32
#define XPLM_VK_3 0x33
#define XPLM_VK_3 0x33
#define XPLM_VK_4 0x34
#define XPLM_VK_4 0x34
#define XPLM_VK_5 0x35
#define XPLM_VK_5 0x35
#define XPLM_VK_6 0x36
#define XPLM_VK_6 0x36
#define XPLM_VK_7 0x37
#define XPLM_VK_7 0x37
#define XPLM_VK_8 0x38
#define XPLM_VK_8 0x38
#define XPLM_VK_9 0x39
#define XPLM_VK_9 0x39
/* XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
#define XPLM_VK_A 0x41
/* XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
#define XPLM_VK_A 0x41
#define XPLM_VK_B 0x42
#define XPLM_VK_B 0x42
#define XPLM_VK_C 0x43
#define XPLM_VK_C 0x43
#define XPLM_VK_D 0x44
#define XPLM_VK_D 0x44
#define XPLM_VK_E 0x45
#define XPLM_VK_E 0x45
#define XPLM_VK_F 0x46
#define XPLM_VK_F 0x46
#define XPLM_VK_G 0x47
#define XPLM_VK_G 0x47
#define XPLM_VK_H 0x48
#define XPLM_VK_H 0x48
#define XPLM_VK_I 0x49
#define XPLM_VK_I 0x49
#define XPLM_VK_J 0x4A
#define XPLM_VK_J 0x4A
#define XPLM_VK_K 0x4B
#define XPLM_VK_K 0x4B
#define XPLM_VK_L 0x4C
#define XPLM_VK_L 0x4C
#define XPLM_VK_M 0x4D
#define XPLM_VK_M 0x4D
#define XPLM_VK_N 0x4E
#define XPLM_VK_N 0x4E
#define XPLM_VK_O 0x4F
#define XPLM_VK_O 0x4F
#define XPLM_VK_P 0x50
#define XPLM_VK_P 0x50
#define XPLM_VK_Q 0x51
#define XPLM_VK_Q 0x51
#define XPLM_VK_R 0x52
#define XPLM_VK_R 0x52
#define XPLM_VK_S 0x53
#define XPLM_VK_S 0x53
#define XPLM_VK_T 0x54
#define XPLM_VK_T 0x54
#define XPLM_VK_U 0x55
#define XPLM_VK_U 0x55
#define XPLM_VK_V 0x56
#define XPLM_VK_V 0x56
#define XPLM_VK_W 0x57
#define XPLM_VK_W 0x57
#define XPLM_VK_X 0x58
#define XPLM_VK_X 0x58
#define XPLM_VK_Y 0x59
#define XPLM_VK_Y 0x59
#define XPLM_VK_Z 0x5A
#define XPLM_VK_Z 0x5A
#define XPLM_VK_NUMPAD0 0x60
#define XPLM_VK_NUMPAD0 0x60
#define XPLM_VK_NUMPAD1 0x61
#define XPLM_VK_NUMPAD1 0x61
#define XPLM_VK_NUMPAD2 0x62
#define XPLM_VK_NUMPAD2 0x62
#define XPLM_VK_NUMPAD3 0x63
#define XPLM_VK_NUMPAD3 0x63
#define XPLM_VK_NUMPAD4 0x64
#define XPLM_VK_NUMPAD4 0x64
#define XPLM_VK_NUMPAD5 0x65
#define XPLM_VK_NUMPAD5 0x65
#define XPLM_VK_NUMPAD6 0x66
#define XPLM_VK_NUMPAD6 0x66
#define XPLM_VK_NUMPAD7 0x67
#define XPLM_VK_NUMPAD7 0x67
#define XPLM_VK_NUMPAD8 0x68
#define XPLM_VK_NUMPAD8 0x68
#define XPLM_VK_NUMPAD9 0x69
#define XPLM_VK_NUMPAD9 0x69
#define XPLM_VK_MULTIPLY 0x6A
#define XPLM_VK_MULTIPLY 0x6A
#define XPLM_VK_ADD 0x6B
#define XPLM_VK_ADD 0x6B
#define XPLM_VK_SEPARATOR 0x6C
#define XPLM_VK_SEPARATOR 0x6C
#define XPLM_VK_SUBTRACT 0x6D
#define XPLM_VK_SUBTRACT 0x6D
#define XPLM_VK_DECIMAL 0x6E
#define XPLM_VK_DECIMAL 0x6E
#define XPLM_VK_DIVIDE 0x6F
#define XPLM_VK_DIVIDE 0x6F
#define XPLM_VK_F1 0x70
#define XPLM_VK_F1 0x70
#define XPLM_VK_F2 0x71
#define XPLM_VK_F2 0x71
#define XPLM_VK_F3 0x72
#define XPLM_VK_F3 0x72
#define XPLM_VK_F4 0x73
#define XPLM_VK_F4 0x73
#define XPLM_VK_F5 0x74
#define XPLM_VK_F5 0x74
#define XPLM_VK_F6 0x75
#define XPLM_VK_F6 0x75
#define XPLM_VK_F7 0x76
#define XPLM_VK_F7 0x76
#define XPLM_VK_F8 0x77
#define XPLM_VK_F8 0x77
#define XPLM_VK_F9 0x78
#define XPLM_VK_F9 0x78
#define XPLM_VK_F10 0x79
#define XPLM_VK_F10 0x79
#define XPLM_VK_F11 0x7A
#define XPLM_VK_F11 0x7A
#define XPLM_VK_F12 0x7B
#define XPLM_VK_F12 0x7B
#define XPLM_VK_F13 0x7C
#define XPLM_VK_F13 0x7C
#define XPLM_VK_F14 0x7D
#define XPLM_VK_F14 0x7D
#define XPLM_VK_F15 0x7E
#define XPLM_VK_F15 0x7E
#define XPLM_VK_F16 0x7F
#define XPLM_VK_F16 0x7F
#define XPLM_VK_F17 0x80
#define XPLM_VK_F17 0x80
#define XPLM_VK_F18 0x81
#define XPLM_VK_F18 0x81
#define XPLM_VK_F19 0x82
#define XPLM_VK_F19 0x82
#define XPLM_VK_F20 0x83
#define XPLM_VK_F20 0x83
#define XPLM_VK_F21 0x84
#define XPLM_VK_F21 0x84
#define XPLM_VK_F22 0x85
#define XPLM_VK_F22 0x85
#define XPLM_VK_F23 0x86
#define XPLM_VK_F23 0x86
#define XPLM_VK_F24 0x87
#define XPLM_VK_F24 0x87
/* The following definitions are extended and are not based on the Microsoft *
* key set. */
#define XPLM_VK_EQUAL 0xB0
/* The following definitions are extended and are not based on the Microsoft *
* key set. */
#define XPLM_VK_EQUAL 0xB0
#define XPLM_VK_MINUS 0xB1
#define XPLM_VK_MINUS 0xB1
#define XPLM_VK_RBRACE 0xB2
#define XPLM_VK_RBRACE 0xB2
#define XPLM_VK_LBRACE 0xB3
#define XPLM_VK_LBRACE 0xB3
#define XPLM_VK_QUOTE 0xB4
#define XPLM_VK_QUOTE 0xB4
#define XPLM_VK_SEMICOLON 0xB5
#define XPLM_VK_SEMICOLON 0xB5
#define XPLM_VK_BACKSLASH 0xB6
#define XPLM_VK_BACKSLASH 0xB6
#define XPLM_VK_COMMA 0xB7
#define XPLM_VK_COMMA 0xB7
#define XPLM_VK_SLASH 0xB8
#define XPLM_VK_SLASH 0xB8
#define XPLM_VK_PERIOD 0xB9
#define XPLM_VK_PERIOD 0xB9
#define XPLM_VK_BACKQUOTE 0xBA
#define XPLM_VK_BACKQUOTE 0xBA
#define XPLM_VK_ENTER 0xBB
#define XPLM_VK_ENTER 0xBB
#define XPLM_VK_NUMPAD_ENT 0xBC
#define XPLM_VK_NUMPAD_ENT 0xBC
#define XPLM_VK_NUMPAD_EQ 0xBD
#define XPLM_VK_NUMPAD_EQ 0xBD
#ifdef __cplusplus
}
XPSDK/CHeaders/XPLM/XPLMDisplay.h
+1305 -390
View File
File diff suppressed because it is too large Load Diff
XPSDK/CHeaders/XPLM/XPLMGraphics.h
+209 -185
View File
@@ -2,17 +2,15 @@
#define _XPLMGraphics_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMGraphics
***************************************************************************/
/*
* Graphics routines for X-Plane and OpenGL.
*
* A few notes on coordinate systems:
*
* X-Plane uses three kinds of coordinates. Global coordinates are specified
@@ -26,18 +24,19 @@
* not truly straight up and down at other points). The Z axis is aligned
* north-south at 0, 0, 0 with positive Z pointing south (but since the earth
* is round it isn't exactly north-south as you move east or west of 0, 0, 0).
* One unit is one meter and the point 0,0,0 is on the surface of the earth
* at sea level for some latitude and longitude picked by the sim such that
* the user's aircraft is reasonably nearby.
* One unit is one meter and the point 0,0,0 is on the surface of the earth at
* sea level for some latitude and longitude picked by the sim such that the
* user's aircraft is reasonably nearby.
*
* Cockpit coordinates are 2d, with the X axis horizontal and the Y axis
* vertical. The point 0,0 is the bottom left and 1024,768 is the upper right
* of the screen. This is true no matter what resolution the user's monitor is
* in; when running in higher resolution, graphics will be scaled.
* 2-d Panel coordinates are 2d, with the X axis horizontal and the Y axis
* vertical. The point 0,0 is the bottom left and 1024,768 is the upper
* right of the screen. This is true no matter what resolution the user's
* monitor is in; when running in higher resolution, graphics will be
* scaled.
*
* Use X-Plane's routines to convert between global and local coordinates. Do
* not attempt to do this conversion yourself; the precise 'roundness' of
* X-Plane's physics model may not match your own, and (to make things
* X-Plane's physics model may not match your own, and (to make things
* weirder) the user can potentially customize the physics of the current
* planet.
*
@@ -64,19 +63,25 @@ extern "C" {
* XPLM Texture IDs name well-known textures in the sim for you to use. This
* allows you to recycle textures from X-Plane, saving VRAM.
*
* *Warning*: do not use these enums. The only remaining use they have is to
* access the legacy compatibility v10 UI texture; if you need this, get it
* via the Widgets library.
*
*/
enum {
/* The bitmap that contains window outlines, button outlines, fonts, etc. */
xplm_Tex_GeneralInterface = 0
/* The bitmap that contains window outlines, button outlines, fonts, etc. */
xplm_Tex_GeneralInterface = 0,
/* The exterior paint for the user's aircraft (daytime). */
,
xplm_Tex_AircraftPaint = 1
#if defined(XPLM_DEPRECATED)
/* The exterior paint for the user's aircraft (daytime). */
xplm_Tex_AircraftPaint = 1,
/* The exterior light map for the user's aircraft. */
,
xplm_Tex_AircraftLiteMap = 2
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* The exterior light map for the user's aircraft. */
xplm_Tex_AircraftLiteMap = 2,
#endif /* XPLM_DEPRECATED */
};
typedef int XPLMTextureID;
@@ -84,31 +89,28 @@ typedef int XPLMTextureID;
/*
* XPLMSetGraphicsState
*
* XPLMSetGraphicsState changes OpenGL's graphics state in a number of ways:
* XPLMSetGraphicsState changes OpenGL's fixed function pipeline state. You
* are not responsible for restoring any state that is accessed via
* XPLMSetGraphicsState, but you are responsible for not accessing this state
* directly.
*
* inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG);
*
* inNumberTexUnits - enables or disables a number of multitexturing units. If
* the number is 0, 2d texturing is disabled entirely, as in
* glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a
* number of multitexturing units are enabled sequentially, starting with
* unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable
* (GL_TEXTURE_2D);
*
* inEnableLighting - enables or disables OpenGL lighting, e.g.
* glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);
*
* inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g.
* glEnable(GL_ALPHA_TEST);
*
* inEnableAlphaBlending - enables or disables alpha blending per pixel, e.g.
* glEnable(GL_BLEND);
*
* inEnableDepthTesting - enables per pixel depth testing, as in
* glEnable(GL_DEPTH_TEST);
*
* inEnableDepthWriting - enables writing back of depth information to the
* depth bufffer, as in glDepthMask(GL_TRUE);
* - inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG);
* - inNumberTexUnits - enables or disables a number of multitexturing units.
* If the number is 0, 2d texturing is disabled entirely, as in
* glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a
* number of multitexturing units are enabled sequentially, starting with
* unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable
* (GL_TEXTURE_2D);
* - inEnableLighting - enables or disables OpenGL lighting, e.g.
* glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);
* - inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g.
* glEnable(GL_ALPHA_TEST);
* - inEnableAlphaBlending - enables or disables alpha blending per pixel,
* e.g. glEnable(GL_BLEND);
* - inEnableDepthTesting - enables per pixel depth testing, as in
* glEnable(GL_DEPTH_TEST);
* - inEnableDepthWriting - enables writing back of depth information to the
* depth bufffer, as in glDepthMask(GL_TRUE);
*
* The purpose of this function is to change OpenGL state while keeping
* X-Plane aware of the state changes; this keeps X-Plane from getting
@@ -116,73 +118,77 @@ typedef int XPLMTextureID;
* having to set all state before all draws; XPLMSetGraphicsState internally
* skips calls to change state that is already properly enabled.
*
* X-Plane does not have a 'default' OGL state to plug-ins; plug-ins should
* totally set OGL state before drawing. Use XPLMSetGraphicsState instead of
* any of the above OpenGL calls.
* X-Plane does not have a 'default' OGL state for plug-ins with respect to
* the above state vector; plug-ins should totally set OGL state using this
* API before drawing. Use XPLMSetGraphicsState instead of any of the above
* OpenGL calls.
*
* WARNING: Any routine that performs drawing (e.g. XPLMDrawString or widget
* code) may change X-Plane's state. Always set state before drawing after
* unknown code has executed.
*
* *Deprecation Warnings*: X-Plane's lighting and fog environemnt is
* significantly more complex than the fixed function pipeline can express;
* do not assume that lighting and fog state is a good approximation for 3-d
* drawing. Prefer to use XPLMInstancing to draw objects. All calls to
* XPLMSetGraphicsState should have no fog or lighting.
*
*/
XPLM_API void XPLMSetGraphicsState(int inEnableFog,
int inNumberTexUnits,
int inEnableLighting,
int inEnableAlphaTesting,
int inEnableAlphaBlending,
int inEnableDepthTesting,
int inEnableDepthWriting);
XPLM_API void XPLMSetGraphicsState(
int inEnableFog,
int inNumberTexUnits,
int inEnableLighting,
int inEnableAlphaTesting,
int inEnableAlphaBlending,
int inEnableDepthTesting,
int inEnableDepthWriting);
/*
* XPLMBindTexture2d
*
* XPLMBindTexture2d changes what texture is bound to the 2d texturing target.
* This routine caches the current 2d texture across all texturing units in
* the sim and plug-ins, preventing extraneous binding. For example, consider
* several plug-ins running in series; if they all use the 'general interface'
* bitmap to do UI, calling this function will skip the rebinding of the
* general interface texture on all but the first plug-in, which can provide
* better frame rate son some graphics cards.
* XPLMBindTexture2d changes what texture is bound to the 2d texturing
* target. This routine caches the current 2d texture across all texturing
* units in the sim and plug-ins, preventing extraneous binding. For
* example, consider several plug-ins running in series; if they all use the
* 'general interface' bitmap to do UI, calling this function will skip the
* rebinding of the general interface texture on all but the first plug-in,
* which can provide better frame rate son some graphics cards.
*
* inTextureID is the ID of the texture object to bind; inTextureUnit is a
* zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4
* units. (This number may increase in future versions of x-plane.)
* zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4
* units. (This number may increase in future versions of X-Plane.)
*
* Use this routine instead of glBindTexture(GL_TEXTURE_2D, ....);
*
*/
XPLM_API void XPLMBindTexture2d(int inTextureNum, int inTextureUnit);
XPLM_API void XPLMBindTexture2d(
int inTextureNum,
int inTextureUnit);
/*
* XPLMGenerateTextureNumbers
*
* This routine generates unused texture numbers that a plug-in can use to
* safely bind textures. Use this routine instead of glGenTextures;
* glGenTextures will allocate texture numbers in ranges that X-Plane reserves
* for its own use but does not always use; for example, it might provide an
* ID within the range of textures reserved for terrain...loading a new .env
* file as the plane flies might then cause X-Plane to use this texture ID.
* X-Plane will then overwrite the plug-ins texture. This routine returns
* texture IDs that are out of X-Plane's usage range.
* Use this routine instead of glGenTextures to generate new texture object
* IDs. This routine historically ensured that plugins don't use texure IDs
* that X-Plane is reserving for its own use.
*
*/
XPLM_API void XPLMGenerateTextureNumbers(int *outTextureIDs, int inCount);
XPLM_API void XPLMGenerateTextureNumbers(
int * outTextureIDs,
int inCount);
#if defined(XPLM_DEPRECATED)
/*
* XPLMGetTexture
*
* XPLMGetTexture returns the OpenGL texture enumeration of an X-Plane texture
* based on a generic identifying code. For example, you can get the texture
* for X-Plane's UI bitmaps. This allows you to build new gauges that take
* advantage of x-plane's textures, for smooth artwork integration and also
* saving texture memory. Note that the texture might not be loaded yet,
* depending on what the plane's panel contains.
*
* OPEN ISSUE: We really need a way to make sure X-Plane loads this texture if
* it isn't around, or at least a way to find out whether it is loaded or not.
* XPLMGetTexture returns the OpenGL texture ID of an X-Plane texture based on
* a generic identifying code. For example, you can get the texture for
* X-Plane's UI bitmaps.
*
*/
XPLM_API int XPLMGetTexture(XPLMTextureID inTexture);
XPLM_API int XPLMGetTexture(
XPLMTextureID inTexture);
#endif /* XPLM_DEPRECATED */
/*
* XPLMWorldToLocal
@@ -193,12 +199,13 @@ XPLM_API int XPLMGetTexture(XPLMTextureID inTexture);
* meters in the local OpenGL coordinate system.
*
*/
XPLM_API void XPLMWorldToLocal(double inLatitude,
double inLongitude,
double inAltitude,
double *outX,
double *outY,
double *outZ);
XPLM_API void XPLMWorldToLocal(
double inLatitude,
double inLongitude,
double inAltitude,
double * outX,
double * outY,
double * outZ);
/*
* XPLMLocalToWorld
@@ -212,12 +219,13 @@ XPLM_API void XPLMWorldToLocal(double inLatitude,
* try to avoid round tripping from local to world and back.
*
*/
XPLM_API void XPLMLocalToWorld(double inX,
double inY,
double inZ,
double *outLatitude,
double *outLongitude,
double *outAltitude);
XPLM_API void XPLMLocalToWorld(
double inX,
double inY,
double inZ,
double * outLatitude,
double * outLongitude,
double * outAltitude);
/*
* XPLMDrawTranslucentDarkBox
@@ -227,19 +235,15 @@ XPLM_API void XPLMLocalToWorld(double inX,
* used by X-Plane to show text files and ATC info.
*
*/
XPLM_API void XPLMDrawTranslucentDarkBox(int inLeft,
int inTop,
int inRight,
int inBottom);
XPLM_API void XPLMDrawTranslucentDarkBox(
int inLeft,
int inTop,
int inRight,
int inBottom);
/***************************************************************************
* X-PLANE TEXT
***************************************************************************/
/*
*
*
*/
/*
* XPLMFontID
@@ -257,82 +261,97 @@ XPLM_API void XPLMDrawTranslucentDarkBox(int inLeft,
*
*/
enum {
/* Mono-spaced font for user interface. Available in all versions of the
SDK. */
xplmFont_Basic = 0
/* Mono-spaced font for user interface. Available in all versions of the SDK.*/
xplmFont_Basic = 0,
/* Deprecated, do not use. */
,
xplmFont_Menus = 1
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_Menus = 1,
/* Deprecated, do not use. */
,
xplmFont_Metal = 2
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_Metal = 2,
/* Deprecated, do not use. */
,
xplmFont_Led = 3
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_Led = 3,
/* Deprecated, do not use. */
,
xplmFont_LedWide = 4
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_LedWide = 4,
/* Deprecated, do not use. */
,
xplmFont_PanelHUD = 5
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_PanelHUD = 5,
/* Deprecated, do not use. */
,
xplmFont_PanelEFIS = 6
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_PanelEFIS = 6,
/* Deprecated, do not use. */
,
xplmFont_PanelGPS = 7
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_PanelGPS = 7,
/* Deprecated, do not use. */
,
xplmFont_RadiosGA = 8
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_RadiosGA = 8,
/* Deprecated, do not use. */
,
xplmFont_RadiosBC = 9
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_RadiosBC = 9,
/* Deprecated, do not use. */
,
xplmFont_RadiosHM = 10
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_RadiosHM = 10,
/* Deprecated, do not use. */
,
xplmFont_RadiosGANarrow = 11
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_RadiosGANarrow = 11,
/* Deprecated, do not use. */
,
xplmFont_RadiosBCNarrow = 12
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_RadiosBCNarrow = 12,
/* Deprecated, do not use. */
,
xplmFont_RadiosHMNarrow = 13
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_RadiosHMNarrow = 13,
/* Deprecated, do not use. */
,
xplmFont_Timer = 14
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_Timer = 14,
/* Deprecated, do not use. */
,
xplmFont_FullRound = 15
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_FullRound = 15,
/* Deprecated, do not use. */
,
xplmFont_SmallRound = 16
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_SmallRound = 16,
/* Deprecated, do not use. */
,
xplmFont_Menus_Localized = 17
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/* Deprecated, do not use. */
xplmFont_Menus_Localized = 17,
#endif /* XPLM_DEPRECATED */
#if defined(XPLM200)
/* Proportional UI font. */
,
xplmFont_Proportional = 18
/* Proportional UI font. */
xplmFont_Proportional = 18,
#endif /* XPLM200 */
@@ -350,12 +369,13 @@ typedef int XPLMFontID;
* to 1.0.
*
*/
XPLM_API void XPLMDrawString(float *inColorRGB,
int inXOffset,
int inYOffset,
char *inChar,
int *inWordWrapWidth, /* Can be NULL */
XPLMFontID inFontID);
XPLM_API void XPLMDrawString(
float * inColorRGB,
int inXOffset,
int inYOffset,
char * inChar,
int * inWordWrapWidth, /* Can be NULL */
XPLMFontID inFontID);
/*
* XPLMDrawNumber
@@ -363,19 +383,20 @@ XPLM_API void XPLMDrawString(float *inColorRGB,
* This routine draws a number similar to the digit editing fields in
* PlaneMaker and data output display in X-Plane. Pass in a color, a
* position, a floating point value, and formatting info. Specify how many
* integer and how many decimal digits to show and whether to show a sign, as
* integer and how many decimal digits to show and whether to show a sign, as
* well as a character set. This routine returns the xOffset plus width of the
* string drawn.
*
*/
XPLM_API void XPLMDrawNumber(float *inColorRGB,
int inXOffset,
int inYOffset,
double inValue,
int inDigits,
int inDecimals,
int inShowSign,
XPLMFontID inFontID);
XPLM_API void XPLMDrawNumber(
float * inColorRGB,
int inXOffset,
int inYOffset,
double inValue,
int inDigits,
int inDecimals,
int inShowSign,
XPLMFontID inFontID);
/*
* XPLMGetFontDimensions
@@ -386,10 +407,11 @@ XPLM_API void XPLMDrawNumber(float *inColorRGB,
* will be an arbitrary, hopefully average width.
*
*/
XPLM_API void XPLMGetFontDimensions(XPLMFontID inFontID,
int *outCharWidth, /* Can be NULL */
int *outCharHeight, /* Can be NULL */
int *outDigitsOnly); /* Can be NULL */
XPLM_API void XPLMGetFontDimensions(
XPLMFontID inFontID,
int * outCharWidth, /* Can be NULL */
int * outCharHeight, /* Can be NULL */
int * outDigitsOnly); /* Can be NULL */
#if defined(XPLM200)
/*
@@ -402,8 +424,10 @@ XPLM_API void XPLMGetFontDimensions(XPLMFontID inFontID,
* for fractional pixels.
*
*/
XPLM_API float
XPLMMeasureString(XPLMFontID inFontID, const char *inChar, int inNumChars);
XPLM_API float XPLMMeasureString(
XPLMFontID inFontID,
const char * inChar,
int inNumChars);
#endif /* XPLM200 */
#ifdef __cplusplus
XPSDK/CHeaders/XPLM/XPLMInstance.h
+136
View File
@@ -0,0 +1,136 @@
#ifndef _XPLMInstance_h_
#define _XPLMInstance_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMInstance
***************************************************************************/
/*
* This API provides instanced drawing of X-Plane objects (.obj files). In
* contrast to old drawing APIs, which required you to draw your own objects
* per-frame, the instancing API allows you to simply register an OBJ for
* drawing, then move or manipulate it later (as needed).
*
* This provides one tremendous benefit: it keeps all dataref operations for
* your object in one place. Because datarefs are main thread only, allowing
* dataref access anywhere is a serious performance bottleneck for the
* simulator---the whole simulator has to pause and wait for each dataref
* access. This performance penalty will only grow worse as X-Plane moves
* toward an ever more heavily multithreaded engine.
*
* The instancing API allows X-Plane to isolate all dataref manipulations for
* all plugin object drawing to one place, potentially providing huge
* performance gains.
*
* Here's how it works:
*
* When an instance is created, it provides a list of all datarefs you want to
* manipulate in for the OBJ in the future. This list of datarefs replaces the
* ad-hoc collections of dataref objects previously used by art assets. Then,
* per-frame, you can manipulate the instance by passing in a "block" of
* packed floats representing the current values of the datarefs for your
* instance. (Note that the ordering of this set of packed floats must exactly
* match the ordering of the datarefs when you created your instance.)
*
*/
#include "XPLMDefs.h"
#include "XPLMScenery.h"
#ifdef __cplusplus
extern "C" {
#endif
/***************************************************************************
* Instance Creation and Destruction
***************************************************************************/
/*
* Registers and unregisters instances.
*
*/
/*
* XPLMInstanceRef
*
* An opaque handle to an instance.
*
*/
typedef void * XPLMInstanceRef;
/*
* XPLMCreateInstance
*
* XPLMCreateInstance creates a new instance, managed by your plug-in, and
* returns a handle to the instance. A few important requirements:
*
* * The object passed in must be fully loaded and returned from the XPLM
* before you can create your instance; you cannot pass a null obj ref, nor
* can you change the ref later.
*
* * If you use any custom datarefs in your object, they must be registered
* before the object is loaded. This is true even if their data will be
* provided via the instance dataref list.
*
* * The instance dataref array must be a valid ptr to an array of at least
* one item that is null terminated. That is, if you do not want any
* datarefs, you must passa ptr to an array with a null item. You cannot
* pass null for this.
*
*/
XPLM_API XPLMInstanceRef XPLMCreateInstance(
XPLMObjectRef obj,
const char ** datarefs);
/*
* XPLMDestroyInstance
*
* XPLMDestroyInstance destroys and deallocates your instance; once called,
* you are still responsible for releasing the OBJ ref.
*
* Tip: you can release your OBJ ref after you call XPLMCreateInstance as long
* as you never use it again; the instance will maintain its own reference to
* the OBJ and the object OBJ be deallocated when the instance is destroyed.
*
*/
XPLM_API void XPLMDestroyInstance(
XPLMInstanceRef instance);
/***************************************************************************
* Instance Manipulation
***************************************************************************/
/*
* XPLMInstanceSetPosition
*
* Updates both the position of the instance and all datarefs you registered
* for it. Call this from a flight loop callback or UI callback.
*
* __DO NOT__ call XPLMInstanceSetPosition from a drawing callback; the whole
* point of instancing is that you do not need any drawing callbacks. Setting
* instance data from a drawing callback may have undefined consequences, and
* the drawing callback hurts FPS unnecessarily.
*
* The memory pointed to by the data pointer must be large enough to hold one
* float for every data ref you have registered, and must contain valid
* floating point data.
*
* BUG: before X-Plane 11.50, if you have no dataref registered, you must
* still pass a valid pointer for data and not null.
*
*/
XPLM_API void XPLMInstanceSetPosition(
XPLMInstanceRef instance,
const XPLMDrawInfo_t * new_position,
const float * data);
#ifdef __cplusplus
}
#endif
#endif
XPSDK/CHeaders/XPLM/XPLMMap.h
+628
View File
@@ -0,0 +1,628 @@
#ifndef _XPLMMap_h_
#define _XPLMMap_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMMap
***************************************************************************/
/*
* This API allows you to create new layers within X-Plane maps. Your layers
* can draw arbitrary OpenGL, but they conveniently also have access to
* X-Plane's built-in icon and label drawing functions.
*
* As of X-Plane 11, map drawing happens in three stages:
*
* 1. backgrounds and "fill,"
* 2. icons, and
* 3. labels.
*
* Thus, all background drawing gets layered beneath all icons, which likewise
* get layered beneath all labels. Within each stage, the map obeys a
* consistent layer ordering, such that "fill" layers (layers that cover a
* large amount of map area, like the terrain and clouds) appear beneath
* "markings" layers (like airport icons). This ensures that layers with fine
* details don't get obscured by layers with larger details.
*
* The XPLM map API reflects both aspects of this draw layering: you can
* register a layer as providing either markings or fill, and X-Plane will
* draw your fill layers beneath your markings layers (regardless of
* registration order). Likewise, you are guaranteed that your layer's icons
* (added from within an icon callback) will go above your layer's OpenGL
* drawing, and your labels will go above your icons.
*
* The XPLM guarantees that all plugin-created fill layers go on top of all
* native X-Plane fill layers, and all plugin-created markings layers go on
* top of all X-Plane markings layers (with the exception of the aircraft
* icons). It also guarantees that the draw order of your own plugin's layers
* will be consistent. But, for layers created by different plugins, the only
* guarantee is that we will draw all of one plugin's layers of each type
* (fill, then markings), then all of the others'; we don't guarantee which
* plugin's fill and markings layers go on top of the other's.
*
* As of X-Plane 11, maps use true cartographic projections for their drawing,
* and different maps may use different projections. For that reason, all
* drawing calls include an opaque handle for the projection you should use to
* do the drawing. Any time you would draw at a particular latitude/longitude,
* you'll need to ask the projection to translate that position into "map
* coordinates." (Note that the projection is guaranteed not to change between
* calls to your prepare-cache hook, so if you cache your map coordinates
* ahead of time, there's no need to re-project them when you actually draw.)
*
* In addition to mapping normal latitude/longitude locations into map
* coordinates, the projection APIs also let you know the current heading for
* north. (Since X-Plane 11 maps can rotate to match the heading of the user's
* aircraft, it's not safe to assume that north is at zero degrees rotation.)
*
*/
#include "XPLMDefs.h"
#ifdef __cplusplus
extern "C" {
#endif
#if defined(XPLM300)
/***************************************************************************
* DRAWING CALLBACKS
***************************************************************************/
/*
* When you create a new map layer (using XPLMCreateMapLayer), you can provide
* any or all of these callbacks. They allow you to insert your own OpenGL
* drawing, text labels, and icons into the X-Plane map at the appropriate
* places, allowing your layer to behave as similarly to X-Plane's built-in
* layers as possible.
*
*/
/*
* XPLMMapLayerID
*
* This is an opaque handle for a plugin-created map layer. Pass it to the map
* drawing APIs from an appropriate callback to draw in the layer you created.
*
*/
typedef void * XPLMMapLayerID;
/*
* XPLMMapProjectionID
*
* This is an opaque handle for a map projection. Pass it to the projection
* APIs to translate between map coordinates and latitude/longitudes.
*
*/
typedef void * XPLMMapProjectionID;
/*
* XPLMMapStyle
*
* Indicates the visual style being drawn by the map. In X-Plane, the user can
* choose between a number of map types, and different map types may have use
* a different visual representation for the same elements (for instance, the
* visual style of the terrain layer changes drastically between the VFR and
* IFR layers), or certain layers may be disabled entirely in some map types
* (e.g., localizers are only visible in the IFR low-enroute style).
*
*/
enum {
xplm_MapStyle_VFR_Sectional = 0,
xplm_MapStyle_IFR_LowEnroute = 1,
xplm_MapStyle_IFR_HighEnroute = 2,
};
typedef int XPLMMapStyle;
/*
* XPLMMapDrawingCallback_f
*
* This is the OpenGL map drawing callback for plugin-created map layers. You
* can perform arbitrary OpenGL drawing from this callback, with one
* exception: changes to the Z-buffer are not permitted, and will result in
* map drawing errors.
*
* All drawing done from within this callback appears beneath all built-in
* X-Plane icons and labels, but above the built-in "fill" layers (layers
* providing major details, like terrain and water). Note, however, that the
* relative ordering between the drawing callbacks of different plugins is not
* guaranteed.
*
*/
typedef void (* XPLMMapDrawingCallback_f)(
XPLMMapLayerID inLayer,
const float * inMapBoundsLeftTopRightBottom,
float zoomRatio,
float mapUnitsPerUserInterfaceUnit,
XPLMMapStyle mapStyle,
XPLMMapProjectionID projection,
void * inRefcon);
/*
* XPLMMapIconDrawingCallback_f
*
* This is the icon drawing callback that enables plugin-created map layers to
* draw icons using X-Plane's built-in icon drawing functionality. You can
* request an arbitrary number of PNG icons to be drawn via
* XPLMDrawMapIconFromSheet() from within this callback, but you may not
* perform any OpenGL drawing here.
*
* Icons enqueued by this function will appear above all OpenGL drawing
* (performed by your optional XPLMMapDrawingCallback_f), and above all
* built-in X-Plane map icons of the same layer type ("fill" or "markings," as
* determined by the XPLMMapLayerType in your XPLMCreateMapLayer_t). Note,
* however, that the relative ordering between the drawing callbacks of
* different plugins is not guaranteed.
*
*/
typedef void (* XPLMMapIconDrawingCallback_f)(
XPLMMapLayerID inLayer,
const float * inMapBoundsLeftTopRightBottom,
float zoomRatio,
float mapUnitsPerUserInterfaceUnit,
XPLMMapStyle mapStyle,
XPLMMapProjectionID projection,
void * inRefcon);
/*
* XPLMMapLabelDrawingCallback_f
*
* This is the label drawing callback that enables plugin-created map layers
* to draw text labels using X-Plane's built-in labeling functionality. You
* can request an arbitrary number of text labels to be drawn via
* XPLMDrawMapLabel() from within this callback, but you may not perform any
* OpenGL drawing here.
*
* Labels enqueued by this function will appear above all OpenGL drawing
* (performed by your optional XPLMMapDrawingCallback_f), and above all
* built-in map icons and labels of the same layer type ("fill" or "markings,"
* as determined by the XPLMMapLayerType in your XPLMCreateMapLayer_t). Note,
* however, that the relative ordering between the drawing callbacks of
* different plugins is not guaranteed.
*
*/
typedef void (* XPLMMapLabelDrawingCallback_f)(
XPLMMapLayerID inLayer,
const float * inMapBoundsLeftTopRightBottom,
float zoomRatio,
float mapUnitsPerUserInterfaceUnit,
XPLMMapStyle mapStyle,
XPLMMapProjectionID projection,
void * inRefcon);
#endif /* XPLM300 */
#if defined(XPLM300)
/***************************************************************************
* LAYER MANAGEMENT CALLBACKS
***************************************************************************/
/*
* These are various "bookkeeping" callbacks that your map layer can receive
* (if you provide the callback in your XPLMCreateMapLayer_t). They allow you
* to manage the lifecycle of your layer, as well as cache any
* computationally-intensive preparation you might need for drawing.
*
*/
/*
* XPLMMapPrepareCacheCallback_f
*
* A callback used to allow you to cache whatever information your layer needs
* to draw in the current map area.
*
* This is called each time the map's total bounds change. This is typically
* triggered by new DSFs being loaded, such that X-Plane discards old,
* now-distant DSFs and pulls in new ones. At that point, the available bounds
* of the map also change to match the new DSF area.
*
* By caching just the information you need to draw in this area, your future
* draw calls can be made faster, since you'll be able to simply "splat" your
* precomputed information each frame.
*
* We guarantee that the map projection will not change between successive
* prepare cache calls, nor will any draw call give you bounds outside these
* total map bounds. So, if you cache the projected map coordinates of all the
* items you might want to draw in the total map area, you can be guaranteed
* that no draw call will be asked to do any new work.
*
*/
typedef void (* XPLMMapPrepareCacheCallback_f)(
XPLMMapLayerID inLayer,
const float * inTotalMapBoundsLeftTopRightBottom,
XPLMMapProjectionID projection,
void * inRefcon);
/*
* XPLMMapWillBeDeletedCallback_f
*
* Called just before your map layer gets deleted. Because SDK-created map
* layers have the same lifetime as the X-Plane map that contains them, if the
* map gets unloaded from memory, your layer will too.
*
*/
typedef void (* XPLMMapWillBeDeletedCallback_f)(
XPLMMapLayerID inLayer,
void * inRefcon);
#endif /* XPLM300 */
#if defined(XPLM300)
/***************************************************************************
* MAP LAYER CREATION AND DESTRUCTION
***************************************************************************/
/*
* Enables the creation of new map layers. Layers are created for a particular
* instance of the X-Plane map. For instance, if you want your layer to appear
* in both the normal map interface and the Instructor Operator Station (IOS),
* you would need two separate calls to XPLMCreateMapLayer(), with two
* different values for your XPLMCreateMapLayer_t::layer_name.
*
* Your layer's lifetime will be determined by the lifetime of the map it is
* created in. If the map is destroyed (on the X-Plane side), your layer will
* be too, and you'll receive a callback to your
* XPLMMapWillBeDeletedCallback_f.
*
*/
/*
* XPLMMapLayerType
*
* Indicates the type of map layer you are creating. Fill layers will always
* be drawn beneath markings layers.
*
*/
enum {
/* A layer that draws "fill" graphics, like weather patterns, terrain, etc. *
* Fill layers frequently cover a large portion of the visible map area. */
xplm_MapLayer_Fill = 0,
/* A layer that provides markings for particular map features, like NAVAIDs, *
* airports, etc. Even dense markings layers cover a small portion of the *
* total map area. */
xplm_MapLayer_Markings = 1,
};
typedef int XPLMMapLayerType;
/* Globally unique identifier for X-Plane's Map window, used as the *
* mapToCreateLayerIn parameter in XPLMCreateMapLayer_t */
#define XPLM_MAP_USER_INTERFACE "XPLM_MAP_USER_INTERFACE"
/* Globally unique identifier for X-Plane's Instructor Operator Station *
* window, used as the mapToCreateLayerIn parameter in XPLMCreateMapLayer_t */
#define XPLM_MAP_IOS "XPLM_MAP_IOS"
/*
* XPLMCreateMapLayer_t
*
* This structure defines all of the parameters used to create a map layer
* using XPLMCreateMapLayer. The structure will be expanded in future SDK APIs
* to include more features. Always set the structSize member to the size of
* your struct in bytes!
*
* Each layer must be associated with exactly one map instance in X-Plane.
* That map, and that map alone, will call your callbacks. Likewise, when that
* map is deleted, your layer will be as well.
*
*/
typedef struct {
/* Used to inform XPLMCreateMapLayer() of the SDK version you compiled *
* against; should always be set to sizeof(XPLMCreateMapLayer_t) */
int structSize;
/* Globally unique string identifying the map you want this layer to appear *
* in. As of XPLM300, this is limited to one of XPLM_MAP_USER_INTERFACE or *
* XPLM_MAP_IOS */
const char * mapToCreateLayerIn;
/* The type of layer you are creating, used to determine draw order (all *
* plugin-created markings layers are drawn above all plugin-created fill *
* layers) */
XPLMMapLayerType layerType;
/* Optional callback to inform you this layer is being deleted (due to its *
* owning map being destroyed) */
XPLMMapWillBeDeletedCallback_f willBeDeletedCallback;
/* Optional callback you want to use to prepare your draw cache when the map *
* bounds change (set to NULL if you don't want this callback) */
XPLMMapPrepareCacheCallback_f prepCacheCallback;
/* Optional callback you want to use for arbitrary OpenGL drawing, which goes *
* beneath all icons in the map's layering system (set to NULL if you don't *
* want this callback) */
XPLMMapDrawingCallback_f drawCallback;
/* Optional callback you want to use for drawing icons, which go above all *
* built-in X-Plane icons (except the aircraft) in the map's layering system *
* (set to NULL if you don't want this callback) */
XPLMMapIconDrawingCallback_f iconCallback;
/* Optional callback you want to use for drawing map labels, which go above *
* all built-in X-Plane icons and labels (except those of aircraft) in the *
* map's layering system (set to NULL if you don't want this callback) */
XPLMMapLabelDrawingCallback_f labelCallback;
/* True if you want a checkbox to be created in the map UI to toggle this *
* layer on and off; false if the layer should simply always be enabled */
int showUiToggle;
/* Short label to use for this layer in the user interface */
const char * layerName;
/* A reference to arbitrary data that will be passed to your callbacks */
void * refcon;
} XPLMCreateMapLayer_t;
/*
* XPLMCreateMapLayer
*
* This routine creates a new map layer. You pass in an XPLMCreateMapLayer_t
* structure with all of the fields set in. You must set the structSize of
* the structure to the size of the actual structure you used.
*
* Returns NULL if the layer creation failed. This happens most frequently
* because the map you specified in your
* XPLMCreateMapLayer_t::mapToCreateLayerIn field doesn't exist (that is, if
* XPLMMapExists() returns 0 for the specified map). You can use
* XPLMRegisterMapCreationHook() to get a notification each time a new map is
* opened in X-Plane, at which time you can create layers in it.
*
*/
XPLM_API XPLMMapLayerID XPLMCreateMapLayer(
XPLMCreateMapLayer_t * inParams);
/*
* XPLMDestroyMapLayer
*
* Destroys a map layer you created (calling your
* XPLMMapWillBeDeletedCallback_f if applicable). Returns true if a deletion
* took place.
*
*/
XPLM_API int XPLMDestroyMapLayer(
XPLMMapLayerID inLayer);
/*
* XPLMMapCreatedCallback_f
*
* A callback to notify your plugin that a new map has been created in
* X-Plane. This is the best time to add a custom map layer using
* XPLMCreateMapLayer().
*
* No OpenGL drawing is permitted within this callback.
*
*/
typedef void (* XPLMMapCreatedCallback_f)(
const char * mapIdentifier,
void * refcon);
/*
* XPLMRegisterMapCreationHook
*
* Registers your callback to receive a notification each time a new map is
* constructed in X-Plane. This callback is the best time to add your custom
* map layer using XPLMCreateMapLayer().
*
* Note that you will not be notified about any maps that already exist---you
* can use XPLMMapExists() to check for maps that were created previously.
*
*/
XPLM_API void XPLMRegisterMapCreationHook(
XPLMMapCreatedCallback_f callback,
void * refcon);
/*
* XPLMMapExists
*
* Returns 1 if the map with the specified identifier already exists in
* X-Plane. In that case, you can safely call XPLMCreateMapLayer() specifying
* that your layer should be added to that map.
*
*/
XPLM_API int XPLMMapExists(
const char * mapIdentifier);
#endif /* XPLM300 */
#if defined(XPLM300)
/***************************************************************************
* MAP DRAWING
***************************************************************************/
/*
* These APIs are only valid from within a map drawing callback (one of
* XPLMIconDrawingCallback_t or XPLMMapLabelDrawingCallback_f). Your drawing
* callbacks are registered when you create a new map layer as part of your
* XPLMCreateMapLayer_t. The functions here hook into X-Plane's built-in map
* drawing functionality for icons and labels, so that you get a consistent
* style with the rest of the X-Plane map.
*
* Note that the X-Plane 11 map introduces a strict ordering: layers of type
* xplm_MapLayer_Fill get drawn beneath all xplm_MapLayer_Markings layers.
* Likewise, all OpenGL drawing (performed in your layer's
* XPLMMapDrawingCallback_f) will appear beneath any icons and labels you
* draw.
*
*/
/*
* XPLMMapOrientation
*
* Indicates whether a map element should be match its rotation to the map
* itself, or to the user interface. For instance, the map itself may be
* rotated such that "up" matches the user's aircraft, but you may want to
* draw a text label such that it is always rotated zero degrees relative to
* the user's perspective. In that case, you would have it draw with UI
* orientation.
*
*/
enum {
/* Orient such that a 0 degree rotation matches the map's north */
xplm_MapOrientation_Map = 0,
/* Orient such that a 0 degree rotation is "up" relative to the user interface*/
xplm_MapOrientation_UI = 1,
};
typedef int XPLMMapOrientation;
/*
* XPLMDrawMapIconFromSheet
*
* Enables plugin-created map layers to draw PNG icons using X-Plane's
* built-in icon drawing functionality. Only valid from within an
* XPLMIconDrawingCallback_t (but you can request an arbitrary number of icons
* to be drawn from within your callback).
*
* X-Plane will automatically manage the memory for your texture so that it
* only has to be loaded from disk once as long as you continue drawing it
* per-frame. (When you stop drawing it, the memory may purged in a "garbage
* collection" pass, require a load from disk in the future.)
*
* Instead of having X-Plane draw a full PNG, this method allows you to use UV
* coordinates to request a portion of the image to be drawn. This allows you
* to use a single texture load (of an icon sheet, for example) to draw many
* icons. Doing so is much more efficient than drawing a dozen different small
* PNGs.
*
* The UV coordinates used here treat the texture you load as being comprised
* of a number of identically sized "cells." You specify the width and height
* in cells (ds and dt, respectively), as well as the coordinates within the
* cell grid for the sub-image you'd like to draw.
*
* Note that you can use different ds and dt values in subsequent calls with
* the same texture sheet. This enables you to use icons of different sizes in
* the same sheet if you arrange them properly in the PNG.
*
* This function is only valid from within an XPLMIconDrawingCallback_t (but
* you can request an arbitrary number of icons to be drawn from within your
* callback).
*
*/
XPLM_API void XPLMDrawMapIconFromSheet(
XPLMMapLayerID layer,
const char * inPngPath,
int s,
int t,
int ds,
int dt,
float mapX,
float mapY,
XPLMMapOrientation orientation,
float rotationDegrees,
float mapWidth);
/*
* XPLMDrawMapLabel
*
* Enables plugin-created map layers to draw text labels using X-Plane's
* built-in labeling functionality. Only valid from within an
* XPLMMapLabelDrawingCallback_f (but you can request an arbitrary number of
* text labels to be drawn from within your callback).
*
*/
XPLM_API void XPLMDrawMapLabel(
XPLMMapLayerID layer,
const char * inText,
float mapX,
float mapY,
XPLMMapOrientation orientation,
float rotationDegrees);
#endif /* XPLM300 */
#if defined(XPLM300)
/***************************************************************************
* MAP PROJECTIONS
***************************************************************************/
/*
* As of X-Plane 11, the map draws using true cartographic projections, and
* different maps may use different projections. Thus, to draw at a particular
* latitude and longitude, you must first transform your real-world
* coordinates into map coordinates.
*
* The map projection is also responsible for giving you the current scale of
* the map. That is, the projection can tell you how many map units correspond
* to 1 meter at a given point.
*
* Finally, the map projection can give you the current rotation of the map.
* Since X-Plane 11 maps can rotate to match the heading of the aircraft, the
* map's rotation can potentially change every frame.
*
*/
/*
* XPLMMapProject
*
* Projects a latitude/longitude into map coordinates. This is the inverse of
* XPLMMapUnproject().
*
* Only valid from within a map layer callback (one of
* XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
* XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
*
*/
XPLM_API void XPLMMapProject(
XPLMMapProjectionID projection,
double latitude,
double longitude,
float * outX,
float * outY);
/*
* XPLMMapUnproject
*
* Transforms map coordinates back into a latitude and longitude. This is the
* inverse of XPLMMapProject().
*
* Only valid from within a map layer callback (one of
* XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
* XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
*
*/
XPLM_API void XPLMMapUnproject(
XPLMMapProjectionID projection,
float mapX,
float mapY,
double * outLatitude,
double * outLongitude);
/*
* XPLMMapScaleMeter
*
* Returns the number of map units that correspond to a distance of one meter
* at a given set of map coordinates.
*
* Only valid from within a map layer callback (one of
* XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
* XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
*
*/
XPLM_API float XPLMMapScaleMeter(
XPLMMapProjectionID projection,
float mapX,
float mapY);
/*
* XPLMMapGetNorthHeading
*
* Returns the heading (in degrees clockwise) from the positive Y axis in the
* cartesian mapping coordinate system to true north at the point passed in.
* You can use it as a clockwise rotational offset to align icons and other
* 2-d drawing with true north on the map, compensating for rotations in the
* map due to projection.
*
* Only valid from within a map layer callback (one of
* XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
* XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
*
*/
XPLM_API float XPLMMapGetNorthHeading(
XPLMMapProjectionID projection,
float mapX,
float mapY);
#endif /* XPLM300 */
#ifdef __cplusplus
}
#endif
#endif
XPSDK/CHeaders/XPLM/XPLMMenus.h
+138 -58
View File
@@ -2,27 +2,46 @@
#define _XPLMMenus_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMMenus
***************************************************************************/
/*
* XPLMMenus - Theory of Operation
*
* Plug-ins can create menus in the menu bar of X-Plane. This is done by
* Plug-ins can create menus in the menu bar of X-Plane. This is done by
* creating a menu and then creating items. Menus are referred to by an
* opaque ID. Items are referred to by index number. For each menu and item
* you specify a void *. Per menu you specify a handler function that is
* called with each void * when the menu item is picked. Menu item indices
* are zero based.
* opaque ID. Items are referred to by (zero-based) index number.
*
* Menus are "sandboxed" between plugins---no plugin can access the menus of
* any other plugin. Furthermore, all menu indices are relative to your
* plugin's menus only; if your plugin creates two sub-menus in the Plugins
* menu at different times, it doesn't matter how many other plugins also
* create sub-menus of Plugins in the intervening time: your sub-menus will be
* given menu indices 0 and 1. (The SDK does some work in the back-end to
* filter out menus that are irrelevant to your plugin in order to deliver
* this consistency for each plugin.)
*
* When you create a menu item, you specify how we should handle clicks on
* that menu item. You can either have the XPLM trigger a callback (the
* XPLMMenuHandler_f associated with the menu that contains the item), or you
* can simply have a command be triggered (with no associated call to your
* menu handler). The advantage of the latter method is that X-Plane will
* display any keyboard shortcuts associated with the command. (In contrast,
* there are no keyboard shortcuts associated with menu handler callbacks with
* specific parameters.)
*
* Menu text in X-Plane is UTF8; X-Plane's character set covers latin, greek
* and cyrillic characters, Katakana, as well as some Japanese symbols. Some
* APIs have a inDeprecatedAndIgnored parameter that used to select a
* character set; since X-Plane 9 all localization is done via UTF-8 only.
*
*/
#include "XPLMDefs.h"
#include "XPLMUtilities.h"
#ifdef __cplusplus
extern "C" {
@@ -31,31 +50,24 @@ extern "C" {
/***************************************************************************
* XPLM MENUS
***************************************************************************/
/*
*
*
*/
/*
* XPLMMenuCheck
*
* These enumerations define the various 'check' states for an X-Plane menu.
* 'checking' in x-plane actually appears as a light which may or may not be
* lit. So there are three possible states.
* 'checking' in X-Plane actually appears as a light which may or may not be
* lit. So there are three possible states.
*
*/
enum {
/* there is no symbol to the left of the menu item. */
xplm_Menu_NoCheck = 0
/* there is no symbol to the left of the menu item. */
xplm_Menu_NoCheck = 0,
/* the menu has a mark next to it that is unmarked (not lit). */
,
xplm_Menu_Unchecked = 1
/* the menu has a mark next to it that is unmarked (not lit). */
xplm_Menu_Unchecked = 1,
/* the menu has a mark next to it that is checked (lit). */
,
xplm_Menu_Checked = 2
/* the menu has a mark next to it that is checked (lit). */
xplm_Menu_Checked = 2,
};
@@ -67,7 +79,7 @@ typedef int XPLMMenuCheck;
* This is a unique ID for each menu you create.
*
*/
typedef void *XPLMMenuID;
typedef void * XPLMMenuID;
/*
* XPLMMenuHandler_f
@@ -77,7 +89,9 @@ typedef void *XPLMMenuID;
* the item was created).
*
*/
typedef void (*XPLMMenuHandler_f)(void *inMenuRef, void *inItemRef);
typedef void (* XPLMMenuHandler_f)(
void * inMenuRef,
void * inItemRef);
/*
* XPLMFindPluginsMenu
@@ -88,6 +102,25 @@ typedef void (*XPLMMenuHandler_f)(void *inMenuRef, void *inItemRef);
*/
XPLM_API XPLMMenuID XPLMFindPluginsMenu(void);
#if defined(XPLM300)
/*
* XPLMFindAircraftMenu
*
* This function returns the ID of the menu for the currently-loaded aircraft,
* used for showing aircraft-specific commands.
*
* The aircraft menu is created by X-Plane at startup, but it remains hidden
* until it is populated via XPLMAppendMenuItem() or
* XPLMAppendMenuItemWithCommand().
*
* Only plugins loaded with the user's current aircraft are allowed to access
* the aircraft menu. For all other plugins, this will return NULL, and any
* attempts to add menu items to it will fail.
*
*/
XPLM_API XPLMMenuID XPLMFindAircraftMenu(void);
#endif /* XPLM300 */
/*
* XPLMCreateMenu
*
@@ -103,11 +136,12 @@ XPLM_API XPLMMenuID XPLMFindPluginsMenu(void);
* a submenu where the title is not visible.
*
*/
XPLM_API XPLMMenuID XPLMCreateMenu(const char *inName,
XPLMMenuID inParentMenu,
int inParentItem,
XPLMMenuHandler_f inHandler,
void *inMenuRef);
XPLM_API XPLMMenuID XPLMCreateMenu(
const char * inName,
XPLMMenuID inParentMenu,
int inParentItem,
XPLMMenuHandler_f inHandler,
void * inMenuRef);
/*
* XPLMDestroyMenu
@@ -116,7 +150,8 @@ XPLM_API XPLMMenuID XPLMCreateMenu(const char *inName,
* submenu if necessary. (Normally this function will not be necessary.)
*
*/
XPLM_API void XPLMDestroyMenu(XPLMMenuID inMenuID);
XPLM_API void XPLMDestroyMenu(
XPLMMenuID inMenuID);
/*
* XPLMClearAllMenuItems
@@ -125,32 +160,68 @@ XPLM_API void XPLMDestroyMenu(XPLMMenuID inMenuID);
* it. Use this function if you need to change the number of items on a menu.
*
*/
XPLM_API void XPLMClearAllMenuItems(XPLMMenuID inMenuID);
XPLM_API void XPLMClearAllMenuItems(
XPLMMenuID inMenuID);
/*
* XPLMAppendMenuItem
*
* This routine appends a new menu item to the bottom of a menu and returns
* its index. Pass in the menu to add the item to, the items name, and a void
* * ref for this item. If you pass in inForceEnglish, this menu item will be
* drawn using the english character set no matter what language x-plane is
* running in. Otherwise the menu item will be drawn localized. (An example
* of why you'd want to do this is for a proper name.) See XPLMUtilities for
* determining the current langauge.
* * ref for this item.
*
* Returns a negative index if the append failed (due to an invalid parent
* menu argument).
*
* Note that all menu indices returned are relative to your plugin's menus
* only; if your plugin creates two sub-menus in the Plugins menu at different
* times, it doesn't matter how many other plugins also create sub-menus of
* Plugins in the intervening time: your sub-menus will be given menu indices
* 0 and 1. (The SDK does some work in the back-end to filter out menus that
* are irrelevant to your plugin in order to deliver this consistency for each
* plugin.)
*
*/
XPLM_API int XPLMAppendMenuItem(XPLMMenuID inMenu,
const char *inItemName,
void *inItemRef,
int inForceEnglish);
XPLM_API int XPLMAppendMenuItem(
XPLMMenuID inMenu,
const char * inItemName,
void * inItemRef,
int inDeprecatedAndIgnored);
#if defined(XPLM300)
/*
* XPLMAppendMenuItemWithCommand
*
* Like XPLMAppendMenuItem(), but instead of the new menu item triggering the
* XPLMMenuHandler_f of the containiner menu, it will simply execute the
* command you pass in. Using a command for your menu item allows the user to
* bind a keyboard shortcut to the command and see that shortcut represented
* in the menu.
*
* Returns a negative index if the append failed (due to an invalid parent
* menu argument).
*
* Like XPLMAppendMenuItem(), all menu indices are relative to your plugin's
* menus only.
*
*/
XPLM_API int XPLMAppendMenuItemWithCommand(
XPLMMenuID inMenu,
const char * inItemName,
XPLMCommandRef inCommandToExecute);
#endif /* XPLM300 */
/*
* XPLMAppendMenuSeparator
*
* This routine adds a seperator to the end of a menu.
* This routine adds a separator to the end of a menu.
*
* Returns a negative index if the append failed (due to an invalid parent
* menu argument).
*
*/
XPLM_API void XPLMAppendMenuSeparator(XPLMMenuID inMenu);
XPLM_API void XPLMAppendMenuSeparator(
XPLMMenuID inMenu);
/*
* XPLMSetMenuItemName
@@ -159,10 +230,11 @@ XPLM_API void XPLMAppendMenuSeparator(XPLMMenuID inMenu);
* ID and the index of the menu item.
*
*/
XPLM_API void XPLMSetMenuItemName(XPLMMenuID inMenu,
int inIndex,
const char *inItemName,
int inForceEnglish);
XPLM_API void XPLMSetMenuItemName(
XPLMMenuID inMenu,
int inIndex,
const char * inItemName,
int inDeprecatedAndIgnored);
/*
* XPLMCheckMenuItem
@@ -170,8 +242,10 @@ XPLM_API void XPLMSetMenuItemName(XPLMMenuID inMenu,
* Set whether a menu item is checked. Pass in the menu ID and item index.
*
*/
XPLM_API void
XPLMCheckMenuItem(XPLMMenuID inMenu, int index, XPLMMenuCheck inCheck);
XPLM_API void XPLMCheckMenuItem(
XPLMMenuID inMenu,
int index,
XPLMMenuCheck inCheck);
/*
* XPLMCheckMenuItemState
@@ -180,9 +254,10 @@ XPLM_API void
* check mark may be on or off, or a menu may not have an icon at all.
*
*/
XPLM_API void XPLMCheckMenuItemState(XPLMMenuID inMenu,
int index,
XPLMMenuCheck *outCheck);
XPLM_API void XPLMCheckMenuItemState(
XPLMMenuID inMenu,
int index,
XPLMMenuCheck * outCheck);
/*
* XPLMEnableMenuItem
@@ -190,7 +265,10 @@ XPLM_API void XPLMCheckMenuItemState(XPLMMenuID inMenu,
* Sets whether this menu item is enabled. Items start out enabled.
*
*/
XPLM_API void XPLMEnableMenuItem(XPLMMenuID inMenu, int index, int enabled);
XPLM_API void XPLMEnableMenuItem(
XPLMMenuID inMenu,
int index,
int enabled);
#if defined(XPLM210)
/*
@@ -200,7 +278,9 @@ XPLM_API void XPLMEnableMenuItem(XPLMMenuID inMenu, int index, int enabled);
* one; your plugin must track the change in index numbers.
*
*/
XPLM_API void XPLMRemoveMenuItem(XPLMMenuID inMenu, int inIndex);
XPLM_API void XPLMRemoveMenuItem(
XPLMMenuID inMenu,
int inIndex);
#endif /* XPLM210 */
#ifdef __cplusplus
XPSDK/CHeaders/XPLM/XPLMNavigation.h
+106 -117
View File
@@ -2,17 +2,15 @@
#define _XPLMNavigation_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMNavigation
***************************************************************************/
/*
* XPLMNavigation - THEORY OF OPERATION
*
* The XPLM Navigation APIs give you some access to the navigation databases
* inside X-Plane. X-Plane stores all navigation information in RAM, so by
* using these APIs you can gain access to most information without having to
@@ -20,7 +18,7 @@
*
* You can also use this API to program the FMS. You must use the navigation
* APIs to find the nav-aids you want to program into the FMS, since the FMS
* is powered internally by x-plane's navigation database.
* is powered internally by X-Plane's navigation database.
*
*/
@@ -33,11 +31,6 @@ extern "C" {
/***************************************************************************
* NAVIGATION DATABASE ACCESS
***************************************************************************/
/*
*
*
*/
/*
* XPLMNavType
@@ -53,43 +46,31 @@ extern "C" {
*
*/
enum {
xplm_Nav_Unknown = 0
xplm_Nav_Unknown = 0,
,
xplm_Nav_Airport = 1
xplm_Nav_Airport = 1,
,
xplm_Nav_NDB = 2
xplm_Nav_NDB = 2,
,
xplm_Nav_VOR = 4
xplm_Nav_VOR = 4,
,
xplm_Nav_ILS = 8
xplm_Nav_ILS = 8,
,
xplm_Nav_Localizer = 16
xplm_Nav_Localizer = 16,
,
xplm_Nav_GlideSlope = 32
xplm_Nav_GlideSlope = 32,
,
xplm_Nav_OuterMarker = 64
xplm_Nav_OuterMarker = 64,
,
xplm_Nav_MiddleMarker = 128
xplm_Nav_MiddleMarker = 128,
,
xplm_Nav_InnerMarker = 256
xplm_Nav_InnerMarker = 256,
,
xplm_Nav_Fix = 512
xplm_Nav_Fix = 512,
,
xplm_Nav_DME = 1024
xplm_Nav_DME = 1024,
,
xplm_Nav_LatLon = 2048
xplm_Nav_LatLon = 2048,
};
@@ -101,7 +82,7 @@ typedef int XPLMNavType;
* XPLMNavRef is an iterator into the navigation database. The navigation
* database is essentially an array, but it is not necessarily densely
* populated. The only assumption you can safely make is that like-typed
* nav-aids are grouped together.
* nav-aids are grouped together.
*
* Use XPLMNavRef to refer to a nav-aid.
*
@@ -111,7 +92,7 @@ typedef int XPLMNavType;
*/
typedef int XPLMNavRef;
#define XPLM_NAV_NOT_FOUND -1
#define XPLM_NAV_NOT_FOUND -1
/*
* XPLMGetFirstNavAid
@@ -126,17 +107,14 @@ XPLM_API XPLMNavRef XPLMGetFirstNavAid(void);
/*
* XPLMGetNextNavAid
*
* Given a nav aid ref, this routine returns the next navaid. It returns
* XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the navaid
* passed in was the last one in the database. Use this routine to iterate
* across all like-typed navaids or the entire database.
*
* WARNING: due to a bug in the SDK, when fix loading is disabled in the
* rendering settings screen, calling this routine with the last airport
* returns a bogus nav aid. Using this nav aid can crash x-plane.
* Given a valid nav aid ref, this routine returns the next navaid. It
* returns XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the
* navaid passed in was the last one in the database. Use this routine to
* iterate across all like-typed navaids or the entire database.
*
*/
XPLM_API XPLMNavRef XPLMGetNextNavAid(XPLMNavRef inNavAidRef);
XPLM_API XPLMNavRef XPLMGetNextNavAid(
XPLMNavRef inNavAidRef);
/*
* XPLMFindFirstNavAidOfType
@@ -145,12 +123,9 @@ XPLM_API XPLMNavRef XPLMGetNextNavAid(XPLMNavRef inNavAidRef);
* database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the
* database. You must pass exactly one nav aid type to this routine.
*
* WARNING: due to a bug in the SDK, when fix loading is disabled in the
* rendering settings screen, calling this routine with fixes returns a bogus
* nav aid. Using this nav aid can crash x-plane.
*
*/
XPLM_API XPLMNavRef XPLMFindFirstNavAidOfType(XPLMNavType inType);
XPLM_API XPLMNavRef XPLMFindFirstNavAidOfType(
XPLMNavType inType);
/*
* XPLMFindLastNavAidOfType
@@ -159,12 +134,9 @@ XPLM_API XPLMNavRef XPLMFindFirstNavAidOfType(XPLMNavType inType);
* database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the
* database. You must pass exactly one nav aid type to this routine.
*
* WARNING: due to a bug in the SDK, when fix loading is disabled in the
* rendering settings screen, calling this routine with fixes returns a bogus
* nav aid. Using this nav aid can crash x-plane.
*
*/
XPLM_API XPLMNavRef XPLMFindLastNavAidOfType(XPLMNavType inType);
XPLM_API XPLMNavRef XPLMFindLastNavAidOfType(
XPLMNavType inType);
/*
* XPLMFindNavAid
@@ -172,34 +144,35 @@ XPLM_API XPLMNavRef XPLMFindLastNavAidOfType(XPLMNavType inType);
* This routine provides a number of searching capabilities for the nav
* database. XPLMFindNavAid will search through every nav aid whose type is
* within inType (multiple types may be added together) and return any
* nav-aids found based on the following rules:
* nav-aids found based on the following rules:
*
* If inLat and inLon are not NULL, the navaid nearest to that lat/lon will be
* returned, otherwise the last navaid found will be returned.
* * If inLat and inLon are not NULL, the navaid nearest to that lat/lon will
* be returned, otherwise the last navaid found will be returned.
*
* If inFrequency is not NULL, then any navaids considered must match this
* frequency. Note that this will screen out radio beacons that do not have
* frequency data published (like inner markers) but not fixes and airports.
* * If inFrequency is not NULL, then any navaids considered must match this
* frequency. Note that this will screen out radio beacons that do not have
* frequency data published (like inner markers) but not fixes and airports.
*
* If inNameFragment is not NULL, only navaids that contain the fragment in
* their name will be returned.
* * If inNameFragment is not NULL, only navaids that contain the fragment in
* their name will be returned.
*
* If inIDFragment is not NULL, only navaids that contain the fragment in
* their IDs will be returned.
* * If inIDFragment is not NULL, only navaids that contain the fragment in
* their IDs will be returned.
*
* This routine provides a simple way to do a number of useful searches:
*
* Find the nearest navaid on this frequency. Find the nearest airport. Find
* the VOR whose ID is "KBOS". Find the nearest airport whose name contains
* "Chicago".
* * Find the nearest navaid on this frequency.
* * Find the nearest airport.
* * Find the VOR whose ID is "KBOS".
* * Find the nearest airport whose name contains "Chicago".
*
*/
XPLM_API XPLMNavRef XPLMFindNavAid(const char *inNameFragment, /* Can be NULL */
const char *inIDFragment, /* Can be NULL */
float *inLat, /* Can be NULL */
float *inLon, /* Can be NULL */
int *inFrequency, /* Can be NULL */
XPLMNavType inType);
XPLM_API XPLMNavRef XPLMFindNavAid(
const char * inNameFragment, /* Can be NULL */
const char * inIDFragment, /* Can be NULL */
float * inLat, /* Can be NULL */
float * inLon, /* Can be NULL */
int * inFrequency, /* Can be NULL */
XPLMNavType inType);
/*
* XPLMGetNavAidInfo
@@ -221,16 +194,17 @@ XPLM_API XPLMNavRef XPLMFindNavAid(const char *inNameFragment, /* Can be NULL */
* string.
*
*/
XPLM_API void XPLMGetNavAidInfo(XPLMNavRef inRef,
XPLMNavType *outType, /* Can be NULL */
float *outLatitude, /* Can be NULL */
float *outLongitude, /* Can be NULL */
float *outHeight, /* Can be NULL */
int *outFrequency, /* Can be NULL */
float *outHeading, /* Can be NULL */
char *outID, /* Can be NULL */
char *outName, /* Can be NULL */
char *outReg); /* Can be NULL */
XPLM_API void XPLMGetNavAidInfo(
XPLMNavRef inRef,
XPLMNavType * outType, /* Can be NULL */
float * outLatitude, /* Can be NULL */
float * outLongitude, /* Can be NULL */
float * outHeight, /* Can be NULL */
int * outFrequency, /* Can be NULL */
float * outHeading, /* Can be NULL */
char * outID, /* Can be NULL */
char * outName, /* Can be NULL */
char * outReg); /* Can be NULL */
/***************************************************************************
* FLIGHT MANAGEMENT COMPUTER
@@ -253,7 +227,7 @@ XPLM_API void XPLMGetNavAidInfo(XPLMNavRef inRef,
* This routine returns the number of entries in the FMS.
*
*/
XPLM_API int XPLMCountFMSEntries(void);
XPLM_API int XPLMCountFMSEntries(void);
/*
* XPLMGetDisplayedFMSEntry
@@ -261,7 +235,7 @@ XPLM_API int XPLMCountFMSEntries(void);
* This routine returns the index of the entry the pilot is viewing.
*
*/
XPLM_API int XPLMGetDisplayedFMSEntry(void);
XPLM_API int XPLMGetDisplayedFMSEntry(void);
/*
* XPLMGetDestinationFMSEntry
@@ -269,15 +243,16 @@ XPLM_API int XPLMGetDisplayedFMSEntry(void);
* This routine returns the index of the entry the FMS is flying to.
*
*/
XPLM_API int XPLMGetDestinationFMSEntry(void);
XPLM_API int XPLMGetDestinationFMSEntry(void);
/*
* XPLMSetDisplayedFMSEntry
*
* This routine changes which entry the FMS is showing to the index specified.
* *
*
*/
XPLM_API void XPLMSetDisplayedFMSEntry(int inIndex);
XPLM_API void XPLMSetDisplayedFMSEntry(
int inIndex);
/*
* XPLMSetDestinationFMSEntry
@@ -285,27 +260,38 @@ XPLM_API void XPLMSetDisplayedFMSEntry(int inIndex);
* This routine changes which entry the FMS is flying the aircraft toward.
*
*/
XPLM_API void XPLMSetDestinationFMSEntry(int inIndex);
XPLM_API void XPLMSetDestinationFMSEntry(
int inIndex);
/*
* XPLMGetFMSEntryInfo
*
* This routine returns information about a given FMS entry. A reference to a
* navaid can be returned allowing you to find additional information (such as
* a frequency, ILS heading, name, etc.). Some information is available
* immediately. For a lat/lon entry, the lat/lon is returned by this routine
* but the navaid cannot be looked up (and the reference will be
* XPLM_NAV_NOT_FOUND. FMS name entry buffers should be at least 256 chars in
* length.
* This routine returns information about a given FMS entry. If the entry is
* an airport or navaid, a reference to a nav entry can be returned allowing
* you to find additional information (such as a frequency, ILS heading, name,
* etc.). Note that this reference can be XPLM_NAV_NOT_FOUND until the
* information has been looked up asynchronously, so after flightplan changes,
* it might take up to a second for this field to become populated. The other
* information is available immediately. For a lat/lon entry, the lat/lon is
* returned by this routine but the navaid cannot be looked up (and the
* reference will be XPLM_NAV_NOT_FOUND). FMS name entry buffers should be at
* least 256 chars in length.
*
* WARNING: Due to a bug in X-Plane prior to 11.31, the navaid reference will
* not be set to XPLM_NAV_NOT_FOUND while no data is available, and instead
* just remain the value of the variable that you passed the pointer to.
* Therefore, always initialize the variable to XPLM_NAV_NOT_FOUND before
* passing the pointer to this function.
*
*/
XPLM_API void XPLMGetFMSEntryInfo(int inIndex,
XPLMNavType *outType, /* Can be NULL */
char *outID, /* Can be NULL */
XPLMNavRef *outRef, /* Can be NULL */
int *outAltitude, /* Can be NULL */
float *outLat, /* Can be NULL */
float *outLon); /* Can be NULL */
XPLM_API void XPLMGetFMSEntryInfo(
int inIndex,
XPLMNavType * outType, /* Can be NULL */
char * outID, /* Can be NULL */
XPLMNavRef * outRef, /* Can be NULL */
int * outAltitude, /* Can be NULL */
float * outLat, /* Can be NULL */
float * outLon); /* Can be NULL */
/*
* XPLMSetFMSEntryInfo
@@ -316,8 +302,10 @@ XPLM_API void XPLMGetFMSEntryInfo(int inIndex,
* support VORs and NDBs. Use the routines below to clear or fly to a lat/lon.
*
*/
XPLM_API void
XPLMSetFMSEntryInfo(int inIndex, XPLMNavRef inRef, int inAltitude);
XPLM_API void XPLMSetFMSEntryInfo(
int inIndex,
XPLMNavRef inRef,
int inAltitude);
/*
* XPLMSetFMSEntryLatLon
@@ -326,10 +314,11 @@ XPLM_API void
* coordinates.
*
*/
XPLM_API void XPLMSetFMSEntryLatLon(int inIndex,
float inLat,
float inLon,
int inAltitude);
XPLM_API void XPLMSetFMSEntryLatLon(
int inIndex,
float inLat,
float inLon,
int inAltitude);
/*
* XPLMClearFMSEntry
@@ -338,7 +327,8 @@ XPLM_API void XPLMSetFMSEntryLatLon(int inIndex,
* plan.
*
*/
XPLM_API void XPLMClearFMSEntry(int inIndex);
XPLM_API void XPLMClearFMSEntry(
int inIndex);
/***************************************************************************
* GPS RECEIVER
@@ -348,7 +338,6 @@ XPLM_API void XPLMClearFMSEntry(int inIndex);
*
*/
/*
* XPLMGetGPSDestinationType
*
XPSDK/CHeaders/XPLM/XPLMPlanes.h
+123 -81
View File
@@ -2,18 +2,22 @@
#define _XPLMPlanes_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMPlanes
***************************************************************************/
/*
* The XPLMPlanes APIs allow you to control the various aircraft in x-plane,
* The XPLMPlanes APIs allow you to control the various aircraft in X-Plane,
* both the user's and the sim's.
*
* *Note*: unlike almost all other APIs in the SDK, aircraft paths are _full_
* file system paths for historical reasons. You'll need to prefix all
* relative paths with the X-Plane path as accessed via XPLMGetSystemPath.
*
*/
#include "XPLMDefs.h"
@@ -25,11 +29,6 @@ extern "C" {
/***************************************************************************
* USER AIRCRAFT ACCESS
***************************************************************************/
/*
*
*
*/
/*
* XPLMSetUsersAircraft
@@ -39,26 +38,44 @@ extern "C" {
* (hard drive and everything including the .acf extension) to the .acf file.
*
*/
XPLM_API void XPLMSetUsersAircraft(const char *inAircraftPath);
XPLM_API void XPLMSetUsersAircraft(
const char * inAircraftPath);
/*
* XPLMPlaceUserAtAirport
*
* This routine places the user at a given airport. Specify the airport by
* its ICAO code (e.g. 'KBOS').
* its X-Plane airport ID (e.g. 'KBOS').
*
*/
XPLM_API void XPLMPlaceUserAtAirport(const char *inAirportCode);
XPLM_API void XPLMPlaceUserAtAirport(
const char * inAirportCode);
#if defined(XPLM300)
/*
* XPLMPlaceUserAtLocation
*
* Places the user at a specific location after performing any necessary
* scenery loads.
*
* As with in-air starts initiated from the X-Plane user interface, the
* aircraft will always start with its engines running, regardless of the
* user's preferences (i.e., regardless of what the dataref
* `sim/operation/prefs/startup_running` says).
*
*/
XPLM_API void XPLMPlaceUserAtLocation(
double latitudeDegrees,
double longitudeDegrees,
float elevationMetersMSL,
float headingDegreesTrue,
float speedMetersPerSecond);
#endif /* XPLM300 */
/***************************************************************************
* GLOBAL AIRCRAFT ACCESS
***************************************************************************/
/*
*
*
*/
/* The user's aircraft is always index 0. */
#define XPLM_USER_AIRCRAFT 0
/* The user's aircraft is always index 0. */
#define XPLM_USER_AIRCRAFT 0
#if defined(XPLM_DEPRECATED)
/*
* XPLMPlaneDrawState_t
*
@@ -72,34 +89,35 @@ XPLM_API void XPLMPlaceUserAtAirport(const char *inAirportCode);
* calculates what the actual controls look like based on the .acf file for
* that airplane. Note for the yoke inputs, this is what the pilot of the
* plane has commanded (post artificial stability system if there were one)
* and affects aelerons, rudder, etc. It is not necessarily related to the
* and affects aelerons, rudder, etc. It is not necessarily related to the
* actual position of the plane!
*
*/
typedef struct {
/* The size of the draw state struct. */
int structSize;
/* A ratio from [0..1] describing how far the landing gear is extended. */
float gearPosition;
/* Ratio of flap deployment, 0 = up, 1 = full deploy. */
float flapRatio;
/* Ratio of spoiler deployment, 0 = none, 1 = full deploy. */
float spoilerRatio;
/* Ratio of speed brake deployment, 0 = none, 1 = full deploy. */
float speedBrakeRatio;
/* Ratio of slat deployment, 0 = none, 1 = full deploy. */
float slatRatio;
/* Wing sweep ratio, 0 = forward, 1 = swept. */
float wingSweep;
/* Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. */
float thrust;
/* Total pitch input for this plane. */
float yokePitch;
/* Total Heading input for this plane. */
float yokeHeading;
/* Total Roll input for this plane. */
float yokeRoll;
/* The size of the draw state struct. */
int structSize;
/* A ratio from [0..1] describing how far the landing gear is extended. */
float gearPosition;
/* Ratio of flap deployment, 0 = up, 1 = full deploy. */
float flapRatio;
/* Ratio of spoiler deployment, 0 = none, 1 = full deploy. */
float spoilerRatio;
/* Ratio of speed brake deployment, 0 = none, 1 = full deploy. */
float speedBrakeRatio;
/* Ratio of slat deployment, 0 = none, 1 = full deploy. */
float slatRatio;
/* Wing sweep ratio, 0 = forward, 1 = swept. */
float wingSweep;
/* Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. */
float thrust;
/* Total pitch input for this plane. */
float yokePitch;
/* Total Heading input for this plane. */
float yokeHeading;
/* Total Roll input for this plane. */
float yokeRoll;
} XPLMPlaneDrawState_t;
#endif /* XPLM_DEPRECATED */
/*
* XPLMCountAircraft
*
@@ -110,9 +128,10 @@ typedef struct {
* aircraft the user has enabled in the rendering options window.
*
*/
XPLM_API void XPLMCountAircraft(int *outTotalAircraft,
int *outActiveAircraft,
XPLMPluginID *outController);
XPLM_API void XPLMCountAircraft(
int * outTotalAircraft,
int * outActiveAircraft,
XPLMPluginID * outController);
/*
* XPLMGetNthAircraftModel
*
@@ -122,8 +141,10 @@ XPLM_API void XPLMCountAircraft(int *outTotalAircraft,
* length.
*
*/
XPLM_API void
XPLMGetNthAircraftModel(int inIndex, char *outFileName, char *outPath);
XPLM_API void XPLMGetNthAircraftModel(
int inIndex,
char * outFileName,
char * outPath);
/***************************************************************************
* EXCLUSIVE AIRCRAFT ACCESS
***************************************************************************/
@@ -142,25 +163,30 @@ XPLM_API void
* multiplayer.
*
*/
typedef void (*XPLMPlanesAvailable_f)(void *inRefcon);
typedef void (* XPLMPlanesAvailable_f)(
void * inRefcon);
/*
* XPLMAcquirePlanes
*
* XPLMAcquirePlanes grants your plugin exclusive access to the aircraft. It
* returns 1 if you gain access, 0 if you do not. inAircraft - pass in an
* array of pointers to strings specifying the planes you want loaded. For
* any plane index you do not want loaded, pass a 0-length string. Other
* strings should be full paths with the .acf extension. NULL terminates this
* array, or pass NULL if there are no planes you want loaded. If you pass in
* a callback and do not receive access to the planes your callback will be
* called when the airplanes are available. If you do receive airplane access,
* your callback will not be called.
* returns 1 if you gain access, 0 if you do not.
*
* inAircraft - pass in an array of pointers to strings specifying the planes
* you want loaded. For any plane index you do not want loaded, pass a
* 0-length string. Other strings should be full paths with the .acf
* extension. NULL terminates this array, or pass NULL if there are no planes
* you want loaded.
*
* If you pass in a callback and do not receive access to the planes your
* callback will be called when the airplanes are available. If you do receive
* airplane access, your callback will not be called.
*
*/
XPLM_API int XPLMAcquirePlanes(char **inAircraft, /* Can be NULL */
XPLMPlanesAvailable_f inCallback,
void *inRefcon);
XPLM_API int XPLMAcquirePlanes(
char ** inAircraft, /* Can be NULL */
XPLMPlanesAvailable_f inCallback,
void * inRefcon);
/*
* XPLMReleasePlanes
@@ -169,7 +195,7 @@ XPLM_API int XPLMAcquirePlanes(char **inAircraft, /* Can be NULL */
* disabled, access to planes is released for you and you must reacquire it.
*
*/
XPLM_API void XPLMReleasePlanes(void);
XPLM_API void XPLMReleasePlanes(void);
/*
* XPLMSetActiveAircraftCount
@@ -179,31 +205,40 @@ XPLM_API void XPLMReleasePlanes(void);
* planes available is actually used.
*
*/
XPLM_API void XPLMSetActiveAircraftCount(int inCount);
XPLM_API void XPLMSetActiveAircraftCount(
int inCount);
/*
* XPLMSetAircraftModel
*
* This routine loads an aircraft model. It may only be called if you have
* exclusive access to the airplane APIs. Pass in the path of the model with
* the .acf extension. The index is zero based, but you may not pass in 0
* This routine loads an aircraft model. It may only be called if you have
* exclusive access to the airplane APIs. Pass in the path of the model with
* the .acf extension. The index is zero based, but you may not pass in 0
* (use XPLMSetUsersAircraft to load the user's aircracft).
*
*/
XPLM_API void XPLMSetAircraftModel(int inIndex, const char *inAircraftPath);
XPLM_API void XPLMSetAircraftModel(
int inIndex,
const char * inAircraftPath);
/*
* XPLMDisableAIForPlane
*
* This routine turns off X-Plane's AI for a given plane. The plane will
* continue to draw and be a real plane in X-Plane, but will not move itself.
* continue to draw and be a real plane in X-Plane, but will not move itself.
*
*/
XPLM_API void XPLMDisableAIForPlane(int inPlaneIndex);
XPLM_API void XPLMDisableAIForPlane(
int inPlaneIndex);
#if defined(XPLM_DEPRECATED)
/*
* XPLMDrawAircraft
*
* WARNING: Aircraft drawing via this API is deprecated and will not work in
* future versions of X-Plane. Use XPLMInstance for 3-d drawing of custom
* aircraft models.
*
* This routine draws an aircraft. It can only be called from a 3-d drawing
* callback. Pass in the position of the plane in OpenGL local coordinates
* and the orientation of the plane. A 1 for full drawing indicates that the
@@ -211,23 +246,29 @@ XPLM_API void XPLMDisableAIForPlane(int inPlaneIndex);
* drawn. (This saves rendering time when planes are far away.)
*
*/
XPLM_API void XPLMDrawAircraft(int inPlaneIndex,
float inX,
float inY,
float inZ,
float inPitch,
float inRoll,
float inYaw,
int inFullDraw,
XPLMPlaneDrawState_t *inDrawStateInfo);
XPLM_API void XPLMDrawAircraft(
int inPlaneIndex,
float inX,
float inY,
float inZ,
float inPitch,
float inRoll,
float inYaw,
int inFullDraw,
XPLMPlaneDrawState_t * inDrawStateInfo);
#endif /* XPLM_DEPRECATED */
#if defined(XPLM_DEPRECATED)
/*
* XPLMReinitUsersPlane
*
* WARNING: DO NOT USE. Use XPLMPlaceUserAtAirport or
* XPLMPlaceUserAtLocation.
*
* This function recomputes the derived flight model data from the aircraft
* structure in memory. If you have used the data access layer to modify the
* aircraft structure, use this routine to resynchronize x-plane; since
* X-plane works at least partly from derived values, the sim will not behave
* aircraft structure, use this routine to resynchronize X-Plane; since
* X-Plane works at least partly from derived values, the sim will not behave
* properly until this is called.
*
* WARNING: this routine does not necessarily place the airplane at the
@@ -236,7 +277,8 @@ XPLM_API void XPLMDrawAircraft(int inPlaneIndex,
* flight.
*
*/
XPLM_API void XPLMReinitUsersPlane(void);
XPLM_API void XPLMReinitUsersPlane(void);
#endif /* XPLM_DEPRECATED */
#ifdef __cplusplus
}
XPSDK/CHeaders/XPLM/XPLMPlugin.h
+173 -62
View File
@@ -2,14 +2,14 @@
#define _XPLMPlugin_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMPlugin
***************************************************************************/
/*
* These APIs provide facilities to find and work with other plugins and
* manage other plugins.
@@ -50,7 +50,7 @@ XPLM_API XPLMPluginID XPLMGetMyID(void);
* disabled and enabled.
*
*/
XPLM_API int XPLMCountPlugins(void);
XPLM_API int XPLMCountPlugins(void);
/*
* XPLMGetNthPlugin
@@ -60,7 +60,8 @@ XPLM_API int XPLMCountPlugins(void);
* order.
*
*/
XPLM_API XPLMPluginID XPLMGetNthPlugin(int inIndex);
XPLM_API XPLMPluginID XPLMGetNthPlugin(
int inIndex);
/*
* XPLMFindPluginByPath
@@ -70,7 +71,8 @@ XPLM_API XPLMPluginID XPLMGetNthPlugin(int inIndex);
* path does not point to a currently loaded plug-in.
*
*/
XPLM_API XPLMPluginID XPLMFindPluginByPath(const char *inPath);
XPLM_API XPLMPluginID XPLMFindPluginByPath(
const char * inPath);
/*
* XPLMFindPluginBySignature
@@ -83,26 +85,28 @@ XPLM_API XPLMPluginID XPLMFindPluginByPath(const char *inPath);
* locate another plugin that your plugin interoperates with
*
*/
XPLM_API XPLMPluginID XPLMFindPluginBySignature(const char *inSignature);
XPLM_API XPLMPluginID XPLMFindPluginBySignature(
const char * inSignature);
/*
* XPLMGetPluginInfo
*
* This routine returns information about a plug-in. Each parameter should be
* a pointer to a buffer of at least 256 characters, or NULL to not receive
* the information.
* a pointer to a buffer of at least
* 256 characters, or NULL to not receive the information.
*
* outName - the human-readable name of the plug-in. outFilePath - the
* outName - the human-readable name of the plug-in. outFilePath - the
* absolute file path to the file that contains this plug-in. outSignature - a
* unique string that identifies this plug-in. outDescription - a
* human-readable description of this plug-in.
*
*/
XPLM_API void XPLMGetPluginInfo(XPLMPluginID inPlugin,
char *outName, /* Can be NULL */
char *outFilePath, /* Can be NULL */
char *outSignature, /* Can be NULL */
char *outDescription); /* Can be NULL */
XPLM_API void XPLMGetPluginInfo(
XPLMPluginID inPlugin,
char * outName, /* Can be NULL */
char * outFilePath, /* Can be NULL */
char * outSignature, /* Can be NULL */
char * outDescription); /* Can be NULL */
/***************************************************************************
* ENABLING/DISABLING PLUG-INS
@@ -120,18 +124,20 @@ XPLM_API void XPLMGetPluginInfo(XPLMPluginID inPlugin,
* Returns whether the specified plug-in is enabled for running.
*
*/
XPLM_API int XPLMIsPluginEnabled(XPLMPluginID inPluginID);
XPLM_API int XPLMIsPluginEnabled(
XPLMPluginID inPluginID);
/*
* XPLMEnablePlugin
*
* This routine enables a plug-in if it is not already enabled. It returns 1
* This routine enables a plug-in if it is not already enabled. It returns 1
* if the plugin was enabled or successfully enables itself, 0 if it does not.
* Plugins may fail to enable (for example, if resources cannot be acquired)
* by returning 0 from their XPluginEnable callback.
*
*/
XPLM_API int XPLMEnablePlugin(XPLMPluginID inPluginID);
XPLM_API int XPLMEnablePlugin(
XPLMPluginID inPluginID);
/*
* XPLMDisablePlugin
@@ -139,19 +145,20 @@ XPLM_API int XPLMEnablePlugin(XPLMPluginID inPluginID);
* This routine disableds an enabled plug-in.
*
*/
XPLM_API void XPLMDisablePlugin(XPLMPluginID inPluginID);
XPLM_API void XPLMDisablePlugin(
XPLMPluginID inPluginID);
/*
* XPLMReloadPlugins
*
* This routine reloads all plug-ins. Once this routine is called and you
* return from the callback you were within (e.g. a menu select callback) you
* will receive your XPluginDisable and XPluginStop callbacks and your DLL
* will receive your XPluginDisable and XPluginStop callbacks and your DLL
* will be unloaded, then the start process happens as if the sim was starting
* up.
*
*/
XPLM_API void XPLMReloadPlugins(void);
XPLM_API void XPLMReloadPlugins(void);
/***************************************************************************
* INTERPLUGIN MESSAGING
@@ -160,9 +167,24 @@ XPLM_API void XPLMReloadPlugins(void);
* Plugin messages are defined as 32-bit integers. Messages below 0x00FFFFFF
* are reserved for X-Plane and the plugin SDK.
*
* Messages come with a pointer parameter; the meaning of this pointer depends
* on the message itself. In some messages, the pointer parameter contains an
* actual typed pointer to data that can be inspected in the plugin; in these
* cases the documentation will state that the parameter "points to"
* information.
*
* in other cases, the value of the pointer is actually an integral number
* stuffed into the pointer's storage. In these second cases, the pointer
* parameter needs to be cast, not dereferenced. In these caess, the
* documentation will state that the parameter "contains" a value, which will
* always be an integral type.
*
* Some messages don't use the pointer parameter - in this case your plugin
* should ignore it.
*
* Messages have two conceptual uses: notifications and commands. Commands
* are sent from one plugin to another to induce behavior; notifications are
* sent from one plugin to all others for informational purposes. It is
* are sent from one plugin to another to induce behavior; notifications are
* sent from one plugin to all others for informational purposes. It is
* important that commands and notifications not have the same values because
* this could cause a notification sent by one plugin to accidentally induce a
* command in another.
@@ -171,59 +193,91 @@ XPLM_API void XPLMReloadPlugins(void);
* (e.g. be greater or equal to unsigned 0x8000000) while commands should have
* this bit be cleared.
*
* The following messages are sent to your plugin by x-plane.
* The following messages are sent to your plugin by X-Plane.
*
*/
/* This message is sent to your plugin whenever the user's plane crashes. */
/* This message is sent to your plugin whenever the user's plane crashes. The *
* parameter is ignored. */
#define XPLM_MSG_PLANE_CRASHED 101
/* This message is sent to your plugin whenever a new plane is loaded. The *
* parameter is the number of the plane being loaded; 0 indicates the user's *
* plane. */
/* This message is sent to your plugin whenever a new plane is loaded. The *
* parameter contains the index number of the plane being loaded; 0 indicates *
* the user's plane. */
#define XPLM_MSG_PLANE_LOADED 102
/* This messages is called whenever the user's plane is positioned at a new *
* airport. */
/* This messages is sent whenever the user's plane is positioned at a new *
* airport. The parameter is ignored. */
#define XPLM_MSG_AIRPORT_LOADED 103
/* This message is sent whenever new scenery is loaded. Use datarefs to *
* determine the new scenery files that were loaded. */
/* This message is sent whenever new scenery is loaded. Use datarefs to *
* determine the new scenery files that were loaded. The parameter is ignored.*/
#define XPLM_MSG_SCENERY_LOADED 104
/* This message is sent whenever the user adjusts the number of X-Plane *
* aircraft models. You must use XPLMCountPlanes to find out how many planes *
* are now available. This message will only be sent in XP7 and higher *
* because in XP6 the number of aircraft is not user-adjustable. */
/* This message is sent whenever the user adjusts the number of X-Plane *
* aircraft models. You must use XPLMCountPlanes to find out how many planes *
* are now available. This message will only be sent in XP7 and higher *
* because in XP6 the number of aircraft is not user-adjustable. The parameter*
* is ignored. */
#define XPLM_MSG_AIRPLANE_COUNT_CHANGED 105
#if defined(XPLM200)
/* This message is sent to your plugin whenever a plane is unloaded. The *
* parameter is the number of the plane being unloaded; 0 indicates the user's *
* plane. The parameter is of type int, passed as the value of the pointer. *
* (That is: the parameter is an int, not a pointer to an int.) */
/* This message is sent to your plugin whenever a plane is unloaded. The *
* parameter contains the index number of the plane being unloaded; 0 *
* indicates the user's plane. The parameter is of type int, passed as the *
* value of the pointer. (That is: the parameter is an int, not a pointer to *
* an int.) */
#define XPLM_MSG_PLANE_UNLOADED 106
#endif /* XPLM200 */
#if defined(XPLM210)
/* This message is sent to your plugin right before X-Plane writes its *
* preferences file. You can use this for two purposes: to write your own *
* preferences, and to modify any datarefs to influence preferences output. *
* For example, if your plugin temporarily modifies saved preferences, you can *
* put them back to their default values here to avoid having the tweaks be *
* persisted if your plugin is not loaded on the next invocation of X-Plane. */
/* This message is sent to your plugin right before X-Plane writes its *
* preferences file. You can use this for two purposes: to write your own *
* preferences, and to modify any datarefs to influence preferences output. *
* For example, if your plugin temporarily modifies saved preferences, you can*
* put them back to their default values here to avoid having the tweaks be *
* persisted if your plugin is not loaded on the next invocation of X-Plane. *
* The parameter is ignored. */
#define XPLM_MSG_WILL_WRITE_PREFS 107
#endif /* XPLM210 */
#if defined(XPLM210)
/* This message is sent to your plugin right after a livery is loaded for an *
* airplane. You can use this to check the new livery (via datarefs) and *
* react accordingly. The parameter is of type int, passed as the value of a *
* pointer and represents the aicraft plane number - 0 is the user's plane. */
/* This message is sent to your plugin right after a livery is loaded for an *
* airplane. You can use this to check the new livery (via datarefs) and *
* react accordingly. The parameter contains the index number of the aircraft*
* whose livery is changing. */
#define XPLM_MSG_LIVERY_LOADED 108
#endif /* XPLM210 */
#if defined(XPLM301)
/* Sent to your plugin right before X-Plane enters virtual reality mode (at *
* which time any windows that are not positioned in VR mode will no longer be*
* visible to the user). The parameter is unused and should be ignored. */
#define XPLM_MSG_ENTERED_VR 109
#endif /* XPLM301 */
#if defined(XPLM301)
/* Sent to your plugin right before X-Plane leaves virtual reality mode (at *
* which time you may want to clean up windows that are positioned in VR *
* mode). The parameter is unused and should be ignored. */
#define XPLM_MSG_EXITING_VR 110
#endif /* XPLM301 */
#if defined(XPLM303)
/* Sent to your plugin if another plugin wants to take over AI planes. If you *
* are a synthetic traffic provider, that probably means a plugin for an *
* online network has connected and wants to supply aircraft flown by real *
* humans and you should cease to provide synthetic traffic. If however you *
* are providing online traffic from real humans, you probably don't want to *
* disconnect, in which case you just ignore this message. The sender is the *
* plugin ID of the plugin asking for control of the planes now. You can use *
* it to find out who is requesting and whether you should yield to them. *
* Synthetic traffic providers should always yield to online networks. The *
* parameter is unused and should be ignored. */
#define XPLM_MSG_RELEASE_PLANES 111
#endif /* XPLM303 */
/*
* XPLMSendMessageToPlugin
*
@@ -232,9 +286,10 @@ XPLM_API void XPLMReloadPlugins(void);
* a message receive function receive the message.
*
*/
XPLM_API void XPLMSendMessageToPlugin(XPLMPluginID inPlugin,
int inMessage,
void *inParam);
XPLM_API void XPLMSendMessageToPlugin(
XPLMPluginID inPlugin,
int inMessage,
void * inParam);
#if defined(XPLM200)
/***************************************************************************
@@ -247,9 +302,58 @@ XPLM_API void XPLMSendMessageToPlugin(XPLMPluginID inPlugin,
* behavior.
*
* Each feature is defined by a permanent string name. The feature string
* names will vary with the particular installation of X-Plane, so plugins
* names will vary with the particular installation of X-Plane, so plugins
* should not expect a feature to be guaranteed present.
*
* XPLM_WANTS_REFLECTIONS
* ----------------------
*
* Available in the SDK 2.0 and later for X-Plane 9, enabling this capability
* causes your plugin to receive drawing hook callbacks when X-Plane builds
* its off-screen reflection and shadow rendering passes. Plugins should
* enable this and examine the dataref sim/graphics/view/plane_render_type to
* determine whether the drawing callback is for a reflection, shadow
* calculation, or the main screen. Rendering can be simlified or omitted for
* reflections, and non-solid drawing should be skipped for shadow
* calculations.
*
* **Note**: direct drawing via draw callbacks is not recommended; use the
* XPLMInstance API to create object models instead.
*
* XPLM_USE_NATIVE_PATHS
* ---------------------
*
* available in the SDK 2.1 and later for X-Plane 10, this modifies the plugin
* system to use Unix-style paths on all operating systems. With this enabled:
*
* * OS X paths will match the native OS X Unix.
* * Windows will use forward slashes but preserve C:\ or another drive letter
* when using complete file paths.
* * Linux uses its native file system path scheme.
*
* Without this enabled:
*
* * OS X will use CFM file paths separated by a colon.
* * Windows will use back-slashes and conventional DOS paths.
* * Linux uses its native file system path scheme.
*
* All plugins should enable this feature on OS X to access the native file
* system.
*
* XPLM_USE_NATIVE_WIDGET_WINDOWS
* ------------------------------
*
* Available in the SDK 3.0.2 SDK, this capability tells the widgets library
* to use new, modern X-Plane backed XPLMDisplay windows to anchor all widget
* trees. Without it, widgets will always use legacy windows.
*
* Plugins should enable this to allow their widget hierarchies to respond to
* the user's UI size settings and to map widget-based windwos to a VR HMD.
*
* Before enabling this, make sure any custom widget code in your plugin is
* prepared to cope with the UI coordinate system not being th same as the
* OpenGL window coordinate system.
*
*/
@@ -261,7 +365,9 @@ XPLM_API void XPLMSendMessageToPlugin(XPLMPluginID inPlugin,
* for each feature.
*
*/
typedef void (*XPLMFeatureEnumerator_f)(const char *inFeature, void *inRef);
typedef void (* XPLMFeatureEnumerator_f)(
const char * inFeature,
void * inRef);
/*
* XPLMHasFeature
@@ -270,7 +376,8 @@ typedef void (*XPLMFeatureEnumerator_f)(const char *inFeature, void *inRef);
* 0 if it does not.
*
*/
XPLM_API int XPLMHasFeature(const char *inFeature);
XPLM_API int XPLMHasFeature(
const char * inFeature);
/*
* XPLMIsFeatureEnabled
@@ -280,7 +387,8 @@ XPLM_API int XPLMHasFeature(const char *inFeature);
* feature.
*
*/
XPLM_API int XPLMIsFeatureEnabled(const char *inFeature);
XPLM_API int XPLMIsFeatureEnabled(
const char * inFeature);
/*
* XPLMEnableFeature
@@ -290,7 +398,9 @@ XPLM_API int XPLMIsFeatureEnabled(const char *inFeature);
* depending on the feature.
*
*/
XPLM_API void XPLMEnableFeature(const char *inFeature, int inEnable);
XPLM_API void XPLMEnableFeature(
const char * inFeature,
int inEnable);
/*
* XPLMEnumerateFeatures
@@ -300,8 +410,9 @@ XPLM_API void XPLMEnableFeature(const char *inFeature, int inEnable);
* the features that X-Plane can support.
*
*/
XPLM_API void XPLMEnumerateFeatures(XPLMFeatureEnumerator_f inEnumerator,
void *inRef);
XPLM_API void XPLMEnumerateFeatures(
XPLMFeatureEnumerator_f inEnumerator,
void * inRef);
#endif /* XPLM200 */
#ifdef __cplusplus
XPSDK/CHeaders/XPLM/XPLMProcessing.h
+114 -98
View File
@@ -2,23 +2,38 @@
#define _XPLMProcessing_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMProcessing
***************************************************************************/
/*
* This API allows you to get regular callbacks during the flight loop, the
* part of X-Plane where the plane's position calculates the physics of
* flight, etc. Use these APIs to accomplish periodic tasks like logging data
* flight, etc. Use these APIs to accomplish periodic tasks like logging data
* and performing I/O.
*
* WARNING: Do NOT use these callbacks to draw! You cannot draw during flight
* loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info)
* for graphics.
* You can receive a callback either just before or just after the per-frame
* physics calculations happen - you can use post-FM callbacks to "patch" the
* flight model after it has run.
*
* If the user has set the number of flight model iterations per frame greater
* than one your plugin will _not_ see this; these integrations run on the
* sub-section of the flight model where iterations improve responsiveness
* (e.g. physical integration, not simple systems tracking) and are thus
* opaque to plugins.
*
* Flight loop scheduling, when scheduled by time, is scheduled by a "first
* callback after the deadline" schedule, e.g. your callbacks will always be
* slightly late to ensure that we don't run faster than your deadline.
*
* WARNING: Do NOT use these callbacks to draw! You cannot draw during flight
* loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info)
* for graphics. (One exception: you can use a post-flight loop callback to
* update your own off-screen FBOs.)
*
*/
@@ -31,11 +46,6 @@ extern "C" {
/***************************************************************************
* FLIGHT LOOP CALLBACKS
***************************************************************************/
/*
*
*
*/
#if defined(XPLM210)
/*
@@ -46,12 +56,11 @@ extern "C" {
*
*/
enum {
/* Your callback runs before X-Plane integrates the flight model. */
xplm_FlightLoop_Phase_BeforeFlightModel = 0
/* Your callback runs before X-Plane integrates the flight model. */
xplm_FlightLoop_Phase_BeforeFlightModel = 0,
/* Your callback runs after X-Plane integrates the flight model. */
,
xplm_FlightLoop_Phase_AfterFlightModel = 1
/* Your callback runs after X-Plane integrates the flight model. */
xplm_FlightLoop_Phase_AfterFlightModel = 1,
};
@@ -62,56 +71,67 @@ typedef int XPLMFlightLoopPhaseType;
/*
* XPLMFlightLoopID
*
* This is an opaque identifier for a flight loop callback. You can use this
* This is an opaque identifier for a flight loop callback. You can use this
* identifier to easily track and remove your callbacks, or to use the new
* flight loop APIs.
*
*/
typedef void *XPLMFlightLoopID;
typedef void * XPLMFlightLoopID;
#endif /* XPLM210 */
/*
* XPLMFlightLoop_f
*
* This is your flight loop callback. Each time the flight loop is iterated
* through, you receive this call at the end. You receive a time since you
* were last called and a time since the last loop, as well as a loop counter.
* The 'phase' parameter is deprecated and should be ignored.
* This is your flight loop callback. Each time the flight loop is iterated
* through, you receive this call at the end.
*
* Your return value controls when you will next be called. Return 0 to stop
* receiving callbacks. Pass a positive number to specify how many seconds
* until the next callback. (You will be called at or after this time, not
* before.) Pass a negative number to specify how many loops must go by until
* you are called. For example, -1.0 means call me the very next loop. Try
* to run your flight loop as infrequently as is practical, and suspend it
* Flight loop callbacks receive a number of input timing parameters. These
* input timing parameters are not particularly useful; you may need to track
* your own timing data (e.g. by reading datarefs). The input parameters are:
*
* - inElapsedSinceLastCall: the wall time since your last callback.
* - inElapsedTimeSinceLastFlightLoop: the wall time since any flight loop was
* dispatched.
* - inCounter: a monotonically increasing counter, bumped once per flight
* loop dispatch from the sim.
* - inRefcon: your own ptr constant from when you regitered yor callback.
*
* Your return value controls when you will next be called.
*
* - Return 0 to stop receiving callbacks.
* - Pass a positive number to specify how many seconds until the next
* callback. (You will be called at or after this time, not before.)
* - Pass a negative number to specify how many loops must go by until you
* are called. For example, -1.0 means call me the very next loop.
*
* Try to run your flight loop as infrequently as is practical, and suspend it
* (using return value 0) when you do not need it; lots of flight loop
* callbacks that do nothing lowers x-plane's frame rate.
* callbacks that do nothing lowers X-Plane's frame rate.
*
* Your callback will NOT be unregistered if you return 0; it will merely be
* inactive.
*
* The reference constant you passed to your loop is passed back to you.
*
*/
typedef float (*XPLMFlightLoop_f)(float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter,
void *inRefcon);
typedef float (* XPLMFlightLoop_f)(
float inElapsedSinceLastCall,
float inElapsedTimeSinceLastFlightLoop,
int inCounter,
void * inRefcon);
#if defined(XPLM210)
/*
* XPLMCreateFlightLoop_t
*
* XPLMCreateFlightLoop_t contains the parameters to create a new flight loop
* callback. The strsucture can be expanded in future SDKs - always set
* callback. The strsucture can be expanded in future SDKs - always set
* structSize to the size of your structure in bytes.
*
*/
typedef struct {
int structSize;
XPLMFlightLoopPhaseType phase;
XPLMFlightLoop_f callbackFunc;
void *refcon;
int structSize;
XPLMFlightLoopPhaseType phase;
XPLMFlightLoop_f callbackFunc;
void * refcon;
} XPLMCreateFlightLoop_t;
#endif /* XPLM210 */
@@ -119,10 +139,15 @@ typedef struct {
* XPLMGetElapsedTime
*
* This routine returns the elapsed time since the sim started up in decimal
* seconds.
* seconds. This is a wall timer; it keeps counting upward even if the sim is
* pasued.
*
* __WARNING__: XPLMGetElapsedTime is not a very good timer! It lacks
* precision in both its data type and its source. Do not attempt to use it
* for timing critical applications like network multiplayer.
*
*/
XPLM_API float XPLMGetElapsedTime(void);
XPLM_API float XPLMGetElapsedTime(void);
/*
* XPLMGetCycleNumber
@@ -131,114 +156,105 @@ XPLM_API float XPLMGetElapsedTime(void);
* computed/video frame rendered.
*
*/
XPLM_API int XPLMGetCycleNumber(void);
XPLM_API int XPLMGetCycleNumber(void);
/*
* XPLMRegisterFlightLoopCallback
*
* This routine registers your flight loop callback. Pass in a pointer to a
* flight loop function and a refcon. inInterval defines when you will be
* called. Pass in a positive number to specify seconds from registration
* time to the next callback. Pass in a negative number to indicate when you
* will be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to
* not be called; your callback will be inactive.
* This routine registers your flight loop callback. Pass in a pointer to a
* flight loop function and a refcon. inInterval defines when you will be
* called. Pass in a positive number to specify seconds from registration time
* to the next callback. Pass in a negative number to indicate when you will
* be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to not be
* called; your callback will be inactive.
*
* (This legacy function only installs pre-flight-loop callbacks; use
* XPLMCreateFlightLoop for more control.)
*
*/
XPLM_API void XPLMRegisterFlightLoopCallback(XPLMFlightLoop_f inFlightLoop,
float inInterval,
void *inRefcon);
XPLM_API void XPLMRegisterFlightLoopCallback(
XPLMFlightLoop_f inFlightLoop,
float inInterval,
void * inRefcon);
/*
* XPLMUnregisterFlightLoopCallback
*
* This routine unregisters your flight loop callback. Do NOT call it from
* your flight loop callback. Once your flight loop callback is
* unregistered, it will not be called again.
* This routine unregisters your flight loop callback. Do NOT call it from
* your flight loop callback. Once your flight loop callback is unregistered,
* it will not be called again.
*
* Only use this on flight loops registered via
* XPLMRegisterFlightLoopCallback.
*
*/
XPLM_API void XPLMUnregisterFlightLoopCallback(XPLMFlightLoop_f inFlightLoop,
void *inRefcon);
XPLM_API void XPLMUnregisterFlightLoopCallback(
XPLMFlightLoop_f inFlightLoop,
void * inRefcon);
/*
* XPLMSetFlightLoopCallbackInterval
*
* This routine sets when a callback will be called. Do NOT call it from your
* This routine sets when a callback will be called. Do NOT call it from your
* callback; use the return value of the callback to change your callback
* interval from inside your callback.
*
* inInterval is formatted the same way as in XPLMRegisterFlightLoopCallback;
* positive for seconds, negative for cycles, and 0 for deactivating the
* callback. If inRelativeToNow is 1, times are from the time of this call;
* callback. If inRelativeToNow is 1, times are from the time of this call;
* otherwise they are from the time the callback was last called (or the time
* it was registered if it has never been called.
*
*/
XPLM_API void XPLMSetFlightLoopCallbackInterval(XPLMFlightLoop_f inFlightLoop,
float inInterval,
int inRelativeToNow,
void *inRefcon);
XPLM_API void XPLMSetFlightLoopCallbackInterval(
XPLMFlightLoop_f inFlightLoop,
float inInterval,
int inRelativeToNow,
void * inRefcon);
#if defined(XPLM210)
/*
* XPLMCreateFlightLoop
*
* This routine creates a flight loop callback and returns its ID. The flight
* This routine creates a flight loop callback and returns its ID. The flight
* loop callback is created using the input param struct, and is inited to be
* unscheduled.
*
*/
XPLM_API XPLMFlightLoopID
XPLMCreateFlightLoop(XPLMCreateFlightLoop_t *inParams);
XPLM_API XPLMFlightLoopID XPLMCreateFlightLoop(
XPLMCreateFlightLoop_t * inParams);
#endif /* XPLM210 */
#if defined(XPLM210)
/*
* XPLMDestroyFlightLoop
*
* This routine destroys a flight loop callback by ID.
* This routine destroys a flight loop callback by ID. Only call it on flight
* loops created with the newer XPLMCreateFlightLoop API.
*
*/
XPLM_API void XPLMDestroyFlightLoop(XPLMFlightLoopID inFlightLoopID);
XPLM_API void XPLMDestroyFlightLoop(
XPLMFlightLoopID inFlightLoopID);
#endif /* XPLM210 */
#if defined(XPLM210)
/*
* XPLMScheduleFlightLoop
*
* This routine schedules a flight loop callback for future execution. If
* inInterval is negative, it is run in a certain number of frames based on
* the absolute value of the input. If the interval is positive, it is a
* This routine schedules a flight loop callback for future execution. If
* inInterval is negative, it is run in a certain number of frames based on
* the absolute value of the input. If the interval is positive, it is a
* duration in seconds.
*
* If inRelativeToNow is true, ties are interpretted relative to the time this
* routine is called; otherwise they are relative to the last call time or the
* time the flight loop was registered (if never called).
*
* THREAD SAFETY: it is legal to call this routine from any thread under the
* following conditions:
*
* 1. The call must be between the beginning of an XPLMEnable and the end of
* an XPLMDisable sequence. (That is, you must not call this routine from
* thread activity when your plugin was supposed to be disabled. Since
* plugins are only enabled while loaded, this also implies you cannot run
* this routine outside an XPLMStart/XPLMStop sequence.)
*
* 2. You may not call this routine re-entrantly for a single flight loop ID.
* (That is, you can't enable from multiple threads at the same time.)
*
* 3. You must call this routine between the time after XPLMCreateFlightLoop
* returns a value and the time you call XPLMDestroyFlightLoop. (That is, you
* must ensure that your threaded activity is within the life of the object.
* The SDK does not check this for you, nor does it synchronize destruction of
* the object.)
*
* 4. The object must be unscheduled if this routine is to be called from a
* thread other than the main thread.
*
*/
XPLM_API void XPLMScheduleFlightLoop(XPLMFlightLoopID inFlightLoopID,
float inInterval,
int inRelativeToNow);
XPLM_API void XPLMScheduleFlightLoop(
XPLMFlightLoopID inFlightLoopID,
float inInterval,
int inRelativeToNow);
#endif /* XPLM210 */
#ifdef __cplusplus
XPSDK/CHeaders/XPLM/XPLMScenery.h
+195 -131
View File
@@ -2,14 +2,14 @@
#define _XPLMScenery_h_
/*
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 2.1.1
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
* license.txt for usage. X-Plane SDK Version: 2.1.1
*
*/
/***************************************************************************
* XPLMScenery
***************************************************************************/
/*
* This package contains APIs to interact with X-Plane's scenery system.
*
@@ -26,29 +26,32 @@ extern "C" {
* Terrain Y-Testing
***************************************************************************/
/*
* The Y-testing API allows you to locate the physical scenery mesh. This
* would be used to place dynamic graphics on top of the ground in a
* plausible way or do physics interactions.
* The Y-testing API allows you to locate the physical scenery mesh. This
* would be used to place dynamic graphics on top of the ground in a plausible
* way or do physics interactions.
*
* The Y-test API works via probe objects, which are allocated by your plugin
* and used to query terrain. Probe objects exist both to capture which
* algorithm you have requested (see probe types) and also to cache query
* information.
*
* Performance guidelines: It is generally faster to use the same probe for
* nearby points and different probes for different points. Try not to
* allocate more than "hundreds" of probes at most. Share probes if you need
* more. Generally, probing operations are expensive, and should be avoided
* via caching when possible.
* Performance Guidelines
* ----------------------
*
* It is generally faster to use the same probe for nearby points and
* different probes for different points. Try not to allocate more than
* "hundreds" of probes at most. Share probes if you need more. Generally,
* probing operations are expensive, and should be avoided via caching when
* possible.
*
* Y testing returns a location on the terrain, a normal vectory, and a
* velocity vector. The normal vector tells you the slope of the terrain at
* that point. The velocity vector tells you if that terrain is moving (and
* is in meters/second). For example, if your Y test hits the aircraft carrier
* velocity vector. The normal vector tells you the slope of the terrain at
* that point. The velocity vector tells you if that terrain is moving (and is
* in meters/second). For example, if your Y test hits the aircraft carrier
* deck, this tells you the velocity of that point on the deck.
*
* Note: the Y-testing API is limited to probing the loaded scenery area,
* which is approximately 300x300 km in X-Plane 9. Probes outside this area
* which is approximately 300x300 km in X-Plane 9. Probes outside this area
* will return the height of a 0 MSL sphere.
*
*/
@@ -58,14 +61,14 @@ extern "C" {
* XPLMProbeType
*
* XPLMProbeType defines the type of terrain probe - each probe has a
* different algorithm. (Only one type of probe is provided right now, but
* different algorithm. (Only one type of probe is provided right now, but
* future APIs will expose more flexible or poewrful or useful probes.
*
*/
enum {
/* The Y probe gives you the location of the tallest physical scenery along
* * the Y axis going through the queried point. */
xplm_ProbeY = 0
/* The Y probe gives you the location of the tallest physical scenery along *
* the Y axis going through the queried point. */
xplm_ProbeY = 0,
};
@@ -78,19 +81,16 @@ typedef int XPLMProbeType;
*
*/
enum {
/* The probe hit terrain and returned valid values. */
xplm_ProbeHitTerrain = 0
/* The probe hit terrain and returned valid values. */
xplm_ProbeHitTerrain = 0,
/* An error in the API call. Either the probe struct size is bad, or the *
* probe is invalid or the type is mismatched for the specific query call.
*/
,
xplm_ProbeError = 1
/* An error in the API call. Either the probe struct size is bad, or the *
* probe is invalid or the type is mismatched for the specific query call. */
xplm_ProbeError = 1,
/* The probe call succeeded but there is no terrain under this point
* (perhaps * it is off the side of the planet?) */
,
xplm_ProbeMissed = 2
/* The probe call succeeded but there is no terrain under this point (perhaps *
* it is off the side of the planet?) */
xplm_ProbeMissed = 2,
};
@@ -103,41 +103,41 @@ typedef int XPLMProbeResult;
* terrain.
*
*/
typedef void *XPLMProbeRef;
typedef void * XPLMProbeRef;
/*
* XPLMProbeInfo_t
*
* XPLMProbeInfo_t contains the results of a probe call. Make sure to set
* XPLMProbeInfo_t contains the results of a probe call. Make sure to set
* structSize to the size of the struct before using it.
*
*/
typedef struct {
/* Size of structure in bytes - always set this before calling the XPLM. */
int structSize;
/* Resulting X location of the terrain point we hit, in local OpenGL *
* coordinates. */
float locationX;
/* Resulting Y location of the terrain point we hit, in local OpenGL *
* coordinates. */
float locationY;
/* Resulting Z location of the terrain point we hit, in local OpenGL *
* coordinates. */
float locationZ;
/* X component of the normal vector to the terrain we found. */
float normalX;
/* Y component of the normal vector to the terrain we found. */
float normalY;
/* Z component of the normal vector to the terrain we found. */
float normalZ;
/* X component of the velocity vector of the terrain we found. */
float velocityX;
/* Y component of the velocity vector of the terrain we found. */
float velocityY;
/* Z component of the velocity vector of the terrain we found. */
float velocityZ;
/* Tells if the surface we hit is water (otherwise it is land). */
int is_wet;
/* Size of structure in bytes - always set this before calling the XPLM. */
int structSize;
/* Resulting X location of the terrain point we hit, in local OpenGL *
* coordinates. */
float locationX;
/* Resulting Y location of the terrain point we hit, in local OpenGL *
* coordinates. */
float locationY;
/* Resulting Z location of the terrain point we hit, in local OpenGL *
* coordinates. */
float locationZ;
/* X component of the normal vector to the terrain we found. */
float normalX;
/* Y component of the normal vector to the terrain we found. */
float normalY;
/* Z component of the normal vector to the terrain we found. */
float normalZ;
/* X component of the velocity vector of the terrain we found. */
float velocityX;
/* Y component of the velocity vector of the terrain we found. */
float velocityY;
/* Z component of the velocity vector of the terrain we found. */
float velocityZ;
/* Tells if the surface we hit is water (otherwise it is land). */
int is_wet;
} XPLMProbeInfo_t;
/*
@@ -146,7 +146,8 @@ typedef struct {
* Creates a new probe object of a given type and returns.
*
*/
XPLM_API XPLMProbeRef XPLMCreateProbe(XPLMProbeType inProbeType);
XPLM_API XPLMProbeRef XPLMCreateProbe(
XPLMProbeType inProbeType);
/*
* XPLMDestroyProbe
@@ -154,30 +155,83 @@ XPLM_API XPLMProbeRef XPLMCreateProbe(XPLMProbeType inProbeType);
* Deallocates an existing probe object.
*
*/
XPLM_API void XPLMDestroyProbe(XPLMProbeRef inProbe);
XPLM_API void XPLMDestroyProbe(
XPLMProbeRef inProbe);
/*
* XPLMProbeTerrainXYZ
*
* Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe
* object, and an XPLMProbeInfo_t struct that has its structSize member set
* properly. Other fields are filled in if we hit terrain, and a probe result
* Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe
* object, and an XPLMProbeInfo_t struct that has its structSize member set
* properly. Other fields are filled in if we hit terrain, and a probe result
* is returned.
*
*/
XPLM_API XPLMProbeResult XPLMProbeTerrainXYZ(XPLMProbeRef inProbe,
float inX,
float inY,
float inZ,
XPLMProbeInfo_t *outInfo);
XPLM_API XPLMProbeResult XPLMProbeTerrainXYZ(
XPLMProbeRef inProbe,
float inX,
float inY,
float inZ,
XPLMProbeInfo_t * outInfo);
#endif /* XPLM200 */
#if defined(XPLM300)
/***************************************************************************
* Magnetic Variation
***************************************************************************/
/*
* Use the magnetic variation (more properly, the "magnetic declination") API
* to find the offset of magnetic north from true north at a given latitude
* and longitude within the simulator.
*
* In the real world, the Earth's magnetic field is irregular, such that true
* north (the direction along a meridian toward the north pole) does not
* necessarily match what a magnetic compass shows as north.
*
* Using this API ensures that you present the same offsets to users as
* X-Plane's built-in instruments.
*
*/
/*
* XPLMGetMagneticVariation
*
* Returns X-Plane's simulated magnetic variation (declination) at the
* indication latitude and longitude.
*
*/
XPLM_API float XPLMGetMagneticVariation(
double latitude,
double longitude);
/*
* XPLMDegTrueToDegMagnetic
*
* Converts a heading in degrees relative to true north into a value relative
* to magnetic north at the user's current location.
*
*/
XPLM_API float XPLMDegTrueToDegMagnetic(
float headingDegreesTrue);
/*
* XPLMDegMagneticToDegTrue
*
* Converts a heading in degrees relative to magnetic north at the user's
* current location into a value relative to true north.
*
*/
XPLM_API float XPLMDegMagneticToDegTrue(
float headingDegreesMagnetic);
#endif /* XPLM300 */
/***************************************************************************
* Object Drawing
***************************************************************************/
/*
* The object drawing routines let you load and draw X-Plane OBJ files.
* Objects are loaded by file path and managed via an opaque handle. X-Plane
* Objects are loaded by file path and managed via an opaque handle. X-Plane
* naturally reference counts objects, so it is important that you balance
* every successful call to XPLMLoadObject with a call to XPLMUnloadObject!
*
@@ -192,7 +246,7 @@ XPLM_API XPLMProbeResult XPLMProbeTerrainXYZ(XPLMProbeRef inProbe,
* into memory.
*
*/
typedef void *XPLMObjectRef;
typedef void * XPLMObjectRef;
#endif /* XPLM200 */
#if defined(XPLM200)
@@ -205,20 +259,20 @@ typedef void *XPLMObjectRef;
*
*/
typedef struct {
/* Set this to the size of this structure! */
int structSize;
/* X location of the object in local coordinates. */
float x;
/* Y location of the object in local coordinates. */
float y;
/* Z location of the object in local coordinates. */
float z;
/* Pitch in degres to rotate the object, positive is up. */
float pitch;
/* Heading in local coordinates to rotate the object, clockwise. */
float heading;
/* Roll to rotate the object. */
float roll;
/* Set this to the size of this structure! */
int structSize;
/* X location of the object in local coordinates. */
float x;
/* Y location of the object in local coordinates. */
float y;
/* Z location of the object in local coordinates. */
float z;
/* Pitch in degres to rotate the object, positive is up. */
float pitch;
/* Heading in local coordinates to rotate the object, clockwise. */
float heading;
/* Roll to rotate the object. */
float roll;
} XPLMDrawInfo_t;
#endif /* XPLM200 */
@@ -227,44 +281,46 @@ typedef struct {
* XPLMObjectLoaded_f
*
* You provide this callback when loading an object asynchronously; it will be
* called once the object is loaded. Your refcon is passed back. The object
* called once the object is loaded. Your refcon is passed back. The object
* ref passed in is the newly loaded object (ready for use) or NULL if an
* error occured.
*
* If your plugin is disabled, this callback will be delivered as soon as the
* plugin is re-enabled. If your plugin is unloaded before this callback is
* plugin is re-enabled. If your plugin is unloaded before this callback is
* ever called, the SDK will release the object handle for you.
*
*/
typedef void (*XPLMObjectLoaded_f)(XPLMObjectRef inObject, void *inRefcon);
typedef void (* XPLMObjectLoaded_f)(
XPLMObjectRef inObject,
void * inRefcon);
#endif /* XPLM210 */
#if defined(XPLM200)
/*
* XPLMLoadObject
*
* This routine loads an OBJ file and returns a handle to it. If X-plane has
* This routine loads an OBJ file and returns a handle to it. If X-Plane has
* already loaded the object, the handle to the existing object is returned.
* Do not assume you will get the same handle back twice, but do make sure to
* call unload once for every load to avoid "leaking" objects. The object
* will be purged from memory when no plugins and no scenery are using it.
* call unload once for every load to avoid "leaking" objects. The object will
* be purged from memory when no plugins and no scenery are using it.
*
* The path for the object must be relative to the X-System base folder. If
* The path for the object must be relative to the X-System base folder. If
* the path is in the root of the X-System folder you may need to prepend ./
* to it; loading objects in the root of the X-System folder is STRONGLY
* discouraged - your plugin should not dump art resources in the root folder!
*
*
* XPLMLoadObject will return NULL if the object cannot be loaded (either
* because it is not found or the file is misformatted). This routine will
* load any object that can be used in the X-Plane scenery system.
*
* It is important that the datarefs an object uses for animation already be
* loaded before you load the object. For this reason it may be necessary to
* loaded before you load the object. For this reason it may be necessary to
* defer object loading until the sim has fully started.
*
*/
XPLM_API XPLMObjectRef XPLMLoadObject(const char *inPath);
XPLM_API XPLMObjectRef XPLMLoadObject(
const char * inPath);
#endif /* XPLM200 */
#if defined(XPLM210)
@@ -272,9 +328,9 @@ XPLM_API XPLMObjectRef XPLMLoadObject(const char *inPath);
* XPLMLoadObjectAsync
*
* This routine loads an object asynchronously; control is returned to you
* immediately while X-Plane loads the object. The sim will not stop flying
* while the object loads. For large objects, it may be several seconds
* before the load finishes.
* immediately while X-Plane loads the object. The sim will not stop flying
* while the object loads. For large objects, it may be several seconds before
* the load finishes.
*
* You provide a callback function that is called once the load has completed.
* Note that if the object cannot be loaded, you will not find out until the
@@ -285,42 +341,46 @@ XPLM_API XPLMObjectRef XPLMLoadObject(const char *inPath);
* desired.
*
*/
XPLM_API void XPLMLoadObjectAsync(const char *inPath,
XPLMObjectLoaded_f inCallback,
void *inRefcon);
XPLM_API void XPLMLoadObjectAsync(
const char * inPath,
XPLMObjectLoaded_f inCallback,
void * inRefcon);
#endif /* XPLM210 */
#if defined(XPLM200)
#if defined(XPLM_DEPRECATED)
/*
* XPLMDrawObjects
*
* XPLMDrawObjects draws an object from an OBJ file one or more times. You
* pass in the object and an array of XPLMDrawInfo_t structs, one for each
* __Deprecation Warning__: use XPLMInstancing to draw 3-d objects by creating
* instances, rather than these APIs from draw callbacks.
*
* XPLMDrawObjects draws an object from an OBJ file one or more times. You
* pass in the object and an array of XPLMDrawInfo_t structs, one for each
* place you would like the object to be drawn.
*
* X-Plane will attempt to cull the objects based on LOD and visibility, and
* will pick the appropriate LOD.
*
* Lighting is a boolean; pass 1 to show the night version of object with
* night-only lights lit up. Pass 0 to show the daytime version of the
* object.
* night-only lights lit up. Pass 0 to show the daytime version of the object.
*
* earth_relative controls the coordinate system. If this is 1, the rotations
* earth_relative controls the coordinate system. If this is 1, the rotations
* you specify are applied to the object after its coordinate system is
* transformed from local to earth-relative coordinates -- that is, an object
* with no rotations will point toward true north and the Y axis will be up
* against gravity. If this is 0, the object is drawn with your rotations
* from local coordanates -- that is, an object with no rotations is drawn
* pointing down the -Z axis and the Y axis of the object matches the local
* coordinate Y axis.
* against gravity. If this is 0, the object is drawn with your rotations from
* local coordanates -- that is, an object with no rotations is drawn pointing
* down the -Z axis and the Y axis of the object matches the local coordinate
* Y axis.
*
*/
XPLM_API void XPLMDrawObjects(XPLMObjectRef inObject,
int inCount,
XPLMDrawInfo_t *inLocations,
int lighting,
int earth_relative);
#endif /* XPLM200 */
XPLM_API void XPLMDrawObjects(
XPLMObjectRef inObject,
int inCount,
XPLMDrawInfo_t * inLocations,
int lighting,
int earth_relative);
#endif /* XPLM_DEPRECATED */
#if defined(XPLM200)
/*
@@ -328,11 +388,12 @@ XPLM_API void XPLMDrawObjects(XPLMObjectRef inObject,
*
* This routine marks an object as no longer being used by your plugin.
* Objects are reference counted: once no plugins are using an object, it is
* purged from memory. Make sure to call XPLMUnloadObject once for each
* purged from memory. Make sure to call XPLMUnloadObject once for each
* successful call to XPLMLoadObject.
*
*/
XPLM_API void XPLMUnloadObject(XPLMObjectRef inObject);
XPLM_API void XPLMUnloadObject(
XPLMObjectRef inObject);
#endif /* XPLM200 */
#if defined(XPLM200)
@@ -341,7 +402,7 @@ XPLM_API void XPLMUnloadObject(XPLMObjectRef inObject);
***************************************************************************/
/*
* The library access routines allow you to locate scenery objects via the
* X-Plane library system. Right now library access is only provided for
* X-Plane library system. Right now library access is only provided for
* objects, allowing plugin-drawn objects to be extended using the library
* system.
*
@@ -356,27 +417,30 @@ XPLM_API void XPLMUnloadObject(XPLMObjectRef inObject);
* relative to the X-System folder.
*
*/
typedef void (*XPLMLibraryEnumerator_f)(const char *inFilePath, void *inRef);
typedef void (* XPLMLibraryEnumerator_f)(
const char * inFilePath,
void * inRef);
/*
* XPLMLookupObjects
*
* This routine looks up a virtual path in the library system and returns all
* matching elements. You provide a callback - one virtual path may match
* many objects in the library. XPLMLookupObjects returns the number of
* objects found.
* matching elements. You provide a callback - one virtual path may match many
* objects in the library. XPLMLookupObjects returns the number of objects
* found.
*
* The latitude and longitude parameters specify the location the object will
* be used. The library system allows for scenery packages to only provide
* objects to certain local locations. Only objects that are allowed at the
* be used. The library system allows for scenery packages to only provide
* objects to certain local locations. Only objects that are allowed at the
* latitude/longitude you provide will be returned.
*
*/
XPLM_API int XPLMLookupObjects(const char *inPath,
float inLatitude,
float inLongitude,
XPLMLibraryEnumerator_f enumerator,
void *ref);
XPLM_API int XPLMLookupObjects(
const char * inPath,
float inLatitude,
float inLongitude,
XPLMLibraryEnumerator_f enumerator,
void * ref);
#endif /* XPLM200 */
#ifdef __cplusplus
XPSDK/CHeaders/XPLM/XPLMUtilities.h
+756 -615
View File
File diff suppressed because it is too large Load Diff
XPSDK/Delphi/Widgets/XPStandardWidgets.pas
+119 -146
View File
@@ -1,46 +1,40 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPStandardWidgets;
INTERFACE
{
XPStandardWidgets - THEORY OF OPERATION
## THEORY OF OPERATION
The standard widgets are widgets built into the widgets library. While you
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
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.
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.
}
USES XPWidgetDefs;
USES
XPWidgetDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
These windows are dragable and can be selected. Use them to create floating
windows and non-modal dialogs.
}
CONST
xpWidgetClass_MainWindow = 1;
@@ -49,31 +43,29 @@ CONST
These type values are used to control the appearance of a main window.
}
{ The standard main window; pin stripes on XP7, metal frame on XP 6. }
{ 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. }
{ A translucent dark gray window, like the one ATC messages appear in. }
xpMainWindowStyle_Translucent = 1
;
{
Main Window Properties
}
{ This property specifies the type of window. Set to one of the main window }
{ types above. }
{ 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. }
{ This property specifies whether the main window has close boxes in its }
{ corners. }
xpProperty_MainWindowHasCloseBoxes = 1200
;
{
MainWindow Messages
}
{ This message is sent when the close buttons are pressed for your window. }
{ This message is sent when the close buttons are pressed for your window. }
xpMessage_CloseButtonPushed = 1200
;
@@ -81,13 +73,12 @@ CONST
* SUB WINDOW
___________________________________________________________________________}
{
X-plane dialogs are divided into separate areas; the sub window widgets
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.
subwindows inside it. Then place your controls inside the subwindows.
}
CONST
xpWidgetClass_SubWindow = 2;
@@ -96,22 +87,21 @@ CONST
These values control the appearance of the subwindow.
}
{ A panel that sits inside a main window. }
{ A panel that sits inside a main window. }
xpSubWindowStyle_SubWindow = 0
;
{ A screen that sits inside a panel for showing text information. }
{ A screen that sits inside a panel for showing text information. }
xpSubWindowStyle_Screen = 2
;
{ A list view for scrolling lists. }
{ A list view for scrolling lists. }
xpSubWindowStyle_ListView = 3
;
{
SubWindow Properties
}
{ This property specifies the type of window. Set to one of the subwindow }
{ types above. }
{ This property specifies the type of window. Set to one of the subwindow }
{ types above. }
xpProperty_SubWindowType = 1200
;
@@ -120,25 +110,24 @@ CONST
___________________________________________________________________________}
{
The button class provides a number of different button styles and
behaviors, including push buttons, radio buttons, check boxes, etc. The
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.
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.
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.
}
CONST
xpWidgetClass_Button = 3;
@@ -148,21 +137,21 @@ CONST
These define the visual appearance of buttons but not how they respond to
the mouse.
}
{ This is a standard push button, like an "OK" or "Cancel" button in a dialog }
{ box. }
{ 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. }
{ A check box or radio button. Use this and the button behaviors below to }
{ get the desired behavior. }
xpRadioButton = 1
;
{ A window close box. }
{ A window close box. }
xpWindowCloseBox = 3
;
{ A small down arrow. }
{ A small down arrow. }
xpLittleDownArrow = 5
;
{ A small up arrow. }
{ A small up arrow. }
xpLittleUpArrow = 6
;
@@ -171,36 +160,35 @@ CONST
These define how the button responds to mouse clicks.
}
{ 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. }
{ 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. }
{ 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. }
{ 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
}
{ This property sets the visual type of button. Use one of the button types }
{ above. }
{ 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. }
{ 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. }
{ This property tells whether a check box or radio button is "checked" or }
{ not. Not used for push buttons. }
xpProperty_ButtonState = 1302
;
@@ -208,21 +196,21 @@ CONST
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
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.)
}
{ 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. }
{ 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. }
{ 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
;
@@ -231,24 +219,23 @@ CONST
___________________________________________________________________________}
{
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.)
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
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
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).
}
CONST
xpWidgetClass_TextField = 4;
@@ -257,64 +244,60 @@ CONST
These control the look of the text field.
}
{ A field for text entry. }
{ 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. }
{ 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. }
{ A translucent edit field, dark gray. }
xpTextTranslucent = 4
;
{
Text Field Properties
}
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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.) }
{ The font to draw the field's text with. (An XPLMFontID.) }
xpProperty_Font = 1407
;
{ This is the active side of the insert selection. (Internal) }
{ This is the active side of the insert selection. (Internal) }
xpProperty_ActiveEditSide = 1408
;
{
Text Field Messages
}
{ 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. }
{ 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
;
@@ -322,13 +305,12 @@ CONST
* 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
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.
}
CONST
xpWidgetClass_ScrollBar = 5;
@@ -337,45 +319,41 @@ CONST
This defines how the scroll bar looks.
}
{ Scroll bar types. }
{ }
{ A standard x-plane scroll bar (with arrows on the ends). }
{ A standard X-Plane scroll bar (with arrows on the ends). }
xpScrollBarTypeScrollBar = 0
;
{ A slider, no arrows. }
{ A slider, no arrows. }
xpScrollBarTypeSlider = 1
;
{
Scroll Bar Properties
}
{ The current position of the thumb (in between the min and max, inclusive) }
{ 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. }
{ 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. }
{ 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. }
{ How many units to move 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. }
{ The type of scrollbar from the enums above. }
xpProperty_ScrollBarType = 1504
;
{ Used internally. }
{ Used internally. }
xpProperty_ScrollBarSlop = 1505
;
{
Scroll Bar Messages
}
{ 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. }
{ 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
;
@@ -384,21 +362,19 @@ CONST
___________________________________________________________________________}
{
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
for labeling parts of a window. It always shows its descriptor as its
string and is otherwise transparent.
}
CONST
xpWidgetClass_Caption = 6;
{
Caption Properties
}
{ This property specifies whether the caption is lit; use lit captions }
{ against screens. }
{ This property specifies whether the caption is lit; use lit captions }
{ against screens. }
xpProperty_CaptionLit = 1600
;
@@ -407,11 +383,10 @@ CONST
___________________________________________________________________________}
{
The general graphics widget can show one of many icons available from
x-plane.
X-Plane.
}
CONST
xpWidgetClass_GeneralGraphics = 7;
@@ -461,9 +436,8 @@ CONST
{
General Graphics Properties
}
{ This property controls the type of icon that is drawn. }
{ This property controls the type of icon that is drawn. }
xpProperty_GeneralGraphicsType = 1700
;
@@ -471,27 +445,26 @@ CONST
* PROGRESS INDICATOR
___________________________________________________________________________}
{
This widget implements a progress indicator as seen when x-plane starts up.
This widget implements a progress indicator as seen when X-Plane starts up.
}
CONST
xpWidgetClass_Progress = 8;
{
Progress Indicator Properties
}
{ This is the current value of the progress indicator. }
{ This is the current value of the progress indicator. }
xpProperty_ProgressPosition = 1800
;
{ This is the minimum value, equivalent to 0% filled. }
{ This is the minimum value, equivalent to 0% filled. }
xpProperty_ProgressMin = 1801
;
{ This is the maximum value, equivalent to 100% filled. }
{ This is the maximum value, equivalent to 100% filled. }
xpProperty_ProgressMax = 1802
;
IMPLEMENTATION
END.
XPSDK/Delphi/Widgets/XPUIGraphics.pas
+128 -166
View File
@@ -1,29 +1,17 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPUIGraphics;
INTERFACE
{
}
USES XPWidgetDefs;
USES
XPWidgetDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* UI GRAPHICS
___________________________________________________________________________}
{
}
{
XPWindowStyle
@@ -32,35 +20,34 @@ USES XPWidgetDefs;
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
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.
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.
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.
}
TYPE
XPWindowStyle = (
{ An LCD screen that shows help. }
{ An LCD screen that shows help. }
xpWindow_Help = 0
{ A dialog box window. }
{ A dialog box window. }
,xpWindow_MainWindow = 1
{ A panel or frame within a dialog box window. }
{ A panel or frame within a dialog box window. }
,xpWindow_SubWindow = 2
{ An LCD screen within a panel to hold text displays. }
{ An LCD screen within a panel to hold text displays. }
,xpWindow_Screen = 4
{ A list view within a panel for scrolling file names, etc. }
{ A list view within a panel for scrolling file names, etc. }
,xpWindow_ListView = 5
);
@@ -70,159 +57,151 @@ TYPE
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
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.
}
PROCEDURE XPDrawWindow(
inX1 : integer;
inY1 : integer;
inX2 : integer;
inY2 : integer;
inX1 : Integer;
inY1 : Integer;
inX2 : Integer;
inY2 : Integer;
inStyle : XPWindowStyle);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPGetWindowDefaultDimensions
This routine returns the default dimensions for a window. Output is either
This routine returns the default dimensions for a window. Output is either
a minimum or fixed value depending on whether the window is scalable.
}
PROCEDURE XPGetWindowDefaultDimensions(
inStyle : XPWindowStyle;
outWidth : Pinteger; { Can be nil }
outHeight : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outWidth : PInteger; { Can be nil }
outHeight : PInteger); { Can be nil }
cdecl; external XPWIDGETS.DLL;
{
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 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.
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
Scalable Axis Required Background
}
TYPE
XPElementStyle = (
{ x metal }
{ x metal }
xpElement_TextField = 6
{ none metal }
{ none metal }
,xpElement_CheckBox = 9
{ none metal }
{ none metal }
,xpElement_CheckBoxLit = 10
{ none window header }
{ none window header }
,xpElement_WindowCloseBox = 14
{ none window header }
{ none window header }
,xpElement_WindowCloseBoxPressed = 15
{ x metal }
{ x metal }
,xpElement_PushButton = 16
{ x metal }
{ x metal }
,xpElement_PushButtonLit = 17
{ none any }
{ none any }
,xpElement_OilPlatform = 24
{ none any }
{ none any }
,xpElement_OilPlatformSmall = 25
{ none any }
{ none any }
,xpElement_Ship = 26
{ none any }
{ none any }
,xpElement_ILSGlideScope = 27
{ none any }
{ none any }
,xpElement_MarkerLeft = 28
{ none any }
{ none any }
,xpElement_Airport = 29
{ none any }
{ none any }
,xpElement_Waypoint = 30
{ none any }
{ none any }
,xpElement_NDB = 31
{ none any }
{ none any }
,xpElement_VOR = 32
{ none any }
{ none any }
,xpElement_RadioTower = 33
{ none any }
{ none any }
,xpElement_AircraftCarrier = 34
{ none any }
{ none any }
,xpElement_Fire = 35
{ none any }
{ none any }
,xpElement_MarkerRight = 36
{ none any }
{ none any }
,xpElement_CustomObject = 37
{ none any }
{ none any }
,xpElement_CoolingTower = 38
{ none any }
{ none any }
,xpElement_SmokeStack = 39
{ none any }
{ none any }
,xpElement_Building = 40
{ none any }
{ none any }
,xpElement_PowerLine = 41
{ none metal }
{ none metal }
,xpElement_CopyButtons = 45
{ none metal }
{ none metal }
,xpElement_CopyButtonsWithEditingGrid = 46
{ x, y metal }
{ x, y metal }
,xpElement_EditingGrid = 47
{ THIS CAN PROBABLY BE REMOVED }
{ THIS CAN PROBABLY BE REMOVED }
,xpElement_ScrollBar = 48
{ none any }
{ none any }
,xpElement_VORWithCompassRose = 49
{ none metal }
{ none metal }
,xpElement_Zoomer = 51
{ x, y metal }
{ x, y metal }
,xpElement_TextFieldMiddle = 52
{ none metal }
{ none metal }
,xpElement_LittleDownArrow = 53
{ none metal }
{ none metal }
,xpElement_LittleUpArrow = 54
{ none metal }
{ none metal }
,xpElement_WindowDragBar = 61
{ none metal }
{ none metal }
,xpElement_WindowDragBarSmooth = 62
);
@@ -232,41 +211,34 @@ TYPE
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.
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.
}
PROCEDURE XPDrawElement(
inX1 : integer;
inY1 : integer;
inX2 : integer;
inY2 : integer;
inX1 : Integer;
inY1 : Integer;
inX2 : Integer;
inY2 : Integer;
inStyle : XPElementStyle;
inLit : integer);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inLit : Integer);
cdecl; external XPWIDGETS.DLL;
{
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.
element. outCanBeLit tells whether the element has both a lit and unlit
state. Pass `NULL` to not receive any of these parameters.
}
PROCEDURE XPGetElementDefaultDimensions(
inStyle : XPElementStyle;
outWidth : Pinteger; { Can be nil }
outHeight : Pinteger; { Can be nil }
outCanBeLit : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outWidth : PInteger; { Can be nil }
outHeight : PInteger; { Can be nil }
outCanBeLit : PInteger); { Can be nil }
cdecl; external XPWIDGETS.DLL;
{
XPTrackStyle
@@ -275,23 +247,23 @@ TYPE
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
(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.
- 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.
}
TYPE
XPTrackStyle = (
{ not over metal can be lit can be rotated }
{ not over metal can be lit can be rotated }
xpTrack_ScrollBar = 0
{ over metal can be lit can be rotated }
{ over metal can be lit can be rotated }
,xpTrack_Slider = 1
{ over metal cannot be lit cannot be rotated }
{ over metal cannot be lit cannot be rotated }
,xpTrack_Progress = 2
);
@@ -300,81 +272,71 @@ TYPE
{
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
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
positioned appropriately. You can also specify whether the track is lit or
not.
}
PROCEDURE XPDrawTrack(
inX1 : integer;
inY1 : integer;
inX2 : integer;
inY2 : integer;
inMin : integer;
inMax : integer;
inValue : integer;
inX1 : Integer;
inY1 : Integer;
inX2 : Integer;
inY2 : Integer;
inMin : Integer;
inMax : Integer;
inValue : Integer;
inTrackStyle : XPTrackStyle;
inLit : integer);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inLit : Integer);
cdecl; external XPWIDGETS.DLL;
{
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
scalable in the larger dimension. It also returns whether a track can be
lit.
}
PROCEDURE XPGetTrackDefaultDimensions(
inStyle : XPTrackStyle;
outWidth : Pinteger;
outCanBeLit : Pinteger);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outWidth : PInteger;
outCanBeLit : PInteger);
cdecl; external XPWIDGETS.DLL;
{
XPGetTrackMetrics
This routine returns the metrics of a track. If you want to write UI code
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
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
the thumb, and the up area and button. For horizontal scrollers, the left
button decreases; for vertical scrollers, the top button decreases.
}
PROCEDURE XPGetTrackMetrics(
inX1 : integer;
inY1 : integer;
inX2 : integer;
inY2 : integer;
inMin : integer;
inMax : integer;
inValue : integer;
inX1 : Integer;
inY1 : Integer;
inX2 : Integer;
inY2 : Integer;
inMin : Integer;
inMax : Integer;
inValue : Integer;
inTrackStyle : XPTrackStyle;
outIsVertical : Pinteger;
outDownBtnSize : Pinteger;
outDownPageSize : Pinteger;
outThumbSize : Pinteger;
outUpPageSize : Pinteger;
outUpBtnSize : Pinteger);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outIsVertical : PInteger;
outDownBtnSize : PInteger;
outDownPageSize : PInteger;
outThumbSize : PInteger;
outUpPageSize : PInteger;
outUpBtnSize : PInteger);
cdecl; external XPWIDGETS.DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/Widgets/XPWidgetDefs.pas
+226 -240
View File
@@ -1,22 +1,14 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPWidgetDefs;
INTERFACE
{
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* WIDGET DEFINITIONS
___________________________________________________________________________}
@@ -24,20 +16,19 @@ USES XPLMDefs;
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
Use the widget API to create widgets of various classes. You can nest them
into trees of widgets to create complex user interfaces.
}
TYPE
{
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.
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.
}
XPWidgetID = pointer;
PXPWidgetID = ^XPWidgetID;
@@ -45,10 +36,10 @@ TYPE
{
XPWidgetPropertyID
Properties are values attached to instances of your widgets. A property is
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
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.
@@ -56,35 +47,37 @@ TYPE
your own property IDs as well.
}
XPWidgetPropertyID = (
{ A window's refcon is an opaque value used by client code to find other data }
{ based on it. }
{ 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. }
{ 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.) }
{ Is the widget hilited? (For widgets that support this kind of thing.) }
,xpProperty_Hilited = 4
{ Is there a C++ object attached to this widget? }
{ 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. }
{ 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)? }
{ 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. }
{ NOTE: Property IDs 1 - 999 are reserved for the widgets 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
);
@@ -97,14 +90,14 @@ TYPE
to your widget function.
}
XPMouseState_t = RECORD
x : integer;
y : integer;
{ Mouse Button number, left = 0 (right button not yet supported. }
button : integer;
x : Integer;
y : Integer;
{ Mouse Button number, left = 0 (right button not yet supported. }
button : Integer;
{$IFDEF XPLM200}
{ Scroll wheel delta (button in this case would be the wheel axis number). }
delta : integer;
{$ENDIF}
{ Scroll wheel delta (button in this case would be the wheel axis number). }
delta : Integer;
{$ENDIF XPLM200}
END;
PXPMouseState_t = ^XPMouseState_t;
@@ -115,13 +108,13 @@ TYPE
function.
}
XPKeyState_t = RECORD
{ The ASCII key that was pressed. WARNING: this may be 0 for some non-ASCII }
{ key sequences. }
key : char;
{ The flags. Make sure to check this if you only want key-downs! }
{ The ASCII key that was pressed. WARNING: this may be 0 for some non-ASCII }
{ key sequences. }
key : XPLMChar;
{ The flags. Make sure to check this if you only want key-downs! }
flags : XPLMKeyFlags;
{ The virtual key code for the key }
vkey : char;
{ The virtual key code for the key }
vkey : XPLMChar;
END;
PXPKeyState_t = ^XPKeyState_t;
@@ -132,11 +125,11 @@ TYPE
changes.
}
XPWidgetGeometryChange_t = RECORD
dx : integer;
{ +Y = the widget moved up }
dy : integer;
dwidth : integer;
dheight : integer;
dx : Integer;
{ +Y = the widget moved up }
dy : Integer;
dwidth : Integer;
dheight : Integer;
END;
PXPWidgetGeometryChange_t = ^XPWidgetGeometryChange_t;
@@ -147,24 +140,24 @@ TYPE
Currently there are three modes:
}
XPDispatchMode = (
{ The message will only be sent to the target widget. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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 library }
{ functions.) }
,xpMode_Once = 4
);
@@ -173,240 +166,235 @@ TYPE
{
XPWidgetClass
Widget classes define predefined widget types. A widget class basically
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.
}
XPWidgetClass = integer;
XPWidgetClass = Integer;
PXPWidgetClass = ^XPWidgetClass;
CONST
{ An unspecified widget class. Other widget classes are in }
{ XPStandardWidgets.h }
{ An unspecified widget class. Other widget classes are in }
{ XPStandardWidgets.h }
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.
notifications of events. The list of messages may be expanded.
}
TYPE
XPWidgetMessage = (
{ No message, should not be sent. }
{ 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. }
{ 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. }
{ 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 }
{ 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 }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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. }
{ 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 }
{ 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. }
{ 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. }
{ 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 }
{ 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. }
{ 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. }
{ 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 }
{ 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 }
{ 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
{$IFDEF 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. }
{ 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}
{$ENDIF XPLM200}
{$IFDEF 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. }
{ 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}
{$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. }
{ 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
);
@@ -415,27 +403,25 @@ TYPE
{___________________________________________________________________________
* 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.
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.
}
TYPE
XPWidgetFunc_t = FUNCTION(
inMessage : XPWidgetMessage;
inWidget : XPWidgetID;
inParam1 : intptr_t;
inParam2 : intptr_t) : integer; cdecl;
inParam2 : intptr_t) : Integer; cdecl;
IMPLEMENTATION
END.
XPSDK/Delphi/Widgets/XPWidgetUtils.pas
+61 -89
View File
@@ -1,74 +1,70 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPWidgetUtils;
INTERFACE
{
XPWidgetUtils - USAGE NOTES
## USAGE NOTES
The XPWidgetUtils library contains useful functions that make writing and
using widgets less of a pain.
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
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.
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.
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.
}
USES XPWidgetDefs;
USES
XPWidgetDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* GENERAL UTILITIES
___________________________________________________________________________}
{
}
{
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
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
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.
}
TYPE
XPWidgetCreate_t = RECORD
left : integer;
top : integer;
right : integer;
bottom : integer;
visible : integer;
descriptor : Pchar;
isRoot : integer;
containerIndex : integer;
left : Integer;
top : Integer;
right : Integer;
bottom : Integer;
visible : Integer;
descriptor : XPLMString;
{ Whether ethis widget is a root wiget }
isRoot : Integer;
{ The index of the widget to contain within, or a constant }
containerIndex : Integer;
widgetClass : XPWidgetClass;
END;
PXPWidgetCreate_t = ^XPWidgetCreate_t;
@@ -82,13 +78,13 @@ CONST
{
XPUCreateWidgets
This function creates a series of widgets from a table...see
XPCreateWidget_t above. Pass in an array of widget creation structures and
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
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
@@ -97,14 +93,10 @@ CONST
}
PROCEDURE XPUCreateWidgets(
inWidgetDefs : PXPWidgetCreate_t;
inCount : integer;
inCount : Integer;
inParamParent : XPWidgetID;
ioWidgets : PXPWidgetID);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPUMoveWidgetBy
@@ -114,13 +106,9 @@ CONST
}
PROCEDURE XPUMoveWidgetBy(
inWidget : XPWidgetID;
inDeltaX : integer;
inDeltaY : integer);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDeltaX : Integer;
inDeltaY : Integer);
cdecl; external XPWIDGETS.DLL;
{___________________________________________________________________________
* LAYOUT MANAGERS
@@ -132,24 +120,19 @@ CONST
}
{
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'
relative to itself as it is resized. Use this on the top level 'window'
widget for your window.
}
FUNCTION XPUFixedLayout(
inMessage : XPWidgetMessage;
inWidget : XPWidgetID;
inParam1 : intptr_t;
inParam2 : intptr_t) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inParam2 : intptr_t) : Integer;
cdecl; external XPWIDGETS.DLL;
{___________________________________________________________________________
* WIDGET PROC BEHAVIORS
@@ -161,12 +144,11 @@ CONST
}
{
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
already. inEatClick specifies whether clicks in the background should be
consumed by bringin the window to the foreground.
}
FUNCTION XPUSelectIfNeeded(
@@ -174,12 +156,8 @@ CONST
inWidget : XPWidgetID;
inParam1 : intptr_t;
inParam2 : intptr_t;
inEatClick : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inEatClick : Integer) : Integer;
cdecl; external XPWIDGETS.DLL;
{
XPUDefocusKeyboard
@@ -192,17 +170,13 @@ CONST
inWidget : XPWidgetID;
inParam1 : intptr_t;
inParam2 : intptr_t;
inEatClick : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inEatClick : Integer) : Integer;
cdecl; external XPWIDGETS.DLL;
{
XPUDragWidget
XPUDragWidget drags the widget in response to mouse clicks. Pass in not
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).
}
@@ -211,15 +185,13 @@ CONST
inWidget : XPWidgetID;
inParam1 : intptr_t;
inParam2 : intptr_t;
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inLeft : Integer;
inTop : Integer;
inRight : Integer;
inBottom : Integer) : Integer;
cdecl; external XPWIDGETS.DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/Widgets/XPWidgets.pas
+201 -339
View File
@@ -1,44 +1,30 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPWidgets;
INTERFACE
{
WIDGETS - THEORY OF OPERATION AND NOTES
## 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
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.
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.
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 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.
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
@@ -46,151 +32,125 @@ INTERFACE
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
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.
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
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.
- 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.
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.
relationship between widget class and rootness. Root widgets are
imlemented as XPLMDisply windows.
}
USES XPWidgetDefs;
USES
XPWidgetDefs, XPLMDisplay;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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
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.
widget's location on the screen.
- inVisible is 1 if the widget should be drawn, 0 to start the widget as
hidden.
hidden.
- inDescriptor is a null terminated string that will become the widget's
descriptor.
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.
- 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.
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.
}
FUNCTION XPCreateWidget(
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer;
inVisible : integer;
inDescriptor : Pchar;
inIsRoot : integer;
inLeft : Integer;
inTop : Integer;
inRight : Integer;
inBottom : Integer;
inVisible : Integer;
inDescriptor : XPLMString;
inIsRoot : Integer;
inContainer : XPWidgetID;
inClass : XPWidgetClass) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
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. 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.
}
FUNCTION XPCreateCustomWidget(
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer;
inVisible : integer;
inDescriptor : Pchar;
inIsRoot : integer;
inLeft : Integer;
inTop : Integer;
inRight : Integer;
inBottom : Integer;
inVisible : Integer;
inDescriptor : XPLMString;
inIsRoot : Integer;
inContainer : XPWidgetID;
inCallback : XPWidgetFunc_t) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
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
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.
}
PROCEDURE XPDestroyWidget(
inWidget : XPWidgetID;
inDestroyChildren : integer);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDestroyChildren : Integer);
cdecl; external XPWIDGETS.DLL;
{
XPSendMessageToWidget
This sends any message to a widget. You should probably not go around
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
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
@@ -198,54 +158,42 @@ USES XPWidgetDefs;
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 function from the most recently installed to the oldest one receives
the message in order until it is handled.
}
FUNCTION XPSendMessageToWidget(
inWidget : XPWidgetID;
inMessage : XPWidgetMessage;
inMode : XPDispatchMode;
inParam1 : intptr_t;
inParam2 : intptr_t) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inParam2 : intptr_t) : Integer;
cdecl; external XPWIDGETS.DLL;
{___________________________________________________________________________
* 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.
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
coordinates. If the container has layout management code, it will
reposition the subwidget for you, otherwise you must do it with
SetWidgetGeometry.
}
PROCEDURE XPPlaceWidgetWithin(
inSubWidget : XPWidgetID;
inContainer : XPWidgetID);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPCountChildWidgets
@@ -253,118 +201,85 @@ USES XPWidgetDefs;
This routine returns the number of widgets another widget contains.
}
FUNCTION XPCountChildWidgets(
inWidget : XPWidgetID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inWidget : XPWidgetID) : Integer;
cdecl; external XPWIDGETS.DLL;
{
XPGetNthChildWidget
This routine returns the widget ID of a child widget by index. Indexes are
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.
inclusive. If the index is invalid, 0 is returned.
}
FUNCTION XPGetNthChildWidget(
inWidget : XPWidgetID;
inIndex : integer) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer) : XPWidgetID;
cdecl; external XPWIDGETS.DLL;
{
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.
Returns the parent of a widget, or 0 if the widget has no parent. Root
widgets never have parents and therefore always return 0.
}
FUNCTION XPGetParentWidget(
inWidget : XPWidgetID) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPShowWidget
This routine makes a widget visible if it is not already. Note that if a
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.
visible, it will still not be visible to the user.
}
PROCEDURE XPShowWidget(
inWidget : XPWidgetID);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPHideWidget
Makes a widget invisible. See XPShowWidget for considerations of when a
Makes a widget invisible. See XPShowWidget for considerations of when a
widget might not be visible despite its own visibility state.
}
PROCEDURE XPHideWidget(
inWidget : XPWidgetID);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
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
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.
}
FUNCTION XPIsWidgetVisible(
inWidget : XPWidgetID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inWidget : XPWidgetID) : Integer;
cdecl; external XPWIDGETS.DLL;
{
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.
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.
}
FUNCTION XPFindRootWidget(
inWidget : XPWidgetID) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
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
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.
}
PROCEDURE XPBringRootWidgetToFront(
inWidget : XPWidgetID);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPIsWidgetInFront
@@ -374,12 +289,8 @@ USES XPWidgetDefs;
if the widget is not in a rooted hierarchy.
}
FUNCTION XPIsWidgetInFront(
inWidget : XPWidgetID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inWidget : XPWidgetID) : Integer;
cdecl; external XPWIDGETS.DLL;
{
XPGetWidgetGeometry
@@ -389,15 +300,11 @@ USES XPWidgetDefs;
}
PROCEDURE XPGetWidgetGeometry(
inWidget : XPWidgetID;
outLeft : Pinteger; { Can be nil }
outTop : Pinteger; { Can be nil }
outRight : Pinteger; { Can be nil }
outBottom : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outLeft : PInteger; { Can be nil }
outTop : PInteger; { Can be nil }
outRight : PInteger; { Can be nil }
outBottom : PInteger); { Can be nil }
cdecl; external XPWIDGETS.DLL;
{
XPSetWidgetGeometry
@@ -406,102 +313,82 @@ USES XPWidgetDefs;
}
PROCEDURE XPSetWidgetGeometry(
inWidget : XPWidgetID;
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inLeft : Integer;
inTop : Integer;
inRight : Integer;
inBottom : Integer);
cdecl; external XPWIDGETS.DLL;
{
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
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
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.
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
geometry. The parent geometry limits the child's eligibility for mouse
location.
}
FUNCTION XPGetWidgetForLocation(
inContainer : XPWidgetID;
inXOffset : integer;
inYOffset : integer;
inRecursive : integer;
inVisibleOnly : integer) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inXOffset : Integer;
inYOffset : Integer;
inRecursive : Integer;
inVisibleOnly : Integer) : XPWidgetID;
cdecl; external XPWIDGETS.DLL;
{
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.
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.
}
PROCEDURE XPGetWidgetExposedGeometry(
inWidgetID : XPWidgetID;
outLeft : Pinteger; { Can be nil }
outTop : Pinteger; { Can be nil }
outRight : Pinteger; { Can be nil }
outBottom : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outLeft : PInteger; { Can be nil }
outTop : PInteger; { Can be nil }
outRight : PInteger; { Can be nil }
outBottom : PInteger); { Can be nil }
cdecl; external XPWIDGETS.DLL;
{___________________________________________________________________________
* 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
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.
}
PROCEDURE XPSetWidgetDescriptor(
inWidget : XPWidgetID;
inDescriptor : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDescriptor : XPLMString);
cdecl; external XPWIDGETS.DLL;
{
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
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
@@ -509,96 +396,85 @@ USES XPWidgetDefs;
}
FUNCTION XPGetWidgetDescriptor(
inWidget : XPWidgetID;
outDescriptor : Pchar;
inMaxDescLength : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outDescriptor : XPLMString;
inMaxDescLength : Integer) : Integer;
cdecl; external XPWIDGETS.DLL;
{
XPGetWidgetUnderlyingWindow
Returns the window (from the XPLMDisplay API) that backs your widget
window. If you have opted in to modern windows, via a call to
XPLMEnableFeature("XPLM_USE_NATIVE_WIDGET_WINDOWS", 1), you can use the
returned window ID for display APIs like XPLMSetWindowPositioningMode(),
allowing you to pop the widget window out into a real OS window, or move it
into VR.
}
FUNCTION XPGetWidgetUnderlyingWindow(
inWidget : XPWidgetID) : XPLMWindowID;
cdecl; external XPWIDGETS.DLL;
{
XPSetWidgetProperty
This function sets a widget's property. Properties are arbitrary values
This function sets a widget's property. Properties are arbitrary values
associated by a widget by ID.
}
PROCEDURE XPSetWidgetProperty(
inWidget : XPWidgetID;
inProperty : XPWidgetPropertyID;
inValue : intptr_t);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
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
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.
}
FUNCTION XPGetWidgetProperty(
inWidget : XPWidgetID;
inProperty : XPWidgetPropertyID;
inExists : Pinteger) : intptr_t; { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inExists : PInteger) : intptr_t; { Can be nil }
cdecl; external XPWIDGETS.DLL;
{___________________________________________________________________________
* 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.
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.
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.
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.
}
Keyboard focus is not changed if the new widget will not accept it. For
setting to X-Plane, keyboard focus is always accepted.
}
FUNCTION XPSetKeyboardFocus(
inWidget : XPWidgetID) : XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
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
parent, or the next parent that will accept it. This routine does nothing
if this widget does not have focus.
}
PROCEDURE XPLoseKeyboardFocus(
inWidget : XPWidgetID);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPGetWidgetWithFocus
@@ -608,44 +484,32 @@ USES XPWidgetDefs;
has focus.
}
FUNCTION XPGetWidgetWithFocus: XPWidgetID;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{___________________________________________________________________________
* CREATING CUSTOM WIDGETS
___________________________________________________________________________}
{
}
{
XPAddWidgetCallback
This function adds a new widget callback to a widget. This widget callback
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
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.
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.
}
PROCEDURE XPAddWidgetCallback(
inWidget : XPWidgetID;
inNewCallback : XPWidgetFunc_t);
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
{
XPGetWidgetClassFunc
@@ -655,11 +519,9 @@ USES XPWidgetDefs;
}
FUNCTION XPGetWidgetClassFunc(
inWidgetClass : XPWidgetClass) : XPWidgetFunc_t;
{$IFDEF DELPHI}
cdecl; external 'XPWIDGETS.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPWIDGETS.DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMCamera.pas
+50 -69
View File
@@ -1,55 +1,50 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMCamera;
INTERFACE
{
XPLMCamera - THEORY OF OPERATION The XPLMCamera APIs allow plug-ins to
control the camera angle in X-Plane. This has a number of applications,
including but not limited to:
The XPLMCamera APIs allow plug-ins to control the camera angle in X-Plane.
This has a number of applications, including but not limited to:
- Creating new views (including dynamic/user-controllable views) for the
user.
user.
- Creating applications that use X-Plane as a renderer of scenery,
aircrafts, or both.
aircrafts, or both.
The camera is controlled via six parameters: a location in OpenGL
coordinates and pitch, roll and yaw, similar to an airplane's position.
OpenGL coordinate info is described in detail in the XPLMGraphics
documentation; generally you should use the XPLMGraphics routines to
convert from world to local coordinates. The camera's orientation starts
facing level with the ground directly up the negative-Z axis
(approximately north) with the horizon horizontal. It is then rotated
clockwise for yaw, pitched up for positive pitch, and rolled clockwise
around the vector it is looking along for roll.
convert from world to local coordinates. The camera's orientation starts
facing level with the ground directly up the negative-Z axis (approximately
north) with the horizon horizontal. It is then rotated clockwise for yaw,
pitched up for positive pitch, and rolled clockwise around the vector it is
looking along for roll.
You control the camera either either until the user selects a new view or
permanently (the later being similar to how UDP camera control works). You
permanently (the later being similar to how UDP camera control works). You
control the camera by registering a callback per frame from which you
calculate the new camera positions. This guarantees smooth camera motion.
calculate the new camera positions. This guarantees smooth camera motion.
Use the XPLMDataAccess APIs to get information like the position of the
aircraft, etc. for complex camera positioning.
Note: if your goal is to move the virtual pilot in the cockpit, this API is
not needed; simply update the datarefs for the pilot's head position.
For custom exterior cameras, set the camera's mode to an external view
first to get correct sound and 2-d panel behavior.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* CAMERA CONTROL
___________________________________________________________________________}
{
}
{
XPLMCameraControlDuration
@@ -59,11 +54,11 @@ USES XPLMDefs;
}
TYPE
XPLMCameraControlDuration = (
{ Control the camera until the user picks a new view. }
{ Control the camera until the user picks a new view. }
xplm_ControlCameraUntilViewChanges = 1
{ Control the camera until your plugin is disabled or another plugin forcably }
{ takes control. }
{ Control the camera until your plugin is disabled or another plugin forcably}
{ takes control. }
,xplm_ControlCameraForever = 2
);
@@ -72,21 +67,21 @@ TYPE
{
XPLMCameraPosition_t
This structure contains a full specification of the camera. X, Y, and Z
are the camera's position in OpenGL coordiantes; pitch, roll, and yaw are
rotations from a camera facing flat north in degrees. Positive pitch means
This structure contains a full specification of the camera. X, Y, and Z are
the camera's position in OpenGL coordiantes; pitch, roll, and yaw are
rotations from a camera facing flat north in degrees. Positive pitch means
nose up, positive roll means roll right, and positive yaw means yaw right,
all in degrees. Zoom is a zoom factor, with 1.0 meaning normal zoom and 2.0
magnifying by 2x (objects appear larger).
}
XPLMCameraPosition_t = RECORD
x : single;
y : single;
z : single;
pitch : single;
heading : single;
roll : single;
zoom : single;
x : Single;
y : Single;
z : Single;
pitch : Single;
heading : Single;
roll : Single;
zoom : Single;
END;
PXPLMCameraPosition_t = ^XPLMCameraPosition_t;
@@ -94,8 +89,8 @@ TYPE
XPLMCameraControl_f
You use an XPLMCameraControl function to provide continuous control over
the camera. You are passed in a structure in which to put the new camera
position; modify it and return 1 to reposition the camera. Return 0 to
the camera. You are passed in a structure in which to put the new camera
position; modify it and return 1 to reposition the camera. Return 0 to
surrender control of the camera; camera control will be handled by X-Plane
on this draw loop. The contents of the structure as you are called are
undefined.
@@ -105,30 +100,26 @@ TYPE
}
XPLMCameraControl_f = FUNCTION(
outCameraPosition : PXPLMCameraPosition_t; { Can be nil }
inIsLosingControl : integer;
inRefcon : pointer) : integer; cdecl;
inIsLosingControl : Integer;
inRefcon : pointer) : Integer; cdecl;
{
XPLMControlCamera
This function repositions the camera on the next drawing cycle. You must
pass a non-null control function. Specify in inHowLong how long you'd like
control (indefinitely or until a key is pressed).
This function repositions the camera on the next drawing cycle. You must
pass a non-null control function. Specify in inHowLong how long you'd like
control (indefinitely or until a new view mode is set by the user).
}
PROCEDURE XPLMControlCamera(
inHowLong : XPLMCameraControlDuration;
inControlFunc : XPLMCameraControl_f;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMDontControlCamera
This function stops you from controlling the camera. If you have a camera
This function stops you from controlling the camera. If you have a camera
control function, it will not be called with an inIsLosingControl flag.
X-Plane will control the camera on the next cycle.
@@ -136,26 +127,18 @@ TYPE
posession of the camera.
}
PROCEDURE XPLMDontControlCamera;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMIsCameraBeingControlled
This routine returns 1 if the camera is being controlled, zero if it is
not. If it is and you pass in a pointer to a camera control duration, the
not. If it is and you pass in a pointer to a camera control duration, the
current control duration will be returned.
}
FUNCTION XPLMIsCameraBeingControlled(
outCameraControlDuration: PXPLMCameraControlDuration) : integer; { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outCameraControlDuration: PXPLMCameraControlDuration) : Integer; { Can be nil }
cdecl; external XPLM_DLL;
{
XPLMReadCameraPosition
@@ -164,11 +147,9 @@ TYPE
}
PROCEDURE XPLMReadCameraPosition(
outCameraPosition : PXPLMCameraPosition_t);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMDataAccess.pas
+236 -310
View File
@@ -1,84 +1,99 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMDataAccess;
INTERFACE
{
XPLM Data Access API - Theory of Operation
The data access API gives you a generic, flexible, high performance way to
read and write data to and from X-Plane and other plug-ins. For example,
read and write data to and from X-Plane and other plug-ins. For example,
this API allows you to read and set the nav radios, get the plane location,
determine the current effective graphics frame rate, etc.
The data access APIs are the way that you read and write data from the sim
as well as other plugins.
The API works using opaque data references. A data reference is a source
of data; you do not know where it comes from, but once you have it you can
read the data quickly and possibly write it. To get a data reference, you
look it up.
The API works using opaque data references. A data reference is a source of
data; you do not know where it comes from, but once you have it you can
read the data quickly and possibly write it.
Data references are identified by verbose string names
(sim/cockpit/radios/nav1_freq_hz). The actual numeric value of the data
reference is implementation defined and is likely to change each time the
simulator is run (or the plugin that provides the datareference is
reloaded).
Dataref Lookup
--------------
Data references are identified by verbose, permanent string names; by
convention these names use path separates to form a hierarchy of datarefs,
e.g. (sim/cockpit/radios/nav1_freq_hz). The actual opaque numeric value of
the data reference, as returned by the XPLM API, is implementation defined
and changes each time X-Plane is launched; therefore you need to look up
the dataref by path every time your plugin runs.
The task of looking up a data reference is relatively expensive; look up
your data references once based on verbose strings, and save the opaque
data reference value for the duration of your plugin's operation. Reading
and writing data references is relatively fast (the cost is equivalent to
two function calls through function pointers).
your data references once based on the verbose path strings, and save the
opaque data reference value for the duration of your plugin's operation.
Reading and writing data references is relatively fast (the cost is
equivalent to two function calls through function pointers).
This allows data access to be high performance, while leaving in
abstraction; since data references are opaque and are searched for, the
underlying data access system can be rebuilt.
X-Plane publishes over 4000 datarefs; a complete list may be found in the
reference section of the SDK online documentation (from the SDK home page,
choose Documentation).
Dataref Types
-------------
A note on typing: you must know the correct data type to read and write.
APIs are provided for reading and writing data in a number of ways. You
can also double check the data type for a data ref. Note that automatic
conversion is not done for you.
APIs are provided for reading and writing data in a number of ways. You can
also double check the data type for a data ref. Automatic type conversion
is not done for you.
Dataref types are a set, e.g. a dataref can be more than one type. When
this happens, you can choose which API you want to use to read. For
example, it is not uncommon for a dataref to be of type float and double.
This means you can use either XPLMGetDatad or XPLMGetDataf to read it.
Creating New Datarefs
---------------------
X-Plane provides datarefs that come with the sim, but plugins can also
create their own datarefs. A plugin creates a dataref by registering
function callbacks to read and write the dataref. The XPLM will call your
plugin each time some other plugin (or X-Plane) tries to read or write the
dataref. You must provide a read (and optional write) callback for each
data type you support.
A note for plugins sharing data with other plugins: the load order of
plugins is not guaranteed. To make sure that every plugin publishing data
plugins is not guaranteed. To make sure that every plugin publishing data
has published their data references before other plugins try to subscribe,
publish your data references in your start routine but resolve them the
first time your 'enable' routine is called, or the first time they are
needed in code.
X-Plane publishes well over 1000 datarefs; a complete list may be found in
the reference section of the SDK online documentation (from the SDK home
page, choose Documentation).
When a plugin that created a dataref is unloaded, it becomes "orphaned".
The dataref handle continues to be usable, but the dataref is not writable,
and reading it will always return 0 (or 0 items for arrays). If the plugin
is reloaded and re-registers the dataref, the handle becomes un-orphaned
and works again.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* READING AND WRITING DATA
___________________________________________________________________________}
{
These routines allow you to access a wide variety of data from within
x-plane and modify some of it.
These routines allow you to access data from within X-Plane and sometimes
modify it.
}
TYPE
{
XPLMDataRef
A data ref is an opaque handle to data provided by the simulator or another
plugin. It uniquely identifies one variable (or array of variables) over
the lifetime of your plugin. You never hard code these values; you always
plugin. It uniquely identifies one variable (or array of variables) over
the lifetime of your plugin. You never hard code these values; you always
get them from XPLMFindDataRef.
}
XPLMDataRef = pointer;
@@ -92,28 +107,30 @@ TYPE
you expect. But for the most part, you will know the type of data you are
expecting from the online documentation.
Data types each take a bit field, so sets of data types may be formed.
Data types each take a bit field; it is legal to have a single dataref be
more than one type of data. Whe this happens, you can pick any matching
get/set API.
}
XPLMDataTypeID = (
{ Data of a type the current XPLM doesn't do. }
{ Data of a type the current XPLM doesn't do. }
xplmType_Unknown = 0
{ A single 4-byte integer, native endian. }
{ A single 4-byte integer, native endian. }
,xplmType_Int = 1
{ A single 4-byte float, native endian. }
{ A single 4-byte float, native endian. }
,xplmType_Float = 2
{ A single 8-byte double, native endian. }
{ A single 8-byte double, native endian. }
,xplmType_Double = 4
{ An array of 4-byte floats, native endian. }
{ An array of 4-byte floats, native endian. }
,xplmType_FloatArray = 8
{ An array of 4-byte integers, native endian. }
{ An array of 4-byte integers, native endian. }
,xplmType_IntArray = 16
{ A variable block of data. }
{ A variable block of data. }
,xplmType_Data = 32
);
@@ -124,198 +141,163 @@ TYPE
Given a c-style string that names the data ref, this routine looks up the
actual opaque XPLMDataRef that you use to read and write the data. The
string names for datarefs are published on the x-plane SDK web site.
string names for datarefs are published on the X-Plane SDK web site.
This function returns NULL if the data ref cannot be found.
NOTE: this function is relatively expensive; save the XPLMDataRef this
function returns for future use. Do not look up your data ref by string
function returns for future use. Do not look up your data ref by string
every time you need to read or write it.
}
FUNCTION XPLMFindDataRef(
inDataRefName : Pchar) : XPLMDataRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDataRefName : XPLMString) : XPLMDataRef;
cdecl; external XPLM_DLL;
{
XPLMCanWriteDataRef
Given a data ref, this routine returns true if you can successfully set
the data, false otherwise. Some datarefs are read-only.
Given a data ref, this routine returns true if you can successfully set the
data, false otherwise. Some datarefs are read-only.
NOTE: even if a dataref is marked writable, it may not act writable. This
can happen for datarefs that X-Plane writes to on every frame of
simulation. In some cases, the dataref is writable but you have to set a
separate "override" dataref to 1 to stop X-Plane from writing it.
}
FUNCTION XPLMCanWriteDataRef(
inDataRef : XPLMDataRef) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDataRef : XPLMDataRef) : Integer;
cdecl; external XPLM_DLL;
{
XPLMIsDataRefGood
WARNING: This function is deprecated and should not be used. Datarefs are
valid until plugins are reloaded or the sim quits. Plugins sharing
datarefs should support these semantics by not unregistering datarefs
during operation. (You should however unregister datarefs when your plugin
is unloaded, as part of general resource cleanup.)
This function returns true if the passed in handle is a valid dataref that
is not orphaned.
This function returns whether a data ref is still valid. If it returns
false, you should refind the data ref from its original string. Calling an
accessor function on a bad data ref will return a default value, typically
0 or 0-length data.
Note: there is normally no need to call this function; datarefs returned by
XPLMFindDataRef remain valid (but possibly orphaned) unless there is a
complete plugin reload (in which case your plugin is reloaded anyway).
Orphaned datarefs can be safely read and return 0. Therefore you never need
to call XPLMIsDataRefGood to 'check' the safety of a dataref.
(XPLMIsDatarefGood performs some slow checking of the handle validity, so
it has a perormance cost.)
}
FUNCTION XPLMIsDataRefGood(
inDataRef : XPLMDataRef) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDataRef : XPLMDataRef) : Integer;
cdecl; external XPLM_DLL;
{
XPLMGetDataRefTypes
This routine returns the types of the data ref for accessor use. If a data
ref is available in multiple data types, they will all be returned.
This routine returns the types of the data ref for accessor use. If a data
ref is available in multiple data types, the bit-wise OR of these types
will be returned.
}
FUNCTION XPLMGetDataRefTypes(
inDataRef : XPLMDataRef) : XPLMDataTypeID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* DATA ACCESSORS
___________________________________________________________________________}
{
These routines read and write the data references. For each supported data
type there is a reader and a writer.
These routines read and write the data references. For each supported data
type there is a reader and a writer.
If the data ref is invalid or the plugin that provides it is disabled or
If the data ref is orphaned or the plugin that provides it is disabled or
there is a type mismatch, the functions that read data will return 0 as a
default value or not modify the passed in memory. The plugins that write
data will not write under these circumstances or if the data ref is
read-only. NOTE: to keep the overhead of reading datarefs low, these
routines do not do full validation of a dataref; passing a junk value for
a dataref can result in crashing the sim.
read-only.
NOTE: to keep the overhead of reading datarefs low, these routines do not
do full validation of a dataref; passing a junk value for a dataref can
result in crashing the sim. The get/set APIs do check for NULL.
For array-style datarefs, you specify the number of items to read/write and
the offset into the array; the actual number of items read or written is
returned. This may be less to prevent an array-out-of-bounds error.
returned. This may be less to prevent an array-out-of-bounds error.
}
{
XPLMGetDatai
Read an integer data ref and return its value. The return value is the
dataref value or 0 if the dataref is invalid/NULL or the plugin is
disabled.
dataref value or 0 if the dataref is NULL or the plugin is disabled.
}
FUNCTION XPLMGetDatai(
inDataRef : XPLMDataRef) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDataRef : XPLMDataRef) : Integer;
cdecl; external XPLM_DLL;
{
XPLMSetDatai
Write a new value to an integer data ref. This routine is a no-op if the
plugin publishing the dataref is disabled, the dataref is invalid, or the
Write a new value to an integer data ref. This routine is a no-op if the
plugin publishing the dataref is disabled, the dataref is NULL, or the
dataref is not writable.
}
PROCEDURE XPLMSetDatai(
inDataRef : XPLMDataRef;
inValue : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inValue : Integer);
cdecl; external XPLM_DLL;
{
XPLMGetDataf
Read a single precision floating point dataref and return its value. The
return value is the dataref value or 0.0 if the dataref is invalid/NULL or
the plugin is disabled.
return value is the dataref value or 0.0 if the dataref is NULL or the
plugin is disabled.
}
FUNCTION XPLMGetDataf(
inDataRef : XPLMDataRef) : single;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDataRef : XPLMDataRef) : Single;
cdecl; external XPLM_DLL;
{
XPLMSetDataf
Write a new value to a single precision floating point data ref. This
Write a new value to a single precision floating point data ref. This
routine is a no-op if the plugin publishing the dataref is disabled, the
dataref is invalid, or the dataref is not writable.
dataref is NULL, or the dataref is not writable.
}
PROCEDURE XPLMSetDataf(
inDataRef : XPLMDataRef;
inValue : single);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inValue : Single);
cdecl; external XPLM_DLL;
{
XPLMGetDatad
Read a double precision floating point dataref and return its value. The
return value is the dataref value or 0.0 if the dataref is invalid/NULL or
the plugin is disabled.
return value is the dataref value or 0.0 if the dataref is NULL or the
plugin is disabled.
}
FUNCTION XPLMGetDatad(
inDataRef : XPLMDataRef) : real;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDataRef : XPLMDataRef) : Real;
cdecl; external XPLM_DLL;
{
XPLMSetDatad
Write a new value to a double precision floating point data ref. This
Write a new value to a double precision floating point data ref. This
routine is a no-op if the plugin publishing the dataref is disabled, the
dataref is invalid, or the dataref is not writable.
dataref is NULL, or the dataref is not writable.
}
PROCEDURE XPLMSetDatad(
inDataRef : XPLMDataRef;
inValue : real);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inValue : Real);
cdecl; external XPLM_DLL;
{
XPLMGetDatavi
Read a part of an integer array dataref. If you pass NULL for outVaules,
Read a part of an integer array dataref. If you pass NULL for outValues,
the routine will return the size of the array, ignoring inOffset and inMax.
If outValues is not NULL, then up to inMax values are copied from the
dataref into outValues, starting at inOffset in the dataref. If inMax +
inOffset is larger than the size of the dataref, less than inMax values
will be copied. The number of values copied is returned.
will be copied. The number of values copied is returned.
Note: the semantics of array datarefs are entirely implemented by the
plugin (or X-Plane) that provides the dataref, not the SDK itself; the
@@ -324,20 +306,16 @@ TYPE
}
FUNCTION XPLMGetDatavi(
inDataRef : XPLMDataRef;
outValues : Pinteger; { Can be nil }
inOffset : integer;
inMax : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outValues : PInteger; { Can be nil }
inOffset : Integer;
inMax : Integer) : Integer;
cdecl; external XPLM_DLL;
{
XPLMSetDatavi
Write part or all of an integer array dataref. The values passed by
inValues are written into the dataref starting at inOffset. Up to inCount
Write part or all of an integer array dataref. The values passed by
inValues are written into the dataref starting at inOffset. Up to inCount
values are written; however if the values would write "off the end" of the
dataref array, then fewer values are written.
@@ -348,26 +326,22 @@ TYPE
}
PROCEDURE XPLMSetDatavi(
inDataRef : XPLMDataRef;
inValues : Pinteger;
inoffset : integer;
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inValues : PInteger;
inoffset : Integer;
inCount : Integer);
cdecl; external XPLM_DLL;
{
XPLMGetDatavf
Read a part of a single precision floating point array dataref. If you
pass NULL for outVaules, the routine will return the size of the array,
ignoring inOffset and inMax.
Read a part of a single precision floating point array dataref. If you pass
NULL for outVaules, the routine will return the size of the array, ignoring
inOffset and inMax.
If outValues is not NULL, then up to inMax values are copied from the
dataref into outValues, starting at inOffset in the dataref. If inMax +
inOffset is larger than the size of the dataref, less than inMax values
will be copied. The number of values copied is returned.
will be copied. The number of values copied is returned.
Note: the semantics of array datarefs are entirely implemented by the
plugin (or X-Plane) that provides the dataref, not the SDK itself; the
@@ -376,21 +350,17 @@ TYPE
}
FUNCTION XPLMGetDatavf(
inDataRef : XPLMDataRef;
outValues : Psingle; { Can be nil }
inOffset : integer;
inMax : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outValues : PSingle; { Can be nil }
inOffset : Integer;
inMax : Integer) : Integer;
cdecl; external XPLM_DLL;
{
XPLMSetDatavf
Write part or all of a single precision floating point array dataref. The
Write part or all of a single precision floating point array dataref. The
values passed by inValues are written into the dataref starting at
inOffset. Up to inCount values are written; however if the values would
inOffset. Up to inCount values are written; however if the values would
write "off the end" of the dataref array, then fewer values are written.
Note: the semantics of array datarefs are entirely implemented by the
@@ -400,25 +370,21 @@ TYPE
}
PROCEDURE XPLMSetDatavf(
inDataRef : XPLMDataRef;
inValues : Psingle;
inoffset : integer;
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inValues : PSingle;
inoffset : Integer;
inCount : Integer);
cdecl; external XPLM_DLL;
{
XPLMGetDatab
Read a part of a byte array dataref. If you pass NULL for outVaules, the
Read a part of a byte array dataref. If you pass NULL for outVaules, the
routine will return the size of the array, ignoring inOffset and inMax.
If outValues is not NULL, then up to inMax values are copied from the
dataref into outValues, starting at inOffset in the dataref. If inMax +
inOffset is larger than the size of the dataref, less than inMax values
will be copied. The number of values copied is returned.
will be copied. The number of values copied is returned.
Note: the semantics of array datarefs are entirely implemented by the
plugin (or X-Plane) that provides the dataref, not the SDK itself; the
@@ -428,20 +394,16 @@ TYPE
FUNCTION XPLMGetDatab(
inDataRef : XPLMDataRef;
outValue : pointer; { Can be nil }
inOffset : integer;
inMaxBytes : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inOffset : Integer;
inMaxBytes : Integer) : Integer;
cdecl; external XPLM_DLL;
{
XPLMSetDatab
Write part or all of a byte array dataref. The values passed by inValues
are written into the dataref starting at inOffset. Up to inCount values
are written; however if the values would write "off the end" of the dataref
Write part or all of a byte array dataref. The values passed by inValues
are written into the dataref starting at inOffset. Up to inCount values are
written; however if the values would write "off the end" of the dataref
array, then fewer values are written.
Note: the semantics of array datarefs are entirely implemented by the
@@ -452,172 +414,156 @@ TYPE
PROCEDURE XPLMSetDatab(
inDataRef : XPLMDataRef;
inValue : pointer;
inOffset : integer;
inLength : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inOffset : Integer;
inLength : Integer);
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* PUBLISHING YOUR PLUGINS DATA
* PUBLISHING YOUR PLUGIN'S DATA
___________________________________________________________________________}
{
These functions allow you to create data references that other plug-ins can
access via the above data access APIs. Data references published by other
plugins operate the same as ones published by x-plane in all manners except
that your data reference will not be available to other plugins if/when
your plugin is disabled.
These functions allow you to create data references that other plug-ins and
X-Plane can access via the above data access APIs. Data references
published by other plugins operate the same as ones published by X-Plane in
all manners except that your data reference will not be available to other
plugins if/when your plugin is disabled.
You share data by registering data provider callback functions. When a
plug-in requests your data, these callbacks are then called. You provide
You share data by registering data provider callback functions. When a
plug-in requests your data, these callbacks are then called. You provide
one callback to return the value when a plugin 'reads' it and another to
change the value when a plugin 'writes' it.
Important: you must pick a prefix for your datarefs other than "sim/" -
this prefix is reserved for X-Plane. The X-Plane SDK website contains a
this prefix is reserved for X-Plane. The X-Plane SDK website contains a
registry where authors can select a unique first word for dataref names, to
prevent dataref collisions between plugins.
}
{
XPLMGetDatai_f
Data provider function pointers.
These define the function pointers you provide to get or set data. Note
that you are passed a generic pointer for each one. This is the same
pointer you pass in your register routine; you can use it to find global
These define the function pointers you provide to get or set data. Note
that you are passed a generic pointer for each one. This is the same
pointer you pass in your register routine; you can use it to locate plugin
variables, etc.
The semantics of your callbacks are the same as the dataref accessor above
- basically routines like XPLMGetDatai are just pass-throughs from a caller
to your plugin. Be particularly mindful in implementing array dataref
to your plugin. Be particularly mindful in implementing array dataref
read-write accessors; you are responsible for avoiding overruns, supporting
offset read/writes, and handling a read with a NULL buffer.
}
TYPE
XPLMGetDatai_f = FUNCTION(
inRefcon : pointer) : integer; cdecl;
inRefcon : pointer) : Integer; cdecl;
{
XPLMSetDatai_f
}
XPLMSetDatai_f = PROCEDURE(
inRefcon : pointer;
inValue : integer); cdecl;
inValue : Integer); cdecl;
{
XPLMGetDataf_f
}
XPLMGetDataf_f = FUNCTION(
inRefcon : pointer) : single; cdecl;
inRefcon : pointer) : Single; cdecl;
{
XPLMSetDataf_f
}
XPLMSetDataf_f = PROCEDURE(
inRefcon : pointer;
inValue : single); cdecl;
inValue : Single); cdecl;
{
XPLMGetDatad_f
}
XPLMGetDatad_f = FUNCTION(
inRefcon : pointer) : real; cdecl;
inRefcon : pointer) : Real; cdecl;
{
XPLMSetDatad_f
}
XPLMSetDatad_f = PROCEDURE(
inRefcon : pointer;
inValue : real); cdecl;
inValue : Real); cdecl;
{
XPLMGetDatavi_f
}
XPLMGetDatavi_f = FUNCTION(
inRefcon : pointer;
outValues : Pinteger; { Can be nil }
inOffset : integer;
inMax : integer) : integer; cdecl;
outValues : PInteger; { Can be nil }
inOffset : Integer;
inMax : Integer) : Integer; cdecl;
{
XPLMSetDatavi_f
}
XPLMSetDatavi_f = PROCEDURE(
inRefcon : pointer;
inValues : Pinteger;
inOffset : integer;
inCount : integer); cdecl;
inValues : PInteger;
inOffset : Integer;
inCount : Integer); cdecl;
{
XPLMGetDatavf_f
}
XPLMGetDatavf_f = FUNCTION(
inRefcon : pointer;
outValues : Psingle; { Can be nil }
inOffset : integer;
inMax : integer) : integer; cdecl;
outValues : PSingle; { Can be nil }
inOffset : Integer;
inMax : Integer) : Integer; cdecl;
{
XPLMSetDatavf_f
}
XPLMSetDatavf_f = PROCEDURE(
inRefcon : pointer;
inValues : Psingle;
inOffset : integer;
inCount : integer); cdecl;
inValues : PSingle;
inOffset : Integer;
inCount : Integer); cdecl;
{
XPLMGetDatab_f
}
XPLMGetDatab_f = FUNCTION(
inRefcon : pointer;
outValue : pointer; { Can be nil }
inOffset : integer;
inMaxLength : integer) : integer; cdecl;
inOffset : Integer;
inMaxLength : Integer) : Integer; cdecl;
{
XPLMSetDatab_f
}
XPLMSetDatab_f = PROCEDURE(
inRefcon : pointer;
inValue : pointer;
inOffset : integer;
inLength : integer); cdecl;
inOffset : Integer;
inLength : Integer); cdecl;
{
XPLMRegisterDataAccessor
This routine creates a new item of data that can be read and written. Pass
This routine creates a new item of data that can be read and written. Pass
in the data's full name for searching, the type(s) of the data for
accessing, and whether the data can be written to. For each data type you
accessing, and whether the data can be written to. For each data type you
support, pass in a read accessor function and a write accessor function if
necessary. Pass NULL for data types you do not support or write accessors
necessary. Pass NULL for data types you do not support or write accessors
if you are read-only.
You are returned a data ref for the new item of data created. You can use
this data ref to unregister your data later or read or write from it.
You are returned a data ref for the new item of data created. You can use
this data ref to unregister your data later or read or write from it.
}
FUNCTION XPLMRegisterDataAccessor(
inDataName : Pchar;
inDataName : XPLMString;
inDataType : XPLMDataTypeID;
inIsWritable : integer;
inIsWritable : Integer;
inReadInt : XPLMGetDatai_f;
inWriteInt : XPLMSetDatai_f;
inReadFloat : XPLMGetDataf_f;
@@ -632,11 +578,7 @@ TYPE
inWriteData : XPLMSetDatab_f;
inReadRefcon : pointer;
inWriteRefcon : pointer) : XPLMDataRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMUnregisterDataAccessor
@@ -645,19 +587,10 @@ TYPE
You unregister a data ref by the XPLMDataRef you get back from
registration. Once you unregister a data ref, your function pointer will
not be called anymore.
For maximum compatibility, do not unregister your data accessors until
final shutdown (when your XPluginStop routine is called). This allows
other plugins to find your data reference once and use it for their entire
time of operation.
}
PROCEDURE XPLMUnregisterDataAccessor(
inDataRef : XPLMDataRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* SHARING DATA BETWEEN MULTIPLE PLUGINS
@@ -665,45 +598,44 @@ TYPE
{
The data reference registration APIs from the previous section allow a
plugin to publish data in a one-owner manner; the plugin that publishes the
data reference owns the real memory that the data ref uses. This is
data reference owns the real memory that the data ref uses. This is
satisfactory for most cases, but there are also cases where plugnis need to
share actual data.
With a shared data reference, no one plugin owns the actual memory for the
data reference; the plugin SDK allocates that for you. When the first
plugin asks to 'share' the data, the memory is allocated. When the data is
data reference; the plugin SDK allocates that for you. When the first
plugin asks to 'share' the data, the memory is allocated. When the data is
changed, every plugin that is sharing the data is notified.
Shared data references differ from the 'owned' data references from the
previous section in a few ways:
- With shared data references, any plugin can create the data reference;
with owned plugins one plugin must create the data reference and others
subscribe. (This can be a problem if you don't know which set of plugins
will be present).
* With shared data references, any plugin can create the data reference;
with owned plugins one plugin must create the data reference and others
subscribe. (This can be a problem if you don't know which set of plugins
will be present).
- With shared data references, every plugin that is sharing the data is
notified when the data is changed. With owned data references, only the
one owner is notified when the data is changed.
* With shared data references, every plugin that is sharing the data is
notified when the data is changed. With owned data references, only the
one owner is notified when the data is changed.
- With shared data references, you cannot access the physical memory of the
data reference; you must use the XPLMGet... and XPLMSet... APIs. With an
owned data reference, the one owning data reference can manipulate the
data reference's memory in any way it sees fit.
* With shared data references, you cannot access the physical memory of the
data reference; you must use the XPLMGet... and XPLMSet... APIs. With an
owned data reference, the one owning data reference can manipulate the
data reference's memory in any way it sees fit.
Shared data references solve two problems: if you need to have a data
reference used by several plugins but do not know which plugins will be
reference used by several plugins but do not know which plugins will be
installed, or if all plugins sharing data need to be notified when that
data is changed, use shared data references.
}
{
XPLMDataChanged_f
An XPLMDataChanged_f is a callback that the XPLM calls whenever any other
plug-in modifies shared data. A refcon you provide is passed back to help
plug-in modifies shared data. A refcon you provide is passed back to help
identify which data is being changed. In response, you may want to call one
of the XPLMGetDataxxx routines to find the new value of the data.
}
@@ -717,48 +649,42 @@ TYPE
This routine connects a plug-in to shared data, creating the shared data if
necessary. inDataName is a standard path for the data ref, and inDataType
specifies the type. This function will create the data if it does not
exist. If the data already exists but the type does not match, an error is
returned, so it is important that plug-in authors collaborate to establish
exist. If the data already exists but the type does not match, an error is
returned, so it is important that plug-in authors collaborate to establish
public standards for shared data.
If a notificationFunc is passed in and is not NULL, that notification
function will be called whenever the data is modified. The notification
function will be called whenever the data is modified. The notification
refcon will be passed to it. This allows your plug-in to know which shared
data was changed if multiple shared data are handled by one callback, or if
the plug-in does not use global variables.
A one is returned for successfully creating or finding the shared data; a
zero if the data already exists but is of the wrong type.
zero if the data already exists but is of the wrong type.
}
FUNCTION XPLMShareData(
inDataName : Pchar;
inDataName : XPLMString;
inDataType : XPLMDataTypeID;
inNotificationFunc : XPLMDataChanged_f;
inNotificationRefcon: pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inNotificationRefcon: pointer) : Integer;
cdecl; external XPLM_DLL;
{
XPLMUnshareData
This routine removes your notification function for shared data. Call it
when done with the data to stop receiving change notifications. Arguments
This routine removes your notification function for shared data. Call it
when done with the data to stop receiving change notifications. Arguments
must match XPLMShareData. The actual memory will not necessarily be freed,
since other plug-ins could be using it.
}
FUNCTION XPLMUnshareData(
inDataName : Pchar;
inDataName : XPLMString;
inDataType : XPLMDataTypeID;
inNotificationFunc : XPLMDataChanged_f;
inNotificationRefcon: pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inNotificationRefcon: pointer) : Integer;
cdecl; external XPLM_DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMDefs.pas
+35 -43
View File
@@ -1,9 +1,6 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMDefs;
@@ -20,9 +17,6 @@ INTERFACE
}
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{$IFDEF LINUX}
{$DEFINE KYLIX}
{$ENDIF}
@@ -45,14 +39,13 @@ TYPE
the DLL.
You can prefix your five required callbacks with the PLUGIN_API macro to
declare them as exported C functions. The XPLM_API macro identifies
declare them as exported C functions. The XPLM_API macro identifies
functions that are provided to you via the plugin SDK. (Link against
XPLM.lib to use these functions.)
}
{___________________________________________________________________________
* GLOBAL DEFINITIONS
___________________________________________________________________________}
@@ -61,7 +54,6 @@ TYPE
}
TYPE
{
XPLMPluginID
@@ -70,25 +62,26 @@ TYPE
disable or enable a plug-in, or discover what plug-in is 'running' at the
time. A plug-in ID is unique within the currently running instance of
X-Plane unless plug-ins are reloaded. Plug-ins may receive a different
unique ID each time they are loaded.
unique ID each time they are loaded. This includes the unloading and
reloading of plugins that are part of the user's aircraft.
For persistent identification of plug-ins, use XPLMFindPluginBySignature in
XPLMUtiltiies.h
-1 indicates no plug-in.
}
XPLMPluginID = integer;
XPLMPluginID = Integer;
PXPLMPluginID = ^XPLMPluginID;
CONST
{ No plugin. }
{ No plugin. }
XPLM_NO_PLUGIN_ID = (-1);
{ X-Plane itself }
{ X-Plane itself }
XPLM_PLUGIN_XPLANE = (0);
{ The current XPLM revision is 2.10 (210). }
kXPLM_Version = (210);
{ The current XPLM revision is 4.00 (400). }
kXPLM_Version = (400);
{
XPLMKeyFlags
@@ -108,19 +101,19 @@ CONST
}
TYPE
XPLMKeyFlags = (
{ The shift key is down }
{ The shift key is down }
xplm_ShiftFlag = 1
{ The option or alt key is down }
{ The option or alt key is down }
,xplm_OptionAltFlag = 2
{ The control key is down* }
{ The control key is down* }
,xplm_ControlFlag = 4
{ The key is being pressed down }
{ The key is being pressed down }
,xplm_DownFlag = 8
{ The key is being released }
{ The key is being released }
,xplm_UpFlag = 16
);
@@ -134,13 +127,13 @@ TYPE
codes. Not all key presses generate an ASCII value, so plugin code should
be prepared to see null characters come from the keyboard...this usually
represents a key stroke that has no equivalent ASCII, like a page-down
press. Use virtual key codes to find these key strokes. ASCII key codes
take into account modifier keys; shift keys will affect capitals and
punctuation; control key combinations may have no vaild ASCII and produce
NULL. To detect control-key combinations, use virtual key codes, not ASCII
keys.
}
press. Use virtual key codes to find these key strokes.
ASCII key codes take into account modifier keys; shift keys will affect
capitals and punctuation; control key combinations may have no vaild ASCII
and produce NULL. To detect control-key combinations, use virtual key
codes, not ASCII keys.
}
CONST
@@ -188,10 +181,10 @@ CONST
{
These are cross-platform defines for every distinct keyboard press on the
computer. Every physical key on the keyboard has a virtual key code. So
the "two" key on the top row of the main keyboard has a different code
from the "two" key on the numeric key pad. But the 'w' and 'W' character
are indistinguishable by virtual key code because they are the same
physical key (one with and one without the shift key).
the "two" key on the top row of the main keyboard has a different code from
the "two" key on the numeric key pad. But the 'w' and 'W' character are
indistinguishable by virtual key code because they are the same physical
key (one with and one without the shift key).
Use virtual key codes to detect keystrokes that do not have ASCII
equivalents, allow the user to map the numeric keypad separately from the
@@ -203,18 +196,15 @@ CONST
additions and changes. A few differences:
1. Modifier keys are not available as virtual key codes. You cannot get
distinct modifier press and release messages. Please do not try to use
modifier keys as regular keys; doing so will almost certainly interfere
with users' abilities to use the native x-plane key bindings.
distinct modifier press and release messages. Please do not try to use
modifier keys as regular keys; doing so will almost certainly interfere
with users' abilities to use the native X-Plane key bindings.
2. Some keys that do not exist on both Mac and PC keyboards are removed.
3. Do not assume that the values of these keystrokes are interchangeable
with MS v-keys.
with MS v-keys.
}
CONST
XPLM_VK_BACK = $08;
@@ -258,7 +248,7 @@ CONST
XPLM_VK_HELP = $2F;
{ XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) }
{ XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) }
XPLM_VK_0 = $30;
XPLM_VK_1 = $31;
@@ -279,7 +269,7 @@ CONST
XPLM_VK_9 = $39;
{ XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) }
{ XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) }
XPLM_VK_A = $41;
XPLM_VK_B = $42;
@@ -412,8 +402,8 @@ CONST
XPLM_VK_F24 = $87;
{ The following definitions are extended and are not based on the Microsoft }
{ key set. }
{ The following definitions are extended and are not based on the Microsoft }
{ key set. }
XPLM_VK_EQUAL = $B0;
XPLM_VK_MINUS = $B1;
@@ -442,5 +432,7 @@ CONST
XPLM_VK_NUMPAD_EQ = $BD;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMDisplay.pas
+1249 -454
View File
File diff suppressed because it is too large Load Diff
XPSDK/Delphi/XPLM/XPLMGraphics.pas
+186 -203
View File
@@ -1,16 +1,11 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMGraphics;
INTERFACE
{
Graphics routines for X-Plane and OpenGL.
A few notes on coordinate systems:
X-Plane uses three kinds of coordinates. Global coordinates are specified
@@ -24,27 +19,26 @@ INTERFACE
not truly straight up and down at other points). The Z axis is aligned
north-south at 0, 0, 0 with positive Z pointing south (but since the earth
is round it isn't exactly north-south as you move east or west of 0, 0, 0).
One unit is one meter and the point 0,0,0 is on the surface of the earth
at sea level for some latitude and longitude picked by the sim such that
the user's aircraft is reasonably nearby.
One unit is one meter and the point 0,0,0 is on the surface of the earth at
sea level for some latitude and longitude picked by the sim such that the
user's aircraft is reasonably nearby.
Cockpit coordinates are 2d, with the X axis horizontal and the Y axis
vertical. The point 0,0 is the bottom left and 1024,768 is the upper right
of the screen. This is true no matter what resolution the user's monitor is
in; when running in higher resolution, graphics will be scaled.
2-d Panel coordinates are 2d, with the X axis horizontal and the Y axis
vertical. The point 0,0 is the bottom left and 1024,768 is the upper
right of the screen. This is true no matter what resolution the user's
monitor is in; when running in higher resolution, graphics will be
scaled.
Use X-Plane's routines to convert between global and local coordinates. Do
not attempt to do this conversion yourself; the precise 'roundness' of
X-Plane's physics model may not match your own, and (to make things
X-Plane's physics model may not match your own, and (to make things
weirder) the user can potentially customize the physics of the current
planet.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* X-PLANE GRAPHICS
___________________________________________________________________________}
@@ -53,23 +47,30 @@ USES XPLMDefs;
}
{
XPLMTextureID
XPLM Texture IDs name well-known textures in the sim for you to use. This
allows you to recycle textures from X-Plane, saving VRAM.
*Warning*: do not use these enums. The only remaining use they have is to
access the legacy compatibility v10 UI texture; if you need this, get it
via the Widgets library.
}
TYPE
XPLMTextureID = (
{ The bitmap that contains window outlines, button outlines, fonts, etc. }
{ The bitmap that contains window outlines, button outlines, fonts, etc. }
xplm_Tex_GeneralInterface = 0
{ The exterior paint for the user's aircraft (daytime). }
{$IFDEF XPLM_DEPRECATED}
{ The exterior paint for the user's aircraft (daytime). }
,xplm_Tex_AircraftPaint = 1
{$ENDIF XPLM_DEPRECATED}
{ The exterior light map for the user's aircraft. }
{$IFDEF XPLM_DEPRECATED}
{ The exterior light map for the user's aircraft. }
,xplm_Tex_AircraftLiteMap = 2
{$ENDIF XPLM_DEPRECATED}
);
PXPLMTextureID = ^XPLMTextureID;
@@ -77,31 +78,28 @@ TYPE
{
XPLMSetGraphicsState
XPLMSetGraphicsState changes OpenGL's graphics state in a number of ways:
XPLMSetGraphicsState changes OpenGL's fixed function pipeline state. You
are not responsible for restoring any state that is accessed via
XPLMSetGraphicsState, but you are responsible for not accessing this state
directly.
inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG);
inNumberTexUnits - enables or disables a number of multitexturing units. If
the number is 0, 2d texturing is disabled entirely, as in
glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a
number of multitexturing units are enabled sequentially, starting with
unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable
(GL_TEXTURE_2D);
inEnableLighting - enables or disables OpenGL lighting, e.g.
glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);
inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g.
glEnable(GL_ALPHA_TEST);
inEnableAlphaBlending - enables or disables alpha blending per pixel, e.g.
glEnable(GL_BLEND);
inEnableDepthTesting - enables per pixel depth testing, as in
glEnable(GL_DEPTH_TEST);
inEnableDepthWriting - enables writing back of depth information to the
depth bufffer, as in glDepthMask(GL_TRUE);
- inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG);
- inNumberTexUnits - enables or disables a number of multitexturing units.
If the number is 0, 2d texturing is disabled entirely, as in
glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a
number of multitexturing units are enabled sequentially, starting with
unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable
(GL_TEXTURE_2D);
- inEnableLighting - enables or disables OpenGL lighting, e.g.
glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);
- inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g.
glEnable(GL_ALPHA_TEST);
- inEnableAlphaBlending - enables or disables alpha blending per pixel,
e.g. glEnable(GL_BLEND);
- inEnableDepthTesting - enables per pixel depth testing, as in
glEnable(GL_DEPTH_TEST);
- inEnableDepthWriting - enables writing back of depth information to the
depth bufffer, as in glDepthMask(GL_TRUE);
The purpose of this function is to change OpenGL state while keeping
X-Plane aware of the state changes; this keeps X-Plane from getting
@@ -109,95 +107,77 @@ TYPE
having to set all state before all draws; XPLMSetGraphicsState internally
skips calls to change state that is already properly enabled.
X-Plane does not have a 'default' OGL state to plug-ins; plug-ins should
totally set OGL state before drawing. Use XPLMSetGraphicsState instead of
any of the above OpenGL calls.
X-Plane does not have a 'default' OGL state for plug-ins with respect to
the above state vector; plug-ins should totally set OGL state using this
API before drawing. Use XPLMSetGraphicsState instead of any of the above
OpenGL calls.
WARNING: Any routine that performs drawing (e.g. XPLMDrawString or widget
code) may change X-Plane's state. Always set state before drawing after
unknown code has executed.
*Deprecation Warnings*: X-Plane's lighting and fog environemnt is
significantly more complex than the fixed function pipeline can express;
do not assume that lighting and fog state is a good approximation for 3-d
drawing. Prefer to use XPLMInstancing to draw objects. All calls to
XPLMSetGraphicsState should have no fog or lighting.
}
PROCEDURE XPLMSetGraphicsState(
inEnableFog : integer;
inNumberTexUnits : integer;
inEnableLighting : integer;
inEnableAlphaTesting: integer;
inEnableAlphaBlending: integer;
inEnableDepthTesting: integer;
inEnableDepthWriting: integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inEnableFog : Integer;
inNumberTexUnits : Integer;
inEnableLighting : Integer;
inEnableAlphaTesting: Integer;
inEnableAlphaBlending: Integer;
inEnableDepthTesting: Integer;
inEnableDepthWriting: Integer);
cdecl; external XPLM_DLL;
{
XPLMBindTexture2d
XPLMBindTexture2d changes what texture is bound to the 2d texturing target.
This routine caches the current 2d texture across all texturing units in
the sim and plug-ins, preventing extraneous binding. For example, consider
several plug-ins running in series; if they all use the 'general interface'
bitmap to do UI, calling this function will skip the rebinding of the
general interface texture on all but the first plug-in, which can provide
better frame rate son some graphics cards.
XPLMBindTexture2d changes what texture is bound to the 2d texturing
target. This routine caches the current 2d texture across all texturing
units in the sim and plug-ins, preventing extraneous binding. For
example, consider several plug-ins running in series; if they all use the
'general interface' bitmap to do UI, calling this function will skip the
rebinding of the general interface texture on all but the first plug-in,
which can provide better frame rate son some graphics cards.
inTextureID is the ID of the texture object to bind; inTextureUnit is a
zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4
units. (This number may increase in future versions of x-plane.)
zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4
units. (This number may increase in future versions of X-Plane.)
Use this routine instead of glBindTexture(GL_TEXTURE_2D, ....);
}
PROCEDURE XPLMBindTexture2d(
inTextureNum : integer;
inTextureUnit : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inTextureNum : Integer;
inTextureUnit : Integer);
cdecl; external XPLM_DLL;
{
XPLMGenerateTextureNumbers
This routine generates unused texture numbers that a plug-in can use to
safely bind textures. Use this routine instead of glGenTextures;
glGenTextures will allocate texture numbers in ranges that X-Plane reserves
for its own use but does not always use; for example, it might provide an
ID within the range of textures reserved for terrain...loading a new .env
file as the plane flies might then cause X-Plane to use this texture ID.
X-Plane will then overwrite the plug-ins texture. This routine returns
texture IDs that are out of X-Plane's usage range.
Use this routine instead of glGenTextures to generate new texture object
IDs. This routine historically ensured that plugins don't use texure IDs
that X-Plane is reserving for its own use.
}
PROCEDURE XPLMGenerateTextureNumbers(
outTextureIDs : Pinteger;
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outTextureIDs : PInteger;
inCount : Integer);
cdecl; external XPLM_DLL;
{$IFDEF XPLM_DEPRECATED}
{
XPLMGetTexture
XPLMGetTexture returns the OpenGL texture enumeration of an X-Plane texture
based on a generic identifying code. For example, you can get the texture
for X-Plane's UI bitmaps. This allows you to build new gauges that take
advantage of x-plane's textures, for smooth artwork integration and also
saving texture memory. Note that the texture might not be loaded yet,
depending on what the plane's panel contains.
OPEN ISSUE: We really need a way to make sure X-Plane loads this texture if
it isn't around, or at least a way to find out whether it is loaded or not.
XPLMGetTexture returns the OpenGL texture ID of an X-Plane texture based on
a generic identifying code. For example, you can get the texture for
X-Plane's UI bitmaps.
}
FUNCTION XPLMGetTexture(
inTexture : XPLMTextureID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inTexture : XPLMTextureID) : Integer;
cdecl; external XPLM_DLL;
{$ENDIF XPLM_DEPRECATED}
{
XPLMWorldToLocal
@@ -208,17 +188,13 @@ TYPE
meters in the local OpenGL coordinate system.
}
PROCEDURE XPLMWorldToLocal(
inLatitude : real;
inLongitude : real;
inAltitude : real;
outX : Preal;
outY : Preal;
outZ : Preal);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inLatitude : Real;
inLongitude : Real;
inAltitude : Real;
outX : PReal;
outY : PReal;
outZ : PReal);
cdecl; external XPLM_DLL;
{
XPLMLocalToWorld
@@ -232,17 +208,13 @@ TYPE
try to avoid round tripping from local to world and back.
}
PROCEDURE XPLMLocalToWorld(
inX : real;
inY : real;
inZ : real;
outLatitude : Preal;
outLongitude : Preal;
outAltitude : Preal);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inX : Real;
inY : Real;
inZ : Real;
outLatitude : PReal;
outLongitude : PReal;
outAltitude : PReal);
cdecl; external XPLM_DLL;
{
XPLMDrawTranslucentDarkBox
@@ -252,24 +224,15 @@ TYPE
used by X-Plane to show text files and ATC info.
}
PROCEDURE XPLMDrawTranslucentDarkBox(
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inLeft : Integer;
inTop : Integer;
inRight : Integer;
inBottom : Integer);
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* X-PLANE TEXT
___________________________________________________________________________}
{
}
{
XPLMFontID
@@ -287,64 +250,98 @@ TYPE
}
TYPE
XPLMFontID = (
{ Mono-spaced font for user interface. Available in all versions of the SDK. }
{ Mono-spaced font for user interface. Available in all versions of the SDK.}
xplmFont_Basic = 0
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_Menus = 1
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_Metal = 2
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_Led = 3
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_LedWide = 4
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_PanelHUD = 5
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_PanelEFIS = 6
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_PanelGPS = 7
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_RadiosGA = 8
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_RadiosBC = 9
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_RadiosHM = 10
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_RadiosGANarrow = 11
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_RadiosBCNarrow = 12
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_RadiosHMNarrow = 13
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_Timer = 14
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_FullRound = 15
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_SmallRound = 16
{$ENDIF XPLM_DEPRECATED}
{ Deprecated, do not use. }
{$IFDEF XPLM_DEPRECATED}
{ Deprecated, do not use. }
,xplmFont_Menus_Localized = 17
{$ENDIF XPLM_DEPRECATED}
{$IFDEF XPLM200}
{ Proportional UI font. }
{ Proportional UI font. }
,xplmFont_Proportional = 18
{$ENDIF}
{$ENDIF XPLM200}
);
PXPLMFontID = ^XPLMFontID;
@@ -360,17 +357,13 @@ TYPE
to 1.0.
}
PROCEDURE XPLMDrawString(
inColorRGB : Psingle;
inXOffset : integer;
inYOffset : integer;
inChar : Pchar;
inWordWrapWidth : Pinteger; { Can be nil }
inColorRGB : PSingle;
inXOffset : Integer;
inYOffset : Integer;
inChar : XPLMString;
inWordWrapWidth : PInteger; { Can be nil }
inFontID : XPLMFontID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMDrawNumber
@@ -378,24 +371,20 @@ TYPE
This routine draws a number similar to the digit editing fields in
PlaneMaker and data output display in X-Plane. Pass in a color, a
position, a floating point value, and formatting info. Specify how many
integer and how many decimal digits to show and whether to show a sign, as
integer and how many decimal digits to show and whether to show a sign, as
well as a character set. This routine returns the xOffset plus width of the
string drawn.
}
PROCEDURE XPLMDrawNumber(
inColorRGB : Psingle;
inXOffset : integer;
inYOffset : integer;
inValue : real;
inDigits : integer;
inDecimals : integer;
inShowSign : integer;
inColorRGB : PSingle;
inXOffset : Integer;
inYOffset : Integer;
inValue : Real;
inDigits : Integer;
inDecimals : Integer;
inShowSign : Integer;
inFontID : XPLMFontID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMGetFontDimensions
@@ -407,14 +396,10 @@ TYPE
}
PROCEDURE XPLMGetFontDimensions(
inFontID : XPLMFontID;
outCharWidth : Pinteger; { Can be nil }
outCharHeight : Pinteger; { Can be nil }
outDigitsOnly : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outCharWidth : PInteger; { Can be nil }
outCharHeight : PInteger; { Can be nil }
outDigitsOnly : PInteger); { Can be nil }
cdecl; external XPLM_DLL;
{$IFDEF XPLM200}
{
@@ -428,14 +413,12 @@ TYPE
}
FUNCTION XPLMMeasureString(
inFontID : XPLMFontID;
inChar : Pchar;
inNumChars : integer) : single;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
inChar : XPLMString;
inNumChars : Integer) : Single;
cdecl; external XPLM_DLL;
{$ENDIF XPLM200}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMInstance.pas
+125
View File
@@ -0,0 +1,125 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMInstance;
INTERFACE
{
This API provides instanced drawing of X-Plane objects (.obj files). In
contrast to old drawing APIs, which required you to draw your own objects
per-frame, the instancing API allows you to simply register an OBJ for
drawing, then move or manipulate it later (as needed).
This provides one tremendous benefit: it keeps all dataref operations for
your object in one place. Because datarefs are main thread only, allowing
dataref access anywhere is a serious performance bottleneck for the
simulator---the whole simulator has to pause and wait for each dataref
access. This performance penalty will only grow worse as X-Plane moves
toward an ever more heavily multithreaded engine.
The instancing API allows X-Plane to isolate all dataref manipulations for
all plugin object drawing to one place, potentially providing huge
performance gains.
Here's how it works:
When an instance is created, it provides a list of all datarefs you want to
manipulate in for the OBJ in the future. This list of datarefs replaces the
ad-hoc collections of dataref objects previously used by art assets. Then,
per-frame, you can manipulate the instance by passing in a "block" of
packed floats representing the current values of the datarefs for your
instance. (Note that the ordering of this set of packed floats must exactly
match the ordering of the datarefs when you created your instance.)
}
USES
XPLMDefs, XPLMScenery;
{$A4}
{___________________________________________________________________________
* Instance Creation and Destruction
___________________________________________________________________________}
{
Registers and unregisters instances.
}
TYPE
{
XPLMInstanceRef
An opaque handle to an instance.
}
XPLMInstanceRef = pointer;
PXPLMInstanceRef = ^XPLMInstanceRef;
{
XPLMCreateInstance
XPLMCreateInstance creates a new instance, managed by your plug-in, and
returns a handle to the instance. A few important requirements:
* The object passed in must be fully loaded and returned from the XPLM
before you can create your instance; you cannot pass a null obj ref, nor
can you change the ref later.
* If you use any custom datarefs in your object, they must be registered
before the object is loaded. This is true even if their data will be
provided via the instance dataref list.
* The instance dataref array must be a valid ptr to an array of at least
one item that is null terminated. That is, if you do not want any
datarefs, you must passa ptr to an array with a null item. You cannot
pass null for this.
}
FUNCTION XPLMCreateInstance(
obj : XPLMObjectRef;
datarefs : PXPLMString) : XPLMInstanceRef;
cdecl; external XPLM_DLL;
{
XPLMDestroyInstance
XPLMDestroyInstance destroys and deallocates your instance; once called,
you are still responsible for releasing the OBJ ref.
Tip: you can release your OBJ ref after you call XPLMCreateInstance as long
as you never use it again; the instance will maintain its own reference to
the OBJ and the object OBJ be deallocated when the instance is destroyed.
}
PROCEDURE XPLMDestroyInstance(
instance : XPLMInstanceRef);
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* Instance Manipulation
___________________________________________________________________________}
{
XPLMInstanceSetPosition
Updates both the position of the instance and all datarefs you registered
for it. Call this from a flight loop callback or UI callback.
__DO NOT__ call XPLMInstanceSetPosition from a drawing callback; the whole
point of instancing is that you do not need any drawing callbacks. Setting
instance data from a drawing callback may have undefined consequences, and
the drawing callback hurts FPS unnecessarily.
The memory pointed to by the data pointer must be large enough to hold one
float for every data ref you have registered, and must contain valid
floating point data.
BUG: before X-Plane 11.50, if you have no dataref registered, you must
still pass a valid pointer for data and not null.
}
PROCEDURE XPLMInstanceSetPosition(
instance : XPLMInstanceRef;
new_position : PXPLMDrawInfo_t;
data : PSingle);
cdecl; external XPLM_DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMMap.pas
+608
View File
@@ -0,0 +1,608 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMMap;
INTERFACE
{
This API allows you to create new layers within X-Plane maps. Your layers
can draw arbitrary OpenGL, but they conveniently also have access to
X-Plane's built-in icon and label drawing functions.
As of X-Plane 11, map drawing happens in three stages:
1. backgrounds and "fill,"
2. icons, and
3. labels.
Thus, all background drawing gets layered beneath all icons, which likewise
get layered beneath all labels. Within each stage, the map obeys a
consistent layer ordering, such that "fill" layers (layers that cover a
large amount of map area, like the terrain and clouds) appear beneath
"markings" layers (like airport icons). This ensures that layers with fine
details don't get obscured by layers with larger details.
The XPLM map API reflects both aspects of this draw layering: you can
register a layer as providing either markings or fill, and X-Plane will
draw your fill layers beneath your markings layers (regardless of
registration order). Likewise, you are guaranteed that your layer's icons
(added from within an icon callback) will go above your layer's OpenGL
drawing, and your labels will go above your icons.
The XPLM guarantees that all plugin-created fill layers go on top of all
native X-Plane fill layers, and all plugin-created markings layers go on
top of all X-Plane markings layers (with the exception of the aircraft
icons). It also guarantees that the draw order of your own plugin's layers
will be consistent. But, for layers created by different plugins, the only
guarantee is that we will draw all of one plugin's layers of each type
(fill, then markings), then all of the others'; we don't guarantee which
plugin's fill and markings layers go on top of the other's.
As of X-Plane 11, maps use true cartographic projections for their drawing,
and different maps may use different projections. For that reason, all
drawing calls include an opaque handle for the projection you should use to
do the drawing. Any time you would draw at a particular latitude/longitude,
you'll need to ask the projection to translate that position into "map
coordinates." (Note that the projection is guaranteed not to change between
calls to your prepare-cache hook, so if you cache your map coordinates
ahead of time, there's no need to re-project them when you actually draw.)
In addition to mapping normal latitude/longitude locations into map
coordinates, the projection APIs also let you know the current heading for
north. (Since X-Plane 11 maps can rotate to match the heading of the user's
aircraft, it's not safe to assume that north is at zero degrees rotation.)
}
USES
XPLMDefs;
{$A4}
{$IFDEF XPLM300}
{___________________________________________________________________________
* DRAWING CALLBACKS
___________________________________________________________________________}
{
When you create a new map layer (using XPLMCreateMapLayer), you can provide
any or all of these callbacks. They allow you to insert your own OpenGL
drawing, text labels, and icons into the X-Plane map at the appropriate
places, allowing your layer to behave as similarly to X-Plane's built-in
layers as possible.
}
TYPE
{
XPLMMapLayerID
This is an opaque handle for a plugin-created map layer. Pass it to the map
drawing APIs from an appropriate callback to draw in the layer you created.
}
XPLMMapLayerID = pointer;
PXPLMMapLayerID = ^XPLMMapLayerID;
{
XPLMMapProjectionID
This is an opaque handle for a map projection. Pass it to the projection
APIs to translate between map coordinates and latitude/longitudes.
}
XPLMMapProjectionID = pointer;
PXPLMMapProjectionID = ^XPLMMapProjectionID;
{
XPLMMapStyle
Indicates the visual style being drawn by the map. In X-Plane, the user can
choose between a number of map types, and different map types may have use
a different visual representation for the same elements (for instance, the
visual style of the terrain layer changes drastically between the VFR and
IFR layers), or certain layers may be disabled entirely in some map types
(e.g., localizers are only visible in the IFR low-enroute style).
}
XPLMMapStyle = (
xplm_MapStyle_VFR_Sectional = 0
,xplm_MapStyle_IFR_LowEnroute = 1
,xplm_MapStyle_IFR_HighEnroute = 2
);
PXPLMMapStyle = ^XPLMMapStyle;
{
XPLMMapDrawingCallback_f
This is the OpenGL map drawing callback for plugin-created map layers. You
can perform arbitrary OpenGL drawing from this callback, with one
exception: changes to the Z-buffer are not permitted, and will result in
map drawing errors.
All drawing done from within this callback appears beneath all built-in
X-Plane icons and labels, but above the built-in "fill" layers (layers
providing major details, like terrain and water). Note, however, that the
relative ordering between the drawing callbacks of different plugins is not
guaranteed.
}
XPLMMapDrawingCallback_f = PROCEDURE(
inLayer : XPLMMapLayerID;
inMapBoundsLeftTopRightBottom: PSingle;
zoomRatio : Single;
mapUnitsPerUserInterfaceUnit: Single;
mapStyle : XPLMMapStyle;
projection : XPLMMapProjectionID;
inRefcon : pointer); cdecl;
{
XPLMMapIconDrawingCallback_f
This is the icon drawing callback that enables plugin-created map layers to
draw icons using X-Plane's built-in icon drawing functionality. You can
request an arbitrary number of PNG icons to be drawn via
XPLMDrawMapIconFromSheet() from within this callback, but you may not
perform any OpenGL drawing here.
Icons enqueued by this function will appear above all OpenGL drawing
(performed by your optional XPLMMapDrawingCallback_f), and above all
built-in X-Plane map icons of the same layer type ("fill" or "markings," as
determined by the XPLMMapLayerType in your XPLMCreateMapLayer_t). Note,
however, that the relative ordering between the drawing callbacks of
different plugins is not guaranteed.
}
XPLMMapIconDrawingCallback_f = PROCEDURE(
inLayer : XPLMMapLayerID;
inMapBoundsLeftTopRightBottom: PSingle;
zoomRatio : Single;
mapUnitsPerUserInterfaceUnit: Single;
mapStyle : XPLMMapStyle;
projection : XPLMMapProjectionID;
inRefcon : pointer); cdecl;
{
XPLMMapLabelDrawingCallback_f
This is the label drawing callback that enables plugin-created map layers
to draw text labels using X-Plane's built-in labeling functionality. You
can request an arbitrary number of text labels to be drawn via
XPLMDrawMapLabel() from within this callback, but you may not perform any
OpenGL drawing here.
Labels enqueued by this function will appear above all OpenGL drawing
(performed by your optional XPLMMapDrawingCallback_f), and above all
built-in map icons and labels of the same layer type ("fill" or "markings,"
as determined by the XPLMMapLayerType in your XPLMCreateMapLayer_t). Note,
however, that the relative ordering between the drawing callbacks of
different plugins is not guaranteed.
}
XPLMMapLabelDrawingCallback_f = PROCEDURE(
inLayer : XPLMMapLayerID;
inMapBoundsLeftTopRightBottom: PSingle;
zoomRatio : Single;
mapUnitsPerUserInterfaceUnit: Single;
mapStyle : XPLMMapStyle;
projection : XPLMMapProjectionID;
inRefcon : pointer); cdecl;
{$ENDIF XPLM300}
{$IFDEF XPLM300}
{___________________________________________________________________________
* LAYER MANAGEMENT CALLBACKS
___________________________________________________________________________}
{
These are various "bookkeeping" callbacks that your map layer can receive
(if you provide the callback in your XPLMCreateMapLayer_t). They allow you
to manage the lifecycle of your layer, as well as cache any
computationally-intensive preparation you might need for drawing.
}
{
XPLMMapPrepareCacheCallback_f
A callback used to allow you to cache whatever information your layer needs
to draw in the current map area.
This is called each time the map's total bounds change. This is typically
triggered by new DSFs being loaded, such that X-Plane discards old,
now-distant DSFs and pulls in new ones. At that point, the available bounds
of the map also change to match the new DSF area.
By caching just the information you need to draw in this area, your future
draw calls can be made faster, since you'll be able to simply "splat" your
precomputed information each frame.
We guarantee that the map projection will not change between successive
prepare cache calls, nor will any draw call give you bounds outside these
total map bounds. So, if you cache the projected map coordinates of all the
items you might want to draw in the total map area, you can be guaranteed
that no draw call will be asked to do any new work.
}
TYPE
XPLMMapPrepareCacheCallback_f = PROCEDURE(
inLayer : XPLMMapLayerID;
inTotalMapBoundsLeftTopRightBottom: PSingle;
projection : XPLMMapProjectionID;
inRefcon : pointer); cdecl;
{
XPLMMapWillBeDeletedCallback_f
Called just before your map layer gets deleted. Because SDK-created map
layers have the same lifetime as the X-Plane map that contains them, if the
map gets unloaded from memory, your layer will too.
}
XPLMMapWillBeDeletedCallback_f = PROCEDURE(
inLayer : XPLMMapLayerID;
inRefcon : pointer); cdecl;
{$ENDIF XPLM300}
{$IFDEF XPLM300}
{___________________________________________________________________________
* MAP LAYER CREATION AND DESTRUCTION
___________________________________________________________________________}
{
Enables the creation of new map layers. Layers are created for a particular
instance of the X-Plane map. For instance, if you want your layer to appear
in both the normal map interface and the Instructor Operator Station (IOS),
you would need two separate calls to XPLMCreateMapLayer(), with two
different values for your XPLMCreateMapLayer_t::layer_name.
Your layer's lifetime will be determined by the lifetime of the map it is
created in. If the map is destroyed (on the X-Plane side), your layer will
be too, and you'll receive a callback to your
XPLMMapWillBeDeletedCallback_f.
}
{
XPLMMapLayerType
Indicates the type of map layer you are creating. Fill layers will always
be drawn beneath markings layers.
}
TYPE
XPLMMapLayerType = (
{ A layer that draws "fill" graphics, like weather patterns, terrain, etc. }
{ Fill layers frequently cover a large portion of the visible map area. }
xplm_MapLayer_Fill = 0
{ A layer that provides markings for particular map features, like NAVAIDs, }
{ airports, etc. Even dense markings layers cover a small portion of the }
{ total map area. }
,xplm_MapLayer_Markings = 1
);
PXPLMMapLayerType = ^XPLMMapLayerType;
CONST
{ Globally unique identifier for X-Plane's Map window, used as the }
{ mapToCreateLayerIn parameter in XPLMCreateMapLayer_t }
XPLM_MAP_USER_INTERFACE = "XPLM_MAP_USER_INTERFACE";
{ Globally unique identifier for X-Plane's Instructor Operator Station }
{ window, used as the mapToCreateLayerIn parameter in XPLMCreateMapLayer_t }
XPLM_MAP_IOS = "XPLM_MAP_IOS";
{
XPLMCreateMapLayer_t
This structure defines all of the parameters used to create a map layer
using XPLMCreateMapLayer. The structure will be expanded in future SDK APIs
to include more features. Always set the structSize member to the size of
your struct in bytes!
Each layer must be associated with exactly one map instance in X-Plane.
That map, and that map alone, will call your callbacks. Likewise, when that
map is deleted, your layer will be as well.
}
TYPE
XPLMCreateMapLayer_t = RECORD
{ Used to inform XPLMCreateMapLayer() of the SDK version you compiled }
{ against; should always be set to sizeof(XPLMCreateMapLayer_t) }
structSize : Integer;
{ Globally unique string identifying the map you want this layer to appear }
{ in. As of XPLM300, this is limited to one of XPLM_MAP_USER_INTERFACE or }
{ XPLM_MAP_IOS }
mapToCreateLayerIn : XPLMString;
{ The type of layer you are creating, used to determine draw order (all }
{ plugin-created markings layers are drawn above all plugin-created fill }
{ layers) }
layerType : XPLMMapLayerType;
{ Optional callback to inform you this layer is being deleted (due to its }
{ owning map being destroyed) }
willBeDeletedCallback : XPLMMapWillBeDeletedCallback_f;
{ Optional callback you want to use to prepare your draw cache when the map }
{ bounds change (set to NULL if you don't want this callback) }
prepCacheCallback : XPLMMapPrepareCacheCallback_f;
{ Optional callback you want to use for arbitrary OpenGL drawing, which goes }
{ beneath all icons in the map's layering system (set to NULL if you don't }
{ want this callback) }
drawCallback : XPLMMapDrawingCallback_f;
{ Optional callback you want to use for drawing icons, which go above all }
{ built-in X-Plane icons (except the aircraft) in the map's layering system }
{ (set to NULL if you don't want this callback) }
iconCallback : XPLMMapIconDrawingCallback_f;
{ Optional callback you want to use for drawing map labels, which go above }
{ all built-in X-Plane icons and labels (except those of aircraft) in the }
{ map's layering system (set to NULL if you don't want this callback) }
labelCallback : XPLMMapLabelDrawingCallback_f;
{ True if you want a checkbox to be created in the map UI to toggle this }
{ layer on and off; false if the layer should simply always be enabled }
showUiToggle : Integer;
{ Short label to use for this layer in the user interface }
layerName : XPLMString;
{ A reference to arbitrary data that will be passed to your callbacks }
refcon : pointer;
END;
PXPLMCreateMapLayer_t = ^XPLMCreateMapLayer_t;
{
XPLMCreateMapLayer
This routine creates a new map layer. You pass in an XPLMCreateMapLayer_t
structure with all of the fields set in. You must set the structSize of
the structure to the size of the actual structure you used.
Returns NULL if the layer creation failed. This happens most frequently
because the map you specified in your
XPLMCreateMapLayer_t::mapToCreateLayerIn field doesn't exist (that is, if
XPLMMapExists() returns 0 for the specified map). You can use
XPLMRegisterMapCreationHook() to get a notification each time a new map is
opened in X-Plane, at which time you can create layers in it.
}
FUNCTION XPLMCreateMapLayer(
inParams : PXPLMCreateMapLayer_t) : XPLMMapLayerID;
cdecl; external XPLM_DLL;
{
XPLMDestroyMapLayer
Destroys a map layer you created (calling your
XPLMMapWillBeDeletedCallback_f if applicable). Returns true if a deletion
took place.
}
FUNCTION XPLMDestroyMapLayer(
inLayer : XPLMMapLayerID) : Integer;
cdecl; external XPLM_DLL;
{
XPLMMapCreatedCallback_f
A callback to notify your plugin that a new map has been created in
X-Plane. This is the best time to add a custom map layer using
XPLMCreateMapLayer().
No OpenGL drawing is permitted within this callback.
}
TYPE
XPLMMapCreatedCallback_f = PROCEDURE(
mapIdentifier : XPLMString;
refcon : pointer); cdecl;
{
XPLMRegisterMapCreationHook
Registers your callback to receive a notification each time a new map is
constructed in X-Plane. This callback is the best time to add your custom
map layer using XPLMCreateMapLayer().
Note that you will not be notified about any maps that already exist---you
can use XPLMMapExists() to check for maps that were created previously.
}
PROCEDURE XPLMRegisterMapCreationHook(
callback : XPLMMapCreatedCallback_f;
refcon : pointer);
cdecl; external XPLM_DLL;
{
XPLMMapExists
Returns 1 if the map with the specified identifier already exists in
X-Plane. In that case, you can safely call XPLMCreateMapLayer() specifying
that your layer should be added to that map.
}
FUNCTION XPLMMapExists(
mapIdentifier : XPLMString) : Integer;
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
{$IFDEF XPLM300}
{___________________________________________________________________________
* MAP DRAWING
___________________________________________________________________________}
{
These APIs are only valid from within a map drawing callback (one of
XPLMIconDrawingCallback_t or XPLMMapLabelDrawingCallback_f). Your drawing
callbacks are registered when you create a new map layer as part of your
XPLMCreateMapLayer_t. The functions here hook into X-Plane's built-in map
drawing functionality for icons and labels, so that you get a consistent
style with the rest of the X-Plane map.
Note that the X-Plane 11 map introduces a strict ordering: layers of type
xplm_MapLayer_Fill get drawn beneath all xplm_MapLayer_Markings layers.
Likewise, all OpenGL drawing (performed in your layer's
XPLMMapDrawingCallback_f) will appear beneath any icons and labels you
draw.
}
{
XPLMMapOrientation
Indicates whether a map element should be match its rotation to the map
itself, or to the user interface. For instance, the map itself may be
rotated such that "up" matches the user's aircraft, but you may want to
draw a text label such that it is always rotated zero degrees relative to
the user's perspective. In that case, you would have it draw with UI
orientation.
}
TYPE
XPLMMapOrientation = (
{ Orient such that a 0 degree rotation matches the map's north }
xplm_MapOrientation_Map = 0
{ Orient such that a 0 degree rotation is "up" relative to the user interface}
,xplm_MapOrientation_UI = 1
);
PXPLMMapOrientation = ^XPLMMapOrientation;
{
XPLMDrawMapIconFromSheet
Enables plugin-created map layers to draw PNG icons using X-Plane's
built-in icon drawing functionality. Only valid from within an
XPLMIconDrawingCallback_t (but you can request an arbitrary number of icons
to be drawn from within your callback).
X-Plane will automatically manage the memory for your texture so that it
only has to be loaded from disk once as long as you continue drawing it
per-frame. (When you stop drawing it, the memory may purged in a "garbage
collection" pass, require a load from disk in the future.)
Instead of having X-Plane draw a full PNG, this method allows you to use UV
coordinates to request a portion of the image to be drawn. This allows you
to use a single texture load (of an icon sheet, for example) to draw many
icons. Doing so is much more efficient than drawing a dozen different small
PNGs.
The UV coordinates used here treat the texture you load as being comprised
of a number of identically sized "cells." You specify the width and height
in cells (ds and dt, respectively), as well as the coordinates within the
cell grid for the sub-image you'd like to draw.
Note that you can use different ds and dt values in subsequent calls with
the same texture sheet. This enables you to use icons of different sizes in
the same sheet if you arrange them properly in the PNG.
This function is only valid from within an XPLMIconDrawingCallback_t (but
you can request an arbitrary number of icons to be drawn from within your
callback).
}
PROCEDURE XPLMDrawMapIconFromSheet(
layer : XPLMMapLayerID;
inPngPath : XPLMString;
s : Integer;
t : Integer;
ds : Integer;
dt : Integer;
mapX : Single;
mapY : Single;
orientation : XPLMMapOrientation;
rotationDegrees : Single;
mapWidth : Single);
cdecl; external XPLM_DLL;
{
XPLMDrawMapLabel
Enables plugin-created map layers to draw text labels using X-Plane's
built-in labeling functionality. Only valid from within an
XPLMMapLabelDrawingCallback_f (but you can request an arbitrary number of
text labels to be drawn from within your callback).
}
PROCEDURE XPLMDrawMapLabel(
layer : XPLMMapLayerID;
inText : XPLMString;
mapX : Single;
mapY : Single;
orientation : XPLMMapOrientation;
rotationDegrees : Single);
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
{$IFDEF XPLM300}
{___________________________________________________________________________
* MAP PROJECTIONS
___________________________________________________________________________}
{
As of X-Plane 11, the map draws using true cartographic projections, and
different maps may use different projections. Thus, to draw at a particular
latitude and longitude, you must first transform your real-world
coordinates into map coordinates.
The map projection is also responsible for giving you the current scale of
the map. That is, the projection can tell you how many map units correspond
to 1 meter at a given point.
Finally, the map projection can give you the current rotation of the map.
Since X-Plane 11 maps can rotate to match the heading of the aircraft, the
map's rotation can potentially change every frame.
}
{
XPLMMapProject
Projects a latitude/longitude into map coordinates. This is the inverse of
XPLMMapUnproject().
Only valid from within a map layer callback (one of
XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
}
PROCEDURE XPLMMapProject(
projection : XPLMMapProjectionID;
latitude : Real;
longitude : Real;
outX : PSingle;
outY : PSingle);
cdecl; external XPLM_DLL;
{
XPLMMapUnproject
Transforms map coordinates back into a latitude and longitude. This is the
inverse of XPLMMapProject().
Only valid from within a map layer callback (one of
XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
}
PROCEDURE XPLMMapUnproject(
projection : XPLMMapProjectionID;
mapX : Single;
mapY : Single;
outLatitude : PReal;
outLongitude : PReal);
cdecl; external XPLM_DLL;
{
XPLMMapScaleMeter
Returns the number of map units that correspond to a distance of one meter
at a given set of map coordinates.
Only valid from within a map layer callback (one of
XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
}
FUNCTION XPLMMapScaleMeter(
projection : XPLMMapProjectionID;
mapX : Single;
mapY : Single) : Single;
cdecl; external XPLM_DLL;
{
XPLMMapGetNorthHeading
Returns the heading (in degrees clockwise) from the positive Y axis in the
cartesian mapping coordinate system to true north at the point passed in.
You can use it as a clockwise rotational offset to align icons and other
2-d drawing with true north on the map, compensating for rotations in the
map due to projection.
Only valid from within a map layer callback (one of
XPLMMapPrepareCacheCallback_f, XPLMMapDrawingCallback_f,
XPLMMapIconDrawingCallback_f, or XPLMMapLabelDrawingCallback_f.)
}
FUNCTION XPLMMapGetNorthHeading(
projection : XPLMMapProjectionID;
mapX : Single;
mapY : Single) : Single;
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMMenus.pas
+118 -100
View File
@@ -1,54 +1,62 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMMenus;
INTERFACE
{
XPLMMenus - Theory of Operation
Plug-ins can create menus in the menu bar of X-Plane. This is done by
Plug-ins can create menus in the menu bar of X-Plane. This is done by
creating a menu and then creating items. Menus are referred to by an
opaque ID. Items are referred to by index number. For each menu and item
you specify a void *. Per menu you specify a handler function that is
called with each void * when the menu item is picked. Menu item indices
are zero based.
opaque ID. Items are referred to by (zero-based) index number.
Menus are "sandboxed" between plugins---no plugin can access the menus of
any other plugin. Furthermore, all menu indices are relative to your
plugin's menus only; if your plugin creates two sub-menus in the Plugins
menu at different times, it doesn't matter how many other plugins also
create sub-menus of Plugins in the intervening time: your sub-menus will be
given menu indices 0 and 1. (The SDK does some work in the back-end to
filter out menus that are irrelevant to your plugin in order to deliver
this consistency for each plugin.)
When you create a menu item, you specify how we should handle clicks on
that menu item. You can either have the XPLM trigger a callback (the
XPLMMenuHandler_f associated with the menu that contains the item), or you
can simply have a command be triggered (with no associated call to your
menu handler). The advantage of the latter method is that X-Plane will
display any keyboard shortcuts associated with the command. (In contrast,
there are no keyboard shortcuts associated with menu handler callbacks with
specific parameters.)
Menu text in X-Plane is UTF8; X-Plane's character set covers latin, greek
and cyrillic characters, Katakana, as well as some Japanese symbols. Some
APIs have a inDeprecatedAndIgnored parameter that used to select a
character set; since X-Plane 9 all localization is done via UTF-8 only.
}
USES XPLMDefs;
USES
XPLMDefs, XPLMUtilities;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* XPLM MENUS
___________________________________________________________________________}
{
}
{
XPLMMenuCheck
These enumerations define the various 'check' states for an X-Plane menu.
'checking' in x-plane actually appears as a light which may or may not be
lit. So there are three possible states.
'checking' in X-Plane actually appears as a light which may or may not be
lit. So there are three possible states.
}
TYPE
XPLMMenuCheck = (
{ there is no symbol to the left of the menu item. }
{ there is no symbol to the left of the menu item. }
xplm_Menu_NoCheck = 0
{ the menu has a mark next to it that is unmarked (not lit). }
{ the menu has a mark next to it that is unmarked (not lit). }
,xplm_Menu_Unchecked = 1
{ the menu has a mark next to it that is checked (lit). }
{ the menu has a mark next to it that is checked (lit). }
,xplm_Menu_Checked = 2
);
@@ -80,11 +88,26 @@ TYPE
at startup.
}
FUNCTION XPLMFindPluginsMenu: XPLMMenuID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$IFDEF XPLM300}
{
XPLMFindAircraftMenu
This function returns the ID of the menu for the currently-loaded aircraft,
used for showing aircraft-specific commands.
The aircraft menu is created by X-Plane at startup, but it remains hidden
until it is populated via XPLMAppendMenuItem() or
XPLMAppendMenuItemWithCommand().
Only plugins loaded with the user's current aircraft are allowed to access
the aircraft menu. For all other plugins, this will return NULL, and any
attempts to add menu items to it will fail.
}
FUNCTION XPLMFindAircraftMenu: XPLMMenuID;
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
{
XPLMCreateMenu
@@ -101,16 +124,12 @@ TYPE
a submenu where the title is not visible.
}
FUNCTION XPLMCreateMenu(
inName : Pchar;
inName : XPLMString;
inParentMenu : XPLMMenuID;
inParentItem : integer;
inParentItem : Integer;
inHandler : XPLMMenuHandler_f;
inMenuRef : pointer) : XPLMMenuID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMDestroyMenu
@@ -120,11 +139,7 @@ TYPE
}
PROCEDURE XPLMDestroyMenu(
inMenuID : XPLMMenuID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMClearAllMenuItems
@@ -134,46 +149,67 @@ TYPE
}
PROCEDURE XPLMClearAllMenuItems(
inMenuID : XPLMMenuID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMAppendMenuItem
This routine appends a new menu item to the bottom of a menu and returns
its index. Pass in the menu to add the item to, the items name, and a void
* ref for this item. If you pass in inForceEnglish, this menu item will be
drawn using the english character set no matter what language x-plane is
running in. Otherwise the menu item will be drawn localized. (An example
of why you'd want to do this is for a proper name.) See XPLMUtilities for
determining the current langauge.
* ref for this item.
Returns a negative index if the append failed (due to an invalid parent
menu argument).
Note that all menu indices returned are relative to your plugin's menus
only; if your plugin creates two sub-menus in the Plugins menu at different
times, it doesn't matter how many other plugins also create sub-menus of
Plugins in the intervening time: your sub-menus will be given menu indices
0 and 1. (The SDK does some work in the back-end to filter out menus that
are irrelevant to your plugin in order to deliver this consistency for each
plugin.)
}
FUNCTION XPLMAppendMenuItem(
inMenu : XPLMMenuID;
inItemName : Pchar;
inItemName : XPLMString;
inItemRef : pointer;
inForceEnglish : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inDeprecatedAndIgnored: Integer) : Integer;
cdecl; external XPLM_DLL;
{$IFDEF XPLM300}
{
XPLMAppendMenuItemWithCommand
Like XPLMAppendMenuItem(), but instead of the new menu item triggering the
XPLMMenuHandler_f of the containiner menu, it will simply execute the
command you pass in. Using a command for your menu item allows the user to
bind a keyboard shortcut to the command and see that shortcut represented
in the menu.
Returns a negative index if the append failed (due to an invalid parent
menu argument).
Like XPLMAppendMenuItem(), all menu indices are relative to your plugin's
menus only.
}
FUNCTION XPLMAppendMenuItemWithCommand(
inMenu : XPLMMenuID;
inItemName : XPLMString;
inCommandToExecute : XPLMCommandRef) : Integer;
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
{
XPLMAppendMenuSeparator
This routine adds a seperator to the end of a menu.
This routine adds a separator to the end of a menu.
Returns a negative index if the append failed (due to an invalid parent
menu argument).
}
PROCEDURE XPLMAppendMenuSeparator(
inMenu : XPLMMenuID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMSetMenuItemName
@@ -183,14 +219,10 @@ TYPE
}
PROCEDURE XPLMSetMenuItemName(
inMenu : XPLMMenuID;
inIndex : integer;
inItemName : Pchar;
inForceEnglish : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer;
inItemName : XPLMString;
inDeprecatedAndIgnored: Integer);
cdecl; external XPLM_DLL;
{
XPLMCheckMenuItem
@@ -199,13 +231,9 @@ TYPE
}
PROCEDURE XPLMCheckMenuItem(
inMenu : XPLMMenuID;
index : integer;
index : Integer;
inCheck : XPLMMenuCheck);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMCheckMenuItemState
@@ -215,13 +243,9 @@ TYPE
}
PROCEDURE XPLMCheckMenuItemState(
inMenu : XPLMMenuID;
index : integer;
index : Integer;
outCheck : PXPLMMenuCheck);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMEnableMenuItem
@@ -230,13 +254,9 @@ TYPE
}
PROCEDURE XPLMEnableMenuItem(
inMenu : XPLMMenuID;
index : integer;
enabled : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
index : Integer;
enabled : Integer);
cdecl; external XPLM_DLL;
{$IFDEF XPLM210}
{
@@ -247,13 +267,11 @@ TYPE
}
PROCEDURE XPLMRemoveMenuItem(
inMenu : XPLMMenuID;
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
inIndex : Integer);
cdecl; external XPLM_DLL;
{$ENDIF XPLM210}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMNavigation.pas
+91 -175
View File
@@ -1,16 +1,11 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMNavigation;
INTERFACE
{
XPLMNavigation - THEORY OF OPERATION
The XPLM Navigation APIs give you some access to the navigation databases
inside X-Plane. X-Plane stores all navigation information in RAM, so by
using these APIs you can gain access to most information without having to
@@ -18,22 +13,15 @@ INTERFACE
You can also use this API to program the FMS. You must use the navigation
APIs to find the nav-aids you want to program into the FMS, since the FMS
is powered internally by x-plane's navigation database.
is powered internally by X-Plane's navigation database.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* NAVIGATION DATABASE ACCESS
___________________________________________________________________________}
{
}
{
XPLMNavType
@@ -84,14 +72,14 @@ TYPE
XPLMNavRef is an iterator into the navigation database. The navigation
database is essentially an array, but it is not necessarily densely
populated. The only assumption you can safely make is that like-typed
nav-aids are grouped together.
nav-aids are grouped together.
Use XPLMNavRef to refer to a nav-aid.
XPLM_NAV_NOT_FOUND is returned by functions that return an XPLMNavRef when
the iterator must be invalid.
}
XPLMNavRef = integer;
XPLMNavRef = Integer;
PXPLMNavRef = ^XPLMNavRef;
CONST
@@ -105,31 +93,19 @@ CONST
empty.
}
FUNCTION XPLMGetFirstNavAid: XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMGetNextNavAid
Given a nav aid ref, this routine returns the next navaid. It returns
XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the navaid
passed in was the last one in the database. Use this routine to iterate
across all like-typed navaids or the entire database.
WARNING: due to a bug in the SDK, when fix loading is disabled in the
rendering settings screen, calling this routine with the last airport
returns a bogus nav aid. Using this nav aid can crash x-plane.
Given a valid nav aid ref, this routine returns the next navaid. It
returns XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the
navaid passed in was the last one in the database. Use this routine to
iterate across all like-typed navaids or the entire database.
}
FUNCTION XPLMGetNextNavAid(
inNavAidRef : XPLMNavRef) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMFindFirstNavAidOfType
@@ -137,18 +113,10 @@ CONST
This routine returns the ref of the first navaid of the given type in the
database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the
database. You must pass exactly one nav aid type to this routine.
WARNING: due to a bug in the SDK, when fix loading is disabled in the
rendering settings screen, calling this routine with fixes returns a bogus
nav aid. Using this nav aid can crash x-plane.
}
FUNCTION XPLMFindFirstNavAidOfType(
inType : XPLMNavType) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMFindLastNavAidOfType
@@ -156,18 +124,10 @@ CONST
This routine returns the ref of the last navaid of the given type in the
database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the
database. You must pass exactly one nav aid type to this routine.
WARNING: due to a bug in the SDK, when fix loading is disabled in the
rendering settings screen, calling this routine with fixes returns a bogus
nav aid. Using this nav aid can crash x-plane.
}
FUNCTION XPLMFindLastNavAidOfType(
inType : XPLMNavType) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMFindNavAid
@@ -175,39 +135,35 @@ CONST
This routine provides a number of searching capabilities for the nav
database. XPLMFindNavAid will search through every nav aid whose type is
within inType (multiple types may be added together) and return any
nav-aids found based on the following rules:
nav-aids found based on the following rules:
If inLat and inLon are not NULL, the navaid nearest to that lat/lon will be
returned, otherwise the last navaid found will be returned.
* If inLat and inLon are not NULL, the navaid nearest to that lat/lon will
be returned, otherwise the last navaid found will be returned.
If inFrequency is not NULL, then any navaids considered must match this
frequency. Note that this will screen out radio beacons that do not have
frequency data published (like inner markers) but not fixes and airports.
* If inFrequency is not NULL, then any navaids considered must match this
frequency. Note that this will screen out radio beacons that do not have
frequency data published (like inner markers) but not fixes and airports.
If inNameFragment is not NULL, only navaids that contain the fragment in
their name will be returned.
* If inNameFragment is not NULL, only navaids that contain the fragment in
their name will be returned.
If inIDFragment is not NULL, only navaids that contain the fragment in
their IDs will be returned.
* If inIDFragment is not NULL, only navaids that contain the fragment in
their IDs will be returned.
This routine provides a simple way to do a number of useful searches:
Find the nearest navaid on this frequency. Find the nearest airport. Find
the VOR whose ID is "KBOS". Find the nearest airport whose name contains
"Chicago".
* Find the nearest navaid on this frequency.
* Find the nearest airport.
* Find the VOR whose ID is "KBOS".
* Find the nearest airport whose name contains "Chicago".
}
FUNCTION XPLMFindNavAid(
inNameFragment : Pchar; { Can be nil }
inIDFragment : Pchar; { Can be nil }
inLat : Psingle; { Can be nil }
inLon : Psingle; { Can be nil }
inFrequency : Pinteger; { Can be nil }
inNameFragment : XPLMString; { Can be nil }
inIDFragment : XPLMString; { Can be nil }
inLat : PSingle; { Can be nil }
inLon : PSingle; { Can be nil }
inFrequency : PInteger; { Can be nil }
inType : XPLMNavType) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMGetNavAidInfo
@@ -231,19 +187,15 @@ CONST
PROCEDURE XPLMGetNavAidInfo(
inRef : XPLMNavRef;
outType : PXPLMNavType; { Can be nil }
outLatitude : Psingle; { Can be nil }
outLongitude : Psingle; { Can be nil }
outHeight : Psingle; { Can be nil }
outFrequency : Pinteger; { Can be nil }
outHeading : Psingle; { Can be nil }
outID : Pchar; { Can be nil }
outName : Pchar; { Can be nil }
outReg : Pchar); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outLatitude : PSingle; { Can be nil }
outLongitude : PSingle; { Can be nil }
outHeight : PSingle; { Can be nil }
outFrequency : PInteger; { Can be nil }
outHeading : PSingle; { Can be nil }
outID : XPLMString; { Can be nil }
outName : XPLMString; { Can be nil }
outReg : XPLMString); { Can be nil }
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* FLIGHT MANAGEMENT COMPUTER
@@ -259,55 +211,38 @@ CONST
}
{
XPLMCountFMSEntries
This routine returns the number of entries in the FMS.
}
FUNCTION XPLMCountFMSEntries: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
FUNCTION XPLMCountFMSEntries: Integer;
cdecl; external XPLM_DLL;
{
XPLMGetDisplayedFMSEntry
This routine returns the index of the entry the pilot is viewing.
}
FUNCTION XPLMGetDisplayedFMSEntry: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
FUNCTION XPLMGetDisplayedFMSEntry: Integer;
cdecl; external XPLM_DLL;
{
XPLMGetDestinationFMSEntry
This routine returns the index of the entry the FMS is flying to.
}
FUNCTION XPLMGetDestinationFMSEntry: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
FUNCTION XPLMGetDestinationFMSEntry: Integer;
cdecl; external XPLM_DLL;
{
XPLMSetDisplayedFMSEntry
This routine changes which entry the FMS is showing to the index specified.
}
}
PROCEDURE XPLMSetDisplayedFMSEntry(
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer);
cdecl; external XPLM_DLL;
{
XPLMSetDestinationFMSEntry
@@ -315,37 +250,38 @@ CONST
This routine changes which entry the FMS is flying the aircraft toward.
}
PROCEDURE XPLMSetDestinationFMSEntry(
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer);
cdecl; external XPLM_DLL;
{
XPLMGetFMSEntryInfo
This routine returns information about a given FMS entry. A reference to a
navaid can be returned allowing you to find additional information (such as
a frequency, ILS heading, name, etc.). Some information is available
immediately. For a lat/lon entry, the lat/lon is returned by this routine
but the navaid cannot be looked up (and the reference will be
XPLM_NAV_NOT_FOUND. FMS name entry buffers should be at least 256 chars in
length.
This routine returns information about a given FMS entry. If the entry is
an airport or navaid, a reference to a nav entry can be returned allowing
you to find additional information (such as a frequency, ILS heading, name,
etc.). Note that this reference can be XPLM_NAV_NOT_FOUND until the
information has been looked up asynchronously, so after flightplan changes,
it might take up to a second for this field to become populated. The other
information is available immediately. For a lat/lon entry, the lat/lon is
returned by this routine but the navaid cannot be looked up (and the
reference will be XPLM_NAV_NOT_FOUND). FMS name entry buffers should be at
least 256 chars in length.
WARNING: Due to a bug in X-Plane prior to 11.31, the navaid reference will
not be set to XPLM_NAV_NOT_FOUND while no data is available, and instead
just remain the value of the variable that you passed the pointer to.
Therefore, always initialize the variable to XPLM_NAV_NOT_FOUND before
passing the pointer to this function.
}
PROCEDURE XPLMGetFMSEntryInfo(
inIndex : integer;
inIndex : Integer;
outType : PXPLMNavType; { Can be nil }
outID : Pchar; { Can be nil }
outID : XPLMString; { Can be nil }
outRef : PXPLMNavRef; { Can be nil }
outAltitude : Pinteger; { Can be nil }
outLat : Psingle; { Can be nil }
outLon : Psingle); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outAltitude : PInteger; { Can be nil }
outLat : PSingle; { Can be nil }
outLon : PSingle); { Can be nil }
cdecl; external XPLM_DLL;
{
XPLMSetFMSEntryInfo
@@ -356,14 +292,10 @@ CONST
support VORs and NDBs. Use the routines below to clear or fly to a lat/lon.
}
PROCEDURE XPLMSetFMSEntryInfo(
inIndex : integer;
inIndex : Integer;
inRef : XPLMNavRef;
inAltitude : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inAltitude : Integer);
cdecl; external XPLM_DLL;
{
XPLMSetFMSEntryLatLon
@@ -372,15 +304,11 @@ CONST
coordinates.
}
PROCEDURE XPLMSetFMSEntryLatLon(
inIndex : integer;
inLat : single;
inLon : single;
inAltitude : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer;
inLat : Single;
inLon : Single;
inAltitude : Integer);
cdecl; external XPLM_DLL;
{
XPLMClearFMSEntry
@@ -389,12 +317,8 @@ CONST
plan.
}
PROCEDURE XPLMClearFMSEntry(
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer);
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* GPS RECEIVER
@@ -403,8 +327,6 @@ CONST
These APIs let you read data from the GPS unit.
}
{
XPLMGetGPSDestinationType
@@ -412,11 +334,7 @@ CONST
one of fix, airport, VOR or NDB.
}
FUNCTION XPLMGetGPSDestinationType: XPLMNavType;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMGetGPSDestination
@@ -424,11 +342,9 @@ CONST
This routine returns the current GPS destination.
}
FUNCTION XPLMGetGPSDestination: XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMPlanes.pas
+118 -134
View File
@@ -1,30 +1,25 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMPlanes;
INTERFACE
{
The XPLMPlanes APIs allow you to control the various aircraft in x-plane,
The XPLMPlanes APIs allow you to control the various aircraft in X-Plane,
both the user's and the sim's.
*Note*: unlike almost all other APIs in the SDK, aircraft paths are _full_
file system paths for historical reasons. You'll need to prefix all
relative paths with the X-Plane path as accessed via XPLMGetSystemPath.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* USER AIRCRAFT ACCESS
___________________________________________________________________________}
{
}
{
XPLMSetUsersAircraft
@@ -34,36 +29,45 @@ USES XPLMDefs;
(hard drive and everything including the .acf extension) to the .acf file.
}
PROCEDURE XPLMSetUsersAircraft(
inAircraftPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inAircraftPath : XPLMString);
cdecl; external XPLM_DLL;
{
XPLMPlaceUserAtAirport
This routine places the user at a given airport. Specify the airport by
its ICAO code (e.g. 'KBOS').
its X-Plane airport ID (e.g. 'KBOS').
}
PROCEDURE XPLMPlaceUserAtAirport(
inAirportCode : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inAirportCode : XPLMString);
cdecl; external XPLM_DLL;
{$IFDEF XPLM300}
{
XPLMPlaceUserAtLocation
Places the user at a specific location after performing any necessary
scenery loads.
As with in-air starts initiated from the X-Plane user interface, the
aircraft will always start with its engines running, regardless of the
user's preferences (i.e., regardless of what the dataref
`sim/operation/prefs/startup_running` says).
}
PROCEDURE XPLMPlaceUserAtLocation(
latitudeDegrees : Real;
longitudeDegrees : Real;
elevationMetersMSL : Single;
headingDegreesTrue : Single;
speedMetersPerSecond: Single);
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
{___________________________________________________________________________
* GLOBAL AIRCRAFT ACCESS
___________________________________________________________________________}
{
}
CONST
{ The user's aircraft is always index 0. }
{ The user's aircraft is always index 0. }
XPLM_USER_AIRCRAFT = 0;
{$IFDEF XPLM_DEPRECATED}
{
XPLMPlaneDrawState_t
@@ -77,35 +81,36 @@ CONST
calculates what the actual controls look like based on the .acf file for
that airplane. Note for the yoke inputs, this is what the pilot of the
plane has commanded (post artificial stability system if there were one)
and affects aelerons, rudder, etc. It is not necessarily related to the
and affects aelerons, rudder, etc. It is not necessarily related to the
actual position of the plane!
}
TYPE
XPLMPlaneDrawState_t = RECORD
{ The size of the draw state struct. }
structSize : integer;
{ A ratio from [0..1] describing how far the landing gear is extended. }
gearPosition : single;
{ Ratio of flap deployment, 0 = up, 1 = full deploy. }
flapRatio : single;
{ Ratio of spoiler deployment, 0 = none, 1 = full deploy. }
spoilerRatio : single;
{ Ratio of speed brake deployment, 0 = none, 1 = full deploy. }
speedBrakeRatio : single;
{ Ratio of slat deployment, 0 = none, 1 = full deploy. }
slatRatio : single;
{ Wing sweep ratio, 0 = forward, 1 = swept. }
wingSweep : single;
{ Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. }
thrust : single;
{ Total pitch input for this plane. }
yokePitch : single;
{ Total Heading input for this plane. }
yokeHeading : single;
{ Total Roll input for this plane. }
yokeRoll : single;
{ The size of the draw state struct. }
structSize : Integer;
{ A ratio from [0..1] describing how far the landing gear is extended. }
gearPosition : Single;
{ Ratio of flap deployment, 0 = up, 1 = full deploy. }
flapRatio : Single;
{ Ratio of spoiler deployment, 0 = none, 1 = full deploy. }
spoilerRatio : Single;
{ Ratio of speed brake deployment, 0 = none, 1 = full deploy. }
speedBrakeRatio : Single;
{ Ratio of slat deployment, 0 = none, 1 = full deploy. }
slatRatio : Single;
{ Wing sweep ratio, 0 = forward, 1 = swept. }
wingSweep : Single;
{ Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. }
thrust : Single;
{ Total pitch input for this plane. }
yokePitch : Single;
{ Total Heading input for this plane. }
yokeHeading : Single;
{ Total Roll input for this plane. }
yokeRoll : Single;
END;
PXPLMPlaneDrawState_t = ^XPLMPlaneDrawState_t;
{$ENDIF XPLM_DEPRECATED}
{
XPLMCountAircraft
@@ -116,14 +121,10 @@ TYPE
aircraft the user has enabled in the rendering options window.
}
PROCEDURE XPLMCountAircraft(
outTotalAircraft : Pinteger;
outActiveAircraft : Pinteger;
outTotalAircraft : PInteger;
outActiveAircraft : PInteger;
outController : PXPLMPluginID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMGetNthAircraftModel
@@ -133,14 +134,10 @@ TYPE
length.
}
PROCEDURE XPLMGetNthAircraftModel(
inIndex : integer;
outFileName : Pchar;
outPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer;
outFileName : XPLMString;
outPath : XPLMString);
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* EXCLUSIVE AIRCRAFT ACCESS
___________________________________________________________________________}
@@ -150,7 +147,6 @@ TYPE
}
{
XPLMPlanesAvailable_f
@@ -166,24 +162,23 @@ TYPE
XPLMAcquirePlanes
XPLMAcquirePlanes grants your plugin exclusive access to the aircraft. It
returns 1 if you gain access, 0 if you do not. inAircraft - pass in an
array of pointers to strings specifying the planes you want loaded. For
any plane index you do not want loaded, pass a 0-length string. Other
strings should be full paths with the .acf extension. NULL terminates this
array, or pass NULL if there are no planes you want loaded. If you pass in
a callback and do not receive access to the planes your callback will be
called when the airplanes are available. If you do receive airplane access,
your callback will not be called.
returns 1 if you gain access, 0 if you do not.
inAircraft - pass in an array of pointers to strings specifying the planes
you want loaded. For any plane index you do not want loaded, pass a
0-length string. Other strings should be full paths with the .acf
extension. NULL terminates this array, or pass NULL if there are no planes
you want loaded.
If you pass in a callback and do not receive access to the planes your
callback will be called when the airplanes are available. If you do receive
airplane access, your callback will not be called.
}
FUNCTION XPLMAcquirePlanes(
inAircraft : PPchar; { Can be nil }
inAircraft : PXPLMString; { Can be nil }
inCallback : XPLMPlanesAvailable_f;
inRefcon : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inRefcon : pointer) : Integer;
cdecl; external XPLM_DLL;
{
XPLMReleasePlanes
@@ -192,11 +187,7 @@ TYPE
disabled, access to planes is released for you and you must reacquire it.
}
PROCEDURE XPLMReleasePlanes;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMSetActiveAircraftCount
@@ -206,47 +197,40 @@ TYPE
planes available is actually used.
}
PROCEDURE XPLMSetActiveAircraftCount(
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inCount : Integer);
cdecl; external XPLM_DLL;
{
XPLMSetAircraftModel
This routine loads an aircraft model. It may only be called if you have
exclusive access to the airplane APIs. Pass in the path of the model with
the .acf extension. The index is zero based, but you may not pass in 0
This routine loads an aircraft model. It may only be called if you have
exclusive access to the airplane APIs. Pass in the path of the model with
the .acf extension. The index is zero based, but you may not pass in 0
(use XPLMSetUsersAircraft to load the user's aircracft).
}
PROCEDURE XPLMSetAircraftModel(
inIndex : integer;
inAircraftPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer;
inAircraftPath : XPLMString);
cdecl; external XPLM_DLL;
{
XPLMDisableAIForPlane
This routine turns off X-Plane's AI for a given plane. The plane will
continue to draw and be a real plane in X-Plane, but will not move itself.
continue to draw and be a real plane in X-Plane, but will not move itself.
}
PROCEDURE XPLMDisableAIForPlane(
inPlaneIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inPlaneIndex : Integer);
cdecl; external XPLM_DLL;
{$IFDEF XPLM_DEPRECATED}
{
XPLMDrawAircraft
WARNING: Aircraft drawing via this API is deprecated and will not work in
future versions of X-Plane. Use XPLMInstance for 3-d drawing of custom
aircraft models.
This routine draws an aircraft. It can only be called from a 3-d drawing
callback. Pass in the position of the plane in OpenGL local coordinates
and the orientation of the plane. A 1 for full drawing indicates that the
@@ -254,28 +238,29 @@ TYPE
drawn. (This saves rendering time when planes are far away.)
}
PROCEDURE XPLMDrawAircraft(
inPlaneIndex : integer;
inX : single;
inY : single;
inZ : single;
inPitch : single;
inRoll : single;
inYaw : single;
inFullDraw : integer;
inPlaneIndex : Integer;
inX : Single;
inY : Single;
inZ : Single;
inPitch : Single;
inRoll : Single;
inYaw : Single;
inFullDraw : Integer;
inDrawStateInfo : PXPLMPlaneDrawState_t);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM_DEPRECATED}
{$IFDEF XPLM_DEPRECATED}
{
XPLMReinitUsersPlane
WARNING: DO NOT USE. Use XPLMPlaceUserAtAirport or
XPLMPlaceUserAtLocation.
This function recomputes the derived flight model data from the aircraft
structure in memory. If you have used the data access layer to modify the
aircraft structure, use this routine to resynchronize x-plane; since
X-plane works at least partly from derived values, the sim will not behave
aircraft structure, use this routine to resynchronize X-Plane; since
X-Plane works at least partly from derived values, the sim will not behave
properly until this is called.
WARNING: this routine does not necessarily place the airplane at the
@@ -284,11 +269,10 @@ TYPE
flight.
}
PROCEDURE XPLMReinitUsersPlane;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM_DEPRECATED}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMPlugin.pas
+176 -144
View File
@@ -1,9 +1,6 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMPlugin;
@@ -13,11 +10,9 @@ INTERFACE
manage other plugins.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* FINDING PLUGINS
___________________________________________________________________________}
@@ -29,7 +24,6 @@ USES XPLMDefs;
}
{
XPLMGetMyID
@@ -37,11 +31,7 @@ USES XPLMDefs;
get your own ID.
}
FUNCTION XPLMGetMyID: XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMCountPlugins
@@ -49,12 +39,8 @@ USES XPLMDefs;
This routine returns the total number of plug-ins that are loaded, both
disabled and enabled.
}
FUNCTION XPLMCountPlugins: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
FUNCTION XPLMCountPlugins: Integer;
cdecl; external XPLM_DLL;
{
XPLMGetNthPlugin
@@ -64,12 +50,8 @@ USES XPLMDefs;
order.
}
FUNCTION XPLMGetNthPlugin(
inIndex : integer) : XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inIndex : Integer) : XPLMPluginID;
cdecl; external XPLM_DLL;
{
XPLMFindPluginByPath
@@ -79,12 +61,8 @@ USES XPLMDefs;
path does not point to a currently loaded plug-in.
}
FUNCTION XPLMFindPluginByPath(
inPath : Pchar) : XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inPath : XPLMString) : XPLMPluginID;
cdecl; external XPLM_DLL;
{
XPLMFindPluginBySignature
@@ -97,36 +75,28 @@ USES XPLMDefs;
locate another plugin that your plugin interoperates with
}
FUNCTION XPLMFindPluginBySignature(
inSignature : Pchar) : XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inSignature : XPLMString) : XPLMPluginID;
cdecl; external XPLM_DLL;
{
XPLMGetPluginInfo
This routine returns information about a plug-in. Each parameter should be
a pointer to a buffer of at least 256 characters, or NULL to not receive
the information.
a pointer to a buffer of at least
256 characters, or NULL to not receive the information.
outName - the human-readable name of the plug-in. outFilePath - the
outName - the human-readable name of the plug-in. outFilePath - the
absolute file path to the file that contains this plug-in. outSignature - a
unique string that identifies this plug-in. outDescription - a
human-readable description of this plug-in.
}
PROCEDURE XPLMGetPluginInfo(
inPlugin : XPLMPluginID;
outName : Pchar; { Can be nil }
outFilePath : Pchar; { Can be nil }
outSignature : Pchar; { Can be nil }
outDescription : Pchar); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
outName : XPLMString; { Can be nil }
outFilePath : XPLMString; { Can be nil }
outSignature : XPLMString; { Can be nil }
outDescription : XPLMString); { Can be nil }
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* ENABLING/DISABLING PLUG-INS
@@ -137,35 +107,26 @@ USES XPLMDefs;
}
{
XPLMIsPluginEnabled
Returns whether the specified plug-in is enabled for running.
}
FUNCTION XPLMIsPluginEnabled(
inPluginID : XPLMPluginID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inPluginID : XPLMPluginID) : Integer;
cdecl; external XPLM_DLL;
{
XPLMEnablePlugin
This routine enables a plug-in if it is not already enabled. It returns 1
This routine enables a plug-in if it is not already enabled. It returns 1
if the plugin was enabled or successfully enables itself, 0 if it does not.
Plugins may fail to enable (for example, if resources cannot be acquired)
by returning 0 from their XPluginEnable callback.
}
FUNCTION XPLMEnablePlugin(
inPluginID : XPLMPluginID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inPluginID : XPLMPluginID) : Integer;
cdecl; external XPLM_DLL;
{
XPLMDisablePlugin
@@ -174,27 +135,19 @@ USES XPLMDefs;
}
PROCEDURE XPLMDisablePlugin(
inPluginID : XPLMPluginID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMReloadPlugins
This routine reloads all plug-ins. Once this routine is called and you
return from the callback you were within (e.g. a menu select callback) you
will receive your XPluginDisable and XPluginStop callbacks and your DLL
will receive your XPluginDisable and XPluginStop callbacks and your DLL
will be unloaded, then the start process happens as if the sim was starting
up.
}
PROCEDURE XPLMReloadPlugins;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{___________________________________________________________________________
* INTERPLUGIN MESSAGING
@@ -203,9 +156,24 @@ USES XPLMDefs;
Plugin messages are defined as 32-bit integers. Messages below 0x00FFFFFF
are reserved for X-Plane and the plugin SDK.
Messages come with a pointer parameter; the meaning of this pointer depends
on the message itself. In some messages, the pointer parameter contains an
actual typed pointer to data that can be inspected in the plugin; in these
cases the documentation will state that the parameter "points to"
information.
in other cases, the value of the pointer is actually an integral number
stuffed into the pointer's storage. In these second cases, the pointer
parameter needs to be cast, not dereferenced. In these caess, the
documentation will state that the parameter "contains" a value, which will
always be an integral type.
Some messages don't use the pointer parameter - in this case your plugin
should ignore it.
Messages have two conceptual uses: notifications and commands. Commands
are sent from one plugin to another to induce behavior; notifications are
sent from one plugin to all others for informational purposes. It is
are sent from one plugin to another to induce behavior; notifications are
sent from one plugin to all others for informational purposes. It is
important that commands and notifications not have the same values because
this could cause a notification sent by one plugin to accidentally induce a
command in another.
@@ -214,59 +182,94 @@ USES XPLMDefs;
(e.g. be greater or equal to unsigned 0x8000000) while commands should have
this bit be cleared.
The following messages are sent to your plugin by x-plane.
The following messages are sent to your plugin by X-Plane.
}
CONST
{ This message is sent to your plugin whenever the user's plane crashes. }
{ This message is sent to your plugin whenever the user's plane crashes. The }
{ parameter is ignored. }
XPLM_MSG_PLANE_CRASHED = 101;
{ This message is sent to your plugin whenever a new plane is loaded. The }
{ parameter is the number of the plane being loaded; 0 indicates the user's }
{ plane. }
{ This message is sent to your plugin whenever a new plane is loaded. The }
{ parameter contains the index number of the plane being loaded; 0 indicates }
{ the user's plane. }
XPLM_MSG_PLANE_LOADED = 102;
{ This messages is called whenever the user's plane is positioned at a new }
{ airport. }
{ This messages is sent whenever the user's plane is positioned at a new }
{ airport. The parameter is ignored. }
XPLM_MSG_AIRPORT_LOADED = 103;
{ This message is sent whenever new scenery is loaded. Use datarefs to }
{ determine the new scenery files that were loaded. }
{ This message is sent whenever new scenery is loaded. Use datarefs to }
{ determine the new scenery files that were loaded. The parameter is ignored.}
XPLM_MSG_SCENERY_LOADED = 104;
{ This message is sent whenever the user adjusts the number of X-Plane }
{ aircraft models. You must use XPLMCountPlanes to find out how many planes }
{ are now available. This message will only be sent in XP7 and higher }
{ because in XP6 the number of aircraft is not user-adjustable. }
{ This message is sent whenever the user adjusts the number of X-Plane }
{ aircraft models. You must use XPLMCountPlanes to find out how many planes }
{ are now available. This message will only be sent in XP7 and higher }
{ because in XP6 the number of aircraft is not user-adjustable. The parameter}
{ is ignored. }
XPLM_MSG_AIRPLANE_COUNT_CHANGED = 105;
{$IFDEF XPLM200}
{ This message is sent to your plugin whenever a plane is unloaded. The }
{ parameter is the number of the plane being unloaded; 0 indicates the user's }
{ plane. The parameter is of type int, passed as the value of the pointer. }
{ (That is: the parameter is an int, not a pointer to an int.) }
CONST
{ This message is sent to your plugin whenever a plane is unloaded. The }
{ parameter contains the index number of the plane being unloaded; 0 }
{ indicates the user's plane. The parameter is of type int, passed as the }
{ value of the pointer. (That is: the parameter is an int, not a pointer to }
{ an int.) }
XPLM_MSG_PLANE_UNLOADED = 106;
{$ENDIF}
{$ENDIF XPLM200}
{$IFDEF XPLM210}
{ This message is sent to your plugin right before X-Plane writes its }
{ preferences file. You can use this for two purposes: to write your own }
{ preferences, and to modify any datarefs to influence preferences output. }
{ For example, if your plugin temporarily modifies saved preferences, you can }
{ put them back to their default values here to avoid having the tweaks be }
{ persisted if your plugin is not loaded on the next invocation of X-Plane. }
CONST
{ This message is sent to your plugin right before X-Plane writes its }
{ preferences file. You can use this for two purposes: to write your own }
{ preferences, and to modify any datarefs to influence preferences output. }
{ For example, if your plugin temporarily modifies saved preferences, you can}
{ put them back to their default values here to avoid having the tweaks be }
{ persisted if your plugin is not loaded on the next invocation of X-Plane. }
{ The parameter is ignored. }
XPLM_MSG_WILL_WRITE_PREFS = 107;
{$ENDIF}
{$ENDIF XPLM210}
{$IFDEF XPLM210}
{ This message is sent to your plugin right after a livery is loaded for an }
{ airplane. You can use this to check the new livery (via datarefs) and }
{ react accordingly. The parameter is of type int, passed as the value of a }
{ pointer and represents the aicraft plane number - 0 is the user's plane. }
{ This message is sent to your plugin right after a livery is loaded for an }
{ airplane. You can use this to check the new livery (via datarefs) and }
{ react accordingly. The parameter contains the index number of the aircraft}
{ whose livery is changing. }
XPLM_MSG_LIVERY_LOADED = 108;
{$ENDIF}
{$ENDIF XPLM210}
{$IFDEF XPLM301}
CONST
{ Sent to your plugin right before X-Plane enters virtual reality mode (at }
{ which time any windows that are not positioned in VR mode will no longer be}
{ visible to the user). The parameter is unused and should be ignored. }
XPLM_MSG_ENTERED_VR = 109;
{$ENDIF XPLM301}
{$IFDEF XPLM301}
{ Sent to your plugin right before X-Plane leaves virtual reality mode (at }
{ which time you may want to clean up windows that are positioned in VR }
{ mode). The parameter is unused and should be ignored. }
XPLM_MSG_EXITING_VR = 110;
{$ENDIF XPLM301}
{$IFDEF XPLM303}
CONST
{ Sent to your plugin if another plugin wants to take over AI planes. If you }
{ are a synthetic traffic provider, that probably means a plugin for an }
{ online network has connected and wants to supply aircraft flown by real }
{ humans and you should cease to provide synthetic traffic. If however you }
{ are providing online traffic from real humans, you probably don't want to }
{ disconnect, in which case you just ignore this message. The sender is the }
{ plugin ID of the plugin asking for control of the planes now. You can use }
{ it to find out who is requesting and whether you should yield to them. }
{ Synthetic traffic providers should always yield to online networks. The }
{ parameter is unused and should be ignored. }
XPLM_MSG_RELEASE_PLANES = 111;
{$ENDIF XPLM303}
{
XPLMSendMessageToPlugin
@@ -277,13 +280,9 @@ CONST
}
PROCEDURE XPLMSendMessageToPlugin(
inPlugin : XPLMPluginID;
inMessage : integer;
inMessage : Integer;
inParam : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$IFDEF XPLM200}
{___________________________________________________________________________
@@ -296,13 +295,60 @@ CONST
behavior.
Each feature is defined by a permanent string name. The feature string
names will vary with the particular installation of X-Plane, so plugins
names will vary with the particular installation of X-Plane, so plugins
should not expect a feature to be guaranteed present.
XPLM_WANTS_REFLECTIONS
----------------------
Available in the SDK 2.0 and later for X-Plane 9, enabling this capability
causes your plugin to receive drawing hook callbacks when X-Plane builds
its off-screen reflection and shadow rendering passes. Plugins should
enable this and examine the dataref sim/graphics/view/plane_render_type to
determine whether the drawing callback is for a reflection, shadow
calculation, or the main screen. Rendering can be simlified or omitted for
reflections, and non-solid drawing should be skipped for shadow
calculations.
**Note**: direct drawing via draw callbacks is not recommended; use the
XPLMInstance API to create object models instead.
XPLM_USE_NATIVE_PATHS
---------------------
available in the SDK 2.1 and later for X-Plane 10, this modifies the plugin
system to use Unix-style paths on all operating systems. With this enabled:
* OS X paths will match the native OS X Unix.
* Windows will use forward slashes but preserve C:\ or another drive letter
when using complete file paths.
* Linux uses its native file system path scheme.
Without this enabled:
* OS X will use CFM file paths separated by a colon.
* Windows will use back-slashes and conventional DOS paths.
* Linux uses its native file system path scheme.
All plugins should enable this feature on OS X to access the native file
system.
XPLM_USE_NATIVE_WIDGET_WINDOWS
------------------------------
Available in the SDK 3.0.2 SDK, this capability tells the widgets library
to use new, modern X-Plane backed XPLMDisplay windows to anchor all widget
trees. Without it, widgets will always use legacy windows.
Plugins should enable this to allow their widget hierarchies to respond to
the user's UI size settings and to map widget-based windwos to a VR HMD.
Before enabling this, make sure any custom widget code in your plugin is
prepared to cope with the UI coordinate system not being th same as the
OpenGL window coordinate system.
}
{
XPLMFeatureEnumerator_f
@@ -312,7 +358,7 @@ CONST
}
TYPE
XPLMFeatureEnumerator_f = PROCEDURE(
inFeature : Pchar;
inFeature : XPLMString;
inRef : pointer); cdecl;
{
@@ -322,12 +368,8 @@ TYPE
0 if it does not.
}
FUNCTION XPLMHasFeature(
inFeature : Pchar) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inFeature : XPLMString) : Integer;
cdecl; external XPLM_DLL;
{
XPLMIsFeatureEnabled
@@ -337,12 +379,8 @@ TYPE
feature.
}
FUNCTION XPLMIsFeatureEnabled(
inFeature : Pchar) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inFeature : XPLMString) : Integer;
cdecl; external XPLM_DLL;
{
XPLMEnableFeature
@@ -352,13 +390,9 @@ TYPE
depending on the feature.
}
PROCEDURE XPLMEnableFeature(
inFeature : Pchar;
inEnable : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
inFeature : XPLMString;
inEnable : Integer);
cdecl; external XPLM_DLL;
{
XPLMEnumerateFeatures
@@ -370,12 +404,10 @@ TYPE
PROCEDURE XPLMEnumerateFeatures(
inEnumerator : XPLMFeatureEnumerator_f;
inRef : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM200}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMProcessing.pas
+109 -131
View File
@@ -1,9 +1,6 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMProcessing;
@@ -11,27 +8,35 @@ INTERFACE
{
This API allows you to get regular callbacks during the flight loop, the
part of X-Plane where the plane's position calculates the physics of
flight, etc. Use these APIs to accomplish periodic tasks like logging data
flight, etc. Use these APIs to accomplish periodic tasks like logging data
and performing I/O.
WARNING: Do NOT use these callbacks to draw! You cannot draw during flight
loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info)
for graphics.
You can receive a callback either just before or just after the per-frame
physics calculations happen - you can use post-FM callbacks to "patch" the
flight model after it has run.
If the user has set the number of flight model iterations per frame greater
than one your plugin will _not_ see this; these integrations run on the
sub-section of the flight model where iterations improve responsiveness
(e.g. physical integration, not simple systems tracking) and are thus
opaque to plugins.
Flight loop scheduling, when scheduled by time, is scheduled by a "first
callback after the deadline" schedule, e.g. your callbacks will always be
slightly late to ensure that we don't run faster than your deadline.
WARNING: Do NOT use these callbacks to draw! You cannot draw during flight
loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info)
for graphics. (One exception: you can use a post-flight loop callback to
update your own off-screen FBOs.)
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* FLIGHT LOOP CALLBACKS
___________________________________________________________________________}
{
}
{$IFDEF XPLM210}
{
@@ -42,85 +47,98 @@ USES XPLMDefs;
}
TYPE
XPLMFlightLoopPhaseType = (
{ Your callback runs before X-Plane integrates the flight model. }
{ Your callback runs before X-Plane integrates the flight model. }
xplm_FlightLoop_Phase_BeforeFlightModel = 0
{ Your callback runs after X-Plane integrates the flight model. }
{ Your callback runs after X-Plane integrates the flight model. }
,xplm_FlightLoop_Phase_AfterFlightModel = 1
);
PXPLMFlightLoopPhaseType = ^XPLMFlightLoopPhaseType;
{$ENDIF}
{$ENDIF XPLM210}
{$IFDEF XPLM210}
{
XPLMFlightLoopID
This is an opaque identifier for a flight loop callback. You can use this
This is an opaque identifier for a flight loop callback. You can use this
identifier to easily track and remove your callbacks, or to use the new
flight loop APIs.
}
XPLMFlightLoopID = pointer;
PXPLMFlightLoopID = ^XPLMFlightLoopID;
{$ENDIF}
{$ENDIF XPLM210}
{
XPLMFlightLoop_f
This is your flight loop callback. Each time the flight loop is iterated
through, you receive this call at the end. You receive a time since you
were last called and a time since the last loop, as well as a loop counter.
The 'phase' parameter is deprecated and should be ignored.
This is your flight loop callback. Each time the flight loop is iterated
through, you receive this call at the end.
Your return value controls when you will next be called. Return 0 to stop
receiving callbacks. Pass a positive number to specify how many seconds
until the next callback. (You will be called at or after this time, not
before.) Pass a negative number to specify how many loops must go by until
you are called. For example, -1.0 means call me the very next loop. Try
to run your flight loop as infrequently as is practical, and suspend it
Flight loop callbacks receive a number of input timing parameters. These
input timing parameters are not particularly useful; you may need to track
your own timing data (e.g. by reading datarefs). The input parameters are:
- inElapsedSinceLastCall: the wall time since your last callback.
- inElapsedTimeSinceLastFlightLoop: the wall time since any flight loop was
dispatched.
- inCounter: a monotonically increasing counter, bumped once per flight
loop dispatch from the sim.
- inRefcon: your own ptr constant from when you regitered yor callback.
Your return value controls when you will next be called.
- Return 0 to stop receiving callbacks.
- Pass a positive number to specify how many seconds until the next
callback. (You will be called at or after this time, not before.)
- Pass a negative number to specify how many loops must go by until you
are called. For example, -1.0 means call me the very next loop.
Try to run your flight loop as infrequently as is practical, and suspend it
(using return value 0) when you do not need it; lots of flight loop
callbacks that do nothing lowers x-plane's frame rate.
callbacks that do nothing lowers X-Plane's frame rate.
Your callback will NOT be unregistered if you return 0; it will merely be
inactive.
The reference constant you passed to your loop is passed back to you.
}
TYPE
XPLMFlightLoop_f = FUNCTION(
inElapsedSinceLastCall: single;
inElapsedTimeSinceLastFlightLoop: single;
inCounter : integer;
inRefcon : pointer) : single; cdecl;
inElapsedSinceLastCall: Single;
inElapsedTimeSinceLastFlightLoop: Single;
inCounter : Integer;
inRefcon : pointer) : Single; cdecl;
{$IFDEF XPLM210}
{
XPLMCreateFlightLoop_t
XPLMCreateFlightLoop_t contains the parameters to create a new flight loop
callback. The strsucture can be expanded in future SDKs - always set
callback. The strsucture can be expanded in future SDKs - always set
structSize to the size of your structure in bytes.
}
TYPE
XPLMCreateFlightLoop_t = RECORD
structSize : integer;
structSize : Integer;
phase : XPLMFlightLoopPhaseType;
callbackFunc : XPLMFlightLoop_f;
refcon : pointer;
END;
PXPLMCreateFlightLoop_t = ^XPLMCreateFlightLoop_t;
{$ENDIF}
{$ENDIF XPLM210}
{
XPLMGetElapsedTime
This routine returns the elapsed time since the sim started up in decimal
seconds.
seconds. This is a wall timer; it keeps counting upward even if the sim is
pasued.
__WARNING__: XPLMGetElapsedTime is not a very good timer! It lacks
precision in both its data type and its source. Do not attempt to use it
for timing critical applications like network multiplayer.
}
FUNCTION XPLMGetElapsedTime: single;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
FUNCTION XPLMGetElapsedTime: Single;
cdecl; external XPLM_DLL;
{
XPLMGetCycleNumber
@@ -128,149 +146,109 @@ TYPE
This routine returns a counter starting at zero for each sim cycle
computed/video frame rendered.
}
FUNCTION XPLMGetCycleNumber: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
FUNCTION XPLMGetCycleNumber: Integer;
cdecl; external XPLM_DLL;
{
XPLMRegisterFlightLoopCallback
This routine registers your flight loop callback. Pass in a pointer to a
flight loop function and a refcon. inInterval defines when you will be
called. Pass in a positive number to specify seconds from registration
time to the next callback. Pass in a negative number to indicate when you
will be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to
not be called; your callback will be inactive.
This routine registers your flight loop callback. Pass in a pointer to a
flight loop function and a refcon. inInterval defines when you will be
called. Pass in a positive number to specify seconds from registration time
to the next callback. Pass in a negative number to indicate when you will
be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to not be
called; your callback will be inactive.
(This legacy function only installs pre-flight-loop callbacks; use
XPLMCreateFlightLoop for more control.)
}
PROCEDURE XPLMRegisterFlightLoopCallback(
inFlightLoop : XPLMFlightLoop_f;
inInterval : single;
inInterval : Single;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMUnregisterFlightLoopCallback
This routine unregisters your flight loop callback. Do NOT call it from
your flight loop callback. Once your flight loop callback is
unregistered, it will not be called again.
This routine unregisters your flight loop callback. Do NOT call it from
your flight loop callback. Once your flight loop callback is unregistered,
it will not be called again.
Only use this on flight loops registered via
XPLMRegisterFlightLoopCallback.
}
PROCEDURE XPLMUnregisterFlightLoopCallback(
inFlightLoop : XPLMFlightLoop_f;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMSetFlightLoopCallbackInterval
This routine sets when a callback will be called. Do NOT call it from your
This routine sets when a callback will be called. Do NOT call it from your
callback; use the return value of the callback to change your callback
interval from inside your callback.
inInterval is formatted the same way as in XPLMRegisterFlightLoopCallback;
positive for seconds, negative for cycles, and 0 for deactivating the
callback. If inRelativeToNow is 1, times are from the time of this call;
callback. If inRelativeToNow is 1, times are from the time of this call;
otherwise they are from the time the callback was last called (or the time
it was registered if it has never been called.
}
PROCEDURE XPLMSetFlightLoopCallbackInterval(
inFlightLoop : XPLMFlightLoop_f;
inInterval : single;
inRelativeToNow : integer;
inInterval : Single;
inRelativeToNow : Integer;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$IFDEF XPLM210}
{
XPLMCreateFlightLoop
This routine creates a flight loop callback and returns its ID. The flight
This routine creates a flight loop callback and returns its ID. The flight
loop callback is created using the input param struct, and is inited to be
unscheduled.
}
FUNCTION XPLMCreateFlightLoop(
inParams : PXPLMCreateFlightLoop_t) : XPLMFlightLoopID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM210}
{$IFDEF XPLM210}
{
XPLMDestroyFlightLoop
This routine destroys a flight loop callback by ID.
This routine destroys a flight loop callback by ID. Only call it on flight
loops created with the newer XPLMCreateFlightLoop API.
}
PROCEDURE XPLMDestroyFlightLoop(
inFlightLoopID : XPLMFlightLoopID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM210}
{$IFDEF XPLM210}
{
XPLMScheduleFlightLoop
This routine schedules a flight loop callback for future execution. If
inInterval is negative, it is run in a certain number of frames based on
the absolute value of the input. If the interval is positive, it is a
This routine schedules a flight loop callback for future execution. If
inInterval is negative, it is run in a certain number of frames based on
the absolute value of the input. If the interval is positive, it is a
duration in seconds.
If inRelativeToNow is true, ties are interpretted relative to the time this
routine is called; otherwise they are relative to the last call time or the
time the flight loop was registered (if never called).
THREAD SAFETY: it is legal to call this routine from any thread under the
following conditions:
1. The call must be between the beginning of an XPLMEnable and the end of
an XPLMDisable sequence. (That is, you must not call this routine from
thread activity when your plugin was supposed to be disabled. Since
plugins are only enabled while loaded, this also implies you cannot run
this routine outside an XPLMStart/XPLMStop sequence.)
2. You may not call this routine re-entrantly for a single flight loop ID.
(That is, you can't enable from multiple threads at the same time.)
3. You must call this routine between the time after XPLMCreateFlightLoop
returns a value and the time you call XPLMDestroyFlightLoop. (That is, you
must ensure that your threaded activity is within the life of the object.
The SDK does not check this for you, nor does it synchronize destruction of
the object.)
4. The object must be unscheduled if this routine is to be called from a
thread other than the main thread.
}
PROCEDURE XPLMScheduleFlightLoop(
inFlightLoopID : XPLMFlightLoopID;
inInterval : single;
inRelativeToNow : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
inInterval : Single;
inRelativeToNow : Integer);
cdecl; external XPLM_DLL;
{$ENDIF XPLM210}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMScenery.pas
+183 -168
View File
@@ -1,9 +1,6 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
license.txt for usage. X-Plane SDK Version: 2.1.1
}
UNIT XPLMScenery;
@@ -12,56 +9,55 @@ INTERFACE
This package contains APIs to interact with X-Plane's scenery system.
}
USES XPLMDefs;
USES
XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{$IFDEF XPLM200}
{___________________________________________________________________________
* Terrain Y-Testing
___________________________________________________________________________}
{
The Y-testing API allows you to locate the physical scenery mesh. This
would be used to place dynamic graphics on top of the ground in a
plausible way or do physics interactions.
The Y-testing API allows you to locate the physical scenery mesh. This
would be used to place dynamic graphics on top of the ground in a plausible
way or do physics interactions.
The Y-test API works via probe objects, which are allocated by your plugin
and used to query terrain. Probe objects exist both to capture which
algorithm you have requested (see probe types) and also to cache query
information.
Performance guidelines: It is generally faster to use the same probe for
nearby points and different probes for different points. Try not to
allocate more than "hundreds" of probes at most. Share probes if you need
more. Generally, probing operations are expensive, and should be avoided
via caching when possible.
Performance Guidelines
----------------------
It is generally faster to use the same probe for nearby points and
different probes for different points. Try not to allocate more than
"hundreds" of probes at most. Share probes if you need more. Generally,
probing operations are expensive, and should be avoided via caching when
possible.
Y testing returns a location on the terrain, a normal vectory, and a
velocity vector. The normal vector tells you the slope of the terrain at
that point. The velocity vector tells you if that terrain is moving (and
is in meters/second). For example, if your Y test hits the aircraft carrier
velocity vector. The normal vector tells you the slope of the terrain at
that point. The velocity vector tells you if that terrain is moving (and is
in meters/second). For example, if your Y test hits the aircraft carrier
deck, this tells you the velocity of that point on the deck.
Note: the Y-testing API is limited to probing the loaded scenery area,
which is approximately 300x300 km in X-Plane 9. Probes outside this area
which is approximately 300x300 km in X-Plane 9. Probes outside this area
will return the height of a 0 MSL sphere.
}
{
XPLMProbeType
XPLMProbeType defines the type of terrain probe - each probe has a
different algorithm. (Only one type of probe is provided right now, but
different algorithm. (Only one type of probe is provided right now, but
future APIs will expose more flexible or poewrful or useful probes.
}
TYPE
XPLMProbeType = (
{ The Y probe gives you the location of the tallest physical scenery along }
{ the Y axis going through the queried point. }
{ The Y probe gives you the location of the tallest physical scenery along }
{ the Y axis going through the queried point. }
xplm_ProbeY = 0
);
@@ -73,15 +69,15 @@ TYPE
Probe results - possible results from a probe query.
}
XPLMProbeResult = (
{ The probe hit terrain and returned valid values. }
{ The probe hit terrain and returned valid values. }
xplm_ProbeHitTerrain = 0
{ An error in the API call. Either the probe struct size is bad, or the }
{ probe is invalid or the type is mismatched for the specific query call. }
{ An error in the API call. Either the probe struct size is bad, or the }
{ probe is invalid or the type is mismatched for the specific query call. }
,xplm_ProbeError = 1
{ The probe call succeeded but there is no terrain under this point (perhaps }
{ it is off the side of the planet?) }
{ The probe call succeeded but there is no terrain under this point (perhaps }
{ it is off the side of the planet?) }
,xplm_ProbeMissed = 2
);
@@ -99,35 +95,35 @@ TYPE
{
XPLMProbeInfo_t
XPLMProbeInfo_t contains the results of a probe call. Make sure to set
XPLMProbeInfo_t contains the results of a probe call. Make sure to set
structSize to the size of the struct before using it.
}
XPLMProbeInfo_t = RECORD
{ Size of structure in bytes - always set this before calling the XPLM. }
structSize : integer;
{ Resulting X location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationX : single;
{ Resulting Y location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationY : single;
{ Resulting Z location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationZ : single;
{ X component of the normal vector to the terrain we found. }
normalX : single;
{ Y component of the normal vector to the terrain we found. }
normalY : single;
{ Z component of the normal vector to the terrain we found. }
normalZ : single;
{ X component of the velocity vector of the terrain we found. }
velocityX : single;
{ Y component of the velocity vector of the terrain we found. }
velocityY : single;
{ Z component of the velocity vector of the terrain we found. }
velocityZ : single;
{ Tells if the surface we hit is water (otherwise it is land). }
is_wet : integer;
{ Size of structure in bytes - always set this before calling the XPLM. }
structSize : Integer;
{ Resulting X location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationX : Single;
{ Resulting Y location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationY : Single;
{ Resulting Z location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationZ : Single;
{ X component of the normal vector to the terrain we found. }
normalX : Single;
{ Y component of the normal vector to the terrain we found. }
normalY : Single;
{ Z component of the normal vector to the terrain we found. }
normalZ : Single;
{ X component of the velocity vector of the terrain we found. }
velocityX : Single;
{ Y component of the velocity vector of the terrain we found. }
velocityY : Single;
{ Z component of the velocity vector of the terrain we found. }
velocityZ : Single;
{ Tells if the surface we hit is water (otherwise it is land). }
is_wet : Integer;
END;
PXPLMProbeInfo_t = ^XPLMProbeInfo_t;
@@ -138,11 +134,7 @@ TYPE
}
FUNCTION XPLMCreateProbe(
inProbeType : XPLMProbeType) : XPLMProbeRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMDestroyProbe
@@ -151,45 +143,86 @@ TYPE
}
PROCEDURE XPLMDestroyProbe(
inProbe : XPLMProbeRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{
XPLMProbeTerrainXYZ
Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe
object, and an XPLMProbeInfo_t struct that has its structSize member set
properly. Other fields are filled in if we hit terrain, and a probe result
Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe
object, and an XPLMProbeInfo_t struct that has its structSize member set
properly. Other fields are filled in if we hit terrain, and a probe result
is returned.
}
FUNCTION XPLMProbeTerrainXYZ(
inProbe : XPLMProbeRef;
inX : single;
inY : single;
inZ : single;
inX : Single;
inY : Single;
inZ : Single;
outInfo : PXPLMProbeInfo_t) : XPLMProbeResult;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF}
{$ENDIF XPLM200}
{$IFDEF XPLM300}
{___________________________________________________________________________
* Magnetic Variation
___________________________________________________________________________}
{
Use the magnetic variation (more properly, the "magnetic declination") API
to find the offset of magnetic north from true north at a given latitude
and longitude within the simulator.
In the real world, the Earth's magnetic field is irregular, such that true
north (the direction along a meridian toward the north pole) does not
necessarily match what a magnetic compass shows as north.
Using this API ensures that you present the same offsets to users as
X-Plane's built-in instruments.
}
{
XPLMGetMagneticVariation
Returns X-Plane's simulated magnetic variation (declination) at the
indication latitude and longitude.
}
FUNCTION XPLMGetMagneticVariation(
latitude : Real;
longitude : Real) : Single;
cdecl; external XPLM_DLL;
{
XPLMDegTrueToDegMagnetic
Converts a heading in degrees relative to true north into a value relative
to magnetic north at the user's current location.
}
FUNCTION XPLMDegTrueToDegMagnetic(
headingDegreesTrue : Single) : Single;
cdecl; external XPLM_DLL;
{
XPLMDegMagneticToDegTrue
Converts a heading in degrees relative to magnetic north at the user's
current location into a value relative to true north.
}
FUNCTION XPLMDegMagneticToDegTrue(
headingDegreesMagnetic: Single) : Single;
cdecl; external XPLM_DLL;
{$ENDIF XPLM300}
{___________________________________________________________________________
* Object Drawing
___________________________________________________________________________}
{
The object drawing routines let you load and draw X-Plane OBJ files.
Objects are loaded by file path and managed via an opaque handle. X-Plane
Objects are loaded by file path and managed via an opaque handle. X-Plane
naturally reference counts objects, so it is important that you balance
every successful call to XPLMLoadObject with a call to XPLMUnloadObject!
}
{$IFDEF XPLM200}
TYPE
{
@@ -200,7 +233,7 @@ TYPE
}
XPLMObjectRef = pointer;
PXPLMObjectRef = ^XPLMObjectRef;
{$ENDIF}
{$ENDIF XPLM200}
{$IFDEF XPLM200}
{
@@ -211,83 +244,79 @@ TYPE
future expansion.
}
XPLMDrawInfo_t = RECORD
{ Set this to the size of this structure! }
structSize : integer;
{ X location of the object in local coordinates. }
x : single;
{ Y location of the object in local coordinates. }
y : single;
{ Z location of the object in local coordinates. }
z : single;
{ Pitch in degres to rotate the object, positive is up. }
pitch : single;
{ Heading in local coordinates to rotate the object, clockwise. }
heading : single;
{ Roll to rotate the object. }
roll : single;
{ Set this to the size of this structure! }
structSize : Integer;
{ X location of the object in local coordinates. }
x : Single;
{ Y location of the object in local coordinates. }
y : Single;
{ Z location of the object in local coordinates. }
z : Single;
{ Pitch in degres to rotate the object, positive is up. }
pitch : Single;
{ Heading in local coordinates to rotate the object, clockwise. }
heading : Single;
{ Roll to rotate the object. }
roll : Single;
END;
PXPLMDrawInfo_t = ^XPLMDrawInfo_t;
{$ENDIF}
{$ENDIF XPLM200}
{$IFDEF XPLM210}
{
XPLMObjectLoaded_f
You provide this callback when loading an object asynchronously; it will be
called once the object is loaded. Your refcon is passed back. The object
called once the object is loaded. Your refcon is passed back. The object
ref passed in is the newly loaded object (ready for use) or NULL if an
error occured.
If your plugin is disabled, this callback will be delivered as soon as the
plugin is re-enabled. If your plugin is unloaded before this callback is
plugin is re-enabled. If your plugin is unloaded before this callback is
ever called, the SDK will release the object handle for you.
}
TYPE
XPLMObjectLoaded_f = PROCEDURE(
inObject : XPLMObjectRef;
inRefcon : pointer); cdecl;
{$ENDIF}
{$ENDIF XPLM210}
{$IFDEF XPLM200}
{
XPLMLoadObject
This routine loads an OBJ file and returns a handle to it. If X-plane has
This routine loads an OBJ file and returns a handle to it. If X-Plane has
already loaded the object, the handle to the existing object is returned.
Do not assume you will get the same handle back twice, but do make sure to
call unload once for every load to avoid "leaking" objects. The object
will be purged from memory when no plugins and no scenery are using it.
call unload once for every load to avoid "leaking" objects. The object will
be purged from memory when no plugins and no scenery are using it.
The path for the object must be relative to the X-System base folder. If
The path for the object must be relative to the X-System base folder. If
the path is in the root of the X-System folder you may need to prepend ./
to it; loading objects in the root of the X-System folder is STRONGLY
discouraged - your plugin should not dump art resources in the root folder!
XPLMLoadObject will return NULL if the object cannot be loaded (either
because it is not found or the file is misformatted). This routine will
load any object that can be used in the X-Plane scenery system.
It is important that the datarefs an object uses for animation already be
loaded before you load the object. For this reason it may be necessary to
loaded before you load the object. For this reason it may be necessary to
defer object loading until the sim has fully started.
}
FUNCTION XPLMLoadObject(
inPath : Pchar) : XPLMObjectRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
inPath : XPLMString) : XPLMObjectRef;
cdecl; external XPLM_DLL;
{$ENDIF XPLM200}
{$IFDEF XPLM210}
{
XPLMLoadObjectAsync
This routine loads an object asynchronously; control is returned to you
immediately while X-Plane loads the object. The sim will not stop flying
while the object loads. For large objects, it may be several seconds
before the load finishes.
immediately while X-Plane loads the object. The sim will not stop flying
while the object loads. For large objects, it may be several seconds before
the load finishes.
You provide a callback function that is called once the load has completed.
Note that if the object cannot be loaded, you will not find out until the
@@ -298,52 +327,46 @@ TYPE
desired.
}
PROCEDURE XPLMLoadObjectAsync(
inPath : Pchar;
inPath : XPLMString;
inCallback : XPLMObjectLoaded_f;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM210}
{$IFDEF XPLM200}
{$IFDEF XPLM_DEPRECATED}
{
XPLMDrawObjects
XPLMDrawObjects draws an object from an OBJ file one or more times. You
pass in the object and an array of XPLMDrawInfo_t structs, one for each
__Deprecation Warning__: use XPLMInstancing to draw 3-d objects by creating
instances, rather than these APIs from draw callbacks.
XPLMDrawObjects draws an object from an OBJ file one or more times. You
pass in the object and an array of XPLMDrawInfo_t structs, one for each
place you would like the object to be drawn.
X-Plane will attempt to cull the objects based on LOD and visibility, and
will pick the appropriate LOD.
Lighting is a boolean; pass 1 to show the night version of object with
night-only lights lit up. Pass 0 to show the daytime version of the
object.
night-only lights lit up. Pass 0 to show the daytime version of the object.
earth_relative controls the coordinate system. If this is 1, the rotations
earth_relative controls the coordinate system. If this is 1, the rotations
you specify are applied to the object after its coordinate system is
transformed from local to earth-relative coordinates -- that is, an object
with no rotations will point toward true north and the Y axis will be up
against gravity. If this is 0, the object is drawn with your rotations
from local coordanates -- that is, an object with no rotations is drawn
pointing down the -Z axis and the Y axis of the object matches the local
coordinate Y axis.
against gravity. If this is 0, the object is drawn with your rotations from
local coordanates -- that is, an object with no rotations is drawn pointing
down the -Z axis and the Y axis of the object matches the local coordinate
Y axis.
}
PROCEDURE XPLMDrawObjects(
inObject : XPLMObjectRef;
inCount : integer;
inCount : Integer;
inLocations : PXPLMDrawInfo_t;
lighting : integer;
earth_relative : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
lighting : Integer;
earth_relative : Integer);
cdecl; external XPLM_DLL;
{$ENDIF XPLM_DEPRECATED}
{$IFDEF XPLM200}
{
@@ -351,17 +374,13 @@ TYPE
This routine marks an object as no longer being used by your plugin.
Objects are reference counted: once no plugins are using an object, it is
purged from memory. Make sure to call XPLMUnloadObject once for each
purged from memory. Make sure to call XPLMUnloadObject once for each
successful call to XPLMLoadObject.
}
PROCEDURE XPLMUnloadObject(
inObject : XPLMObjectRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
cdecl; external XPLM_DLL;
{$ENDIF XPLM200}
{$IFDEF XPLM200}
{___________________________________________________________________________
@@ -369,14 +388,12 @@ TYPE
___________________________________________________________________________}
{
The library access routines allow you to locate scenery objects via the
X-Plane library system. Right now library access is only provided for
X-Plane library system. Right now library access is only provided for
objects, allowing plugin-drawn objects to be extended using the library
system.
}
{
XPLMLibraryEnumerator_f
@@ -386,34 +403,32 @@ TYPE
}
TYPE
XPLMLibraryEnumerator_f = PROCEDURE(
inFilePath : Pchar;
inFilePath : XPLMString;
inRef : pointer); cdecl;
{
XPLMLookupObjects
This routine looks up a virtual path in the library system and returns all
matching elements. You provide a callback - one virtual path may match
many objects in the library. XPLMLookupObjects returns the number of
objects found.
matching elements. You provide a callback - one virtual path may match many
objects in the library. XPLMLookupObjects returns the number of objects
found.
The latitude and longitude parameters specify the location the object will
be used. The library system allows for scenery packages to only provide
objects to certain local locations. Only objects that are allowed at the
be used. The library system allows for scenery packages to only provide
objects to certain local locations. Only objects that are allowed at the
latitude/longitude you provide will be returned.
}
FUNCTION XPLMLookupObjects(
inPath : Pchar;
inLatitude : single;
inLongitude : single;
inPath : XPLMString;
inLatitude : Single;
inLongitude : Single;
enumerator : XPLMLibraryEnumerator_f;
ref : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
ref : pointer) : Integer;
cdecl; external XPLM_DLL;
{$ENDIF XPLM200}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMUtilities.pas
+689 -665
View File
File diff suppressed because it is too large Load Diff
XPSDK/Libraries/Mac/XPLM.framework/XPLM
BIN
View File
Binary file not shown.
XPSDK/Libraries/Mac/XPWidgets.framework/XPWidgets
BIN
View File
Binary file not shown.
XPSDK/Libraries/Win/XPLM.lib
BIN
View File
Binary file not shown.
XPSDK/Libraries/Win/XPLM_64.lib
BIN
View File
Binary file not shown.
XPSDK/Libraries/Win/XPWidgets.lib
BIN
View File
Binary file not shown.
XPSDK/Libraries/Win/XPWidgets_64.lib
BIN
View File
Binary file not shown.
XPSDK/README.txt
+46 -21
View File
@@ -5,24 +5,12 @@
This download contains the files necessary to build plugins for X-Plane. The
X-Plane plugin website is:
http://www.xsquawkbox.net/xpsdk/
http://https://developer.x-plane.com/sdk/
The website contains full documentation on the SDK including tech notes, sample
plugins, sample code, contact information, and links to the latest versions of
this SDK.
The X-Plane SDK authors can be reached at:
xplanesdk@xsquawkbox.net
Please do not email Austin or Laminar Research for SDK questions or support;
the SDK is a third party effort.
the X-Plane developer mailing list is an unlisted yahoo group frequented by
many X-Plane developers.
x-plane-dev@yahoogroups.com
-------------------------------------------------------------------------------
SDK FILES
-------------------------------------------------------------------------------
@@ -32,25 +20,62 @@ README.txt This document
CHeaders Header files for compiling C/C++ plugins
Delphi Interfaces for compiling Pascal plugins
Libraries Import libraries for linking on Windows
and frameworks for linking on Mac.
and frameworks for linking on Mac.
Note: there are no import/link-time libraries for Linux; on Linux, plugins
simply leave SDK symbols undefined and they are discovered at runtime. The
SDK website explains this process in more detail.
Mac CFM plugins are not supported by the SDK versions 2.0 and higher; the
2.0 SDK requires X-Plane 9.0 or newer, and X-Plane 9 will not run on
Mac OS 9. Therefore CFM plugins are not useful (and are probably
counterproductive since they cannot support x86 code). If you have a CFM
plugin, continue to use the 1.0 SDK to build it. You will have to port to
Mach-O if you want to use 2.0 features.
-------------------------------------------------------------------------------
RELEASE NOTES
-------------------------------------------------------------------------------
This section contains per-release notes for the history of the X-Plane SDK.
X-PLane SDK Release 4.0.0 beta 1 9/18/2022
The 4.0.0 SDK adds support for ARM64 Macs. The 4.0 SDK is supported by X-Plane
12. The new SDK adds support for drawing hooks that draw directly to the G1000
and other avionic cockpit devices.
X-Plane SDK Release 3.0.2 4/29/2020
The SDK 3.0.2 adds the modern 3-d drawing callback for interoperability with
Metal and Vulkan, and deprecates most older drawing callbacks.
X-Plane SDK Release 3.0.1 3/5/2018
The SDK 3.0.1 API adds new messages and APIs to support VR.
X-Plane SDK Release 3.0.0 11/2/7/2017
The SDK 3.0 API supports new features and new packaging for plugins. The 3.0
SDK requires X-Plane 11.0 or newer. New features include:
- Display APIs to match X-Plane 11's UI.
- New map APIs. Legacy 2-d map draw callbacks are deprecated.
- Aircraft-plugins get their own menu
- Aircraft placement by lat-lon-elevation.
- Magnetic variation queries
- Chinese language support
- New instancing API
The 3.0 SDK supports a new plugin packaging schema:
<plugin name>/<ABI>/<plugin name>.xpl
where ABI is one of mac_x64, win_x64 or lin_x64. The new schema is preferred,
so you can pack a version of your plugin that requires 3.0 with this scheme
and include a legacy 2.x plugin using hte old scheme for X-Plane 10
compatibility.
Please use the new scheme where possible - having a unique file name for each
DLL makes crash reports easier to read and triage.
The 3.0 SDK drops support for 32-bit plugins; if you need to ship a 32-bit
plugin for 32-bit X-Plane 10, shipping using two schemes and two binaries may
be the best option.
X-Plane SDK Release 2.1.3 11/14/13
Fixed XPC Wrappers to use int and intptr_t instead of long. This fixes
ixwebsocket/CMakeLists.txt
+2
View File
@@ -43,9 +43,11 @@ if(APPLE)
)
target_compile_options(ixwebsocket PRIVATE
"SHELL:-arch x86_64"
"SHELL:-arch arm64"
)
target_link_options(ixwebsocket PRIVATE
"SHELL:-arch x86_64"
"SHELL:-arch arm64"
)
target_link_libraries(ixwebsocket PRIVATE
"-framework Foundation"