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