/*
TestWidgets Example
Written by Sandy Barbour - 21/02/2003
Modified by Sandy Barbour - 08/12/2009 // How time flies when you are having fun. :-)
Combined example plugin with the Custom Widget creation code.
This example shows how to create 2 custom widgets.
These are then used by the example plugin.
*/
#if IBM
#include <windows.h>
#endif
#if LIN
#include <GL/gl.h>
#else
#if __GNUC__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#endif
#include "XPLMDisplay.h"
#include "XPLMGraphics.h"
#include "XPLMProcessing.h"
#include "XPLMDataAccess.h"
#include "XPLMMenus.h"
#include "XPLMUtilities.h"
#include "XPWidgets.h"
#include "XPStandardWidgets.h"
#include "XPLMCamera.h"
#include "XPUIGraphics.h"
#include "XPWidgetUtils.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <vector>
#include <string>
/*------------------------------------------------------------------------*/
/*
* XPWidgetsEx.h
*
* Copyright 2005 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 1.0.2
*
*/
/************************************************************************
* POPUP MENU PICKS
************************************************************************
*
* This code helps do a popup menu item pick. Since x-plane must be
* running to track the mouse, this popup menu pick is effectively
* asynchronous and non-modal to the code...you call the function and
* some time later your callback is called.
*
* However, due to the way the popup pick is structured, it will appear to
* be somewhat modal to the user in that the next click after the popup
* is called must belong to it.
*
*/
/*
* XPPopupPick_f
*
* This function is called when your popup is picked. inChoice will be the number
* of the item picked, or -1 if no item was picked. (You should almost always ignore
* a -1.
*
*/
typedef void (* XPPopupPick_f)(int inChoice, void * inRefcon);
/*
* XPPickPopup
*
* This routine creates a dynamic 'popup menu' on the fly. If inCurrentItem is
* non-negative, it is the item that will be under the mouse. In this case, the
* mouse X and Y should be the top left of a popup box if there is such a thing.
* If inCurrentItem is -1, the popup menu appears at exactly inMouseX and inMouseY.
*
* You pass in the items, newline terminated ('\n') as well as a callback that is
* called when an item is picked, and a ref con for that function.
*
*/
static void XPPickPopup(
int inMouseX,
int inMouseY,
const char * inItems,
int inCurrentItem,
XPPopupPick_f inCallback,
void * inRefcon);
/* Impl notes: we can dispose from the mouse up. So...on mouse up
* we first call the popup func but then we nuke ourselves. Internally
* there is a data structure that is in the refcon of the xplm window that
* contains the callback for the user and the text, etc. */
/************************************************************************
* POPUP MENU BUTTON WIDGET
************************************************************************
*
* This widget implements a stanard pick-one-from-many-style popup menu
* button. The text is taken from the current item. The descriptor is
* the items, newline-terminated.
*
* A message is sent whenever a new item is picked by the user.
*
*/
#define xpWidgetClass_Popup 9
enum {
// This is the item number of the current item, starting at 0.
xpProperty_PopupCurrentItem = 1800
};
enum {
// This message is sent when an item is picked.
// param 1 is the widget that was picked, param 2
// is the item number.
xpMessage_PopupNewItemPicked = 1800
};
/*
* XPCreatePopup
*
* This routine makes a popup widget for you. You must provide
* a container for this widget, like a window for it to sit in.
*
*/
static XPWidgetID XPCreatePopup(
int inLeft,
int inTop,
int inRight,
int inBottom,
int inVisible,
const char * inDescriptor,
XPWidgetID inContainer);
static int XPPopupButtonProc(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
/************************************************************************
* LISTBOX
************************************************************************
*
* This code helps do a listbox. Since x-plane must be
* running to track the mouse, this listbox is effectively
* asynchronous and non-modal to the code...you call the function and
* some time later your callback is called.
*
* However, due to the way the listbox is structured, it will appear to
* be somewhat modal to the user in that the next click after the listbox
* is called must belong to it.
*
*/
/************************************************************************
* LISTBOX SELECTION WIDGET
************************************************************************
*
* This widget implements a standard pick-one-from-many-style selection menu
* button. The text is taken from the current item. The descriptor is
* the items, newline-terminated.
*
* A message is sent whenever a new item is picked by the user.
*
*/
#define xpWidgetClass_ListBox 10
enum {
// This is the item number of the current item, starting at 0.
xpProperty_ListBoxCurrentItem = 1900,
// This will add an item to the list box at the end.
xpProperty_ListBoxAddItem = 1901,
// This will clear the list box and then add the items.
xpProperty_ListBoxAddItemsWithClear = 1902,
// This will clear the list box.
xpProperty_ListBoxClear = 1903,
// This will insert an item into the list box at the index.
xpProperty_ListBoxInsertItem = 1904,
// This will delete an item from the list box at the index.
xpProperty_ListBoxDeleteItem = 1905,
// This stores the pointer to the listbox data.
xpProperty_ListBoxData = 1906,
// This stores the max Listbox Items.
xpProperty_ListBoxMaxListBoxItems = 1907,
// This stores the highlight state.
xpProperty_ListBoxHighlighted = 1908,
// This stores the scrollbar Min.
xpProperty_ListBoxScrollBarMin = 1909,
// This stores the scrollbar Max.
xpProperty_ListBoxScrollBarMax = 1910,
// This stores the scrollbar SliderPosition.
xpProperty_ListBoxScrollBarSliderPosition = 1911,
// This stores the scrollbar ScrollBarPageAmount.
xpProperty_ListBoxScrollBarPageAmount = 1912
};
enum {
// This message is sent when an item is picked.
// param 1 is the widget that was picked, param 2
// is the item number.
xpMessage_ListBoxItemSelected = 1900
};
/*
* XPCreateListBox
*
* This routine makes a listbox widget for you. You must provide
* a container for this widget, like a window for it to sit in.
*
*/
static XPWidgetID XPCreateListBox(
int inLeft,
int inTop,
int inRight,
int inBottom,
int inVisible,
const char * inDescriptor,
XPWidgetID inContainer);
static int XPListBoxProc(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
/*------------------------------------------------------------------------*/
static int MenuItem1;
static XPWidgetID TestWidgetsWidget, TestWidgetsWindow;
static XPWidgetID TestWidgetsPopup, TestWidgetsListBox;
static XPWidgetID ListboxInfoText1, ListboxInfoText2, ListboxAddItemButton, ListboxFillButton, ListboxClearButton, ListboxInsertButton, ListboxDeleteItemButton, ListboxInputTextEdit;
static XPWidgetID PopupInfoText, PopupInputTextEdit, PopupSetIndexButton;
static XPLMMenuID id;
static char szPopupText[4096];
static char szListBoxText[4096];
static void TestWidgetsMenuHandler(void *, void *);
static void CreateTestWidgets(int x1, int y1, int w, int h);
// Handle any widget messages
static int TestWidgetsHandler(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2);
/*------------------------------------------------------------------------*/
PLUGIN_API int XPluginStart(
char * outName,
char * outSig,
char * outDesc)
{
int item;
strcpy(outName, "TestWidgets");
strcpy(outSig, "xpsdk.examples.TestWidgets");
strcpy(outDesc, "A plug-in that tests new widgets.");
// Build menu
item = XPLMAppendMenuItem(XPLMFindPluginsMenu(), "Test Widgets", NULL, 1);
id = XPLMCreateMenu("Test Widgets", XPLMFindPluginsMenu(), item, TestWidgetsMenuHandler, NULL);
XPLMAppendMenuItem(id, "Open", (void *)"Open", 1);
// Used by widget to make sure only one widgets instance created
MenuItem1 = 0;
// Preload Popup
szPopupText[0] = '\0';
strcat( szPopupText, "Some longer text line 1");
strcat( szPopupText, ";" );
strcat( szPopupText, "Some longer text line 2");
strcat( szPopupText, ";" );
strcat( szPopupText, "Some longer text line 3");
strcat( szPopupText, ";" );
strcat( szPopupText, "Some longer text line 4");
strcat( szPopupText, ";" );
strcat( szPopupText, "Some longer text line 5");
strcat( szPopupText, ";" );
strcat( szPopupText, "Some longer text line 6");
strcat( szPopupText, ";" );
strcat( szPopupText, "Some longer text line 7");
strcat( szPopupText, ";" );
// Preload Listbox
szListBoxText[0] = '\0';
strcat( szListBoxText, "1234567890123456789012345678901234567890123456789012345678901234567890");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 2");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 3");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 4");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 5");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 6");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 7");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 8");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 9");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 10");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 11");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 12");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 13");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 14");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 15");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 16");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 17");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 18");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 19");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 20");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 21");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 22");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 23");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 24");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 25");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 26");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 27");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 28");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 29");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 30");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 31");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 32");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 33");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 34");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 35");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 36");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 37");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 38");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 39");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 40");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 41");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 42");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 43");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 44");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 45");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 46");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 47");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 48");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 49");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 50");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 51");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 52");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 53");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 54");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 55");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 56");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 57");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 58");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 59");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 60");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 61");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 62");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 63");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 64");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 65");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 66");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 67");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 68");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 69");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 70");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 71");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 72");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 73");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 74");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 75");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 76");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 77");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 78");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 79");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 80");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 81");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 82");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 83");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 84");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 85");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 86");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 87");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 88");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 89");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 90");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 91");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 92");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 93");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 94");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 95");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 96");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 97");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 98");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 99");
strcat( szListBoxText, ";" );
strcat( szListBoxText, "Item 100");
strcat( szListBoxText, ";" );
return 1;
}
/*------------------------------------------------------------------------*/
PLUGIN_API void XPluginStop(void)
{
// Clean up
XPLMDestroyMenu(id);
if (MenuItem1 == 1)
{
XPDestroyWidget(TestWidgetsWidget, 1);
MenuItem1 = 0;
}
}
/*------------------------------------------------------------------------*/
PLUGIN_API void XPluginDisable(void)
{
}
/*------------------------------------------------------------------------*/
PLUGIN_API int XPluginEnable(void)
{
return 1;
}
/*------------------------------------------------------------------------*/
PLUGIN_API void XPluginReceiveMessage(XPLMPluginID inFrom, int inMsg, void * inParam)
{
}
/*------------------------------------------------------------------------*/
// Handle any menu messages, only one, to created widget dialog
void TestWidgetsMenuHandler(void * mRef, void * iRef)
{
if (!strcmp((char *) iRef, "Open"))
{
if (MenuItem1 == 0)
{
CreateTestWidgets(300, 650, 450, 600);
MenuItem1 = 1;
}
else
if(!XPIsWidgetVisible(TestWidgetsWidget))
XPShowWidget(TestWidgetsWidget);
}
}
/*------------------------------------------------------------------------*/
// This creates the widgets dialog and any controls
void CreateTestWidgets(int x, int y, int w, int h)
{
int x2 = x + w;
int y2 = y - h;
TestWidgetsWidget = XPCreateWidget(x, y, x2, y2,
1, // Visible
"Test Widgets", // desc
1, // root
NULL, // no container
xpWidgetClass_MainWindow);
XPSetWidgetProperty(TestWidgetsWidget, xpProperty_MainWindowHasCloseBoxes, 1);
TestWidgetsWindow = XPCreateWidget(x+50, y-40, x2-50, y2+30,
1, // Visible
"", // desc
0, // root
TestWidgetsWidget,
xpWidgetClass_SubWindow);
XPSetWidgetProperty(TestWidgetsWindow, xpProperty_SubWindowType, xpSubWindowStyle_SubWindow);
TestWidgetsPopup = XPCreatePopup( x+70, y-50, x2-70, y-72,
1, szPopupText, TestWidgetsWidget );
PopupInfoText = XPCreateWidget(x+70, y-80, x2-70, y-102,
1, "Popup Index 0", 0, TestWidgetsWidget,
xpWidgetClass_TextField);
XPSetWidgetProperty(PopupInfoText, xpProperty_TextFieldType, xpTextEntryField);
PopupSetIndexButton = XPCreateWidget(x+70, y-110, x+170, y-132,
1, " Set Popup Index", 0, TestWidgetsWidget,
xpWidgetClass_Button);
XPSetWidgetProperty(PopupSetIndexButton, xpProperty_ButtonType, xpPushButton);
PopupInputTextEdit = XPCreateWidget(x+180, y-110, x2-70, y-132,
1, "0", 0, TestWidgetsWidget,
xpWidgetClass_TextField);
XPSetWidgetProperty(PopupInputTextEdit, xpProperty_TextFieldType, xpTextEntryField);
TestWidgetsListBox = XPCreateListBox( x+70, y-140, x2-70, y-340,
1, szListBoxText, TestWidgetsWidget );
ListboxInfoText1 = XPCreateWidget(x+70, y-350, x2-70, y-372,
1, "", 0, TestWidgetsWidget,
xpWidgetClass_TextField);
XPSetWidgetProperty(ListboxInfoText1, xpProperty_TextFieldType, xpTextEntryField);
ListboxInfoText2 = XPCreateWidget(x+70, y-390, x2-70, y-392,
1, "", 0, TestWidgetsWidget,
xpWidgetClass_TextField);
XPSetWidgetProperty(ListboxInfoText2, xpProperty_TextFieldType, xpTextEntryField);
ListboxAddItemButton = XPCreateWidget(x+70, y-400, x+130, y-422,
1, " Add Item", 0, TestWidgetsWidget,
xpWidgetClass_Button);
XPSetWidgetProperty(ListboxAddItemButton, xpProperty_ButtonType, xpPushButton);
ListboxFillButton = XPCreateWidget(x+140, y-400, x+200, y-422,
1, " Fill LB", 0, TestWidgetsWidget,
xpWidgetClass_Button);
XPSetWidgetProperty(ListboxFillButton, xpProperty_ButtonType, xpPushButton);
ListboxClearButton = XPCreateWidget(x+210, y-400, x+270, y-422,
1, " Clear LB", 0, TestWidgetsWidget,
xpWidgetClass_Button);
XPSetWidgetProperty(ListboxClearButton, xpProperty_ButtonType, xpPushButton);
ListboxInsertButton = XPCreateWidget(x+70, y-430, x+140, y-452,
1, " Insert Item", 0, TestWidgetsWidget,
xpWidgetClass_Button);
XPSetWidgetProperty(ListboxInsertButton, xpProperty_ButtonType, xpPushButton);
ListboxDeleteItemButton = XPCreateWidget(x+150, y-430, x+220, y-452,
1, " Delete Item", 0, TestWidgetsWidget,
xpWidgetClass_Button);
XPSetWidgetProperty(ListboxDeleteItemButton, xpProperty_ButtonType, xpPushButton);
ListboxInputTextEdit = XPCreateWidget(x+70, y-460, x2-70, y-492,
1, "Add Me", 0, TestWidgetsWidget,
xpWidgetClass_TextField);
XPSetWidgetProperty(ListboxInputTextEdit, xpProperty_TextFieldType, xpTextEntryField);
XPAddWidgetCallback(TestWidgetsWidget, TestWidgetsHandler);
}
/*------------------------------------------------------------------------*/
// Handle any widget messages
int TestWidgetsHandler(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
char Buffer[256];
// Close button pressed, only hide the widget, rather than destropying it.
if (inMessage == xpMessage_CloseButtonPushed)
{
if (MenuItem1 == 1)
{
XPHideWidget(TestWidgetsWidget);
}
return 1;
}
// Test for a button pressed
if (inMessage == xpMsg_PushButtonPressed)
{
// This test adds three items to the listbox
if (inParam1 == (intptr_t)ListboxAddItemButton)
{
strcpy(Buffer, "Line 1");
XPSetWidgetDescriptor(TestWidgetsListBox, Buffer);
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxAddItem, 1);
strcpy(Buffer, "Line 2");
XPSetWidgetDescriptor(TestWidgetsListBox, Buffer);
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxAddItem, 1);
strcpy(Buffer, "Line 3");
XPSetWidgetDescriptor(TestWidgetsListBox, Buffer);
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxAddItem, 1);
return 1;
}
// This test clears the list box and then adds the test items
if (inParam1 == (intptr_t)ListboxFillButton)
{
XPSetWidgetDescriptor(TestWidgetsListBox, szListBoxText);
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxAddItemsWithClear, 1);
return 1;
}
// This test clears the listbox
if (inParam1 == (intptr_t)ListboxClearButton)
{
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxClear, 1);
return 1;
}
// This test inserts the text entered into ListboxInputTextEdit at the
// current selected listbox item position
if (inParam1 == (intptr_t)ListboxInsertButton)
{
XPGetWidgetDescriptor(ListboxInputTextEdit, Buffer, sizeof(Buffer));
XPSetWidgetDescriptor(TestWidgetsListBox, Buffer);
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxInsertItem, 1);
return 1;
}
// This test deletes the current selected listbox item
if (inParam1 == (intptr_t)ListboxDeleteItemButton)
{
XPSetWidgetProperty(TestWidgetsListBox, xpProperty_ListBoxDeleteItem, 1);
return 1;
}
// This test set the popup index to the number
// entered into the PopupInputTextEdit edit box
if (inParam1 == (intptr_t)PopupSetIndexButton)
{
XPGetWidgetDescriptor(PopupInputTextEdit, Buffer, sizeof(Buffer));
int curItem = atoi(Buffer);
XPSetWidgetProperty(TestWidgetsPopup, xpProperty_PopupCurrentItem, curItem);
XPGetWidgetDescriptor(TestWidgetsPopup, Buffer, sizeof(Buffer));
curItem = XPGetWidgetProperty(TestWidgetsPopup, xpProperty_PopupCurrentItem, NULL);
sprintf(Buffer, "Popup Index %d", curItem);
XPSetWidgetDescriptor(PopupInfoText, Buffer);
return 1;
}
}
// This handles the listbox item selected message
// i.e. when you click on an item
if (inMessage == xpMessage_ListBoxItemSelected)
{
XPGetWidgetDescriptor(TestWidgetsListBox, Buffer, sizeof(Buffer));
XPSetWidgetDescriptor(ListboxInfoText1, Buffer);
sprintf(Buffer, "ListBox Index %d", inParam2);
XPSetWidgetDescriptor(ListboxInfoText2, Buffer);
return 1;
}
// This handles the popup item picked message
// i.e. when you selecte another popup entry.
if (inMessage == xpMessage_PopupNewItemPicked)
{
XPGetWidgetDescriptor(TestWidgetsPopup, Buffer, sizeof(Buffer));
int curItem = XPGetWidgetProperty(TestWidgetsPopup, xpProperty_PopupCurrentItem, NULL);
sprintf(Buffer, "Popup Index %d", curItem);
XPSetWidgetDescriptor(PopupInfoText, Buffer);
return 1;
}
return 0;
}
/*------------------------------------------------------------------------*/
/*
* XPListBox.cpp
*
* Copyright 2005 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 1.0.2
*
*/
#define LISTBOX_ITEM_HEIGHT 12
#define IN_RECT(x, y, l, t, r, b) \
(((x) >= (l)) && ((x) <= (r)) && ((y) >= (b)) && ((y) <= (t)))
#if IBM
static double round(double InValue)
{
int WholeValue;
double Fraction;
WholeValue = InValue;
Fraction = InValue - (double) WholeValue;
if (Fraction >= 0.5)
WholeValue++;
return (double) WholeValue;
}
#endif
/************************************************************************
* X-PLANE UI INFRASTRUCTURE CODE
************************************************************************
*
* This code helps provde an x-plane compatible look. It is copied from
* the source code from the widgets DLL; someday listyboxes will be part of
* this, so our listboxes are written off of the same APIs.
*
*/
// Enums for x-plane native colors.
enum {
xpColor_MenuDarkTinge = 0,
xpColor_MenuBkgnd,
xpColor_MenuHilite,
xpColor_MenuLiteTinge,
xpColor_MenuText,
xpColor_MenuTextDisabled,
xpColor_SubTitleText,
xpColor_TabFront,
xpColor_TabBack,
xpColor_CaptionText,
xpColor_ListText,
xpColor_GlassText,
xpColor_Count
};
// Enums for the datarefs we get them from.
static const char * kXPlaneColorNames[] = {
"sim/graphics/colors/menu_dark_rgb",
"sim/graphics/colors/menu_bkgnd_rgb",
"sim/graphics/colors/menu_hilite_rgb",
"sim/graphics/colors/menu_lite_rgb",
"sim/graphics/colors/menu_text_rgb",
"sim/graphics/colors/menu_text_disabled_rgb",
"sim/graphics/colors/subtitle_text_rgb",
"sim/graphics/colors/tab_front_rgb",
"sim/graphics/colors/tab_back_rgb",
"sim/graphics/colors/caption_text_rgb",
"sim/graphics/colors/list_text_rgb",
"sim/graphics/colors/glass_text_rgb"
};
// Those datarefs are only XP7; if we can't find one,
// fall back to this table of X-Plane 6 colors.
static const float kBackupColors[xpColor_Count][3] =
{
{ (const float)(33.0/256.0), (const float)(41.0/256.0), (const float)(44.0/256.0) },
{ (const float)(53.0/256.0), (const float)(64.0/256.0), (const float)(68.0/256.0) },
{ (const float)(65.0/256.0), (const float)(83.0/256.0), (const float)(89.0/256.0) },
{ (const float)(65.0/256.0), (const float)(83.0/256.0), (const float)(89.0/256.0) },
{ (const float)0.8, (const float)0.8, (const float)0.8 },
{ (const float)0.4, (const float)0.4, (const float)0.4 }
};
// This array contains the resolved datarefs
static XPLMDataRef gColorRefs[xpColor_Count];
// Current alpha levels to blit at.
static float gAlphaLevel = 1.0;
// This routine sets up a color from the above table. Pass
// in a float[3] to get the color; pass in NULL to have the
// OpenGL color be set immediately.
static void SetupAmbientColor(int inColorID, float * outColor)
{
// If we're running the first time, resolve all of our datarefs just once.
static bool firstTime = true;
if (firstTime)
{
firstTime = false;
for (int n = 0; n <xpColor_Count; ++n)
{
gColorRefs[n] = XPLMFindDataRef(kXPlaneColorNames[n]);
}
}
// If being asked to set the color immediately, allocate some storage.
float theColor[4];
float * target = outColor ? outColor : theColor;
// If we have a dataref, just fetch the color from the ref.
if (gColorRefs[inColorID])
XPLMGetDatavf(gColorRefs[inColorID], target, 0, 3);
else {
// If we didn't have a dataref, fetch the ambient cabin lighting,
// since XP6 dims the UI with night.
static XPLMDataRef ambient_r = XPLMFindDataRef("sim/graphics/misc/cockpit_light_level_r");
static XPLMDataRef ambient_g = XPLMFindDataRef("sim/graphics/misc/cockpit_light_level_g");
static XPLMDataRef ambient_b = XPLMFindDataRef("sim/graphics/misc/cockpit_light_level_b");
// Use a backup color but dim it.
target[0] = kBackupColors[inColorID][0] * XPLMGetDataf(ambient_r);
target[1] = kBackupColors[inColorID][1] * XPLMGetDataf(ambient_g);
target[2] = kBackupColors[inColorID][2] * XPLMGetDataf(ambient_b);
}
// If the user passed NULL, set the color now using the alpha level.
if (!outColor)
{
theColor[3] = gAlphaLevel;
glColor4fv(theColor);
}
}
// Just remember alpha levels for later.
static void SetAlphaLevels(float inAlphaLevel)
{
gAlphaLevel = inAlphaLevel;
}
#ifndef _WINDOWS
#pragma mark -
#endif
/************************************************************************
* LISTBOX DATA IMPLEMENTATION
************************************************************************/
// This structure represents a listbox internally...it consists of arrays
// per item and some general stuff.
struct XPListBoxData_t {
// Per item:
std::vector<std::string> Items; // The name of the item
std::vector<int> Lefts; // The rectangle of the item, relative to the top left corner of the listbox/
std::vector<int> Rights;
};
static XPListBoxData_t *pListBoxData;
// This routine finds the item that is in a given point, or returns -1 if there is none.
// It simply trolls through all the items.
static int XPListBoxGetItemNumber(XPListBoxData_t * pListBoxData, int inX, int inY)
{
for (unsigned int n = 0; n < pListBoxData->Items.size(); ++n)
{
if ((inX >= pListBoxData->Lefts[n]) && (inX < pListBoxData->Rights[n]) &&
(inY >= (n * LISTBOX_ITEM_HEIGHT)) && (inY < ((n * LISTBOX_ITEM_HEIGHT) + LISTBOX_ITEM_HEIGHT)))
{
return n;
}
}
return -1;
}
static void XPListBoxFillWithData(XPListBoxData_t *pListBoxData, const char *inItems, int Width)
{
std::string Items(inItems);
while (!Items.empty())
{
std::string::size_type split = Items.find(';');
if (split == Items.npos)
{
split = Items.size();
}
std::string Item = Items.substr(0, split);
pListBoxData->Items.push_back(Item);
pListBoxData->Lefts.push_back(0);
pListBoxData->Rights.push_back(Width);
if (Item.size() == Items.size())
break;
else
Items = Items.substr(split+1);
}
}
static void XPListBoxAddItem(XPListBoxData_t *pListBoxData, char *pBuffer, int Width)
{
std::string Item(pBuffer);
pListBoxData->Items.push_back(Item);
pListBoxData->Lefts.push_back(0);
pListBoxData->Rights.push_back(Width);
}
static void XPListBoxClear(XPListBoxData_t *pListBoxData)
{
pListBoxData->Items.clear();
pListBoxData->Lefts.clear();
pListBoxData->Rights.clear();
}
static void XPListBoxInsertItem(XPListBoxData_t *pListBoxData, char *pBuffer, int Width, int CurrentItem)
{
std::string Item(pBuffer);
pListBoxData->Items.insert(pListBoxData->Items.begin() + CurrentItem, Item);
pListBoxData->Lefts.insert(pListBoxData->Lefts.begin() + CurrentItem, 0);
pListBoxData->Rights.insert(pListBoxData->Rights.begin() + CurrentItem, Width);
}
static void XPListBoxDeleteItem(XPListBoxData_t *pListBoxData, int CurrentItem)
{
pListBoxData->Items.erase(pListBoxData->Items.begin() + CurrentItem);
pListBoxData->Lefts.erase(pListBoxData->Lefts.begin() + CurrentItem);
pListBoxData->Rights.erase(pListBoxData->Rights.begin() + CurrentItem);
}
#ifndef _WINDOWS
#pragma mark -
#endif
// This widget Proc implements the actual listbox.
static int XPListBoxProc(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
static int ScrollBarSlop;
// Select if we're in the background.
if (XPUSelectIfNeeded(inMessage, inWidget, inParam1, inParam2, 1/*eat*/)) return 1;
int Left, Top, Right, Bottom, x, y, ListBoxDataOffset, ListBoxIndex;
char Buffer[4096];
int IsVertical, DownBtnSize, DownPageSize, ThumbSize, UpPageSize, UpBtnSize;
bool UpBtnSelected, DownBtnSelected, ThumbSelected, UpPageSelected, DownPageSelected;
XPGetWidgetGeometry(inWidget, &Left, &Top, &Right, &Bottom);
int SliderPosition = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, NULL);
int Min = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMin, NULL);
int Max = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, NULL);
int ScrollBarPageAmount = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarPageAmount, NULL);
int CurrentItem = XPGetWidgetProperty(inWidget, xpProperty_ListBoxCurrentItem, NULL);
int MaxListBoxItems = XPGetWidgetProperty(inWidget, xpProperty_ListBoxMaxListBoxItems, NULL);
int Highlighted = XPGetWidgetProperty(inWidget, xpProperty_ListBoxHighlighted, NULL);
XPListBoxData_t *pListBoxData = (XPListBoxData_t*) XPGetWidgetProperty(inWidget, xpProperty_ListBoxData, NULL);
switch(inMessage)
{
case xpMsg_Create:
// Allocate mem for the structure.
pListBoxData = new XPListBoxData_t;
XPGetWidgetDescriptor(inWidget, Buffer, sizeof(Buffer));
XPListBoxFillWithData(pListBoxData, Buffer, (Right - Left - 20));
XPSetWidgetProperty(inWidget, xpProperty_ListBoxData, (intptr_t)pListBoxData);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxCurrentItem, 0);
Min = 0;
Max = pListBoxData->Items.size();
ScrollBarSlop = 0;
Highlighted = false;
SliderPosition = Max;
MaxListBoxItems = (Top - Bottom) / LISTBOX_ITEM_HEIGHT;
ScrollBarPageAmount = MaxListBoxItems;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMin, Min);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, Max);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarPageAmount, ScrollBarPageAmount);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxMaxListBoxItems, MaxListBoxItems);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxHighlighted, Highlighted);
return 1;
case xpMsg_DescriptorChanged:
return 1;
case xpMsg_PropertyChanged:
if (XPGetWidgetProperty(inWidget, xpProperty_ListBoxAddItem, NULL))
{
XPSetWidgetProperty(inWidget, xpProperty_ListBoxAddItem, 0);
XPGetWidgetDescriptor(inWidget, Buffer, sizeof(Buffer));
XPListBoxAddItem(pListBoxData, Buffer, (Right - Left - 20));
Max = pListBoxData->Items.size();
SliderPosition = Max;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, Max);
}
if (XPGetWidgetProperty(inWidget, xpProperty_ListBoxAddItemsWithClear, NULL))
{
XPSetWidgetProperty(inWidget, xpProperty_ListBoxAddItemsWithClear, 0);
XPGetWidgetDescriptor(inWidget, Buffer, sizeof(Buffer));
XPListBoxClear(pListBoxData);
XPListBoxFillWithData(pListBoxData, Buffer, (Right - Left - 20));
Max = pListBoxData->Items.size();
SliderPosition = Max;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, Max);
}
if (XPGetWidgetProperty(inWidget, xpProperty_ListBoxClear, NULL))
{
XPSetWidgetProperty(inWidget, xpProperty_ListBoxClear, 0);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxCurrentItem, 0);
XPListBoxClear(pListBoxData);
Max = pListBoxData->Items.size();
SliderPosition = Max;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, Max);
}
if (XPGetWidgetProperty(inWidget, xpProperty_ListBoxInsertItem, NULL))
{
XPSetWidgetProperty(inWidget, xpProperty_ListBoxInsertItem, 0);
XPGetWidgetDescriptor(inWidget, Buffer, sizeof(Buffer));
XPListBoxInsertItem(pListBoxData, Buffer, (Right - Left - 20), CurrentItem);
}
if (XPGetWidgetProperty(inWidget, xpProperty_ListBoxDeleteItem, NULL))
{
XPSetWidgetProperty(inWidget, xpProperty_ListBoxDeleteItem, 0);
if ((pListBoxData->Items.size() > 0) && (pListBoxData->Items.size() > CurrentItem))
XPListBoxDeleteItem(pListBoxData, CurrentItem);
}
return 1;
case xpMsg_Draw:
{
int x, y;
XPLMGetMouseLocation(&x, &y);
XPDrawWindow(Left, Bottom, Right-20, Top, xpWindow_ListView);
XPDrawTrack(Right-20, Bottom, Right, Top, Min, Max, SliderPosition, xpTrack_ScrollBar, Highlighted);
XPLMSetGraphicsState(0, 1, 0, 0, 1, 0, 0);
XPLMBindTexture2d(XPLMGetTexture(xplm_Tex_GeneralInterface), 0);
glColor4f(1.0, 1.0, 1.0, 1.0);
unsigned int ItemNumber;
XPLMSetGraphicsState(0, 0, 0, 0, 0, 0, 0);
// Now draw each item.
ListBoxIndex = Max - SliderPosition;
ItemNumber = 0;
while (ItemNumber < MaxListBoxItems)
{
if (ListBoxIndex < pListBoxData->Items.size())
{
// Calculate the item rect in global coordinates.
int ItemTop = Top - (ItemNumber * LISTBOX_ITEM_HEIGHT);
int ItemBottom = Top - ((ItemNumber * LISTBOX_ITEM_HEIGHT) + LISTBOX_ITEM_HEIGHT);
// If we are hilited, draw the hilite bkgnd.
if (CurrentItem == ListBoxIndex)
{
SetAlphaLevels(0.25);
XPLMSetGraphicsState(0, 0, 0, 0, 1, 0, 0);
SetupAmbientColor(xpColor_MenuHilite, NULL);
SetAlphaLevels(1.0);
glBegin(GL_QUADS);
glVertex2i(Left, ItemTop);
glVertex2i(Right-20, ItemTop);
glVertex2i(Right-20, ItemBottom);
glVertex2i(Left, ItemBottom);
glEnd();
}
float text[3];
SetupAmbientColor(xpColor_ListText, text);
char Buffer[512];
int FontWidth, FontHeight;
int ListBoxWidth = (Right - 20) - Left;
strcpy(Buffer, pListBoxData->Items[ListBoxIndex++].c_str());
XPLMGetFontDimensions(xplmFont_Basic, &FontWidth, &FontHeight, NULL);
int MaxChars = ListBoxWidth / FontWidth;
Buffer[MaxChars] = 0;
XPLMDrawString(text,
Left, ItemBottom + 2,
const_cast<char *>(Buffer), NULL, xplmFont_Basic);
}
ItemNumber++;
}
}
return 1;
case xpMsg_MouseUp:
if (IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, Top, Right, Bottom))
{
Highlighted = false;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxHighlighted, Highlighted);
}
if (IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Left, Top, Right-20, Bottom))
{
if (pListBoxData->Items.size() > 0)
{
if (CurrentItem != -1)
XPSetWidgetDescriptor(inWidget, pListBoxData->Items[CurrentItem].c_str());
else
XPSetWidgetDescriptor(inWidget, "");
XPSendMessageToWidget(inWidget, xpMessage_ListBoxItemSelected, xpMode_UpChain, (intptr_t) inWidget, (intptr_t) CurrentItem);
}
}
return 1;
case xpMsg_MouseDown:
if (IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Left, Top, Right-20, Bottom))
{
if (pListBoxData->Items.size() > 0)
{
XPLMGetMouseLocation(&x, &y);
ListBoxDataOffset = XPListBoxGetItemNumber(pListBoxData, x - Left, Top - y);
if (ListBoxDataOffset != -1)
{
ListBoxDataOffset += (Max - SliderPosition);
if (ListBoxDataOffset < pListBoxData->Items.size())
XPSetWidgetProperty(inWidget, xpProperty_ListBoxCurrentItem, ListBoxDataOffset);
}
}
}
if (IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, Top, Right, Bottom))
{
XPGetTrackMetrics(Right-20, Bottom, Right, Top, Min, Max, SliderPosition, xpTrack_ScrollBar, &IsVertical, &DownBtnSize, &DownPageSize, &ThumbSize, &UpPageSize, &UpBtnSize);
int Min = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMin, NULL);
int Max = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, NULL);
if (IsVertical)
{
UpBtnSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, Top, Right, Top - UpBtnSize);
DownBtnSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, Bottom + DownBtnSize, Right, Bottom);
UpPageSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, (Top - UpBtnSize), Right, (Bottom + DownBtnSize + DownPageSize + ThumbSize));
DownPageSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, (Top - UpBtnSize - UpPageSize - ThumbSize), Right, (Bottom + DownBtnSize));
ThumbSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, (Top - UpBtnSize - UpPageSize), Right, (Bottom + DownBtnSize + DownPageSize));
}
else
{
DownBtnSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, Top, Right-20 + UpBtnSize, Bottom);
UpBtnSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20 - DownBtnSize, Top, Right, Bottom);
DownPageSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20 + DownBtnSize, Top, Right - UpBtnSize - UpPageSize - ThumbSize, Bottom);
UpPageSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20 + DownBtnSize + DownPageSize + ThumbSize, Top, Right - UpBtnSize, Bottom);
ThumbSelected = IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20 + DownBtnSize + DownPageSize, Top, Right - UpBtnSize - UpPageSize, Bottom);
}
if (UpPageSelected)
{
SliderPosition+=ScrollBarPageAmount;
if (SliderPosition > Max)
SliderPosition = Max;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
}
else if (DownPageSelected)
{
SliderPosition-=ScrollBarPageAmount;
if (SliderPosition < Min)
SliderPosition = Min;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
}
else if (UpBtnSelected)
{
SliderPosition++;
if (SliderPosition > Max)
SliderPosition = Max;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
}
else if (DownBtnSelected)
{
SliderPosition--;
if (SliderPosition < Min)
SliderPosition = Min;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
}
else if (ThumbSelected)
{
if (IsVertical)
ScrollBarSlop = Bottom + DownBtnSize + DownPageSize + (ThumbSize/2) - MOUSE_Y(inParam1);
else
ScrollBarSlop = Right-20 + DownBtnSize + DownPageSize + (ThumbSize/2) - MOUSE_X(inParam1);
Highlighted = true;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxHighlighted, Highlighted);
}
else
{
Highlighted = false;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxHighlighted, Highlighted);
}
}
return 1;
case xpMsg_MouseDrag:
if (IN_RECT(MOUSE_X(inParam1), MOUSE_Y(inParam1), Right-20, Top, Right, Bottom))
{
XPGetTrackMetrics(Right-20, Bottom, Right, Top, Min, Max, SliderPosition, xpTrack_ScrollBar, &IsVertical, &DownBtnSize, &DownPageSize, &ThumbSize, &UpPageSize, &UpBtnSize);
int Min = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMin, NULL);
int Max = XPGetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarMax, NULL);
ThumbSelected = Highlighted;
if (ThumbSelected)
{
if (inParam1 != 0)
{
if (IsVertical)
{
y = MOUSE_Y(inParam1) + ScrollBarSlop;
SliderPosition = round((float)((float)(y - (Bottom + DownBtnSize + ThumbSize/2)) /
(float)((Top - UpBtnSize - ThumbSize/2) - (Bottom + DownBtnSize + ThumbSize/2))) * Max);
}
else
{
x = MOUSE_X(inParam1) + ScrollBarSlop;
SliderPosition = round((float)((float)(x - (Right-20 + DownBtnSize + ThumbSize/2)) / (float)((Right - UpBtnSize - ThumbSize/2) - (Right-20 + DownBtnSize + ThumbSize/2))) * Max);
}
}
else
SliderPosition = 0;
if (SliderPosition < Min)
SliderPosition = Min;
if (SliderPosition > Max)
SliderPosition = Max;
XPSetWidgetProperty(inWidget, xpProperty_ListBoxScrollBarSliderPosition, SliderPosition);
}
}
return 1;
default:
return 0;
}
}
// To create a listbox, make a new widget with our listbox proc as the widget proc.
static XPWidgetID XPCreateListBox(
int inLeft,
int inTop,
int inRight,
int inBottom,
int inVisible,
const char * inDescriptor,
XPWidgetID inContainer)
{
return XPCreateCustomWidget(
inLeft,
inTop,
inRight,
inBottom,
inVisible,
inDescriptor,
0,
inContainer,
XPListBoxProc);
}
/*------------------------------------------------------------------------*/
/*
* XPPopups.cpp
*
* Copyright 2005 Sandy Barbour and Ben Supnik
*
* All rights reserved. See license.txt for usage.
*
* X-Plane SDK Version: 1.0.2
*
*/
/************************************************************************
* X-PLANE UI INFRASTRUCTURE CODE
************************************************************************
*
* This code helps provde an x-plane compatible look. It is copied from
* the source code from the widgets DLL; someday popups will be part of
* this, so our popups are written off of the same APIs.
*
*/
enum {
// These are for caching, do not use!!
xpProperty_OffsetToCurrentItem = 1898,
xpProperty_CurrentItemLen = 1899
};
#ifndef _WINDOWS
#pragma mark -
#endif
/************************************************************************
* POPUP MENU IMPLEMENTATION
************************************************************************/
// This structure represents a popup menu internally...it consists of arrays
// per item and some general stuff. It is implemented as a giant window; that
// window has a ptr to this struct as its refcon. While the whole window isn't
// drawn in, we make the window full screen so if the user clicks outside the
// popup, we capture the click and dismiss the popup.
struct XPPopupMenu_t {
XPLMWindowID window; // The window that implements us.
// Per item:
std::vector<std::string> items; // The name of the item
std::vector<bool> enabled; // Is it enabled?
std::vector<int> lefts; // The rectangle of the item, relative to the top left corner of the menu/
std::vector<int> rights;
std::vector<int> bottoms;
std::vector<int> tops;
std::vector<int> vstripes; // An array of vertical stripes (relative to the left of the menu
// for really big menus.
int left; // The overall bounds of the menu in global screen coordinates.
int top;
int right;
int bottom;
XPPopupPick_f function; // Info for our callback function.
void * ref;
};
// This routine finds the item that is in a given point, or returns -1 if there is none.
// It simply trolls through all the items.
static int XPItemForHeight(XPPopupMenu_t * pmenu, int inX, int inY)
{
inX -= pmenu->left;
inY -= pmenu->top;
for (unsigned int n = 0; n < pmenu->items.size(); ++n)
{
if ((inX >= pmenu->lefts[n]) && (inX < pmenu->rights[n]) &&
(inY >= pmenu->bottoms[n]) && (inY < pmenu->tops[n]))
{
return n;
}
}
return -1;
}
// This is the drawing hook for a popup menu.
static void XPPopupDrawWindowCB(
XPLMWindowID inWindowID,
void * inRefcon)
{
XPPopupMenu_t * pmenu = (XPPopupMenu_t *) inRefcon;
int x, y;
XPLMGetMouseLocation(&x, &y);
// This is the index number of the currently selected item, based
// on where the mouse is.
int menu_offset = XPItemForHeight(pmenu, x, y);
int item_top = pmenu->top;
unsigned int n;
XPLMSetGraphicsState(0, 0, 0, 0, 0, 0, 0);
// Draw any vertical stripes that must be drawn for multi-column menus.
for (n = 0; n < pmenu->vstripes.size(); ++n)
{
SetupAmbientColor(xpColor_MenuDarkTinge, NULL);
glBegin(GL_LINES);
glVertex2i(pmenu->left + pmenu->vstripes[n] - 1, pmenu->top);
glVertex2i(pmenu->left + pmenu->vstripes[n] - 1, pmenu->bottom);
glEnd();
SetupAmbientColor(xpColor_MenuLiteTinge, NULL);
glBegin(GL_LINES);
glVertex2i(pmenu->left + pmenu->vstripes[n], pmenu->top);
glVertex2i(pmenu->left + pmenu->vstripes[n], pmenu->bottom);
glEnd();
}
// Now draw each item.
for (n = 0; n < pmenu->items.size(); ++n)
{
// Calcualte the item rect in global coordinates.
int item_bottom = pmenu->bottoms[n] + pmenu->top;
int item_top = pmenu->tops[n] + pmenu->top;
int item_left = pmenu->lefts[n] + pmenu->left;
int item_right = pmenu->rights[n] + pmenu->left;
XPDrawElement( item_left,
item_bottom,
item_right,
item_top,
(menu_offset == n && pmenu->enabled[n])? xpElement_PushButtonLit : xpElement_PushButton, 0);
if (!pmenu->enabled[n] && pmenu->items[n] == "-")
{
// Draw two lines for dividers.
XPLMSetGraphicsState(0, 0, 0, 0, 0, 0, 0);
SetupAmbientColor(xpColor_MenuLiteTinge, NULL);
glBegin(GL_LINE_STRIP);
glVertex2i(item_left, item_top - 1);
glVertex2i(item_right, item_top - 1);
glEnd();
SetupAmbientColor(xpColor_MenuDarkTinge, NULL);
glBegin(GL_LINE_STRIP);
glVertex2i(item_left, item_top);
glVertex2i(item_right, item_top);
glEnd();
} else {
// If we are hilited, draw the hilite bkgnd.
if (menu_offset == n && pmenu->enabled[n])
{
SetAlphaLevels(0.25);
XPLMSetGraphicsState(0, 0, 0, 0, 1, 0, 0);
SetupAmbientColor(xpColor_MenuHilite, NULL);
SetAlphaLevels(1.0);
glBegin(GL_QUADS);
glVertex2i(item_left, item_top);
glVertex2i(item_right, item_top);
glVertex2i(item_right, item_bottom);
glVertex2i(item_left, item_bottom);
glEnd();
}
// Draw the text for the menu item, taking into account
// disabling as a color.
float text[3];
SetupAmbientColor(pmenu->enabled[n] ? xpColor_MenuText : xpColor_MenuTextDisabled, text);
int XPlaneVersion, XPLMVersion, HostID;
XPLMGetVersions(&XPlaneVersion, &XPLMVersion, &HostID);
int yOffset = 2;
if (XPlaneVersion < 9400)
yOffset = 2;
else
yOffset = 5;
XPLMDrawString(text,
item_left + 18, item_bottom + yOffset,
const_cast<char *>(pmenu->items[n].c_str()), NULL, xplmFont_Menus);
}
}
}
static void XPPopupHandleKeyCB(
XPLMWindowID inWindowID,
char inKey,
XPLMKeyFlags inFlags,
char inVirtualKey,
void * inRefcon,
int losingFocus)
{
// Nothing to do when a key is pressed; popup menus don't use keys.
}
// This is the mouse click handler.
static int XPPopupHandleMouseClickCB(
XPLMWindowID inWindowID,
int x,
int y,
XPLMMouseStatus inMouse,
void * inRefcon)
{
// Normally we do nothing. But when we get an up click we dismiss.
if (inMouse == xplm_MouseUp)
{
XPPopupMenu_t * pmenu = (XPPopupMenu_t *) inRefcon;
int menu_offset = XPItemForHeight(pmenu, x, y);
// If we got an item click and it is not enabled,
// pretend nothing was picked.
if (menu_offset >= 0 && !pmenu->enabled[menu_offset])
menu_offset = -1;
// Call the callback
if (pmenu->function)
pmenu->function(menu_offset, pmenu->ref);
// cleanup
delete pmenu;
XPLMDestroyWindow(inWindowID);
}
return 1;
}
// This routine just has to build the popup and then the window takes care of itself.
static void XPPickPopup(
int inMouseX,
int inMouseY,
const char * inItems,
int inCurrentItem,
XPPopupPick_f inCallback,
void * inRefcon)
{
int screenWidth, screenHeight;
int fontWidth, fontHeight;
screenWidth = 1024;
screenHeight = 768;
XPLMGetFontDimensions(xplmFont_Menus, &fontWidth, &fontHeight, NULL);
// Allocate mem for the structure and build a new window as big as teh screen.
XPPopupMenu_t * info = new XPPopupMenu_t;
XPLMWindowID windID = XPLMCreateWindow(0, screenHeight, screenWidth, 0, 1,
XPPopupDrawWindowCB, XPPopupHandleKeyCB, XPPopupHandleMouseClickCB, info);
if (inCurrentItem < 0) inCurrentItem = 0;
/************ PARSE THE MENU STRING INTO MENU ITEMS **********/
// Parse the itemes into arrays. Remember how tall they are so
// we can calculate the geometry.
std::vector<int> heights;
std::string items(inItems);
while (!items.empty())
{
std::string::size_type split = items.find(';');
if (split == items.npos)
{
split = items.size();
}
std::string item = items.substr(0, split);
if (item == "-")
{
info->items.push_back("-");
info->enabled.push_back(false);
heights.push_back(2);
} else {
if (!item.empty() && item[0] == '(')
{
info->enabled.push_back(false);
info->items.push_back(item.substr(1));
heights.push_back(12);
} else {
info->enabled.push_back(true);
info->items.push_back(item);
heights.push_back(12);
}
}
if (item.size() == items.size())
break;
else
items = items.substr(split+1);
}
/************ PLACE THE ITEMS IN COLUMNS **********/
unsigned int menuWidth = 0;
int leftOff = 0, topOff = 0;
// Calculate the widest menu item anywhere.
for (std::vector<std::string>::iterator iter = info->items.begin(); iter != info->items.end(); ++iter)
if (iter->size() > menuWidth)
menuWidth = iter->size();
menuWidth *= fontWidth;
menuWidth += 35;
int cols = 1;
int itemsInCol = 0;
int maxLen = 0;
int ourItemLeft = 0, ourItemTop = 0;
// Stack up each item, building new columns as necessary.
for( unsigned int i = 0; i < heights.size(); ++i )
{
itemsInCol++;
info->lefts.push_back(leftOff);
info->rights.push_back(leftOff + menuWidth);
info->tops.push_back(topOff);
info->bottoms.push_back(topOff - heights[i]);
if (i == inCurrentItem)
{
ourItemLeft = leftOff;
ourItemTop = topOff;
}
topOff -= heights[i];
if (maxLen > topOff)
maxLen = topOff;
if (topOff < -(screenHeight - 50))
{
itemsInCol = 0;
cols++;
topOff = 0;
leftOff += menuWidth;
info->vstripes.push_back(leftOff);
}
}
// If we built a new column but had no items for it, throw it out.
if (itemsInCol == 0)
{
cols--;
info->vstripes.pop_back();
}
// Now place the window. Make sure to not let it go off screen.
info->window = windID;
info->left = inMouseX - ourItemLeft;
info->top = inMouseY - ourItemTop;
info->right = inMouseX + (menuWidth * cols) - ourItemLeft;
info->bottom = inMouseY + maxLen - ourItemTop;
if (info->right > (screenWidth-10))
{
int deltaLeft = (info->right - (screenWidth-10));
info->right -= deltaLeft;
info->left -= deltaLeft;
}
if (info->left < 10)
{
int deltaRight = 10 - info->left;
info->right += deltaRight;
info->left += deltaRight;
}
if (info->bottom < 10)
{
int deltaUp = 10 - info->bottom;
info->bottom += deltaUp;
info->top += deltaUp;
}
if (info->top > (screenHeight-30))
{
int deltaDown = (info->top - (screenHeight-30));
info->top -= deltaDown;
info->bottom -= deltaDown;
}
info->function = inCallback;
info->ref = inRefcon;
}
#ifndef _WINDOWS
#pragma mark -
#endif
// This routine is called by our popup menu when it is picked; we
// have stored our widget in our refcon, so we save the new choice
// and send a widget message.
static void XPPopupWidgetProc(int inChoice, void * inRefcon)
{
if (inChoice != -1)
{
XPSetWidgetProperty(inRefcon, xpProperty_PopupCurrentItem, inChoice);
XPSendMessageToWidget(inRefcon, xpMessage_PopupNewItemPicked, xpMode_UpChain, (intptr_t) inRefcon, (intptr_t) inChoice);
}
}
// This widget Proc implements the actual button.
static int XPPopupButtonProc(
XPWidgetMessage inMessage,
XPWidgetID inWidget,
intptr_t inParam1,
intptr_t inParam2)
{
// Select if we're in the background.
if (XPUSelectIfNeeded(inMessage, inWidget, inParam1, inParam2, 1/*eat*/)) return 1;
int fh, fv;
int l, t, r, b;
char buf[4096];
XPGetWidgetGeometry(inWidget, &l, &t, &r, &b);
XPLMGetFontDimensions(xplmFont_Basic, &fh, &fv, NULL);
int curItem = XPGetWidgetProperty(inWidget, xpProperty_PopupCurrentItem, NULL);
switch(inMessage) {
case xpMsg_Create:
case xpMsg_DescriptorChanged:
case xpMsg_PropertyChanged:
// If our data changes, reparse our descriptor to change our current item.
if (inMessage != xpMsg_PropertyChanged || inParam1 == xpProperty_PopupCurrentItem)
{
XPGetWidgetDescriptor(inWidget, buf, sizeof(buf));
char * p = buf;
int picksToSkip = curItem;
while (picksToSkip > 0)
{
while (*p && *p != ';') ++p;
if (*p == 0) break;
++p;
--picksToSkip;
}
char * term = p;
while (*term && *term != ';') ++term;
// Store an offset and length of our descriptor that will show as our current text.
XPSetWidgetProperty(inWidget, xpProperty_OffsetToCurrentItem, p - buf);
XPSetWidgetProperty(inWidget, xpProperty_CurrentItemLen, term - p);
XPSetWidgetProperty(inWidget, xpProperty_Enabled, 1);
}
return 1;
case xpMsg_Draw:
{
float white [4];
float gray [4];
int itemOffset = XPGetWidgetProperty(inWidget, xpProperty_OffsetToCurrentItem, NULL);
int itemLen = XPGetWidgetProperty(inWidget, xpProperty_CurrentItemLen, NULL);
// Drawing time. Find the sim version once.
static int sim;
static float firstTime = true;
static int charWidth;
if (firstTime)
{
firstTime = false;
int plugin;
XPLMHostApplicationID id;
XPLMGetVersions(&sim, &plugin, &id);
XPLMGetFontDimensions(xplmFont_Basic, &charWidth, NULL, NULL);
}
// If we are version 7 of the sim, use Sergio's great new popup item.
// Since there is no UI element code for this, we must draw it by hand!
if (sim >= 700)
{
int center = (t + b) / 2;
XPDrawElement( l - 4, center - 13, r + 4, center + 13,
xpElement_PushButton, 0);
} else
// If we are version 6, use a window drag bar as a fake popup button.
XPDrawElement(l+2, b, r-2, t, xpElement_WindowDragBarSmooth, 0);
// Now draw the button label.
int titleLen = XPGetWidgetDescriptor(inWidget, buf, sizeof(buf));
SetupAmbientColor(xpColor_MenuText, white);
SetupAmbientColor(xpColor_MenuTextDisabled, gray);
if (charWidth)
{
int maxCharCapacity = (r - l - 24) / charWidth;
if (itemLen > maxCharCapacity)
itemLen = maxCharCapacity;
}
buf[itemOffset + itemLen] = 0;
if (buf[itemOffset] == '(') ++itemOffset;
titleLen = strlen(buf + itemOffset);
XPLMDrawString(XPGetWidgetProperty(inWidget, xpProperty_Enabled, 0) ? white : gray, l + 4,
(t + b) / 2 - (fv / 2) + 2,
buf + itemOffset, NULL, xplmFont_Basic);
}
return 1;
case xpMsg_MouseDown:
// If the mouse is clicked, do a popup pick.
if (XPGetWidgetProperty(inWidget, xpProperty_Enabled, 0))
{
XPGetWidgetDescriptor(inWidget, buf, sizeof(buf));
XPPickPopup(l, t, buf, XPGetWidgetProperty(inWidget, xpProperty_PopupCurrentItem, NULL),
XPPopupWidgetProc, inWidget);
return 1;
}
default:
return 0;
}
}
// To create a popup, make a new widget with our button proc as the widget proc.
static XPWidgetID XPCreatePopup(
int inLeft,
int inTop,
int inRight,
int inBottom,
int inVisible,
const char * inDescriptor,
XPWidgetID inContainer)
{
return XPCreateCustomWidget(
inLeft,
inTop,
inRight,
inBottom,
inVisible,
inDescriptor,
0,
inContainer,
XPPopupButtonProc);
}
/*------------------------------------------------------------------------*/
