#ifndef _XPWidgetDefs_h_ #define _XPWidgetDefs_h_ /* * Copyright 2005-2022 Laminar Research, Sandy Barbour and Ben Supnik All * rights reserved. See license.txt for usage. X-Plane SDK Version: 4.0.0 * */ /*************************************************************************** * XPWidgetDefs ***************************************************************************/ #include "XPLMDefs.h" #ifdef __cplusplus extern "C" { #endif #if APL #if XPWIDGETS #if __GNUC__ >= 4 #define WIDGET_API __attribute__((visibility("default"))) #elif __MACH__ #define WIDGET_API #else #define WIDGET_API __declspec(dllexport) #endif #else #define WIDGET_API #endif #elif IBM #if XPWIDGETS #define WIDGET_API __declspec(dllexport) #else #define WIDGET_API __declspec(dllimport) #endif #elif LIN #if XPWIDGETS #if __GNUC__ >= 4 #define WIDGET_API __attribute__((visibility("default"))) #else #define WIDGET_API #endif #else #define WIDGET_API #endif #else #pragma error "Platform not defined!" #endif /*************************************************************************** * WIDGET DEFINITIONS ***************************************************************************/ /* * A widget is a call-back driven screen entity like a push-button, window, * text entry field, etc. * * Use the widget API to create widgets of various classes. You can nest them * into trees of widgets to create complex user interfaces. * */ /* * XPWidgetID * * A Widget ID is an opaque unique non-zero handle identifying your widget. * Use 0 to specify "no widget". This type is defined as wide enough to hold a * pointer. You receive a widget ID when you create a new widget and then use * that widget ID to further refer to the widget. * */ typedef void * XPWidgetID; /* * XPWidgetPropertyID * * Properties are values attached to instances of your widgets. A property is * identified by a 32-bit ID and its value is the width of a pointer. * * Each widget instance may have a property or not have it. When you set a * property on a widget for the first time, the property is added to the * widget; it then stays there for the life of the widget. * * Some property IDs are predefined by the widget package; you can make up * your own property IDs as well. * */ enum { /* A window's refcon is an opaque value used by client code to find other data* * based on it. */ xpProperty_Refcon = 0, /* These properties are used by the utilities to implement dragging. */ xpProperty_Dragging = 1, xpProperty_DragXOff = 2, xpProperty_DragYOff = 3, /* Is the widget highlighted? (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 Widget'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 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, }; typedef int XPWidgetPropertyID; /* * XPMouseState_t * * When the mouse is clicked or dragged, a pointer to this structure is passed * to your widget function. * */ typedef struct { int x; int y; /* Mouse button number, left = 0 (right button not yet supported. */ int button; #if defined(XPLM200) /* Scroll wheel delta (button in this case would be the wheel axis number). */ int delta; #endif /* XPLM200 */ } XPMouseState_t; /* * XPKeyState_t * * When a key is pressed, a pointer to this struct is passed to your widget * function. * */ typedef struct { /* The ASCII key that was pressed. WARNING: this may be 0 for some non-ASCII * * key sequences. */ char key; /* The flags. Make sure to check this if you only want key-downs! */ XPLMKeyFlags flags; /* The virtual key code for the key */ char vkey; } XPKeyState_t; /* * XPWidgetGeometryChange_t * * This structure contains the deltas for your widget's geometry when it * changes. * */ typedef struct { int dx; /* +Y = the widget moved up */ int dy; int dwidth; int dheight; } XPWidgetGeometryChange_t; /* * XPDispatchMode * * The dispatching modes describe how the widgets library sends out messages. * Currently there are three modes: * */ enum { /* The message will only be sent to the target widget. */ xpMode_Direct = 0, /* The message is sent to the target widget, then up the chain of parents * * until the message is handled or a parentless widget is reached. */ xpMode_UpChain = 1, /* The message is sent to the target widget and then all of its children * * recursively depth-first. */ xpMode_Recursive = 2, /* The message is sent 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 library * * functions.) */ xpMode_Once = 4, }; typedef int XPDispatchMode; /* * XPWidgetClass * * Widget classes define predefined widget types. A widget class basically * specifies from a library the widget function to be used for the widget. * Most widgets can be made right from classes. * */ typedef int XPWidgetClass; /* An unspecified widget class. Other widget classes are in * * XPStandardWidgets.h */ #define xpWidgetClass_None 0 /*************************************************************************** * WIDGET MESSAGES ***************************************************************************/ /* * XPWidgetMessage * * Widgets receive 32-bit messages indicating what action is to be taken or * notifications of events. The list of messages may be expanded. * */ enum { /* No message, should not be sent. */ xpMsg_None = 0, /* The create message is sent once per widget that is created with your widget* * function and once for any widget that has your widget function attached. * * * * Dispatching: Direct * * * * Param 1: 1 if you are being added as a subclass, 0 if the widget is first * * being created. */ xpMsg_Create = 1, /* The destroy message is sent once for each message that is destroyed that * * has your widget function. * * * * Dispatching: Direct for all * * * * Param 1: 1 if being deleted by a recursive delete to the parent, 0 for * * explicit deletion. */ xpMsg_Destroy = 2, /* The paint message is sent to your widget to draw itself. The paint message * * is the bare-bones message; in response you must draw yourself, draw your * * children, set up clipping and culling, check for visibility, etc. If you * * don't want to do all of this, ignore the paint message and a draw message * * (see below) will be sent to you. * * * * Dispatching: Direct */ xpMsg_Paint = 3, /* The draw message is sent to your widget when it is time to draw yourself. * * OpenGL will be set up to draw in 2-d global screen coordinates, but you * * should use the XPLM to set up OpenGL state. * * * * Dispatching: Direct */ xpMsg_Draw = 4, /* The key press message is sent once per key that is pressed. The first * * parameter is the type of key code (integer or char) and the second is the * * code itself. By handling this event, you consume the key stroke. * * * * Handling this message 'consumes' the keystroke; not handling it passes it * * to your parent widget. * * * * Dispatching: Up Chain * * * * Param 1: A pointer to an XPKeyState_t structure with the keystroke. */ xpMsg_KeyPress = 5, /* Keyboard focus is being given to you. By handling this message you accept * * keyboard focus. The first parameter will be one if a child of yours gave up* * focus to you, 0 if someone set focus on you explicitly. * * * * Handling this message accepts focus; not handling refuses focus. * * * * Dispatching: direct * * * * Param 1: 1 if you are gaining focus because your child is giving it up, 0 * * if someone is explicitly giving you focus. */ xpMsg_KeyTakeFocus = 6, /* Keyboard focus is being taken away from you. The first parameter will be 1 * * 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 ship 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 you. The child's ID is passed in parameter * * one. * * * * Dispatching: Direct * * * * Param 1: The Widget ID of the child being removed. */ xpMsg_LoseChild = 14, /* You now have a new parent, or have no parent. The parent's ID is passed in,* * or 0 for no parent. * * * * Dispatching: Direct * * * * Param 1: The Widget ID of your parent */ xpMsg_AcceptParent = 15, /* You or a child has been shown. Note that this does not include you being * * shown because your parent was shown, you were put in a new parent, your * * root was shown, etc. * * * * Dispatching: Up chain * * * * Param 1: The widget ID of the shown widget. */ xpMsg_Shown = 16, /* You have been hidden. See limitations above. * * * * Dispatching: Up chain * * * * Param 1: The widget ID of the hidden widget. */ xpMsg_Hidden = 17, /* Your descriptor has changed. * * * * Dispatching: Direct */ xpMsg_DescriptorChanged = 18, /* A property has changed. Param 1 contains the property ID. * * * * Dispatching: Direct * * * * Param 1: The Property ID being changed. * * * * Param 2: The new property value */ xpMsg_PropertyChanged = 19, #if defined(XPLM200) /* The mouse wheel has moved. * * * * Return 1 to consume the mouse wheel move, or 0 to pass the message to a * * parent. Dispatching: Up chain * * * * Param 1: A pointer to an XPMouseState_t containing the mouse status. */ xpMsg_MouseWheel = 20, #endif /* XPLM200 */ #if defined(XPLM200) /* The cursor is over your widget. If you consume this message, change the * * XPLMCursorStatus value to indicate the desired result, with the same rules * * as in XPLMDisplay.h. * * * * Return 1 to consume this message, 0 to pass it on. * * * * Dispatching: Up chain Param 1: A pointer to an XPMouseState_t struct * * containing the mouse status. * * * * Param 2: A pointer to a XPLMCursorStatus - set this to the cursor result * * you desire. */ xpMsg_CursorAdjust = 21, #endif /* XPLM200 */ /* NOTE: Message IDs 1000 - 9999 are allocated to the standard widget classes * * provided with the library with 1000 - 1099 for widget class 0, 1100 - 1199 * * for widget class 1, etc. Message IDs 10,000 and beyond are for plugin use. */ xpMsg_UserStart = 10000, }; typedef int XPWidgetMessage; /*************************************************************************** * WIDGET CALLBACK FUNCTION ***************************************************************************/ /* * XPWidgetFunc_t * * This function defines your custom widget's behavior. It will be called by * the widgets library to send messages to your widget. The message and widget * ID are passed in, as well as two pointer-width signed parameters whose * meaning varies with the message. Return 1 to indicate that you have * processed the message, 0 to indicate that you have not. For any message * that is not understood, return 0. * */ typedef int (* XPWidgetFunc_t)( XPWidgetMessage inMessage, XPWidgetID inWidget, intptr_t inParam1, intptr_t inParam2); #ifdef __cplusplus } #endif #endif