355 lines
14 KiB
C
355 lines
14 KiB
C
#ifndef _XPUIGraphics_h_
|
|
#define _XPUIGraphics_h_
|
|
|
|
/*
|
|
* Copyright 2005-2012 Sandy Barbour and Ben Supnik All rights reserved. See
|
|
* license.txt for usage. X-Plane SDK Version: 2.1.1
|
|
*
|
|
*/
|
|
|
|
/***************************************************************************
|
|
* XPUIGraphics
|
|
***************************************************************************/
|
|
|
|
#include "XPWidgetDefs.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
* UI GRAPHICS
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* XPWindowStyle
|
|
*
|
|
* There are a few built-in window styles in X-Plane that you can use.
|
|
*
|
|
* Note that X-Plane 6 does not offer real shadow-compositing; you must make
|
|
* sure to put a window on top of another window of the right style to the
|
|
* shadows work, etc. This applies to elements with insets and shadows. The
|
|
* rules are:
|
|
*
|
|
* Sub windows must go on top of main windows, and screens and list views on
|
|
* top of subwindows. Only help and main windows can be over the main screen.
|
|
*
|
|
* With X-Plane 7 any window or element may be placed over any other element.
|
|
*
|
|
* Some windows are scaled by stretching, some by repeating. The drawing
|
|
* routines know which scaling method to use. The list view cannot be rescaled
|
|
* in X-Plane 6 because it has both a repeating pattern and a gradient in one
|
|
* element. All other elements can be rescaled.
|
|
*
|
|
*/
|
|
enum {
|
|
/* An LCD screen that shows help. */
|
|
xpWindow_Help = 0,
|
|
|
|
/* A dialog box window. */
|
|
xpWindow_MainWindow = 1,
|
|
|
|
/* A panel or frame within a dialog box window. */
|
|
xpWindow_SubWindow = 2,
|
|
|
|
/* An LCD screen within a panel to hold text displays. */
|
|
xpWindow_Screen = 4,
|
|
|
|
/* A list view within a panel for scrolling file names, etc. */
|
|
xpWindow_ListView = 5,
|
|
|
|
|
|
};
|
|
typedef int XPWindowStyle;
|
|
|
|
/*
|
|
* XPDrawWindow
|
|
*
|
|
* This routine draws a window of the given dimensions at the given offset on
|
|
* the virtual screen in a given style. The window is automatically scaled as
|
|
* appropriate using a bitmap scaling technique (scaling or repeating) as
|
|
* appropriate to the style.
|
|
*
|
|
*/
|
|
WIDGET_API void XPDrawWindow(
|
|
int inX1,
|
|
int inY1,
|
|
int inX2,
|
|
int inY2,
|
|
XPWindowStyle inStyle);
|
|
|
|
/*
|
|
* XPGetWindowDefaultDimensions
|
|
*
|
|
* This routine returns the default dimensions for a window. Output is either
|
|
* a minimum or fixed value depending on whether the window is scalable.
|
|
*
|
|
*/
|
|
WIDGET_API void XPGetWindowDefaultDimensions(
|
|
XPWindowStyle inStyle,
|
|
int * outWidth, /* Can be NULL */
|
|
int * outHeight); /* Can be NULL */
|
|
|
|
/*
|
|
* XPElementStyle
|
|
*
|
|
* Elements are individually drawable UI things like push buttons, etc. The
|
|
* style defines what kind of element you are drawing. Elements can be
|
|
* stretched in one or two dimensions (depending on the element). Some
|
|
* elements can be lit.
|
|
*
|
|
* In X-Plane 6 some elements must be drawn over metal. Some are scalable and
|
|
* some are not. Any element can be drawn anywhere in X-Plane 7.
|
|
*
|
|
* Scalable Axis Required Background
|
|
*
|
|
*/
|
|
enum {
|
|
/* x metal */
|
|
xpElement_TextField = 6,
|
|
|
|
/* none metal */
|
|
xpElement_CheckBox = 9,
|
|
|
|
/* none metal */
|
|
xpElement_CheckBoxLit = 10,
|
|
|
|
/* none window header */
|
|
xpElement_WindowCloseBox = 14,
|
|
|
|
/* none window header */
|
|
xpElement_WindowCloseBoxPressed = 15,
|
|
|
|
/* x metal */
|
|
xpElement_PushButton = 16,
|
|
|
|
/* x metal */
|
|
xpElement_PushButtonLit = 17,
|
|
|
|
/* none any */
|
|
xpElement_OilPlatform = 24,
|
|
|
|
/* none any */
|
|
xpElement_OilPlatformSmall = 25,
|
|
|
|
/* none any */
|
|
xpElement_Ship = 26,
|
|
|
|
/* none any */
|
|
xpElement_ILSGlideScope = 27,
|
|
|
|
/* none any */
|
|
xpElement_MarkerLeft = 28,
|
|
|
|
/* none any */
|
|
xpElement_Airport = 29,
|
|
|
|
/* none any */
|
|
xpElement_Waypoint = 30,
|
|
|
|
/* none any */
|
|
xpElement_NDB = 31,
|
|
|
|
/* none any */
|
|
xpElement_VOR = 32,
|
|
|
|
/* none any */
|
|
xpElement_RadioTower = 33,
|
|
|
|
/* none any */
|
|
xpElement_AircraftCarrier = 34,
|
|
|
|
/* none any */
|
|
xpElement_Fire = 35,
|
|
|
|
/* none any */
|
|
xpElement_MarkerRight = 36,
|
|
|
|
/* none any */
|
|
xpElement_CustomObject = 37,
|
|
|
|
/* none any */
|
|
xpElement_CoolingTower = 38,
|
|
|
|
/* none any */
|
|
xpElement_SmokeStack = 39,
|
|
|
|
/* none any */
|
|
xpElement_Building = 40,
|
|
|
|
/* none any */
|
|
xpElement_PowerLine = 41,
|
|
|
|
/* none metal */
|
|
xpElement_CopyButtons = 45,
|
|
|
|
/* none metal */
|
|
xpElement_CopyButtonsWithEditingGrid = 46,
|
|
|
|
/* x, y metal */
|
|
xpElement_EditingGrid = 47,
|
|
|
|
/* THIS CAN PROBABLY BE REMOVED */
|
|
xpElement_ScrollBar = 48,
|
|
|
|
/* none any */
|
|
xpElement_VORWithCompassRose = 49,
|
|
|
|
/* none metal */
|
|
xpElement_Zoomer = 51,
|
|
|
|
/* x, y metal */
|
|
xpElement_TextFieldMiddle = 52,
|
|
|
|
/* none metal */
|
|
xpElement_LittleDownArrow = 53,
|
|
|
|
/* none metal */
|
|
xpElement_LittleUpArrow = 54,
|
|
|
|
/* none metal */
|
|
xpElement_WindowDragBar = 61,
|
|
|
|
/* none metal */
|
|
xpElement_WindowDragBarSmooth = 62,
|
|
|
|
|
|
};
|
|
typedef int XPElementStyle;
|
|
|
|
/*
|
|
* XPDrawElement
|
|
*
|
|
* XPDrawElement draws a given element at an offset on the virtual screen in
|
|
* set dimensions.
|
|
* *Even* if the element is not scalable, it will be scaled if the width and
|
|
* height do not match the preferred dimensions; it'll just look ugly. Pass
|
|
* inLit to see the lit version of the element; if the element cannot be lit
|
|
* this is ignored.
|
|
*
|
|
*/
|
|
WIDGET_API void XPDrawElement(
|
|
int inX1,
|
|
int inY1,
|
|
int inX2,
|
|
int inY2,
|
|
XPElementStyle inStyle,
|
|
int inLit);
|
|
|
|
/*
|
|
* XPGetElementDefaultDimensions
|
|
*
|
|
* This routine returns the recommended or minimum dimensions of a given UI
|
|
* element. outCanBeLit tells whether the element has both a lit and unlit
|
|
* state. Pass `NULL` to not receive any of these parameters.
|
|
*
|
|
*/
|
|
WIDGET_API void XPGetElementDefaultDimensions(
|
|
XPElementStyle inStyle,
|
|
int * outWidth, /* Can be NULL */
|
|
int * outHeight, /* Can be NULL */
|
|
int * outCanBeLit); /* Can be NULL */
|
|
|
|
/*
|
|
* XPTrackStyle
|
|
*
|
|
* A track is a UI element that displays a value vertically or horizontally.
|
|
* X-Plane has three kinds of tracks: scroll bars, sliders, and progress bars.
|
|
* Tracks can be displayed either horizontally or vertically; tracks will
|
|
* choose their own layout based on the larger dimension of their dimensions
|
|
* (e.g. they know if they are tall or wide). Sliders may be lit or unlit
|
|
* (showing the user manipulating them).
|
|
*
|
|
* - ScrollBar: this is a standard scroll bar with arrows and a thumb to drag.
|
|
* - Slider: this is a simple track with a ball in the middle that can be
|
|
* slid.
|
|
* - Progress: this is a progress indicator showing how a long task is going.
|
|
*
|
|
*/
|
|
enum {
|
|
/* not over metal can be lit can be rotated */
|
|
xpTrack_ScrollBar = 0,
|
|
|
|
/* over metal can be lit can be rotated */
|
|
xpTrack_Slider = 1,
|
|
|
|
/* over metal cannot be lit cannot be rotated */
|
|
xpTrack_Progress = 2,
|
|
|
|
|
|
};
|
|
typedef int XPTrackStyle;
|
|
|
|
/*
|
|
* XPDrawTrack
|
|
*
|
|
* This routine draws a track. You pass in the track dimensions and size; the
|
|
* track picks the optimal orientation for these dimensions. Pass in the
|
|
* track's minimum current and maximum values; the indicator will be
|
|
* positioned appropriately. You can also specify whether the track is lit or
|
|
* not.
|
|
*
|
|
*/
|
|
WIDGET_API void XPDrawTrack(
|
|
int inX1,
|
|
int inY1,
|
|
int inX2,
|
|
int inY2,
|
|
int inMin,
|
|
int inMax,
|
|
int inValue,
|
|
XPTrackStyle inTrackStyle,
|
|
int inLit);
|
|
|
|
/*
|
|
* XPGetTrackDefaultDimensions
|
|
*
|
|
* This routine returns a track's default smaller dimension; all tracks are
|
|
* scalable in the larger dimension. It also returns whether a track can be
|
|
* lit.
|
|
*
|
|
*/
|
|
WIDGET_API void XPGetTrackDefaultDimensions(
|
|
XPTrackStyle inStyle,
|
|
int * outWidth,
|
|
int * outCanBeLit);
|
|
|
|
/*
|
|
* XPGetTrackMetrics
|
|
*
|
|
* This routine returns the metrics of a track. If you want to write UI code
|
|
* to manipulate a track, this routine helps you know where the mouse
|
|
* locations are. For most other elements, the rectangle the element is drawn
|
|
* in is enough information. However, the scrollbar drawing routine does some
|
|
* automatic placement; this routine lets you know where things ended up. You
|
|
* pass almost everything you would pass to the draw routine. You get out the
|
|
* orientation, and other useful stuff.
|
|
*
|
|
* Besides orientation, you get five dimensions for the five parts of a
|
|
* scrollbar, which are the down button, down area (area before the thumb),
|
|
* the thumb, and the up area and button. For horizontal scrollers, the left
|
|
* button decreases; for vertical scrollers, the top button decreases.
|
|
*
|
|
*/
|
|
WIDGET_API void XPGetTrackMetrics(
|
|
int inX1,
|
|
int inY1,
|
|
int inX2,
|
|
int inY2,
|
|
int inMin,
|
|
int inMax,
|
|
int inValue,
|
|
XPTrackStyle inTrackStyle,
|
|
int * outIsVertical,
|
|
int * outDownBtnSize,
|
|
int * outDownPageSize,
|
|
int * outThumbSize,
|
|
int * outUpPageSize,
|
|
int * outUpBtnSize);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|