From 8013ce1003d53759a161b39271614f2314530ffa Mon Sep 17 00:00:00 2001 From: Chris Teubert Date: Wed, 22 Oct 2014 15:52:38 -0700 Subject: [PATCH] Initial Version --- C/User Guide (C).txt | 197 +++ C/src/xplaneConnect.c | 644 ++++++++++ C/src/xplaneConnect.h | 78 ++ .../xpcExample.xcodeproj/project.pbxproj | 259 ++++ .../contents.xcworkspacedata | 7 + .../xcshareddata/xpcExample.xccheckout | 46 + .../UserInterfaceState.xcuserstate | Bin 0 -> 25229 bytes .../xcdebugger/Breakpoints_v2.xcbkptlist | 23 + .../xcschemes/xcschememanagement.plist | 22 + .../xcschemes/xpcExample.xcscheme | 86 ++ C/xpcExample/xpcExample/main.cpp | 131 ++ C/xpcExample/xpcExample/xpcExample.1 | 79 ++ Docs/Capability Matrix.xlsx | Bin 0 -> 29387 bytes Docs/Interface Control Document.xlsx | Bin 0 -> 190601 bytes Docs/PBS.pdf | Bin 0 -> 78989 bytes MATLAB/+XPlaneConnect/clearUDPBuffer.m | 40 + MATLAB/+XPlaneConnect/closeUDP.m | 32 + MATLAB/+XPlaneConnect/openUDP.m | 46 + MATLAB/+XPlaneConnect/pauseSim.m | 50 + MATLAB/+XPlaneConnect/readDATA.m | 98 ++ MATLAB/+XPlaneConnect/readUDP.m | 79 ++ MATLAB/+XPlaneConnect/requestDREF.m | 59 + MATLAB/+XPlaneConnect/selectDATA.m | 49 + MATLAB/+XPlaneConnect/sendCTRL.m | 66 + MATLAB/+XPlaneConnect/sendDATA.m | 63 + MATLAB/+XPlaneConnect/sendDREF.m | 63 + MATLAB/+XPlaneConnect/sendPOSI.m | 66 + MATLAB/+XPlaneConnect/sendSTRU.m | 63 + MATLAB/+XPlaneConnect/sendUDP.m | 64 + MATLAB/+XPlaneConnect/setConn.m | 52 + MATLAB/Documentation (MATLAB).html | 122 ++ MATLAB/pages/clearUDPBuffer.html | 37 + MATLAB/pages/closeUDP.html | 36 + MATLAB/pages/openUDP.html | 39 + MATLAB/pages/pauseSim.html | 36 + MATLAB/pages/readDATA.html | 59 + MATLAB/pages/readUDP.html | 43 + MATLAB/pages/requestDREF.html | 37 + MATLAB/pages/selectDATA.html | 39 + MATLAB/pages/sendCTRL.html | 48 + MATLAB/pages/sendDATA.html | 46 + MATLAB/pages/sendDREF.html | 48 + MATLAB/pages/sendPOSI.html | 50 + MATLAB/pages/sendSTRU.html | 39 + MATLAB/pages/sendUDP.html | 39 + MATLAB/pages/setConn.html | 37 + Readme.txt | 67 + license.pdf | Bin 0 -> 123110 bytes xpcPlugin/Mac/xpcPlugin.xpl | Bin 0 -> 48676 bytes .../SDK/CHeaders/Widgets/XPStandardWidgets.h | 580 +++++++++ xpcPlugin/SDK/CHeaders/Widgets/XPUIGraphics.h | 363 ++++++ xpcPlugin/SDK/CHeaders/Widgets/XPWidgetDefs.h | 486 ++++++++ .../SDK/CHeaders/Widgets/XPWidgetUtils.h | 234 ++++ xpcPlugin/SDK/CHeaders/Widgets/XPWidgets.h | 569 +++++++++ .../SDK/CHeaders/Wrappers/XPCBroadcaster.cpp | 56 + .../SDK/CHeaders/Wrappers/XPCBroadcaster.h | 38 + .../SDK/CHeaders/Wrappers/XPCDisplay.cpp | 104 ++ xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.h | 73 ++ .../SDK/CHeaders/Wrappers/XPCListener.cpp | 27 + xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.h | 36 + .../SDK/CHeaders/Wrappers/XPCProcessing.cpp | 52 + .../SDK/CHeaders/Wrappers/XPCProcessing.h | 37 + xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.cpp | 123 ++ xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.h | 84 ++ .../Wrappers/XPCWidgetAttachments.cpp | 267 ++++ .../CHeaders/Wrappers/XPCWidgetAttachments.h | 146 +++ xpcPlugin/SDK/CHeaders/XPLM/XPLMCamera.h | 168 +++ xpcPlugin/SDK/CHeaders/XPLM/XPLMDataAccess.h | 707 +++++++++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMDefs.h | 518 ++++++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMDisplay.h | 760 +++++++++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMGraphics.h | 408 ++++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMMenus.h | 225 ++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMNavigation.h | 376 ++++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMPlanes.h | 258 ++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMPlugin.h | 331 +++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMProcessing.h | 254 ++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMScenery.h | 400 ++++++ xpcPlugin/SDK/CHeaders/XPLM/XPLMUtilities.h | 839 +++++++++++++ .../SDK/Delphi/Widgets/XPStandardWidgets.pas | 497 ++++++++ xpcPlugin/SDK/Delphi/Widgets/XPUIGraphics.pas | 380 ++++++ xpcPlugin/SDK/Delphi/Widgets/XPWidgetDefs.pas | 441 +++++++ .../SDK/Delphi/Widgets/XPWidgetUtils.pas | 225 ++++ xpcPlugin/SDK/Delphi/Widgets/XPWidgets.pas | 665 ++++++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMCamera.pas | 174 +++ xpcPlugin/SDK/Delphi/XPLM/XPLMDataAccess.pas | 764 ++++++++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMDefs.pas | 446 +++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMDisplay.pas | 835 +++++++++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMGraphics.pas | 441 +++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMMenus.pas | 259 ++++ xpcPlugin/SDK/Delphi/XPLM/XPLMNavigation.pas | 434 +++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMPlanes.pas | 294 +++++ xpcPlugin/SDK/Delphi/XPLM/XPLMPlugin.pas | 381 ++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMProcessing.pas | 276 ++++ xpcPlugin/SDK/Delphi/XPLM/XPLMScenery.pas | 419 +++++++ xpcPlugin/SDK/Delphi/XPLM/XPLMUtilities.pas | 927 ++++++++++++++ .../SDK/Libraries/Mac/XPLM.framework/XPLM | Bin 0 -> 650652 bytes .../Mac/XPWidgets.framework/XPWidgets | Bin 0 -> 210904 bytes xpcPlugin/SDK/Libraries/Win/XPLM.lib | Bin 0 -> 39362 bytes xpcPlugin/SDK/Libraries/Win/XPLM_64.lib | Bin 0 -> 39060 bytes xpcPlugin/SDK/Libraries/Win/XPWidgets.lib | Bin 0 -> 10524 bytes xpcPlugin/SDK/Libraries/Win/XPWidgets_64.lib | Bin 0 -> 10564 bytes xpcPlugin/SDK/README.txt | 192 +++ xpcPlugin/SDK/license.txt | 27 + xpcPlugin/Win/xpcPlugin.xpl | Bin 0 -> 84992 bytes xpcPlugin/XPCPlugin.cpp | 1108 +++++++++++++++++ .../DerivedSources/xpcPlugin_vers.c | 1 + .../Objects-normal/x86_64/XPCPlugin.d | 7 + .../Objects-normal/x86_64/XPCPlugin.dia | Bin 0 -> 736 bytes .../Objects-normal/x86_64/XPCPlugin.o | Bin 0 -> 45756 bytes .../x86_64/xpcPlugin.LinkFileList | 4 + .../Objects-normal/x86_64/xpcPluginTools.d | 5 + .../Objects-normal/x86_64/xpcPluginTools.dia | Bin 0 -> 220 bytes .../Objects-normal/x86_64/xpcPluginTools.o | Bin 0 -> 29484 bytes .../x86_64/xpcPlugin_dependency_info.dat | Bin 0 -> 15163 bytes .../Objects-normal/x86_64/xpcPlugin_vers.d | 2 + .../Objects-normal/x86_64/xpcPlugin_vers.dia | Bin 0 -> 220 bytes .../Objects-normal/x86_64/xpcPlugin_vers.o | Bin 0 -> 2768 bytes .../Objects-normal/x86_64/xplaneConnect.d | 3 + .../Objects-normal/x86_64/xplaneConnect.dia | Bin 0 -> 220 bytes .../Objects-normal/x86_64/xplaneConnect.o | Bin 0 -> 29224 bytes .../Debug/xpcPlugin.build/build-state.dat | 320 +++++ .../xpcPlugin-all-target-headers.hmap | Bin 0 -> 793 bytes .../xpcPlugin-generated-files.hmap | Bin 0 -> 275 bytes .../xpcPlugin-own-target-headers.hmap | Bin 0 -> 793 bytes .../xpcPlugin-project-headers.hmap | Bin 0 -> 937 bytes .../Debug/xpcPlugin.build/xpcPlugin.dep | 10 + .../Debug/xpcPlugin.build/xpcPlugin.hmap | Bin 0 -> 1846 bytes xpcPlugin/xpcPlugin.xcodeproj/project.pbxproj | 384 ++++++ .../contents.xcworkspacedata | 7 + .../xcshareddata/project.xccheckout | 46 + .../xcshareddata/xpcPlugin.xccheckout | 46 + .../UserInterfaceState.xcuserstate | Bin 0 -> 127694 bytes .../WorkspaceSettings.xcsettings | 8 + .../xcdebugger/Breakpoints_v2.xcbkptlist | 21 + .../xcschemes/xcschememanagement.plist | 22 + .../xcschemes/xpcPlugin.xcscheme | 59 + xpcPlugin/xpcPlugin.xpl | Bin 0 -> 42268 bytes xpcPlugin/xpcPlugin/xpcPlugin.opensdf | Bin 0 -> 40 bytes xpcPlugin/xpcPlugin/xpcPlugin.sdf | Bin 0 -> 29753344 bytes xpcPlugin/xpcPlugin/xpcPlugin.sln | 28 + xpcPlugin/xpcPlugin/xpcPlugin.v12.suo | Bin 0 -> 49152 bytes .../x64/Debug/xpcPlugin.Build.CppClean.log | 15 + .../xpcPlugin/x64/Debug/xpcPlugin.log | 19 + .../x64/Debug/xpcPlugin.tlog/CL.read.1.tlog | Bin 0 -> 62002 bytes .../Debug/xpcPlugin.tlog/cl.command.1.tlog | Bin 0 -> 2966 bytes .../Debug/xpcPlugin.tlog/unsuccessfulbuild | 0 .../xpcPlugin.tlog/xpcPlugin.lastbuildstate | 2 + .../xpcPlugin/x64/Debug/xplaneConnect.obj | Bin 0 -> 92032 bytes .../xpcPlugin/xpcPlugin/xpcPlugin.vcxproj | 189 +++ .../xpcPlugin/xpcPlugin.vcxproj.filters | 50 + .../xpcPlugin/xpcPlugin.vcxproj.user | 11 + xpcPlugin/xpcPluginTools.cpp | 515 ++++++++ xpcPlugin/xpcPluginTools.h | 50 + 153 files changed, 22812 insertions(+) create mode 100644 C/User Guide (C).txt create mode 100644 C/src/xplaneConnect.c create mode 100644 C/src/xplaneConnect.h create mode 100644 C/xpcExample/xpcExample.xcodeproj/project.pbxproj create mode 100644 C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata create mode 100644 C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcshareddata/xpcExample.xccheckout create mode 100644 C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcuserdata/cteubert.xcuserdatad/UserInterfaceState.xcuserstate create mode 100644 C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist create mode 100644 C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xcschememanagement.plist create mode 100644 C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xpcExample.xcscheme create mode 100644 C/xpcExample/xpcExample/main.cpp create mode 100644 C/xpcExample/xpcExample/xpcExample.1 create mode 100644 Docs/Capability Matrix.xlsx create mode 100644 Docs/Interface Control Document.xlsx create mode 100644 Docs/PBS.pdf create mode 100644 MATLAB/+XPlaneConnect/clearUDPBuffer.m create mode 100644 MATLAB/+XPlaneConnect/closeUDP.m create mode 100644 MATLAB/+XPlaneConnect/openUDP.m create mode 100644 MATLAB/+XPlaneConnect/pauseSim.m create mode 100644 MATLAB/+XPlaneConnect/readDATA.m create mode 100644 MATLAB/+XPlaneConnect/readUDP.m create mode 100644 MATLAB/+XPlaneConnect/requestDREF.m create mode 100644 MATLAB/+XPlaneConnect/selectDATA.m create mode 100644 MATLAB/+XPlaneConnect/sendCTRL.m create mode 100644 MATLAB/+XPlaneConnect/sendDATA.m create mode 100644 MATLAB/+XPlaneConnect/sendDREF.m create mode 100644 MATLAB/+XPlaneConnect/sendPOSI.m create mode 100644 MATLAB/+XPlaneConnect/sendSTRU.m create mode 100644 MATLAB/+XPlaneConnect/sendUDP.m create mode 100644 MATLAB/+XPlaneConnect/setConn.m create mode 100644 MATLAB/Documentation (MATLAB).html create mode 100644 MATLAB/pages/clearUDPBuffer.html create mode 100644 MATLAB/pages/closeUDP.html create mode 100644 MATLAB/pages/openUDP.html create mode 100644 MATLAB/pages/pauseSim.html create mode 100644 MATLAB/pages/readDATA.html create mode 100644 MATLAB/pages/readUDP.html create mode 100644 MATLAB/pages/requestDREF.html create mode 100644 MATLAB/pages/selectDATA.html create mode 100644 MATLAB/pages/sendCTRL.html create mode 100644 MATLAB/pages/sendDATA.html create mode 100644 MATLAB/pages/sendDREF.html create mode 100644 MATLAB/pages/sendPOSI.html create mode 100644 MATLAB/pages/sendSTRU.html create mode 100644 MATLAB/pages/sendUDP.html create mode 100644 MATLAB/pages/setConn.html create mode 100644 Readme.txt create mode 100644 license.pdf create mode 100755 xpcPlugin/Mac/xpcPlugin.xpl create mode 100755 xpcPlugin/SDK/CHeaders/Widgets/XPStandardWidgets.h create mode 100755 xpcPlugin/SDK/CHeaders/Widgets/XPUIGraphics.h create mode 100755 xpcPlugin/SDK/CHeaders/Widgets/XPWidgetDefs.h create mode 100755 xpcPlugin/SDK/CHeaders/Widgets/XPWidgetUtils.h create mode 100755 xpcPlugin/SDK/CHeaders/Widgets/XPWidgets.h create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.cpp create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.h create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.cpp create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.h create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.cpp create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.h create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.cpp create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.h create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.cpp create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.h create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.cpp create mode 100755 xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMCamera.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMDataAccess.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMDefs.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMDisplay.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMGraphics.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMMenus.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMNavigation.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMPlanes.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMPlugin.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMProcessing.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMScenery.h create mode 100755 xpcPlugin/SDK/CHeaders/XPLM/XPLMUtilities.h create mode 100755 xpcPlugin/SDK/Delphi/Widgets/XPStandardWidgets.pas create mode 100755 xpcPlugin/SDK/Delphi/Widgets/XPUIGraphics.pas create mode 100755 xpcPlugin/SDK/Delphi/Widgets/XPWidgetDefs.pas create mode 100755 xpcPlugin/SDK/Delphi/Widgets/XPWidgetUtils.pas create mode 100755 xpcPlugin/SDK/Delphi/Widgets/XPWidgets.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMCamera.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMDataAccess.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMDefs.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMDisplay.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMGraphics.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMMenus.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMNavigation.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMPlanes.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMPlugin.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMProcessing.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMScenery.pas create mode 100755 xpcPlugin/SDK/Delphi/XPLM/XPLMUtilities.pas create mode 100755 xpcPlugin/SDK/Libraries/Mac/XPLM.framework/XPLM create mode 100755 xpcPlugin/SDK/Libraries/Mac/XPWidgets.framework/XPWidgets create mode 100755 xpcPlugin/SDK/Libraries/Win/XPLM.lib create mode 100755 xpcPlugin/SDK/Libraries/Win/XPLM_64.lib create mode 100755 xpcPlugin/SDK/Libraries/Win/XPWidgets.lib create mode 100755 xpcPlugin/SDK/Libraries/Win/XPWidgets_64.lib create mode 100755 xpcPlugin/SDK/README.txt create mode 100755 xpcPlugin/SDK/license.txt create mode 100755 xpcPlugin/Win/xpcPlugin.xpl create mode 100755 xpcPlugin/XPCPlugin.cpp create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/DerivedSources/xpcPlugin_vers.c create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/XPCPlugin.d create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/XPCPlugin.dia create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/XPCPlugin.o create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPlugin.LinkFileList create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPluginTools.d create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPluginTools.dia create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPluginTools.o create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPlugin_dependency_info.dat create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPlugin_vers.d create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPlugin_vers.dia create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xpcPlugin_vers.o create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xplaneConnect.d create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xplaneConnect.dia create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/Objects-normal/x86_64/xplaneConnect.o create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/build-state.dat create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/xpcPlugin-all-target-headers.hmap create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/xpcPlugin-generated-files.hmap create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/xpcPlugin-own-target-headers.hmap create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/xpcPlugin-project-headers.hmap create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/xpcPlugin.dep create mode 100644 xpcPlugin/build/xpcPlugin.build/Debug/xpcPlugin.build/xpcPlugin.hmap create mode 100755 xpcPlugin/xpcPlugin.xcodeproj/project.pbxproj create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/project.xcworkspace/contents.xcworkspacedata create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/project.xcworkspace/xcshareddata/project.xccheckout create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/project.xcworkspace/xcshareddata/xpcPlugin.xccheckout create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/project.xcworkspace/xcuserdata/cteubert.xcuserdatad/UserInterfaceState.xcuserstate create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/project.xcworkspace/xcuserdata/cteubert.xcuserdatad/WorkspaceSettings.xcsettings create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xcschememanagement.plist create mode 100644 xpcPlugin/xpcPlugin.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xpcPlugin.xcscheme create mode 100755 xpcPlugin/xpcPlugin.xpl create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin.opensdf create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin.sdf create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin.sln create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin.v12.suo create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xpcPlugin.Build.CppClean.log create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xpcPlugin.log create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xpcPlugin.tlog/CL.read.1.tlog create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xpcPlugin.tlog/cl.command.1.tlog create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xpcPlugin.tlog/unsuccessfulbuild create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xpcPlugin.tlog/xpcPlugin.lastbuildstate create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/x64/Debug/xplaneConnect.obj create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/xpcPlugin.vcxproj create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/xpcPlugin.vcxproj.filters create mode 100644 xpcPlugin/xpcPlugin/xpcPlugin/xpcPlugin.vcxproj.user create mode 100644 xpcPlugin/xpcPluginTools.cpp create mode 100644 xpcPlugin/xpcPluginTools.h diff --git a/C/User Guide (C).txt b/C/User Guide (C).txt new file mode 100644 index 0000000..b1fc80f --- /dev/null +++ b/C/User Guide (C).txt @@ -0,0 +1,197 @@ +X-Plane Connect-C (XPC-C) Readme +XPC-C V0.22 May 21, 2014 + +DESCRIPTION + XPC-C is a series of C functions that facilitate communication with X-Plane. + +----------------------------------- +SETUP + Before using XPC Functions you must + 1. Copy the file XPCPlugin.xpl to the "[X-Plane Directory]/Resources/plugins" directory. + 2. Put in X-Plane CD 1 or X-Plane USB Key. + 3. Start X-Plane. + 4. #include "xplaneConnect.h" + +----------------------------------- +BASIC FUNCTIONS + 1. openUDP opens a UDP Socket for communication. This is used to send data or receive. + INPUT: + port (unsigned short): Port Number (ex:49067) + xpIP (char *): IP Address of the computer running x-plane + xpPort (unsigned short): Port number that the X-Plane/ xpcPlugin Receives on (send -1 for default (49009), Typically xpcPlugin is 49009) + + OUTPUT: + socket (xpcSocket): The Opened Socket + + USE: + unsigned short portNumber = 49067; + struct xpcSocket theSocket = openUDP(portNumber); + + 2. closeUDP closes an opened UDP Socket for communication. This is to be done after the program has finished using that socket. Use opedUDP to open socket. + INPUT: + socket (xpcSocket): The Opened Socket + + USE: + closeUDP(theSocket); + + 3. setCONN sets the return port for requested datarefs. + INPUT: + socket (xpcSocket): Socket to use to send the command + recPort (unsigned Short): Port number for requested dataref values to be sent to + + OUTPUT: + status (short): 0 if successful + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + setCONN(theSocket,IP,49009,49022); // Sets receive address to 49022; + + 4. pauseSim pauses/resumes the x-plane simulation + INPUT: + socket (xpcSocket): Socket to use to send the command + pause (short): 1=Pause, 0=Resume + + OUTPUT: + status (short): 0 if successful + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + pauseSim(theSocket, IP, 49009, 1); + + 5. sendDATA set the value of a state in the "DATA Input & Output" Table + INPUT: + socket (xpcSocket): Socket to use to send the command + dataArray (float[][9]): Array of data to be sent. The first element of each row is the item # (corresponding to the number on the X-Plane "DATA Input & Output" Screen). Send -999 to leave the value unchanged. + rows (unsigned short): Number of rows of data being sent + + OUTPUT: + status (short): 0 if successful + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + float data[] = {{14, 1, -999, -999, -999, -999, -999, -999, -999},{25, 0.8, 0.8, -999, -999, -999, -999, -999, -999}}; // Gear and Throttle + sendDATA(theSocket,IP,49009,data,2); + + 6. sendPOSI set the position of an aircraft + INPUT: + socket (xpcSocket): Socket to use to send the command + ACNum (short): Number of aircraft to be moved, use 0 for main aircraft (ownPlane). + numArgs (short): Number of Arguments to be sent (size of position array) + position (float []): Arguments corresponding to aircrafts position + position[0] = Latitude + position[1] = Longitude + position[2] = Altitude (m MSL) + position[3] = Roll (deg) + position[4] = Pitch (deg) + position[5] = True Heading (deg) + position[6] = Gear (0=up, 1=down) + + OUTPUT: + status (short): 0 if successful + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + float posit[] = {37.5242422, -122.06899, 2500, 0, 0, 0, 1}; + sendPOSI(theSocket, IP, 49009, 7, posit); + + 7. sendCTRL send control commands to the aircraft + INPUT: + socket (xpcSocket): Socket to use to send the command + numArgs (short): Number of Arguments to be sent (size of control array) + control (float []): Arguments corresponding to aircraft control command + control[0] = Latitudinal Stick [-1,1] + control[1] = Longitudinal Stick [-1,1] + control[2] = Pedal [-1, 1] + control[3] = Throttle [-1, 1] + control[4] = Gear (0=up, 1=down) + control[5] = Flaps [0, 1] + + OUTPUT: + status (short): 0 if successful + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + float ctrl[] = {0, 0, 0, 0.8, 0, 1}; + sendCTRL(theSocket, IP, 49009, 6, ctrl); + + 8. sendDREF set the value of a specific dataref. Dataref list found at http://www.xsquawkbox.net/xpsdk/docs/DataRefs.html + INPUT: + socket (xpcSocket): Socket to use to send the command + dataRef (char *): Dataref to be set (with or without "sim/" preceeding it) + length (short): length of dataref string + values (float *): Array of values to be sent + length2 (short): Number of values in values array + + OUTPUT: + status (short): 0 if successful + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + char theDREF[] = "cockpit/switches/gear_handle_status"; + float value = 1; + sendDREF(theSocket, IP, 49009, theDREF, strlen(theDREF), &value, 1); + + 9. requestDREF Request the value of specific dref(s). Dataref list found at http://www.xsquawkbox.net/xpsdk/docs/DataRefs.html + INPUT: + outSocket (xpcSocket): Socket to use to send the command + inSocket (xpcSocket): Socket to use to send the command + DREFArray (char[][100]): Array of DataRefs to be requested + DREFSizes (int[]): Array of string lengths for each DataRef in DREFArray + listLength (short): Number of DataRefs in DREFArray + result (*float[]): Array of pointers to the values returned + arrayLen (short[]): Array where each element corresponds to the number of elements in the float array. + + OUTPUT: + length (short): Number of Values Returned + + USE: + char IP[16] = "127.0.0.1"; + struct xpcSocket theSocket = openUDP(49067); + char DREFArray[][100] = {"sim/cockpit/switches/gear_handle_status"}; + requestDREF(theSocket, IP, 49009, DREFArray, strlen(DREFArray[0]),1); + +----------------------------------- +ADVANCED FUNCTIONS (These are mostly used by the xpcPlugin to read requests) + 1. sendUDP + 2. readUDP + 3. readDATA + 4. parseDATA + 5. readPOSI + 6. parsePOSI + 7. readCTRL + 8. parseCTRL + 9. readRequest + 10. parseRequest + 11. parseDREF + 12. readDREF + +----------------------------------- +PLANNED FUNCTIONS + 1. sendVIEW + 2. parseVIEW + 3. readVIEW + 4. sendWYPT + 5. parseWYPT + 6. readWYPT + 7. selectDATA + 8. sendTEXT + 9. readTEXT + 10. parseTEXT + +----------------------------------- +CONTACT + Email Christopher Teubert (christopher.a.teubert@nasa.gov) with any questions. + +----------------------------------- +VERSION HISTORY + 2014.05.23 (V0.22): (CT) Combined request/readDREF + 2014.05.21 (V0.21): (CT) Initial Version + +CONTRIBUTORS + CT: Christopher Teubert (christopher.a.teubert@nasa.gov) diff --git a/C/src/xplaneConnect.c b/C/src/xplaneConnect.c new file mode 100644 index 0000000..315d0b7 --- /dev/null +++ b/C/src/xplaneConnect.c @@ -0,0 +1,644 @@ +// +// xPlaneConnect.c Version 0.25 Beta +// +// DESCRIPTION +// XPLANECONNECT (XPC) Facilitates Communication to and from the XPCPlugin +// +// REQUIREMENTS +// 1. X-Plane Version 9.0 or newer (untested on previous versions) +// 2. XPCPlugin.xpl-must be placed in [X-Plane Directory]/Resources/plugins +// 3. OS X 10.8 or newer (untested on previous versions) +// +// INSTRUCTIONS +// 1. Include the header "xplaneConnect.h" +// EXAMPLE: #include "xplaneConnect.h" +// 2. Open UDP Socket using openUDP +// EXAMPLE: struct xpcSocket theSocket = openUDP(port_number); +// NOTE: Do not send/receive on the same socket +// 3. Use functions described below +// 4. Close UDP Socket using closeUDP +// +// NOTICES: +// Copyright ã 2013-2014 United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All Rights Reserved. +// +// DISCLAIMERS +// No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS." +// +// Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT. +// +// X-Plane API +// Copyright (c) 2008, Sandy Barbour and Ben Supnik All rights reserved. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +// * Neither the names of the authors nor that of X-Plane or Laminar Research may be used to endorse or promote products derived from this software without specific prior written permission from the authors or Laminar Research, respectively. +// +// X-Plane API SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// CONTACT +// For questions email Christopher Teubert (christopher.a.teubert@nasa.gov) +// +// VERSION HISTORY +// 06.24.14 (V0.23): (CT) General Fixes for Windows compatability +// 05.23.14 (V0.22): (CT) Combined request/readDREF +// -fixed readPOSI (gear issue) +// 05.21.14 (V0.2175): (CT) Added Throttle to CTRL +// 05.12.14 (V0.215): (CT) Read/Parse/Send Control +// 05.07.14 (V0.21): (CT) Read/Parse/Send Position +// 04.29.14 (V0.205): (CT) Added check that data was received in read functions +// 03.15.14 (V0.2): (CT) General performance updates, added preconditions +// 02.04.14 (V0.11): (CT) Fixed problem that caused for loops not to work with some compilers. General Stability Improvements, added readRequest, readDREF +// 01.27.14 (V0.1): (CT) First Beta: sendDATA, sendDREF, requestDREF, pauseSim, readDATA +// 11.10.13 (V0.0): (CT) First Version +// +// CONTRIBUTORS +// CT: Christopher Teubert (christopher.a.teubert@nasa.gov) +// +// TO DO +// 1. Update SelectData +// 2. RequestDREF: look into removing DREFSizes +// +// BEGIN CODE + +#include +#include +#include +#include +#include +#include +#include +#include "xplaneConnect.h" + +#ifdef _WIN32 /* WIN32 SYSTEM */ + #include + #define strcasecmp _stricmp + #define strncasecmp _strnicmp + #define snprintf sprintf_s + #define socklen_t int + + void usleep(__int64 usec) + { // From http://www.c-plusplus.de/forum/109539-full + HANDLE timer; + LARGE_INTEGER ft; + + ft.QuadPart = -(10*usec); // Convert to 100 nanosecond interval, negative value indicates relative time + + timer = CreateWaitableTimer(NULL, TRUE, NULL); + SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0); + WaitForSingleObject(timer, INFINITE); + CloseHandle(timer); + } +#endif + +short errorReport(char *functionName, char *errorMessage); +short sendRequest(struct xpcSocket recfd, char DREFArray[][100], short DREFSizes[], short listLength); + +short errorReport(char *functionName, char *errorMessage) +{ + printf("ERROR: %s-%s\n", functionName, errorMessage); + return -1; +} + +struct xpcSocket openUDP(unsigned short port_number, const char *xpIP, unsigned short xpPort) +{ + struct xpcSocket theSocket; + struct sockaddr_in server; + +#if (__APPLE__ || __linux) + struct timeval tv; +#endif + + // Setup Port + server.sin_family = AF_INET; + server.sin_addr.s_addr = INADDR_ANY; + server.sin_port = htons(port_number); + + // Set X-Plane Port and IP + if (strcasecmp(xpIP,"localhost") == 0) // IP + { + strncpy(theSocket.xpIP,"127.0.0.1",9); // Default + } + else + { + memcpy(theSocket.xpIP,xpIP,(size_t) fminl(strlen(xpIP),16)); + } + + if (xpPort <= 0) // Default Port + { + theSocket.xpPort = 49009; // Default + } + else + { + theSocket.xpPort = xpPort; + } + +#ifdef _WIN32 + WSADATA wsa; + if (WSAStartup(MAKEWORD(2,2),&wsa) != 0) + { + perror("ERROR: openUDP- "); + return theSocket; + //ERROR IN Socket Message + } + + if ((theSocket.sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET) + { + perror("ERROR: openUDP- "); + return theSocket; + //ERROR IN Socket Message + } + + if (bind(theSocket.sock, (struct sockaddr *)&server, sizeof(server)) == SOCKET_ERROR) + { + perror("ERROR: openUDP- "); + return theSocket; + //ERROR IN Socket Message + } +#elif (__APPLE__ || __linux) + // Create a SOCKET + theSocket.sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + if ((theSocket.sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) + { + perror((char*) "ERROR: openUDP- "); + return theSocket; + } + + //Bind + if ( bind(theSocket.sock, (struct sockaddr *) &server, sizeof(server)) == -1) + { + perror( (char*) "ERROR: openUDP- "); + return theSocket; + } +#endif + + //Set Timout + int msTimeOut = 500; + +#ifdef _WIN32 + DWORD msTimeOutWin = 1; + setsockopt(theSocket.sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&msTimeOutWin, sizeof(msTimeOutWin)); +#else + tv.tv_sec = 0; /* Sec Timeout */ + tv.tv_usec = msTimeOut; // Microsec Timeout + setsockopt(theSocket.sock, SOL_SOCKET, SO_RCVTIMEO, (char *) &tv, sizeof(struct timeval)); +#endif + + return theSocket; +} + +void closeUDP(struct xpcSocket socketNumber) +{ +#ifdef _WIN32 + closesocket(socketNumber.sock); +#elif (__APPLE__ || __linux) + close(socketNumber.sock); +#endif +} + +short sendUDP(struct xpcSocket recfd, char my_message[], short messageLength) +{ + struct sockaddr_in servaddr; + + my_message[4] = (char) messageLength; + + // Preconditions + if (messageLength <= 0)// Positive Message Length + { + return errorReport("sendUDP", "message length must be positive >0"); + } + + // Code + servaddr.sin_family = AF_INET; + servaddr.sin_port = htons(recfd.xpPort); + servaddr.sin_addr.s_addr = inet_addr(recfd.xpIP); + +#ifdef _WIN32 + const char on = 1; +#else + int on=1; +#endif + + setsockopt(recfd.sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)); + + if (sendto(recfd.sock, my_message, (int) messageLength, 0, (const struct sockaddr *) &servaddr, sizeof(servaddr))<0) + { + perror("ERROR: sendUDP-"); + exit(EXIT_FAILURE); + } + + return 0; +} + +short sendDATA(struct xpcSocket recfd, float dataRef[][9], unsigned short rows) +{ + int i; + unsigned short length = rows*9*sizeof(float) + 5; + char message[5000]; + unsigned short step = 9*sizeof(float); + + strncpy(message,"DATA",4); + + for (i=0;i 1) realloc(resultArray[i],arraySizes[i]); + + for (j=0; j< arraySizes[i]; j++) + { + memcpy(tmp,&my_message[place+1],sizeof(float)); + data[j] = *tmp; + } + + resultArray[i] = malloc(arraySizes[i]*sizeof(float)); + + memcpy(resultArray[i],&data,arraySizes[i]*sizeof(float)); + place += 1 + arraySizes[i]*sizeof(float); + } + + free(tmp); + return count; +} + +short parsePOSI(const char my_message[], float resultArray[], int arraySize, float *gear) +{ + int i; + + // Input Validation + if (arraySize < 1) return -1; + + memcpy(gear,&my_message[30],4); + + for (i=0; (i + #include + #pragma comment(lib,"ws2_32.lib") //Winsock Library + #elif (__APPLE__ || __linux) + #include + #include + #include + #include + #endif + + struct xpcSocket { + short open; + unsigned short port; + + // X-Plane IP and Port + char xpIP[16]; + unsigned short xpPort; + + #ifdef _WIN32 /* WIN32 SYSTEM */ + SOCKET sock; + #elif (__APPLE__ || __linux) //OS X/Linux + int sock; + #endif + }; + + // Basic Functions + struct xpcSocket openUDP(unsigned short port, const char *xpIP, unsigned short xpPort); + void closeUDP(struct xpcSocket); + short sendUDP(struct xpcSocket recfd, char my_message[], short messageLength); + int readUDP(struct xpcSocket recfd, char *dataRef, struct sockaddr *recvaddr); + + // Configuration + short setCONN(struct xpcSocket recfd, unsigned short recPort); + short pauseSim(struct xpcSocket recfd, short); + + // UDP DATA + short parseDATA(const char my_message[], short messageLength, float dataRef[][9]); + short readDATA(struct xpcSocket recfd, float dataRef[][9]); + short sendDATA(struct xpcSocket recfd, float dataRef[][9], unsigned short rows); + + // Position + short parsePOSI(const char my_message[], float resultArray[], int arraySize, float *gear); + short readPOSI(struct xpcSocket recfd, float resultArray[], int arraySize, float *gear); + short sendPOSI(struct xpcSocket recfd, short ACNum, short numArgs, float valueArray[]); + + // Controls + float parseCTRL(const char my_message[], float resultArray[4], short *gear); + float readCTRL(struct xpcSocket recfd, float resultArray[4], short *gear); + short sendCTRL(struct xpcSocket recfd, short numArgs, float valueArray[]); + + // DREF Manipulation + short readDREF(struct xpcSocket recfd, float *resultArray[], short arraySizes[]); + short parseDREF(const char my_message[], char *dataRef, unsigned short *length_of_DREF, float *values, unsigned short *number_of_values); + short sendDREF(struct xpcSocket recfd, const char *dataRef, unsigned short length_of_DREF, float *values, unsigned short number_of_values); + short requestDREF(struct xpcSocket sendfd, struct xpcSocket recfd, char DREFArray[][100], short DREFSizes[], short listLength, float *resultArray[], short arraySizes[]); + int parseGETD(const char my_message[], char *DREFArray[], int DREFSizes[]); + short parseRequest(const char my_message[], float *resultArray[], short arraySizes[]); + short readRequest(struct xpcSocket recfd, float *dataRef[], short arraySizes[], struct sockaddr *recvaddr); + + #endif //ifdef _h + +#ifdef __cplusplus + } +#endif diff --git a/C/xpcExample/xpcExample.xcodeproj/project.pbxproj b/C/xpcExample/xpcExample.xcodeproj/project.pbxproj new file mode 100644 index 0000000..3028f4e --- /dev/null +++ b/C/xpcExample/xpcExample.xcodeproj/project.pbxproj @@ -0,0 +1,259 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + BEDC620118EDF0F5005DB364 /* xplaneConnect.c in Sources */ = {isa = PBXBuildFile; fileRef = BEDC61FF18EDF0F5005DB364 /* xplaneConnect.c */; }; + BEDC620818EDF254005DB364 /* xplaneConnect.c in CopyFiles */ = {isa = PBXBuildFile; fileRef = BEDC61FF18EDF0F5005DB364 /* xplaneConnect.c */; }; + BEDC620918EDF257005DB364 /* xplaneConnect.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = BEDC620018EDF0F5005DB364 /* xplaneConnect.h */; }; + BEF9890F18E4E7F7005554D1 /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BEF9890E18E4E7F7005554D1 /* main.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXCopyFilesBuildPhase section */ + BE60308318E5F7A5004B5E1D /* CopyFiles */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 12; + dstPath = /Users/cteubert/Documents/flightdeckz/connections/src/xplaneconnect; + dstSubfolderSpec = 0; + files = ( + BEDC620818EDF254005DB364 /* xplaneConnect.c in CopyFiles */, + BEDC620918EDF257005DB364 /* xplaneConnect.h in CopyFiles */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + BEDC61FF18EDF0F5005DB364 /* xplaneConnect.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xplaneConnect.c; path = ../src/xplaneConnect.c; sourceTree = ""; }; + BEDC620018EDF0F5005DB364 /* xplaneConnect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = xplaneConnect.h; path = ../src/xplaneConnect.h; sourceTree = ""; }; + BEF9890B18E4E7F7005554D1 /* xpcExample */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = xpcExample; sourceTree = BUILT_PRODUCTS_DIR; }; + BEF9890E18E4E7F7005554D1 /* main.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + BEF9890818E4E7F7005554D1 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + BE60308618E5F980004B5E1D /* xplaneConnect */ = { + isa = PBXGroup; + children = ( + BEDC61FF18EDF0F5005DB364 /* xplaneConnect.c */, + BEDC620018EDF0F5005DB364 /* xplaneConnect.h */, + ); + name = xplaneConnect; + sourceTree = ""; + }; + BEF9890218E4E7F7005554D1 = { + isa = PBXGroup; + children = ( + BEF9890D18E4E7F7005554D1 /* xpcExample */, + BE60308618E5F980004B5E1D /* xplaneConnect */, + BEF9890C18E4E7F7005554D1 /* Products */, + ); + sourceTree = ""; + }; + BEF9890C18E4E7F7005554D1 /* Products */ = { + isa = PBXGroup; + children = ( + BEF9890B18E4E7F7005554D1 /* xpcExample */, + ); + name = Products; + sourceTree = ""; + }; + BEF9890D18E4E7F7005554D1 /* xpcExample */ = { + isa = PBXGroup; + children = ( + BEF9890E18E4E7F7005554D1 /* main.cpp */, + ); + path = xpcExample; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + BEF9890A18E4E7F7005554D1 /* xpcExample */ = { + isa = PBXNativeTarget; + buildConfigurationList = BEF9891418E4E7F7005554D1 /* Build configuration list for PBXNativeTarget "xpcExample" */; + buildPhases = ( + BEF9890718E4E7F7005554D1 /* Sources */, + BEF9890818E4E7F7005554D1 /* Frameworks */, + BE60308318E5F7A5004B5E1D /* CopyFiles */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = xpcExample; + productName = xpcExample; + productReference = BEF9890B18E4E7F7005554D1 /* xpcExample */; + productType = "com.apple.product-type.tool"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + BEF9890318E4E7F7005554D1 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 0500; + ORGANIZATIONNAME = "Chris Teubert"; + }; + buildConfigurationList = BEF9890618E4E7F7005554D1 /* Build configuration list for PBXProject "xpcExample" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = BEF9890218E4E7F7005554D1; + productRefGroup = BEF9890C18E4E7F7005554D1 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + BEF9890A18E4E7F7005554D1 /* xpcExample */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + BEF9890718E4E7F7005554D1 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + BEDC620118EDF0F5005DB364 /* xplaneConnect.c in Sources */, + BEF9890F18E4E7F7005554D1 /* main.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + BEF9891218E4E7F7005554D1 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.8; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + }; + name = Debug; + }; + BEF9891318E4E7F7005554D1 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.8; + SDKROOT = macosx; + }; + name = Release; + }; + BEF9891518E4E7F7005554D1 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include, + /Users/cteubert/Documents/xplaneconnect/xpcPlugin, + ); + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + BEF9891618E4E7F7005554D1 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include, + /Users/cteubert/Documents/xplaneconnect/xpcPlugin, + ); + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + BEF9890618E4E7F7005554D1 /* Build configuration list for PBXProject "xpcExample" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + BEF9891218E4E7F7005554D1 /* Debug */, + BEF9891318E4E7F7005554D1 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + BEF9891418E4E7F7005554D1 /* Build configuration list for PBXNativeTarget "xpcExample" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + BEF9891518E4E7F7005554D1 /* Debug */, + BEF9891618E4E7F7005554D1 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = BEF9890318E4E7F7005554D1 /* Project object */; +} diff --git a/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..5a088f7 --- /dev/null +++ b/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcshareddata/xpcExample.xccheckout b/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcshareddata/xpcExample.xccheckout new file mode 100644 index 0000000..e5d6193 --- /dev/null +++ b/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcshareddata/xpcExample.xccheckout @@ -0,0 +1,46 @@ + + + + + IDESourceControlProjectFavoriteDictionaryKey + + IDESourceControlProjectIdentifier + 2D8FADF5-8504-4A76-A99F-91CA115CE4E3 + IDESourceControlProjectName + xpcExample + IDESourceControlProjectOriginsDictionary + + D7B4D224-FE26-406E-A48F-C604A5BE6975 + https://babelfish.arc.nasa.gov/svn/pcoe/cteubert/xplaneconnect + + IDESourceControlProjectPath + C/xpcExample/xpcExample.xcodeproj/project.xcworkspace + IDESourceControlProjectRelativeInstallPathDictionary + + D7B4D224-FE26-406E-A48F-C604A5BE6975 + ../../../.. + + IDESourceControlProjectRepositoryRootDictionary + + D7B4D224-FE26-406E-A48F-C604A5BE6975 + https://babelfish.arc.nasa.gov/svn/pcoe + + IDESourceControlProjectURL + https://babelfish.arc.nasa.gov/svn/pcoe/cteubert/xplaneconnect/C/xpcExample/xpcExample.xcodeproj + IDESourceControlProjectVersion + 110 + IDESourceControlProjectWCCIdentifier + D7B4D224-FE26-406E-A48F-C604A5BE6975 + IDESourceControlProjectWCConfigurations + + + IDESourceControlRepositoryExtensionIdentifierKey + public.vcs.subversion + IDESourceControlWCCIdentifierKey + D7B4D224-FE26-406E-A48F-C604A5BE6975 + IDESourceControlWCCName + xplaneconnect + + + + diff --git a/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcuserdata/cteubert.xcuserdatad/UserInterfaceState.xcuserstate b/C/xpcExample/xpcExample.xcodeproj/project.xcworkspace/xcuserdata/cteubert.xcuserdatad/UserInterfaceState.xcuserstate new file mode 100644 index 0000000000000000000000000000000000000000..6a63770fc24057b5230cd71036f681a172e179fa GIT binary patch literal 25229 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 + + + + + + + + diff --git a/C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xcschememanagement.plist b/C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xcschememanagement.plist new file mode 100644 index 0000000..a03646a --- /dev/null +++ b/C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xcschememanagement.plist @@ -0,0 +1,22 @@ + + + + + SchemeUserState + + xpcExample.xcscheme + + orderHint + 0 + + + SuppressBuildableAutocreation + + BEF9890A18E4E7F7005554D1 + + primary + + + + + diff --git a/C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xpcExample.xcscheme b/C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xpcExample.xcscheme new file mode 100644 index 0000000..b1a84cb --- /dev/null +++ b/C/xpcExample/xpcExample.xcodeproj/xcuserdata/cteubert.xcuserdatad/xcschemes/xpcExample.xcscheme @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/C/xpcExample/xpcExample/main.cpp b/C/xpcExample/xpcExample/main.cpp new file mode 100644 index 0000000..1c8f016 --- /dev/null +++ b/C/xpcExample/xpcExample/main.cpp @@ -0,0 +1,131 @@ +// +// main.cpp +// xpcExample +// +// Created by Chris Teubert on 3/27/14. +// Copyright (c) 2014 Chris Teubert. All rights reserved. +// + +#include +#include +#include +#include +#include "xplaneConnect.h" + +int main() { + int i,j; + struct xpcSocket sendfd,readfd; + float data[4][9] = {0}; + char DREF[100] = {0}; + char DREFArray[100][100]; + char DREFArray2[100][100]; + short DREFSizes[100]; + float *recDATA[100]; + float POSI[9] = {0.0}; + float CTRL[5] = {0.0}; + float gear; + char IP[16] = "143.232.73.41";//"127.0.0.1";//;// //IP Address of computer running X-Plane + short PORT = 49009; //xpcPlugin Receiving port (usually 49009) + + printf("xplaneconnect Example Script\n- Setting up Simulation\n"); + + for (i = 0; i < 100; i++) { + recDATA[i] = (float *) malloc(40*sizeof(float)); + memset(DREFArray[i],0,100); + memset(DREFArray2[i],0,100); + } + + // Open Sockets + readfd = openUDP(49055, IP, PORT); //Open socket for receiving + sendfd = openUDP(49077, IP, PORT); //Open socket for sending + + // Set up Connection + setCONN(sendfd, 49055); // Setup so data will be received on port 49055 + + // Set Location/Orientation (sendPOSI) + // Set Up Position Array + POSI[0] = 37.524; // Lat + POSI[1] = -122.06899; // Lon + POSI[2] = 2500; // Alt + POSI[3] = 0; // Pitch + POSI[4] = 0; // Roll + POSI[5] = 0; // Heading + POSI[6] = 1; // Gear + + sendPOSI(sendfd, 0, 7, POSI); + POSI[0] = 37.52465; + POSI[4] = 20; + sendPOSI(sendfd, 1, 7, POSI); + + // Set Rates (sendDATA) + + for (i=0;i<4;i++) { // Set array to -999 + for (j=0;j<9;j++) data[i][j] = -999; + } + // Set up Data Array (first item in row is item number (example: 20=position) + data[0][0] = 18; // Alpha + data[0][1] = 0; + data[0][3] = 0; + + data[1][0] = 3;//21; //Velocity + data[1][1] = 130; + data[1][2] = 130; + data[1][3] = 130; + data[1][4] = 130; + + data[2][0] = 16; //PQR + data[2][1] = 0; + data[2][2] = 0; + data[2][3] = 0; + + sendDATA(sendfd, data, 3); // Throttle/Velocity/Alpha/PQR + + // Set CTRL + CTRL[3] = 0.8; // Throttle + + sendCTRL(sendfd, 4, CTRL); + + // pauseSim + pauseSim(sendfd, 1); // Sending 1 to pause + + // Pause for 5 seconds + sleep(5); + + // Unpause + pauseSim(sendfd, 0); // Sending 0 to unpause + printf("- Resuming Simulation\n"); + + // Simulate for 10 seconds + sleep(10); + + // SendDREF (Landing Gear) + printf("- Stowing Landing Gear\n"); + + strcpy(DREF,"cockpit/switches/gear_handle_status"); // Gear handle data reference + DREFSizes[0] = sizeof(DREF); + gear = 1; // Stow gear + + sendDREF(sendfd, DREF, DREFSizes[0], &gear, 1); // Set gear to stow + + // Simulate for 10 seconds + sleep(10); + + // Check Landing gear, Pause + printf("- Confirming Gear Status\n"); + strcpy(DREFArray2[0],"sim/cockpit/switches/gear_handle_status"); + strcpy(DREFArray2[1],"sim/operation/override/override_planepath"); + for (i=0;i<2;i++) { + DREFSizes[i] = (int) strlen(DREFArray2[i]); + } + requestDREF(sendfd, readfd, DREFArray2, DREFSizes, 2, recDATA, DREFSizes); // Request 2 values + + if (*(recDATA[0])==0) { + printf("\tGear Stowed\n"); + } else { + printf("\tERROR: Gear Stowage unsuccessful\n"); + } + + printf("---End Program---\n"); + + return 0; +} diff --git a/C/xpcExample/xpcExample/xpcExample.1 b/C/xpcExample/xpcExample/xpcExample.1 new file mode 100644 index 0000000..1427b4b --- /dev/null +++ b/C/xpcExample/xpcExample/xpcExample.1 @@ -0,0 +1,79 @@ +.\"Modified from man(1) of FreeBSD, the NetBSD mdoc.template, and mdoc.samples. +.\"See Also: +.\"man mdoc.samples for a complete listing of options +.\"man mdoc for the short list of editing options +.\"/usr/share/misc/mdoc.template +.Dd 3/27/14 \" DATE +.Dt xpcExample 1 \" Program name and manual section number +.Os Darwin +.Sh NAME \" Section Header - required - don't modify +.Nm xpcExample, +.\" The following lines are read in generating the apropos(man -k) database. Use only key +.\" words here as the database is built based on the words here and in the .ND line. +.Nm Other_name_for_same_program(), +.Nm Yet another name for the same program. +.\" Use .Nm macro to designate other names for the documented program. +.Nd This line parsed for whatis database. +.Sh SYNOPSIS \" Section Header - required - don't modify +.Nm +.Op Fl abcd \" [-abcd] +.Op Fl a Ar path \" [-a path] +.Op Ar file \" [file] +.Op Ar \" [file ...] +.Ar arg0 \" Underlined argument - use .Ar anywhere to underline +arg2 ... \" Arguments +.Sh DESCRIPTION \" Section Header - required - don't modify +Use the .Nm macro to refer to your program throughout the man page like such: +.Nm +Underlining is accomplished with the .Ar macro like this: +.Ar underlined text . +.Pp \" Inserts a space +A list of items with descriptions: +.Bl -tag -width -indent \" Begins a tagged list +.It item a \" Each item preceded by .It macro +Description of item a +.It item b +Description of item b +.El \" Ends the list +.Pp +A list of flags and their descriptions: +.Bl -tag -width -indent \" Differs from above in tag removed +.It Fl a \"-a flag as a list item +Description of -a flag +.It Fl b +Description of -b flag +.El \" Ends the list +.Pp +.\" .Sh ENVIRONMENT \" May not be needed +.\" .Bl -tag -width "ENV_VAR_1" -indent \" ENV_VAR_1 is width of the string ENV_VAR_1 +.\" .It Ev ENV_VAR_1 +.\" Description of ENV_VAR_1 +.\" .It Ev ENV_VAR_2 +.\" Description of ENV_VAR_2 +.\" .El +.Sh FILES \" File used or created by the topic of the man page +.Bl -tag -width "/Users/joeuser/Library/really_long_file_name" -compact +.It Pa /usr/share/file_name +FILE_1 description +.It Pa /Users/joeuser/Library/really_long_file_name +FILE_2 description +.El \" Ends the list +.\" .Sh DIAGNOSTICS \" May not be needed +.\" .Bl -diag +.\" .It Diagnostic Tag +.\" Diagnostic informtion here. +.\" .It Diagnostic Tag +.\" Diagnostic informtion here. +.\" .El +.Sh SEE ALSO +.\" List links in ascending order by section, alphabetically within a section. +.\" Please do not reference files that do not exist without filing a bug report +.Xr a 1 , +.Xr b 1 , +.Xr c 1 , +.Xr a 2 , +.Xr b 2 , +.Xr a 3 , +.Xr b 3 +.\" .Sh BUGS \" Document known, unremedied bugs +.\" .Sh HISTORY \" Document history if command behaves in a unique manner \ No newline at end of file diff --git a/Docs/Capability Matrix.xlsx b/Docs/Capability Matrix.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..0d2b884d3c92d42300f04b9d0769605c541a491a GIT binary patch literal 29387 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 literal 0 HcmV?d00001 diff --git a/Docs/Interface Control Document.xlsx b/Docs/Interface Control Document.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..074683ed31334fa155be3458812799655446a147 GIT binary patch literal 190601 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

K;pgumw2*o<+REboJee- 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 literal 0 HcmV?d00001 diff --git a/MATLAB/+XPlaneConnect/clearUDPBuffer.m b/MATLAB/+XPlaneConnect/clearUDPBuffer.m new file mode 100644 index 0000000..894f248 --- /dev/null +++ b/MATLAB/+XPlaneConnect/clearUDPBuffer.m @@ -0,0 +1,40 @@ +function socket = clearUDPBuffer(socket,varargin) +% clearUDPBuffer Script that clears an UDP Socket Buffer by closing and +% reopening the socket +% Version 0.25 +% +% Inputs +% Socket: UDP Socket to be cleared +% +% Outputs +% Socket: UDP Socket +% +% Use +% 1. import XPlaneConnect.*; +% 2. Socket = openUDP(49005); +% 3. Socket = clearUDPBuffer(Socket); +% +% Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/18/14: [CT] Added Versioning +% 09/12/13: [CT] Add optional arguments +% 09/10/13: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +% BEGIN CODE + + import XPlaneConnect.* + + %% Close and reopen socket + if ~socket.isClosed() + port = socket.getLocalPort(); %get port of socket + socket.close; %Close Socket + socket = openUDP(port,varargin); %open new socket + end +end \ No newline at end of file diff --git a/MATLAB/+XPlaneConnect/closeUDP.m b/MATLAB/+XPlaneConnect/closeUDP.m new file mode 100644 index 0000000..69a8128 --- /dev/null +++ b/MATLAB/+XPlaneConnect/closeUDP.m @@ -0,0 +1,32 @@ +function [socket] = closeUDP(socket) +% closeUDP Script that closes a UDP Socket +% Version 0.25 +% +% Inputs +% Socket: UDP Socket to be closed +% +% Outputs +% Socket: Closed Socket +% +% Use +% 1. import XPlaneConnect.*; +% 2. Socket = openUDP(49005); +% 3. Status = closeUDP(Socket); +% +% Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/18/14: [CT] V0.2: Added Versioning +% 09/10/13: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +% BEGIN CODE + +socket.close; + +end \ No newline at end of file diff --git a/MATLAB/+XPlaneConnect/openUDP.m b/MATLAB/+XPlaneConnect/openUDP.m new file mode 100644 index 0000000..560f45a --- /dev/null +++ b/MATLAB/+XPlaneConnect/openUDP.m @@ -0,0 +1,46 @@ +function [socket] = openUDP(port, varargin) +%openUDP Script that opens an UDP Socket +% Version 0.25 +% +%Inputs +% port: UDP Port for socket +% timeout (optional): Optional parameter for time to UDP timeout (in ms) +%Outputs +% Socket: UDP Socket +% +% Use +% 1. import XPlaneConnect.*; +% 2. Socket = openUDP(49005); %Open socket at port 49005 with timeout=0.1 sec +% or +% 2. Socket = openUDP(49005); %Open socket at port 49005 with timeout=0.2 sec +% +%Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/18/14: [CT] Added Versioning +% 09/12/13: [CT] Added optional timeout input argument +% 09/10/13: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +% BEGIN CODE + +import java.net.DatagramSocket + +%% create socket + socket = DatagramSocket(port); + socket.setSoTimeout(100); + socket.setReceiveBufferSize(2000); + +%% interpret input +if ~isempty(varargin) + if isnumeric(varargin(1)) + socket.setSoTimeout(varargin(1)); + end +end + +end diff --git a/MATLAB/+XPlaneConnect/pauseSim.m b/MATLAB/+XPlaneConnect/pauseSim.m new file mode 100644 index 0000000..6230501 --- /dev/null +++ b/MATLAB/+XPlaneConnect/pauseSim.m @@ -0,0 +1,50 @@ +function status = pauseSim( pause, varargin ) +%pauseSim pause Simulation +% Version 0.25 +% +%Inputs +% Pause: binary value 0=run, 1=pause +% IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine) +% port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin +% +%Outputs +% status: If there was an error. Status<0 means there was an error. +% +%Use +% 1. import XPlaneConnect.*; +% 2. status = pauseSim(1); +% +%Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/19/14: [CT] V0.2: First Created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +%BEGIN CODE + +import XPlaneConnect.* + +%% Handle Input + % Optional parameters + p = inputParser; + addRequired(p,'pause',@isnumeric); + addOptional(p,'IP','127.0.0.1',@ischar); + addOptional(p,'port',49009,@isnumeric); + parse(p,pause,varargin{:}); + + % Check format of input-TODO + +%% BODY + message = zeros(1,7); + + message(1:4) = 'SIMU'-0; + message(6) = uint8(p.Results.pause); + message(7) = 0; + + status = sendUDP(message, p.Results.IP, p.Results.port); +end \ No newline at end of file diff --git a/MATLAB/+XPlaneConnect/readDATA.m b/MATLAB/+XPlaneConnect/readDATA.m new file mode 100644 index 0000000..a7bb490 --- /dev/null +++ b/MATLAB/+XPlaneConnect/readDATA.m @@ -0,0 +1,98 @@ +function [ sensor ] = readDATA( socket ) +% readDATA Reads UDP Socket and interprets data +% Version 0.25 +% +% Inputs +% location: Either an opened UDP Socket or integer port number +% +% Outputs +% If data is X-Plane data format: +% data: Matlab X-Plane DATA Structure +% .h: Header array containing header numbers corresponding to values in the X-Plane UDP Data screen. +% .d: 2-D Data array. Each row contains eight values corresponding to the header value (.h(1) corresponds to .d(1,:)) +% .raw: raw UDP data array received by readUDP +% +% If data is matlab structure: +% data: Matlab Structure. raw UDP data saved to data.raw +% +% If data is any other format: +% data: Matlab Structure containing one field +% .raw & .d: raw UDP data array received by readUDP +% +% Use +% 1. import XPlaneConnect.*; +% 2. socket = openUDP(49005); +% 3. data = readDATA(socket); +% 4. status = closeUDP(socket); +% or +% 1. import XPlaneConnect.*; +% 2. data = readDATA(49005); +% +% NOTE: sending in a port number instead of an opened socket clears the UDP buffer. This only works if the data is being sent at a fast rate. Sending in a UDP Socket reads the first packet in the buffer. +% +% Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/18/14: [CT] V0.2: Updated to work with new Plugin +% 09/10/13: [CT] Updated to receive UDP socket or port number +% 06/10/13: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +% BEGIN CODE + + import XPlaneConnect.* + + %% Read UDP Socket + [ sensor.raw] = readUDP(socket); + + %% Interpret Input + bits = size(sensor.raw); + if sensor.raw ~= -998 %If the signal exists + header = char(sensor.raw(1:4)'); + if strcmp(header,'DATA') %DATA signal type + Values = floor((bits-5)/36); + sensor.d = []; + sensor.h = zeros(Values(1),1); + for i=1:Values(1) + sensor.h(i) = sensor.raw(6+(i-1)*36); + sensor.d = [sensor.d; typecast(uint8(sensor.raw(10+(i-1)*36:5+i*36))','single')]; + end + elseif strcmp(header,'STRU') %STRU signal type + a = 6; + while a + end + + % Send DATA + if length(dataStream) > 5 + status = sendUDP(dataStream, p.Results.IP, p.Results.port); + else + disp('Warning in sendDATA: Sending empty dataStream') + status = -2; + end + +end + diff --git a/MATLAB/+XPlaneConnect/sendDREF.m b/MATLAB/+XPlaneConnect/sendDREF.m new file mode 100644 index 0000000..94fc72a --- /dev/null +++ b/MATLAB/+XPlaneConnect/sendDREF.m @@ -0,0 +1,63 @@ +function status = sendDREF( dataRef, Value, varargin ) +% sendDREF Send a command to change any DataRef in X-Plane over UDP. This requires the X-Plane Connect Plugin to be running +% Version 0.25 +% +% Inputs +% dataRef: The X-Plane Dataref that will be chaged +% Value: The value that the above dataref is set to +% IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine) +% port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp +% +% Outputs +% status: If there was an error. status<0 means there was an error. +% +% Use +% 1. import XPlaneConnect.* +% 2. dataRef = 'sim/aircraft/parts/acf_gear_deploy'; // Landing Gear +% 3. Value = 0; +% 4. status = sendDREF(dataRef, Value); +% +% Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/18/14: [CT] V0.2: First Version +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +% BEGIN CODE + +import XPlaneConnect.* + +status = 0; + +%% Handle Input +p = inputParser; +addRequired(p,'dataRef'); +addRequired(p,'Value'); +addOptional(p,'IP','127.0.0.1',@ischar); +addOptional(p,'port',49009,@isnumeric); +parse(p,dataRef, Value ,varargin{:}); + +%% BODY + dataStream = zeros(1,7+length(p.Results.dataRef)+length(p.Results.Value)*4); + % Build Header + dataStream(1:4) = 'DREF'-0; + + % Add DREF + dataStream(6) = uint8(length(p.Results.dataRef)); + len = 6+length(p.Results.dataRef); + dataStream(7:len)=p.Results.dataRef-0; + + % Add Value + dataStream(len+1) =uint8(length(p.Results.Value)); + dataStream(len+2:end)=typecast(single(p.Results.Value),'uint8'); + + % Send DREF + if length(dataStream) > 5 + status = sendUDP(dataStream, p.Results.IP, p.Results.port); + end +end \ No newline at end of file diff --git a/MATLAB/+XPlaneConnect/sendPOSI.m b/MATLAB/+XPlaneConnect/sendPOSI.m new file mode 100644 index 0000000..28c1e09 --- /dev/null +++ b/MATLAB/+XPlaneConnect/sendPOSI.m @@ -0,0 +1,66 @@ +function [ status ] = sendPOSI( posi, varargin ) +% sendPOSI Send X-Plane Aircraft Position over UDP +% Version 0.25 +% +% Inputs +% posi: Position array where the elements are as follows: +% 1. Latitiude (deg) +% 2. Longitude (deg) +% 3. Altitude (m above MSL) +% 4. Roll (deg) +% 5. Pitch (deg) +% 6. True Heading (deg) +% 7. Gear (0=up, 1=down) +% acft (optional): Aircraft # (default is 0; 0 = own aircraft) +% IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine) +% port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp +% +% Outputs +% status: If there was an error. Status<0 means there was an error. +% +% Use +% 1. import XPlaneConnect.*; +% 2. #Send the data array to port 49009 on the computer at IP address 172.0.100.54. +% 3. status = sendPOSI([37.5242422, -122.06899, 2500, 0, 0, 0, 1], 1, '172.0.100.54'); +% +% Note: send the value -998 to not overwrite that parameter. That is, if -998 is sent, the parameter will stay at the current X-Plane value +% +% Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 09/25/14: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% +% BEGIN CODE + +import XPlaneConnect.* + +%% Handle Input +p = inputParser; +addRequired(p,'posi'); +addOptional(p,'acft',0,@isnumeric); +addOptional(p,'IP','127.0.0.1',@ischar); +addOptional(p,'port',49009,@isnumeric); +parse(p,posi,varargin{:}); + +%% BODY + header = ['POSI'-0,0]; + dataStream = [header, p.Results.acft]; + + % Deal with position update + position = [37.4185718,-121.935565,500,0,0,0, 0]; + + for i=1:min(length(position),length(p.Results.posi)) + position(i) = p.Results.posi(i); + end + dataStream = [dataStream, typecast(single(position),'uint8')]; + + % Send POSI + status = sendUDP(dataStream, p.Results.IP, p.Results.port); + +end + diff --git a/MATLAB/+XPlaneConnect/sendSTRU.m b/MATLAB/+XPlaneConnect/sendSTRU.m new file mode 100644 index 0000000..105f36b --- /dev/null +++ b/MATLAB/+XPlaneConnect/sendSTRU.m @@ -0,0 +1,63 @@ +function [ status ] = sendSTRU( STRU, varargin ) +%sendSTRU Send a MATLAB structure over UDP +% Version 0.25 +% +%Inputs +% stru: A MATLAB structure +% IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine) +% port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin +% +%Outputs +% status: If there was an error. Status<0 means there was an error. +% +%Use +% 1. import XPlaneConnect.*; +% 2. data = struct('a',[1:20],'b',1.853,'name','Example Structure'); +% 3. #Send the data structure to port 49005 on the computer at IP address 172.0.100.54 +% 4. status = sendUDP( data, '172.0.100.54', 49005 ); +% +%Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/18/14: [CT] V0.2: Added Versioning +% 08/01/13: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% +%BEGIN CODE + + import XPlaneConnect.* + + %% Handle Input + p = inputParser; + addRequired(p,'STRU'); + addOptional(p,'IP','127.0.0.1',@ischar); + addOptional(p,'port',49009,@isnumeric); + parse(p,STRU,varargin{:}); + + %% Form Data Array representing the structure + DATA = ['STRU'-0,0]; %array header + fieldName = fieldnames(p.Results.STRU); %all Struct fields + for i=1:length(fieldName) %for each field + field = getfield(p.Results.STRU,fieldName{i}); %get field + if ischar(field) %String + dim1 = 0; %Indicates string + dim2 = length(field); %length + data = field-0; %data + else %Numeric + dim1 = size(field,1); %Array Dim1 + dim2 = size(field,2); %Array Dim2 + data = typecast(single(reshape(field',1,dim1*dim2)),'uint8'); %Data + end + + DATA = [DATA,length(fieldName{i}),fieldName{i}-0,dim1,dim2,data]; %add to array + end + + %% Send Array + status = sendUDP(DATA, p.Results.IP, p.Results.port); + +end + diff --git a/MATLAB/+XPlaneConnect/sendUDP.m b/MATLAB/+XPlaneConnect/sendUDP.m new file mode 100644 index 0000000..893b9d4 --- /dev/null +++ b/MATLAB/+XPlaneConnect/sendUDP.m @@ -0,0 +1,64 @@ +function [ status ] = sendUDP( data, IP, port ) +%sendUDP Send an one dimensional array of type uint8 data over an UDP connection using a java DatagramSocket +% Version 0.25 +% +%Inputs +% Data: 1-D array of type uint8 data to be sent +% IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine) +% port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin +% +%Outputs +% status: If there was an error. Status<0 means there was an error. +% +%Use +% 1. import XPlaneConnect.*; +% 2. data = uint8([1:20]); +% 3. #Send the data array to port 49005 on the computer at IP address 172.0.100.54. +% 4. status = sendUDP( data, '172.0.100.54', 49005 ); +% +%Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 09/25/14: [CT] V0.24: Added persistant socket +% 04/21/14: [CT] V0.2:Added Versioning, support for DREF/SIMU/GETD/CONN +% 06/10/13: [CT] Code created +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +%BEGIN CODE + + import java.net.DatagramSocket + import java.net.DatagramPacket + import java.net.InetAddress + + data(5) = length(data); + status = 0; + + %% Send array + persistent socket + if isempty(socket) + try + socket = DatagramSocket; + catch err + status = 1; + disp(err) + end + end + + try + IP = InetAddress.getByName(IP); + packet = DatagramPacket(data, length(data), IP, port); %create packet + socket.send(packet); + catch err + status = 1; + disp(err) + end + + + +end + diff --git a/MATLAB/+XPlaneConnect/setConn.m b/MATLAB/+XPlaneConnect/setConn.m new file mode 100644 index 0000000..3086b82 --- /dev/null +++ b/MATLAB/+XPlaneConnect/setConn.m @@ -0,0 +1,52 @@ +function status = setConn( recvPort, IP, port ) +% setConn Send a command to set up the port where you will receive data on +% this computer. +% Version 0.25 +% +% Inputs +% Receiving Port: Port that data will be sent to in the future for this connection +% IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine) +% port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp +% +% Outputs +% status: If there was an error. status<0 means there was an error. +% +% Use +% 1. import XPlaneConnect.* +% 2. status = setConn(49011); +% +% Change Log +% 10/02/14: [CT] V0.25: Updated to work with updated xpcPlugin +% 04/21/14: [CT] V0.2: First Version +% +% Contributors +% [CT] Christopher Teubert (SGT, Inc.) +% christopher.a.teubert@nasa.gov +% +% To Do +% 1. Verify Input +% +% BEGIN CODE + import XPlaneConnect.* + + status = 0; + message = zeros(1,9); + +%% Handle Input + % Optional parameters + if ~exist('IP','var'), IP = "127.0.0.1"; end + if ~exist('port','var'), port = 49009; end + + % Check format of input-TODO + +%% BODY + % Header + message(1:4) = 'CONN'-0; + + % RecvPort + message(6:9) = typecast(uint32(recvPort),'uint8'); + + % Send + sendUDP(IP,port,message); + +end \ No newline at end of file diff --git a/MATLAB/Documentation (MATLAB).html b/MATLAB/Documentation (MATLAB).html new file mode 100644 index 0000000..dd3a645 --- /dev/null +++ b/MATLAB/Documentation (MATLAB).html @@ -0,0 +1,122 @@ + + + + + + XPlaneConnect Toolbox + + + + +

XPC-MATLAB

+Version 0.25 September 29, 2014
+Chris Teubert (Christopher.A.Teubert@nasa.gov)
+ +

Summary

+XPC-MATLAB is a series of MATLAB functions that facilitate communication with X-Plane. This toolbox allows for the real-time application of active control to an XPlane simulation, flight visualization, record state during a flight, or interact with a mission using UDP. + +

Table of Contents

+
    +
  1. Functions
    2. +
  2. Setup +
  3. Use
    4. +
  4. Example
    5. +
  5. Future Work
    6. +
  6. Notices and Disclaimers
    7. +
  7. Change Log
    8. +
+ +

Functions

 +

Basic Package

+ + +
  + - sendDATA: + Send X-Plane Formatted DATA over UDP
  + - sendPOSI: + Send Position and orientation update command to X-Plane over UDP for any aircraft (own or traffic)
  + - sendCTRL: + Send control commands to X-Plane over UDP for any aircraft (own or traffic)
  + - sendDREF: + Set any X-Plane internal variable (dataref) over UDP
  + - selectDATA: + Choose specific X-Plane DATA parameters to be sent by X-Plane over UDP
  + - setConn: + Sets the return port for requested datarefs.
  + - pauseSim: + Pause simulation
  + - openUDP: + Script that opens an UDP Socket
  + - closeUDP: + Script that closes an UDP Socket
+ +

Advanced/Special-Use Functions

+ +
  + - clearUDPBuffer: + Script that clears an UDP Socket Buffer
  + - readDATA: + Read X-Plane Formatted Data from UDP Socket
  + - readUDP: + Read Array from UDP Socket
  + - sendSTRU: + Send a MATLAB structure over UDP
  + - sendUDP: + Send array over UDP
+ +

Future

+ +
  + - requestDREF: + Request the value of a specific data ref
  + - drawWaypoint: + NOT FUNCTIONAL
+ +

Setup

 +Before using XPC Functions you must +1. Install X-Plane (http://www.x-plane.com) +2. Copy the file xpcPlugin.xpl to the "[X-Plane Directory]/Resources/plugins" directory. + a. For Mac xpcPlugin can be found in the "[XPlaneConnect]/xpcPlugin/Mac" directory. + a. For Windows xpcPlugin can be found in the "[XPlaneConnect]/xpcPlugin/Win" directory. +3. Insert X-Plane CD 1 or X-Plane USB Key. +4. Start X-Plane. +5. import XPlaneConnect.* + +

Examples

 +

Files

+TO BE ADDED +

Description

+ +

Future Work

 +
    +
    • +
+ +

Notices and Disclaimers

 +Notices:
+Copyright ©2013-2014 United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All Rights Reserved.
+ +
Disclaimers: + +

No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS."

+ +

Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT.

+ +
X-Plane API
+Copyright (c) 2008, Sandy Barbour and Ben Supnik All rights reserved.
+

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

+
    +
  • Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    • +
  • Neither the names of the authors nor that of X-Plane or Laminar Research may be used to endorse or promote products derived from this software without specific prior written permission from the authors or Laminar Research, respectively.
    • +
+ +

X-Plane API SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ +

Change Log

 +-October 16, 2014 (Chris Teubert): Added Notices and Disclaimers
+-September 29, 2014 (Chris Teubert): Updated documentation to use new plugin
+-September 11, 2013 (Chris Teubert): Updated for Version 0.7
+-February 13, 2013 (Chris Teubert): Hello World! + + + diff --git a/MATLAB/pages/clearUDPBuffer.html b/MATLAB/pages/clearUDPBuffer.html new file mode 100644 index 0000000..f09b945 --- /dev/null +++ b/MATLAB/pages/clearUDPBuffer.html @@ -0,0 +1,37 @@ + + + + + + XPlaneConnect Toolbox-ClearUDPBuffer + + + + +<-- Back
+

clearUDPBuffer

+Script that clears an UDP Socket Buffer + +

Inputs

+
    +
  • Socket: UDP Socket to be cleared
    • +
+ +

Outputs

+
    +
  • Socket: UDP Socket
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. Socket = openUDP(49005);
+3. Socket = clearUDPBuffer(Socket);
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+09/12/13: [CT] Add optional arguments
+09/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/closeUDP.html b/MATLAB/pages/closeUDP.html new file mode 100644 index 0000000..e2a64c5 --- /dev/null +++ b/MATLAB/pages/closeUDP.html @@ -0,0 +1,36 @@ + + + + + + XPlaneConnect Toolbox-closeUDP + + + + +<-- Back
+

closeUDP

+Script that closes a UDP Socket + +

Inputs

+
    +
  • Socket: UDP Socket to be closed
    • +
+ +

Outputs

+
    +
  • Status: Integer indicating the success of socket closing. 1 = Success 0 = Failure
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. Socket = openUDP(49005);
+3. Status = closeUDP(Socket);
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+09/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/openUDP.html b/MATLAB/pages/openUDP.html new file mode 100644 index 0000000..d13ed2b --- /dev/null +++ b/MATLAB/pages/openUDP.html @@ -0,0 +1,39 @@ + + + + + + XPlaneConnect Toolbox-openUDP + + + + +<-- Back
+

openUDP

+Script that opens a UDP Socket + +

Inputs

+
    +
  • port: UDP Port for socket
    • +
  • timeout (optional): Optional parameter for time to UDP timeout (in ms)-Default 0.1 seconds
    • +
+ +

Outputs

+
    +
  • Socket: UDP Socket
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. Socket = openUDP(49005);%Open socket at port 49005 with timeout of 0.1 seconds

+or

+2. Socket = openUDP(49005,200);%Open socket at port 49005 with timeout of 0.2 seconds

+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+09/12/13: [CT] Added optional timeout input argument
+09/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/pauseSim.html b/MATLAB/pages/pauseSim.html new file mode 100644 index 0000000..bf799c0 --- /dev/null +++ b/MATLAB/pages/pauseSim.html @@ -0,0 +1,36 @@ + + + + + + XPlaneConnect Toolbox-pauseSim + + + + +<-- Back
+

pauseSim

+ +

Inputs

+
    +
  • Pause: binary value 0=run, 1=pause
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. status = pauseSim(1);
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+06/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/readDATA.html b/MATLAB/pages/readDATA.html new file mode 100644 index 0000000..12cef1b --- /dev/null +++ b/MATLAB/pages/readDATA.html @@ -0,0 +1,59 @@ + + + + + + XPlaneConnect Toolbox-readDATA + + + + +<-- Back
+

readDATA

+Reads UDP Socket and interprets data + +

Inputs

+
    +
  • location: Either an opened UDP Socket or integer port number
    • +
+ +

Outputs

+If data is X-Plane data format: +
    +
  • data: Matlab X-Plane DATA Structure
      +
    • .h: Header array containing header numbers corresponding to values in the X-Plane UDP Data screen.
      • +
    • .d: 2-D Data array. Each row contains eight values corresponding to the header value (.h(1) corresponds to .d(1,:))
      • +
    • .raw: raw UDP data array received by readUDP
    • +
+If data is matlab structure: +
    +
  • data: Matlab Structure. Raw udp data saved to data.raw
    • +
+If data is any other format: +
    +
  • data: Matlab Structure containing one field
      +
    • .raw & .d: raw UDP data array received by readUDP
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. socket = openUDP(49005);
+3. data = readDATA(socket);
+4. status = closeUDP(socket);

+ +or

+ +1. import XPlaneConnect.*;
+2. data = readDATA(49005); + +

Note

+NOTE: sending in a port number instead of an opened socket clears the UDP buffer. This only works if the data is being sent at a fast rate. Sending in a UDP Socket reads the first packet in the buffer.
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+09/10/13: [CT] Updated to receive UDP socket or port number
+06/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/readUDP.html b/MATLAB/pages/readUDP.html new file mode 100644 index 0000000..8a636f2 --- /dev/null +++ b/MATLAB/pages/readUDP.html @@ -0,0 +1,43 @@ + + + + + + XPlaneConnect Toolbox-readUDP + + + + +<-- Back
+

readUDP

+Read Array from UDP Socket + +

Inputs

+
    +
  • location: Either an opened UDP Socket or integer port number
    • +
+ +

Outputs

+
    +
  • data: UDP uint8 Array. Equal to -998 in the case of an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. socket = openUDP(49005);
+3. data = readUDP(socket);
+4. status = closeUDP(socket);

+ +or

+ +1. import XPlaneConnect.*;
+2. data = readUDP(49005);
+ +

Note

+NOTE: sending in a port number instead of an opened socket clears the UDP buffer. This only works if the data is being sent at a fast rate. Sending in a UDP Socket reads the first packet in the buffer. + +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+09/08/13: [CT] Added option for either UDP Socket or port number input
+06/10/13: [CT] Code created

+<-- Back
\ No newline at end of file diff --git a/MATLAB/pages/requestDREF.html b/MATLAB/pages/requestDREF.html new file mode 100644 index 0000000..ff822de --- /dev/null +++ b/MATLAB/pages/requestDREF.html @@ -0,0 +1,37 @@ + + + + + + XPlaneConnect Toolbox-requestDREF + + + + +<-- Back
+

requestDREF

+ +

Inputs

+
    +
  • DREFArray: Cell Array of DataRefs to be requested
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin
    • +
+ +

Outputs

+
    +
  • status: If there was an error. status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. DREFArray = {'sim/cockpit2/controls/yoke_heading_ratio','sim/cockpit2/controls/yoke_roll_ratio'};
+3. status = requestDREF( DREFArray, '172.0.100.54' );
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+06/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/selectDATA.html b/MATLAB/pages/selectDATA.html new file mode 100644 index 0000000..2a9e3e0 --- /dev/null +++ b/MATLAB/pages/selectDATA.html @@ -0,0 +1,39 @@ + + + + + + XPlaneConnect Toolbox-selectDATA + + + + +<-- Back
+

selectDATA

+Choose specific X-Plane parameters to be send over UDP + +

Inputs

+
    +
  • index: An array of the values that to be sent. Corresponds to the numbers on the XPlane Output screen (ACTUAL NAME?)
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. Status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. values = [1, 2, 3, 27, 40]; +3. status = selectDATA(values,'127.0.0.1',49005);
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+04/18/14: [CT] V0.2: Added Versioning
+06/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/sendCTRL.html b/MATLAB/pages/sendCTRL.html new file mode 100644 index 0000000..9bb501a --- /dev/null +++ b/MATLAB/pages/sendCTRL.html @@ -0,0 +1,48 @@ + + + + + + XPlaneConnect Toolbox-sendCTRL + + + + +<-- Back
+

sendCTRL

+Send position and orientation update command to X-Plane over UDP. This requires the X-Plane Connect Plugin to be running + +

Inputs

+
    +
  • ctrl: Array of 6 values where: +
      +
    • ctrl(1) Latitudinal Stick [-1,1]
      • +
    • ctrl(2) Longitudinal Stick [-1,1]
      • +
    • ctrl(3) Pedal [-1, 1]
      • +
    • ctrl(4) Throttle [-1, 1]
      • +
    • ctrl(5) Gear (0=up, 1=down)
      • +
    • ctrl(6) Flaps [0, 1]
      • +
    +
  • aircraft number (optional): 0=own aircraft
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. ctrl = [0, 0, 0, 0.8, 0, 0]; +3. status = sendCTRL(ctrl); % Set position of own aircraft
+4. status2 = sendCTRL(ctrl,1); % Set position of aircraft 1
+ +

Change Log

+10/02/14: [CT] V0.9 Updated to use new xpcPlugin
+09/26/14: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/sendDATA.html b/MATLAB/pages/sendDATA.html new file mode 100644 index 0000000..02df49d --- /dev/null +++ b/MATLAB/pages/sendDATA.html @@ -0,0 +1,46 @@ + + + + + + XPlaneConnect Toolbox-sendDATA + + + + +<-- Back
+

sendDATA

+Send X-Plane formatted DATA over UDP. This function is used to change one of the parameters listed in the x-plane udp data screen (see http://www.nuclearprojects.com/xplane/images/xp_datainout.jpg) + +

Inputs

+
    +
  • data: X-Plane formatted data. Is a matlab structure with the following fields: +
      +
    • .h: Header array containing header numbers corresponding to values in the X-Plane UDP Data screen.
      • +
    • .d: 2-D Data array. Each row contains eight values corresponding to the header value (.h(1) corresponds to .d(1,:))
      • +
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. Status=1 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. data = struct('h',14,'d',[1,-998,-998,-998,-998,-998,-998,-998]); %Set Gear
+3. %Send the data array to port 49005 on the computer at IP address 172.0.100.54.
+4. status = sendDATA(data, '172.0.100.54', 49005); + +

note

+Note: send the value -998 to not overwrite that parameter. That is, if -998 is sent, the parameter will stay at the current X-Plane value
+ +

Change Log

+10/01/14: [CT] V0.9: updated to function with new xpcPlugin
+06/10/13: [CT] First created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/sendDREF.html b/MATLAB/pages/sendDREF.html new file mode 100644 index 0000000..c5dd742 --- /dev/null +++ b/MATLAB/pages/sendDREF.html @@ -0,0 +1,48 @@ + + + + + + XPlaneConnect Toolbox-sendCTRL + + + + +<-- Back
+

sendCTRL

+Send position and orientation update command to X-Plane over UDP. This requires the X-Plane Connect Plugin to be running + +

Inputs

+
    +
      +
    • data(1) Latitudinal Stick [-1,1]
      • +
    • data(2) Longitudinal Stick [-1,1]
      • +
    • data(3) Pedal [-1, 1]
      • +
    • data(4) Throttle [-1, 1]
      • +
    • data(5) Gear (0=up, 1=down)
      • +
    • data(6) Flaps [0, 1]
      • +
    +
  • aircraft number (optional): 0=own aircraft
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*
+2. dataRef = 'sim/aircraft/parts/acf_gear_deploy'; // Landing Gear
+3. Value = 0;
+4. status = sendDREF(dataRef, Value);
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to use new xpcPlugin +06/10/13: [CT] Code created

+ +<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/sendPOSI.html b/MATLAB/pages/sendPOSI.html new file mode 100644 index 0000000..4642b96 --- /dev/null +++ b/MATLAB/pages/sendPOSI.html @@ -0,0 +1,50 @@ + + + + + + XPlaneConnect Toolbox-sendDREF + + + + +<-- Back
+

sendPosition

+Send position and orientation update command to X-Plane over UDP. This requires the X-Plane Connect Plugin to be running + +

Inputs

+
    +
  • data: Array of 6 values where: +
      +
    • data(1) is the aircraft's Latitude (degrees)
      • +
    • data(2) is the aircraft's Longitude (degrees)
      • +
    • data(3) is the aircraft's altitude (meters above sea level)
      • +
    • data(4) is the aircraft's roll angle (degrees)
      • +
    • data(5) is the aircraft's pitch angle (degrees)
      • +
    • data(6) is the aircraft's heading/yaw angle (degrees)
      • +
    +
  • aircraft number (optional): 0=own aircraft
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. latlon = [37.4185718,-121.935565]; %Lat,lon of NASA Ames Research Center
+3. alt = 500; %meters above sea level
+4. orient = [0,20,180]; %Orientation (roll,pitch,yaw/heading). 20 degrees yaw, heading south
+5. status = sendPOSI([latlon,alt,orient]); % Set position of own aircraft
+6. status2 = sendPOSI([[latlon(1)+0.005,latlon(2)],alt,orient],1); % Set position of aircraft 1
+ +

Change Log

+10/02/14: [CT] V0.9 Updated to use new xpcPlugin
+06/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/sendSTRU.html b/MATLAB/pages/sendSTRU.html new file mode 100644 index 0000000..7ec9b57 --- /dev/null +++ b/MATLAB/pages/sendSTRU.html @@ -0,0 +1,39 @@ + + + + + + XPlaneConnect Toolbox-sendSTRU + + + + +<-- Back
+

sendSTRU

+Send a MATLAB structure over UDP + +

Inputs

+
    +
  • stru: A MATLAB structure
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin
    • +
+ +

Outputs

+
    +
  • status: If there was an error. Status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. data = struct('a',[1:20],'b',1.853,'name','Example Structure');
+3. #Send the data structure to port 49005 on the computer at IP address 172.0.100.54
+4. status = sendSTRU( data, '172.0.100.54', 49005 );
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+08/01/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/sendUDP.html b/MATLAB/pages/sendUDP.html new file mode 100644 index 0000000..92e4ae4 --- /dev/null +++ b/MATLAB/pages/sendUDP.html @@ -0,0 +1,39 @@ + + + + + + XPlaneConnect Toolbox-sendUDP + + + + +<-- Back
+

sendUDP

+Send an one dimensional array of type uint8 data over an UDP connection + +

Inputs

+
    +
  • data: 1-D array of type uint8 data to be sent
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. Status=1 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*;
+2. data = uint8([1:20]);
+3. #Send the data array to port 49005 on the computer at IP address 172.0.100.54.
+4. status = sendUDP( data, '172.0.100.54', 49005 );
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+06/10/13: [CT] Code created

+<-- Back
+ + + \ No newline at end of file diff --git a/MATLAB/pages/setConn.html b/MATLAB/pages/setConn.html new file mode 100644 index 0000000..568f929 --- /dev/null +++ b/MATLAB/pages/setConn.html @@ -0,0 +1,37 @@ + + + + + + XPlaneConnect Toolbox-setConn + + + + +<-- Back
+

setConn

+Send a command to set up the port where you will receive data on this computer. + +

Inputs

+
    +
  • Receiving Port: Port that data will be sent to in the future for this connection
    • +
  • IP Address (optional): IP Address of the machine that will receive the data as a character array. Default is '127.0.0.1' (local machine)
    • +
  • port (optional): Port on the receiving machine where the data will be sent. Default is 49009 (XPlaneConnect). In general use 49009 to send to the plugin and 49005 to send to the x-plane udp
    • +
+ +

Outputs

+
    +
  • status: If there was an error. status<0 means there was an error.
    • +
+ +

Use

+1. import XPlaneConnect.*
+2. status = setConn(49011);
+ +

Change Log

+10/02/14: [CT] V0.9: Updated to work with updated xpcPlugin
+04/21/14: [CT] V0.2: First Version

+<-- Back
+ + + \ No newline at end of file diff --git a/Readme.txt b/Readme.txt new file mode 100644 index 0000000..f7a1d6f --- /dev/null +++ b/Readme.txt @@ -0,0 +1,67 @@ +X-Plane Connect (XPC) Toolbox + +Description +The X-Plane Connect (XPC) Toolbox facilitates communication with X-Plane. This toolbox allows for the real-time manipulation of X-Plane variables. Possible applications include active control of an XPlane simulation, flight visualization, recording states during a flight, or interacting with a mission over UDP. + +Architecture +XPC includes a plugin (xpcPlugin) which is to be copied into the X-Plane Plugin Directory ([X-Plane Directory]/Resources/Plugin/), and the xpcScripts-A series of functions for communication with X-Plane. + +xpcPlugin (Directory: xpcPlugin/) + +xpcScripts + C: (Directory: C/src/, Example: C/xpcExample/) + MATLAB: (Directory: Matlab/+XPlaneConnect/, Example: MATLAB/xpcExample/) + java: (future-Not complete yet): (Directory: java/src/, Example: java/xpcExample/) + python: (future-Not complete yet): (Directory: python/xpc/, Example: python/xpcExample/) + +Instructions: + 1. Purchase/Install X-Plane + 2. Copy the X-Plane Plugin to the plugin directory + Windows Plugin: xpcPlugin/Win/xpcPlugin.xpl + Mac Plugin: xpcPlugin/Mac/xpcPlugin.xpl + Plugin Directory: [X-Plane Directory]/Resources/plugins/ + 3. Write code using the xpcScrips to manipulate X-Plane + +Capabilities: + Set Aircraft Position (own or other aircraft): Use sendPOSI() + Control Aircraft (own or other aircraft): Use sendCTRL() + Set any internal X-Plane dataref: Use sendDREF() + Get the value of any X-Plane dataref: Use requestDREF() + Pause Simulation: Use pauseSim() + +Compatability: + Windows: + Tested on Windows Vista and Windows 7 + Mac OSX + Tested on OS X 10.8-10.10 + X-Plane + Tested with X-Plane 9 & 10 + +Notices: + +Copyright ©2013-2014 United States Government as represented by the Administrator of the National Aeronautics and Space Administration. All Rights Reserved. + +Disclaimers + +No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS." + +Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT. +X-Plane API +Copyright (c) 2008, Sandy Barbour and Ben Supnik All rights reserved. +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Neither the names of the authors nor that of X-Plane or Laminar Research + may be used to endorse or promote products derived from this software + without specific prior written permission from the authors or + Laminar Research, respectively. + +X-Plane API SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Version History: + 10/16/2014: [CT] Added Notices and Disclaimers + 10/03/2014: [CT] First version + +Contributors: + CT: Chris Teubert (christopher.a.teubert@nasa.gov) diff --git a/license.pdf b/license.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4e9883060d7b63136a81e308bd36da23f9481d25 GIT binary patch literal 123110 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®sD_DK_TP#~} z`J?`V!d-?%Y2%IVF(EWQ#i&W@#%==v#*HDw)M}b*Jh8(d_)ST`aSU>Ei?l1o_<-)6zteKWH}XdL)GvcB!KNUl zNHEB^gROBQbUPCH48D@rWL48nJTQx0xDq&$(`@ogAo(-6s7DILX3IgVz(O<@6Tk%kAfpQ{N7!aJT!o!;*TVgW$NE_@Vm^&w24jxs_h1 zWtDEk_sgB6VXUdNpZp8Px7Uv|I8?!;^aN|Bwz+BD7K>vTsGE^xH%REDY{_(S!Ww&A zJXO{D;v}T}g}r_Z=YLq$Q&M*~_0K6ElB&bH6(IRuZ`8yp-AT+hgom1d*Z-acJ$BfW zCM^khzu>!A6ohIfdzaIkEDb!tcGpbl7yTq=o(uZXOfE+p2r)gv@u-a%V~hb*clbK; zGJk5@9r(SXFmC^axOzs8WelW{KGJwOU5sw*p6lrbmE1_0b% z;rnsD+XA&|R!Cnz{kY4cRX?;wuMNG3{7Cz0EB0c0^cH!p!#PUdzo!NW|=6h53qd^}&b6p0PuonInvlC`7a^=li z6X3@nQLE^c(J>iB{)+W?ZLw!_VP6f%qwzP2joPHVvkzlbIyrbw6fD|eOe&KxC%;VT zH-8M%@TVq288Ps!M&DhWZaBgz6@%Mt!MhYWj9M8VvpV)WuvwTaOb}Mwz`mB?<|!b4 z;x8r$)D(n*aGW1A&h=Sn8TM`J}cByfc7EnZm)87oA#j3BkMWw4DvND zGe%BrAesU58k8n1jOW?SX(yMC+ zs>=h7aw~{STO;5@H_F> z-J~9mTmGa}-w4c|W6T|KdqAU!cJ$3kBI#9z@t7KFE+yNNa5a2gr)g2H{{U>AvZ3f8 zcji&xQ?NE&cc-7w+U1IWKWc*THEN1BW(A-+;)qMqh@0ElA!3!^4&6Z+@ zrLA+7Q=(c$J)GBA-pQq8-(Y#WZev?v+UG?b^jf$0#>R71YvJ@9Fu? z*|RFR9oTIphwNL1CIl~Dk5>;JQ!N=H#@8Ix=zzH?P-vB+-gt~9M>LB8y%cDLcq(5l zV>l^hlSs!mk*ccDZ*M~1VD3#lz4ez;)lTjXZ!7~+|eWj!s zKppRXDj?Xv5dxt~XfOiZg^Rrypk`)-%FKE=p8(Ih?pl^)i-&JNuV^Cl1wN*aC$Y5- zIAWn=(x%0y=AceHyW@X}WLVmvUy6mMS+?#%*7m-zVTaFb4n}sJl+<5k2p)e0sRi7U zP)Zq|Yd4TXC=5jI?;UuRO~--Ru=4n+rUof)o5{IE1OeKkKRQc=l?{ z6H!#7i0`VY<84dgKIwntbU64?1J$UKPv^*RFT;r`q&_j-v({k2Vf_B-`4w09lF`f*3na&8pdHEd2OIlvDnOA>{Itol6DKz9@d1+fkCHWgFLL-T3$0YZ`kN*9qW>_G)0EKxLN!`esqFcb69y}G<)(gmpU|U z{@sSI{U)DR9hDjth;u$UgXHsx)A^`BggUrvWh+zNV`VK&QkBA;YkyfrFgHC|8Sgcw zCo}h!w48I;V8-4OkTi?PO_y==!MWd-e#@t(nS&1IsW0#ISD!Hf9Eh=nY+IHKnb#~kAC5D_Py(Zv)d#6c$T(rLK4K+Z8I;EBA{)sL&wviG zm=PAc=Z_MT^GdTfs=|0)WqI;0+~JMXYbF*|z6uL_dBl`9fv<1KUr({3C@Tr(Tl80g zyVrB)FxSgBE+Iu|b_5<*j?r$zDS%xMd_|0I(l_p4BadJ4`P!Aphbh_+BZ>*DnM$0? zN#=}^nCt{S$aeN7;fp+Cfx#D_P&G3yfms6i_WsuFPj{9@_A3+$-Hbsq3ky`*kqtJ^ zyOi6|dcJ0(tGFj@l;ow@JtfNT8y9j#I_*lDYsB!rK%$n9smzB!G!!vSzB1sxC(iAB zf2I}LX^0+{-!X&x15FN$AnDepC@KgYoZE5MYltukV|G2`s{DpinyE(G0wVl744b4# z{rAMv+#l;@Nb;k#W>dW?}6EV&^&5mQAYU%=C zt?vjf;-y$sFIja~_F)kjla4-PWN_Rcly>cSQKce!E|`Sxd99bxpp;j~<}Uly`R%h9 zI5>8p@qcd+|#IPH+RVKD)BVHiQDH7etsWV)=?vSI-AqF z=jOw)*oL)_J<<~XanFoYRU$V%oI;UWncN}q>GWNU9>pw{9OO{t=`#vhuR#!+24L>-!E`OK4>uzsn=B&rT?=H6$?#$p6E!-YbC5VaJq z7lJHJslce!l^GGUbiNJMOW&Z78@r>-z<6M}j%r$Y?b)ChPk2 z-8?%_Wz)318k8v#ZxQo5V?^rkw1TKq($k!725UmVk1a?58CFVKd2P$83W^JSs@R0K zl;}Jif7gzlDeW^Wb=1V(X4BJk=PV{NTnVl(l|gOl>P$e^f$Sv%rZ?@kyi$L&R~mgO za>^oeLpN_NFQI0pF9=0s$)6mp0@I?1Ymx-{S(`vVkXLM*cIcokRQCeehi5Q^+W4HI zCxFK%WKdS+{ki|(hnd9S0y`6R1hwN0LbZ=8h%ssA1^d0$h8MOB%AP{$x9FaAuj|>^ z&v2t_$BpVxj2BbdIyflv(f8|@$nWqhBHji>-{{jRRGd3i2UuS#AACsX`&xq* z-FKk{qkgH&SAwd*aHfborF1kt(oM!G^QDx^VzK{ehMhpVfU4@{UY*j%5? zpgNX5J;wO7H09^rrRkaFH+qICMa->+u`NGB3kodi>XN>$od1l}(6@Gehif297m~h2 z-k;D%uX_g14&Ctr@{P>pqwpGMshBT(guAn!TnfrUSEcpr<)~im7V*Jh0mia zuabX47f!rG{nv5VuTbfafZ`?YdLd5#;8lO!`4c6q>~3vn`zOBb53=)Lu)s_&B;Q|H z;J_)Kg6g;@MgvryQc>F>X1p)fKsGXFbb z@ptM8+n-ZU7=GuS{F3~gck&|t2fh13!~Lbh{)s*PZwL4P_*Us}pD+FI2lp>-4E&!7 z?wSA6O@HQK|4neu!uTIp#!M|s$HhU^A1Bm5L+@Z31-|aVwo<7ZL}gliUi-|^Txra& z57A)r3We;b^=59Bj~BOHKx{$kGmQDnbnJ9->j2-O^`<_fcf{vVB-3_|EWY+HrW;EO zqSyoL2UVYjR@3hmjxRYi1=6{8(5i-u8@~yqv8GLRyBk9K7*8 z1-?p7vb}Zq2Ch++`(Z;7n7XTX8=PFcjGvi(56M<5pFcxl6}bR1-fdnQ3vBpgWjzk@ zTTipesLxkUzVAVsV&gL8=I6b;2iEZMc8_^*w=*rBX!j08Xu5onRQ7mpFHiDex>@Tzgqr#di1y~72ZvX({WjFuce24MXT9;^n>KI&1vI0 z3^*iNnXIkGt4YfWck@<>O78hcsawvvy(joJrBWhuOl=8a!^dWd?sV?M z-gC-^PP0cWeWN)-C9f!Al7MzJDq)}smW9sNDC`KEcd>5i@dZqesU7z=cX zp}j?4*WWCz<8V5AefdCO-Xw)GsdmTge*bk(wPPnixvj^NqSL;dfko242WmxFzF*3g z)&^zefzdbW1S*fc5}}@sx3}?P$tyoKffjQV3OrPeM4J~36>9$H6!Ly%u0X0-0HIqn z5W)fVLA@H`oc;3!Gi*(nK^({M1>(DMApvqz^>zW8;^zNiHrwj11j zFXIaFj56U=Mm0OUNIvMaZjQ0jI5J`!Ufk90O>kGJW}YvAemVSCjCEH{Lh8jdH;)RS zlxez$kFP4%dl^kz8z$+xXyEylc=zPHSkuH+xC$77KpeJ}*YvdhSa0HhiG=ulJB{ch z*!_V%I|F(VYsuJ;cm}2oHLPVsT82qtn_;Rk=7WYAD6HRHPv62e%dbgty}vf0Xg99= zc3G)fq;4Fuj}t?CqWS@(f4%#gGq&7o>S5Js>4e*-yaiRcFN1Clv3qYc1}tfbbS>nkmz#G7D{ME zi27Fbuo+B$$9(_s3&h-JZT7o|W^>8BPVT12vd@g~BxsDf9$E#Zk>RkL*uWf;;>ym) zXN!kcz7O{?f?CB7(eSk;XU?yP%lGi#gGJy@UL2FbY6pwX49?e=S5QqKbd_oliDG8W4GSL=Nq(K|JD6V9+e8srsN*XX{S)7T0sn-!nc|qHpp! zY5WX*X04LRHd)$H+F9wbff~gqo^j|j^(|KnMLQ3#Oh4}vlR-!=Q^K5GCjOd}roxF} zAczT9o_eV3J9doj3<+^y6hBUzr}Zjhuh)k&_&NGYGpS9>owlb}2hkKd`%?$ktPA2P zkKH#EE{D;~Ce23lW93uHx`j31W5QD_d~54_S)P-IDyjuB3v2h9aLR;v;}>|#H6B`t zaBY&%1n&d|$k_@z8+P<=>Bz#@HX>quE`QYc&5<1bBP0^Aeo;D}vY*%cvsr&X-OQdCt4K0(-@1AqLbo394_EuG>@9m4*OKOX%C`=WhB`_3S? zj%XRMx3CG;6f8>fwR|0wjUd6${o0ZT6lo0!=Eq$GkE-`$@LPSWvLiCb>AgHIT|!+A zFki#$q`$xRdT5s9-gNRmQS6Uvc1CdIBIx}ZVy;d-dz^6a(OqCT663Jbgg+5C%veYC zIhyOxT`o!}Db=N^B414ioo`&nCH5hEi>yksy7uHSRMt+6LW*)sxKKQCyesEkmqqF| zV0Tq%LS%SF)$;hqa);utXtE|cd3)+7N5CwUsx&x8fn1r&Wph($*AU02w6 zG!p#Suu(?-PmtF04E`1^@wZ={A6C??Ac>QI=aTG0f9tL&YU?E0u z?+I>$Zj#Dcs2^#m*p|{qbZ$!Q0F-%rwjja~cmj-VqVELTaW-3VS`;HT$)Cd5VFfZA zU=#E7;ce0>hA={A#ew@j5fqGM{+U!npgYc84c*4&&5CF zAFPVe`H~xE#4DHWh?V8nmK09yb9q6c&Tm}7S(ijI1;GAurJ5#Z%EJ|FnP+VRa;oZ8c%``^8&ztp?W114sXDty!>;j{Gn>Y}Hqt)UZlP_X%8|6=yj={kM~l`} zPpsVr?>x??w9+@^;Wa5&V4rXrrBLG$R=~Y=|zss`vkNPA-Ow(z6EZhGIWR zHA3Yso|!vlBNydCS;yO3ziNqG+LRKfK^f<)>ODz@9xi?gE3C1X&a6685)sT9^^_Ph z*FcM}(rKiiv_9*8(rrRDNd7qON)5ZxlpyD*bROo#jd!roH9sEavFFL+SJYc zWdiRjeZ;{BbC;+}%unkW)~p_$n3Fmh*|5#1$bvXHB|jw@nl3wWmznOtp$c~h@r47ed-JJYV4UE{Bf z+&XbJA=Sp#u1RI9os-ofV%c>bu}R8=hwk&2KOv-=Gy%k@hnV7vl%c32LV0iz@-jqLxS^-p?wiJ?iVoAGS*ld&j13Je z{@{>fo=TD)F3H;>@M4e_TcbKy)w0VmS!YuMWnOQ7eLF`_KzrBjBsQpSpDJl91r)#K zs>Nsy-t5R5ejgGShfYL+@C+|tFhX-3_hJq z?$j}OR6Y2(OwEAQ!43}9r@ngoo9t5?>ERN(?)gkT;G1CP`cWReO*xX3ZiDJIhT4RTEWJmFLE7qA-ZF~BSAeOecA(VhTdA0$9+tw|JWg{py;q1IGUe`v7>z_O zNX+chlewKAQ9s`oXkA5?O>WZ@LL%!PPHv>^%6xR&#uQ+ul_XWTagyR{$Tez*Nf|k% z(=a;6ux-KS7ZWVIw0*d37`|=r8aZu&>;@{(#tbzfR{C&r_j=`vRJt#|ab2z@>)xSv zFYClXwkKy=F$8(tO6@pNJ4PBjQ_xSDtWK`l$ChXGHiBd!UGXhjK-CjzDIJR_*yvWwU`` zUkY^Q!eULqKEa*#OW3bURxV4j*rlZNT6Rg5>xWrx6+XT3gv&hpQS#!W)It--(fL|G zw^&XyKe;3i9!uuL^xNGvWn6racL4N-8Z}>5f?}zZ)1+hXs6$d|W%P^+d?z6T`CnIfi|y`42?n-^8$t zoc|$)E!5JqU6MfcVPE?>5j!Q2x6l^O`g$<=hzw0zQ!~p-|4X1;Bsc0lajDzxsx83^ zj}u*cpa7Goi~8KztorPc&eb%Jmh5hGQ%A?a?wwPI9(~`)tZc&W(DhCE&^z0aa@*-S z%B&ql)OWncCY;||q!YY8TzhPo*wNTfq+qGLDoIGosHI>jrJl-1Ot8p|pt$G<6_HYC zV>|uaikv$-??JD+q*3TR0Rr{3@_w|YdNsFU2Q={mflrdF4d!@7G*)vkg{MJv(EtH;vq$|OXf`1rS{ zYsgMk9p1x_0=Si0XNxR!Rde-gRhHf2Jp-Y!mT6;jUTal&Ywg3>O|F|)JdgVyip*0Q z&80fuj#_qz*~dU+a}(}%DV@~g;#Erw>~qewl{qdQE@H@wj!3uv=OP0UT?f4>+04^cYvP26u zed+|qzZtA?j9g>h(Z5tWI0tiwzkYJm`-3v+TGhpxbcPyji#h&SjixDV2j!4P$&cDh z>Y&oOk_`M)*hyi@RMLRM$(l$ilsx$;V48t35qsj>dz-_m22ca`Ei<}Er=)R*n)#Hi zD@1)4sw@dV{iav8MxA8kzQOgZ43|?6Sp74vI?9OXE;Hkg{1Ama!rdR6&DRx+0ZX*= zT(fjJuwQ}~J8Z9FjVNppv#J=R|2lpTmS4NWvdKr+A;FmP14L?A5OPqDvPfm@;3x{C zA2e#T8SyhEpmJKQvHravqo4imotFYJxsKr#yyqVbkOU7W!rFt=?Z}L?A7aWJ$EDK2=(vDkc)Y zHUQ`G#6`zNixe@I6#tm$D)S}Jp>R}a4NC4qvSb@^g$9FKe}*HUdu$C)OH|yb)S41H zy3>wOpJYt0=?JS3c-C7O7W?c+kx+WpGQ%y{Noc$7tG0l{kh;D5TA4?~yG}W>AOvrG z-SoQbT+#E?B7>oOjV@tDLM4QO_*0>REC%#ePM<1HBe{J4z{Zii9%8g7z)>#2krgWA zNCG09f5Im!bL`L7FnK{qCiIR!65iy{Zs%>Vqo*C0MA&&k;UH2Mq;BYNl;LDf3Jfc~ zqM@LE6Jq=s9NAG^%|CW*A*rj!8)M-*x6az6z$k?W71ZZ=ly=3%l12 znHq+?&!R;#i~`W_x)w*EdP5IVgF3tJdS_IYGa$_SS>S!J2D6!1)KVWM4U3mL-sg;G z9Hka#b~&KUB5~MwA^veg19?~~z;9Qtu#5CZAt1zOhS-b59Dkl@p|)~QJBTXgB(zIe zwWO°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 z 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 Z#to$m#ZFQg!4^`vcl3x|-gr3izW}-z0)PMj literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/CHeaders/Widgets/XPStandardWidgets.h b/xpcPlugin/SDK/CHeaders/Widgets/XPStandardWidgets.h new file mode 100755 index 0000000..fe5b4a8 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Widgets/XPStandardWidgets.h @@ -0,0 +1,580 @@ +#ifndef _XPStandardWidgets_h_ +#define _XPStandardWidgets_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * 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. + * + */ + +#include "XPWidgetDefs.h" + +#ifdef __cplusplus +extern "C" { +#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. + * + */ + + + +#define xpWidgetClass_MainWindow 1 + +/* + * Main Window Type Values + * + * These type values are used to control the appearance of a main window. + * + */ +enum { + /* 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 + * + * + */ +enum { + /* 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 + * + * + */ +enum { + /* 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. + * + */ + + + +#define xpWidgetClass_SubWindow 2 + +/* + * SubWindow Type Values + * + * These values control the appearance of the subwindow. + * + */ +enum { + /* 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 + * + * + */ +enum { + /* 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. + * + */ + + + +#define xpWidgetClass_Button 3 + +/* + * Button Types + * + * These define the visual appearance of buttons but not how they respond to + * the mouse. + * + */ +enum { + /* 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. + * + */ +enum { + /* Standard push button behavior. The button hilites while the mouse is * + * clicked over it and unhilites when the mouse is moved outside of it or * + * released. If the mouse is released over the button, the * + * xpMsg_PushButtonPressed message is sent. */ + xpButtonBehaviorPushButton = 0 + + /* 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 + * + * + */ +enum { + /* 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.) + * + */ +enum { + /* This message is sent when the user completes a click and release in a * + * button with push button behavior. Parameter one of the message is the * + * widget ID of the button. This message is dispatched up the widget * + * hierarchy. */ + xpMsg_PushButtonPressed = 1300 + + /* This message is sent when 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). + * + */ + + + +#define xpWidgetClass_TextField 4 + +/* + * Text Field Type Values + * + * These control the look of the text field. + * + */ +enum { + /* 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 + * + * + */ +enum { + /* This is the character position the selection starts at, zero based. If it * + * is the same as the end insertion point, the insertion point is not a * + * selection. */ + xpProperty_EditFieldSelStart = 1400 + + /* This is the character position 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 + * + * + */ +enum { + /* Text Field Messages * + * * + * The text field sends this message to itself when its text changes. It * + * sends the message up the call chain; param1 is the text field's widget ID. */ + xpMsg_TextFieldChanged = 1400 + + +}; + +/*************************************************************************** + * 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. + * + */ + + + +#define xpWidgetClass_ScrollBar 5 + +/* + * Scroll Bar Type Values + * + * This defines how the scroll bar looks. + * + */ +enum { + /* 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 + * + * + */ +enum { + /* 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 + * + * + */ +enum { + /* The Scroll Bar sends this message when the slider position changes. It * + * sends the message up the call chain; param1 is the Scroll Bar widget ID. */ + xpMsg_ScrollBarSliderPositionChanged = 1500 + + +}; + +/*************************************************************************** + * 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. + * + */ + + + +#define xpWidgetClass_Caption 6 + +/* + * Caption Properties + * + * + */ +enum { + /* 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. + * + */ + + + +#define xpWidgetClass_GeneralGraphics 7 + +/* + * General Graphics Types Values + * + * These define the icon for the general graphics. + * + */ +enum { + 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 + * + * + */ +enum { + /* 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. + * + */ + + + +#define xpWidgetClass_Progress 8 + +/* + * Progress Indicator Properties + * + * + */ +enum { + /* 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 + + +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/Widgets/XPUIGraphics.h b/xpcPlugin/SDK/CHeaders/Widgets/XPUIGraphics.h new file mode 100755 index 0000000..24822c6 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Widgets/XPUIGraphics.h @@ -0,0 +1,363 @@ +#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 + * + */ + +/* + * + * + */ + +#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 diff --git a/xpcPlugin/SDK/CHeaders/Widgets/XPWidgetDefs.h b/xpcPlugin/SDK/CHeaders/Widgets/XPWidgetDefs.h new file mode 100755 index 0000000..18a1bca --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Widgets/XPWidgetDefs.h @@ -0,0 +1,486 @@ +#ifndef _XPWidgetDefs_h_ +#define _XPWidgetDefs_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * + * + */ + +#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 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 + + +}; +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 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 + + +}; +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 * + * 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 + +#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 ptr-width signed parameters whose + * meaning varies with the message. Return 1 to indicate that you have + * processed the message, 0 to indicate that you have not. For any message + * that is not understood, return 0. + * + */ +typedef int (* XPWidgetFunc_t)( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + intptr_t inParam1, + intptr_t inParam2); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/Widgets/XPWidgetUtils.h b/xpcPlugin/SDK/CHeaders/Widgets/XPWidgetUtils.h new file mode 100755 index 0000000..e61d272 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Widgets/XPWidgetUtils.h @@ -0,0 +1,234 @@ +#ifndef _XPWidgetUtils_h_ +#define _XPWidgetUtils_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * 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. + * + */ + +#include "XPWidgetDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * GENERAL UTILITIES + ***************************************************************************/ +/* + * + * + */ + + + + +/* + * Convenience accessors + * + * It can be clumsy accessing the variables passed in by pointer to a struct + * for mouse and reshape messages; these accessors let you simply pass in the param + * right from the arguments of your widget proc and get back the value you want. + * + */ +#define MOUSE_X(param) (((XPMouseState_t *) (param))->x) +#define MOUSE_Y(param) (((XPMouseState_t *) (param))->y) + +#define DELTA_X(param) (((XPWidgetGeometryChange_t *) (param))->dx) +#define DELTA_Y(param) (((XPWidgetGeometryChange_t *) (param))->dy) +#define DELTA_W(param) (((XPWidgetGeometryChange_t *) (param))->dwidth) +#define DELTA_H(param) (((XPWidgetGeometryChange_t *) (param))->dheight) + +#define KEY_CHAR(param) (((XPKeyState_t *) (param))->key) +#define KEY_FLAGS(param) (((XPKeyState_t *) (param))->flags) +#define KEY_VKEY(param) (((XPKeyState_t *) (param))->vkey) + +#define IN_RECT(x, y, l, t, r, b) \ + (((x) >= (l)) && ((x) <= (r)) && ((y) >= (b)) && ((y) <= (t))) + +/* + * 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. + * + */ +typedef struct { + int left; + int top; + int right; + int bottom; + int visible; + const char * descriptor; + int isRoot; + int containerIndex; + XPWidgetClass widgetClass; +} XPWidgetCreate_t; + +#define NO_PARENT -1 + +#define PARAM_PARENT -2 + +#define WIDGET_COUNT(x) ((sizeof(x) / sizeof(XPWidgetCreate_t))) + +/* + * XPUCreateWidgets + * + * This function creates a series of widgets from a table...see + * XPCreateWidget_t above. Pass in an array of widget creation structures and + * 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. + * + */ +WIDGET_API void XPUCreateWidgets( + const XPWidgetCreate_t * inWidgetDefs, + int inCount, + XPWidgetID inParamParent, + XPWidgetID * ioWidgets); + +/* + * XPUMoveWidgetBy + * + * Simply moves a widget by an amount, +x = right, +y=up, without resizing the + * widget. + * + */ +WIDGET_API void XPUMoveWidgetBy( + XPWidgetID inWidget, + int inDeltaX, + int inDeltaY); + +/*************************************************************************** + * 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. + * + */ +WIDGET_API int XPUFixedLayout( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + intptr_t inParam1, + intptr_t inParam2); + +/*************************************************************************** + * 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. + * + */ +WIDGET_API int XPUSelectIfNeeded( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + intptr_t inParam1, + intptr_t inParam2, + int inEatClick); + +/* + * XPUDefocusKeyboard + * + * This causes a click in the widget to send keyboard focus back to X-Plane. + * This stops editing of any text fields, etc. + * + */ +WIDGET_API int XPUDefocusKeyboard( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + intptr_t inParam1, + intptr_t inParam2, + int inEatClick); + +/* + * XPUDragWidget + * + * XPUDragWidget drags the widget in response to mouse clicks. Pass in not + * only the event, but the global coordinates of the drag region, which might + * be a sub-region of your widget (for example, a title bar). + * + */ +WIDGET_API int XPUDragWidget( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + intptr_t inParam1, + intptr_t inParam2, + int inLeft, + int inTop, + int inRight, + int inBottom); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/Widgets/XPWidgets.h b/xpcPlugin/SDK/CHeaders/Widgets/XPWidgets.h new file mode 100755 index 0000000..13ca62e --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Widgets/XPWidgets.h @@ -0,0 +1,569 @@ +#ifndef _XPWidgets_h_ +#define _XPWidgets_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * 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. + * + */ + +#include "XPWidgetDefs.h" + +#ifdef __cplusplus +extern "C" { +#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. + * + */ +WIDGET_API XPWidgetID XPCreateWidget( + int inLeft, + int inTop, + int inRight, + int inBottom, + int inVisible, + const char * inDescriptor, + int inIsRoot, + XPWidgetID inContainer, + XPWidgetClass inClass); + +/* + * XPCreateCustomWidget + * + * This function is the same as XPCreateWidget except that instead of passing + * a class ID, you pass your widget callback function pointer defining the + * widget. Use this function to define a custom widget. All parameters are + * the same as XPCreateWidget, except that the widget class has been replaced + * with the widget function. + * + */ +WIDGET_API XPWidgetID XPCreateCustomWidget( + int inLeft, + int inTop, + int inRight, + int inBottom, + int inVisible, + const char * inDescriptor, + int inIsRoot, + XPWidgetID inContainer, + XPWidgetFunc_t inCallback); + +/* + * XPDestroyWidget + * + * This class destroys a widget. Pass in the ID of the widget to kill. If + * you pass 1 for inDestroyChilren, the widget's children will be destroyed + * first, then this widget will be destroyed. (Furthermore, the widget's + * children will be destroyed with the inDestroyChildren flag set to 1, so the + * destruction will recurse down the widget tree.) If you pass 0 for this + * flag, the child widgets will simply end up with their parent set to 0. + * + */ +WIDGET_API void XPDestroyWidget( + XPWidgetID inWidget, + int inDestroyChildren); + +/* + * 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. + * + */ +WIDGET_API int XPSendMessageToWidget( + XPWidgetID inWidget, + XPWidgetMessage inMessage, + XPDispatchMode inMode, + intptr_t inParam1, + intptr_t inParam2); + +/*************************************************************************** + * WIDGET POSITIONING AND VISIBILITY + ***************************************************************************/ +/* + * + * + */ + + +/* + * XPPlaceWidgetWithin + * + * This function changes which container a widget resides in. You may NOT use + * this function on a root widget! inSubWidget is the widget that will be + * moved. Pass a widget ID in inContainer to make inSubWidget be a child of + * inContainer. It will become the last/closest widget in the container. + * Pass 0 to remove the widget from any container. Any call to this other + * than passing the widget ID of the old parent of the affected widget will + * cause the widget to be removed from its old parent. Placing a widget within + * its own parent simply makes it the last widget. + * + * 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. + * + */ +WIDGET_API void XPPlaceWidgetWithin( + XPWidgetID inSubWidget, + XPWidgetID inContainer); + +/* + * XPCountChildWidgets + * + * This routine returns the number of widgets another widget contains. + * + */ +WIDGET_API int XPCountChildWidgets( + XPWidgetID inWidget); + +/* + * 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. + * + */ +WIDGET_API XPWidgetID XPGetNthChildWidget( + XPWidgetID inWidget, + int inIndex); + +/* + * XPGetParentWidget + * + * This routine returns the parent of a widget, or 0 if the widget has no + * parent. Root widgets never have parents and therefore always return 0. + * + */ +WIDGET_API XPWidgetID XPGetParentWidget( + XPWidgetID inWidget); + +/* + * 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. + * + */ +WIDGET_API void XPShowWidget( + XPWidgetID inWidget); + +/* + * XPHideWidget + * + * Makes a widget invisible. See XPShowWidget for considerations of when a + * widget might not be visible despite its own visibility state. + * + */ +WIDGET_API void XPHideWidget( + XPWidgetID inWidget); + +/* + * 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. + * + */ +WIDGET_API int XPIsWidgetVisible( + XPWidgetID inWidget); + +/* + * XPFindRootWidget + * + * XPFindRootWidget returns the Widget ID of the root widget that contains the + * passed in widget or NULL if the passed in widget is not in a rooted + * hierarchy. + * + */ +WIDGET_API XPWidgetID XPFindRootWidget( + XPWidgetID inWidget); + +/* + * XPBringRootWidgetToFront + * + * This routine makes the specified widget be in the front most widget + * hierarchy. If this widget is a root widget, its widget hierarchy comes to + * front, otherwise the widget's root is brought to the front. If this widget + * is not in an active widget hiearchy (e.g. there is no root widget at the + * top of the tree), this routine does nothing. + * + */ +WIDGET_API void XPBringRootWidgetToFront( + XPWidgetID inWidget); + +/* + * 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. + * + */ +WIDGET_API int XPIsWidgetInFront( + XPWidgetID inWidget); + +/* + * XPGetWidgetGeometry + * + * This routine returns the bounding box of a widget in global coordinates. + * Pass NULL for any parameter you are not interested in. + * + */ +WIDGET_API void XPGetWidgetGeometry( + XPWidgetID inWidget, + int * outLeft, /* Can be NULL */ + int * outTop, /* Can be NULL */ + int * outRight, /* Can be NULL */ + int * outBottom); /* Can be NULL */ + +/* + * XPSetWidgetGeometry + * + * This function changes the bounding box of a widget. + * + */ +WIDGET_API void XPSetWidgetGeometry( + XPWidgetID inWidget, + int inLeft, + int inTop, + int inRight, + int inBottom); + +/* + * XPGetWidgetForLocation + * + * Given a widget and a location, this routine returns the widget ID of the + * child of that widget that owns that location. If inRecursive is true then + * 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. + * + */ +WIDGET_API XPWidgetID XPGetWidgetForLocation( + XPWidgetID inContainer, + int inXOffset, + int inYOffset, + int inRecursive, + int inVisibleOnly); + +/* + * XPGetWidgetExposedGeometry + * + * This routine returns the bounds of the area of a widget that is completely + * within its parent widgets. Since a widget's bounding box can be outside + * its parent, part of its area will not be elligible for mouse clicks and + * should not draw. Use XPGetWidgetGeometry to find out what area defines + * your widget's shape, but use this routine to find out what area to actually + * draw into. Note that the widget library does not use OpenGL clipping to + * keep frame rates up, although you could use it internally. + * + */ +WIDGET_API void XPGetWidgetExposedGeometry( + XPWidgetID inWidgetID, + int * outLeft, /* Can be NULL */ + int * outTop, /* Can be NULL */ + int * outRight, /* Can be NULL */ + int * outBottom); /* Can be NULL */ + +/*************************************************************************** + * ACCESSING WIDGET DATA + ***************************************************************************/ +/* + * + * + */ + + +/* + * XPSetWidgetDescriptor + * + * Every widget has a descriptor, which is a text string. What the text + * string is used for varies from widget to widget; for example, a push + * button's text is its descriptor, a caption shows its descriptor, and a text + * field's descriptor is the text being edited. In other words, the usage for + * the text varies from widget to widget, but this API provides a universal + * and convenient way to get at it. While not all UI widgets need their + * descriptor, many do. + * + */ +WIDGET_API void XPSetWidgetDescriptor( + XPWidgetID inWidget, + const char * inDescriptor); + +/* + * XPGetWidgetDescriptor + * + * This routine returns the widget's descriptor. Pass in the length of the + * buffer you are going to receive the descriptor in. The descriptor will be + * null terminated for you. This routine returns the length of the actual + * descriptor; if you pass NULL for outDescriptor, you can get the + * descriptor's length without getting its text. If the length of the + * descriptor exceeds your buffer length, the buffer will not be null + * terminated (this routine has 'strncpy' semantics). + * + */ +WIDGET_API int XPGetWidgetDescriptor( + XPWidgetID inWidget, + char * outDescriptor, + int inMaxDescLength); + +/* + * XPSetWidgetProperty + * + * This function sets a widget's property. Properties are arbitrary values + * associated by a widget by ID. + * + */ +WIDGET_API void XPSetWidgetProperty( + XPWidgetID inWidget, + XPWidgetPropertyID inProperty, + intptr_t inValue); + +/* + * 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. + * + */ +WIDGET_API intptr_t XPGetWidgetProperty( + XPWidgetID inWidget, + XPWidgetPropertyID inProperty, + int * inExists); /* Can be NULL */ + +/*************************************************************************** + * KEYBOARD MANAGEMENT + ***************************************************************************/ +/* + * + * + */ + + +/* + * XPSetKeyboardFocus + * + * XPSetKeyboardFocus controls which widget will receive keystrokes. Pass the + * Widget ID of the widget to get the keys. Note that if the widget does not + * care about keystrokes, they will go to the parent widget, and if no widget + * cares about them, they go to X-Plane. + * + * 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. + * + * * + */ +WIDGET_API XPWidgetID XPSetKeyboardFocus( + XPWidgetID inWidget); + +/* + * XPLoseKeyboardFocus + * + * This causes the specified widget to lose focus; focus is passed to its + * parent, or the next parent that will accept it. This routine does nothing + * if this widget does not have focus. + * + */ +WIDGET_API void XPLoseKeyboardFocus( + XPWidgetID inWidget); + +/* + * 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. + * + */ +WIDGET_API XPWidgetID XPGetWidgetWithFocus(void); + +/*************************************************************************** + * 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. + * + */ +WIDGET_API void XPAddWidgetCallback( + XPWidgetID inWidget, + XPWidgetFunc_t inNewCallback); + +/* + * XPGetWidgetClassFunc + * + * Given a widget class, this function returns the callbacks that power that + * widget class. + * + */ +WIDGET_API XPWidgetFunc_t XPGetWidgetClassFunc( + XPWidgetClass inWidgetClass); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.cpp b/xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.cpp new file mode 100755 index 0000000..c2b9c1d --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.cpp @@ -0,0 +1,56 @@ +#include "XPCBroadcaster.h" +#include "XPCListener.h" + +XPCBroadcaster::XPCBroadcaster() : + mIterator(NULL) +{ +} + +XPCBroadcaster::~XPCBroadcaster() +{ + ListenerVector::iterator iter; + mIterator = &iter; + for (iter = mListeners.begin(); iter != mListeners.end(); ++iter) + { + (*iter)->BroadcasterRemoved(this); + } +} + +void XPCBroadcaster::AddListener( + XPCListener * inListener) +{ + mListeners.push_back(inListener); + inListener->BroadcasterAdded(this); +} + +void XPCBroadcaster::RemoveListener( + XPCListener * inListener) +{ + ListenerVector::iterator iter = std::find + (mListeners.begin(), mListeners.end(), inListener); + if (iter == mListeners.end()) + return; + + if (mIterator != NULL) + { + if (*mIterator >= iter) + (*mIterator)--; + } + + mListeners.erase(iter); + inListener->BroadcasterRemoved(this); +} + +void XPCBroadcaster::BroadcastMessage( + long inMessage, + void * inParam) +{ + ListenerVector::iterator iter; + mIterator = &iter; + for (iter = mListeners.begin(); iter != mListeners.end(); ++iter) + { + (*iter)->ListenToMessage(inMessage, inParam); + } + mIterator = NULL; +} + diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.h b/xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.h new file mode 100755 index 0000000..382c3f9 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCBroadcaster.h @@ -0,0 +1,38 @@ +#ifndef _XPCBroadcaster_h_ +#define _XPCBroadcaster_h_ + +#include +#include + +class XPCListener; + +class XPCBroadcaster { +public: + + XPCBroadcaster(); + virtual ~XPCBroadcaster(); + + void AddListener( + XPCListener * inListener); + void RemoveListener( + XPCListener * inListener); + +protected: + + void BroadcastMessage( + long inMessage, + void * inParam=0); + +private: + + typedef std::vector ListenerVector; + + ListenerVector mListeners; + + // Reentrancy support + + ListenerVector::iterator * mIterator; + +}; + +#endif \ No newline at end of file diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.cpp b/xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.cpp new file mode 100755 index 0000000..fc996ca --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.cpp @@ -0,0 +1,104 @@ +#include "XPCDisplay.h" + +XPCKeySniffer::XPCKeySniffer(int inBeforeWindows) : mBeforeWindows(inBeforeWindows) +{ + XPLMRegisterKeySniffer(KeySnifferCB, mBeforeWindows, reinterpret_cast(this)); +} + +XPCKeySniffer::~XPCKeySniffer() +{ + XPLMUnregisterKeySniffer(KeySnifferCB, mBeforeWindows, reinterpret_cast(this)); +} + + +int XPCKeySniffer::KeySnifferCB( + char inCharKey, + XPLMKeyFlags inFlags, + char inVirtualKey, + void * inRefCon) +{ + XPCKeySniffer * me = reinterpret_cast(inRefCon); + return me->HandleKeyStroke(inCharKey, inFlags, inVirtualKey); +} + +XPCWindow::XPCWindow( + int inLeft, + int inTop, + int inRight, + int inBottom, + int inIsVisible) +{ + mWindow = XPLMCreateWindow(inLeft, inTop, inRight, inBottom, inIsVisible, + DrawCB, HandleKeyCB, MouseClickCB, + reinterpret_cast(this)); +} + +XPCWindow::~XPCWindow() +{ + XPLMDestroyWindow(mWindow); +} + +void XPCWindow::GetWindowGeometry( + int * outLeft, + int * outTop, + int * outRight, + int * outBottom) +{ + XPLMGetWindowGeometry(mWindow, outLeft, outTop, outRight, outBottom); +} + +void XPCWindow::SetWindowGeometry( + int inLeft, + int inTop, + int inRight, + int inBottom) +{ + XPLMSetWindowGeometry(mWindow, inLeft, inTop, inRight, inBottom); +} + +int XPCWindow::GetWindowIsVisible(void) +{ + return XPLMGetWindowIsVisible(mWindow); +} + +void XPCWindow::SetWindowIsVisible( + int inIsVisible) +{ + XPLMSetWindowIsVisible(mWindow, inIsVisible); +} + +void XPCWindow::TakeKeyboardFocus(void) +{ + XPLMTakeKeyboardFocus(mWindow); +} + +void XPCWindow::BringWindowToFront(void) +{ + XPLMBringWindowToFront(mWindow); +} + +int XPCWindow::IsWindowInFront(void) +{ + return XPLMIsWindowInFront(mWindow); +} + +void XPCWindow::DrawCB(XPLMWindowID inWindowID, void * inRefcon) +{ + XPCWindow * me = reinterpret_cast(inRefcon); + me->DoDraw(); +} + +void XPCWindow::HandleKeyCB(XPLMWindowID inWindowID, char inKey, XPLMKeyFlags inFlags, char inVirtualKey, void * inRefcon, int losingFocus) +{ + XPCWindow * me = reinterpret_cast(inRefcon); + if (losingFocus) + me->LoseFocus(); + else + me->HandleKey(inKey, inFlags, inVirtualKey); +} + +int XPCWindow::MouseClickCB(XPLMWindowID inWindowID, int x, int y, XPLMMouseStatus inMouse, void * inRefcon) +{ + XPCWindow * me = reinterpret_cast(inRefcon); + return me->HandleClick(x, y, inMouse); +} diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.h b/xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.h new file mode 100755 index 0000000..2465928 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCDisplay.h @@ -0,0 +1,73 @@ +#ifndef _XPCDisplay_h_ +#define _XPCDisplay_h_ + +#include "XPLMDisplay.h" + +class XPCKeySniffer { +public: + + XPCKeySniffer(int inBeforeWindows); + virtual ~XPCKeySniffer(); + + virtual int HandleKeyStroke( + char inCharKey, + XPLMKeyFlags inFlags, + char inVirtualKey)=0; + +private: + + int mBeforeWindows; + + static int KeySnifferCB( + char inCharKey, + XPLMKeyFlags inFlags, + char inVirtualKey, + void * inRefCon); +}; + + + +class XPCWindow { +public: + + XPCWindow( + int inLeft, + int inTop, + int inRight, + int inBottom, + int inIsVisible); + virtual ~XPCWindow(); + + virtual void DoDraw(void)=0; + virtual void HandleKey(char inKey, XPLMKeyFlags inFlags, char inVirtualKey)=0; + virtual void LoseFocus(void)=0; + virtual int HandleClick(int x, int y, XPLMMouseStatus inMouse)=0; + + void GetWindowGeometry( + int * outLeft, + int * outTop, + int * outRight, + int * outBottom); + void SetWindowGeometry( + int inLeft, + int inTop, + int inRight, + int inBottom); + int GetWindowIsVisible(void); + void SetWindowIsVisible( + int inIsVisible); + void TakeKeyboardFocus(void); + void BringWindowToFront(void); + int IsWindowInFront(void); + +private: + + XPLMWindowID mWindow; + + static void DrawCB(XPLMWindowID inWindowID, void * inRefcon); + static void HandleKeyCB(XPLMWindowID inWindowID, char inKey, XPLMKeyFlags inFlags, char inVirtualKey, void * inRefcon, int losingFocus); + static int MouseClickCB(XPLMWindowID inWindowID, int x, int y, XPLMMouseStatus inMouse, void * inRefcon); + +}; + +#endif \ No newline at end of file diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.cpp b/xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.cpp new file mode 100755 index 0000000..b4c77aa --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.cpp @@ -0,0 +1,27 @@ +#include "XPCListener.h" +#include "XPCBroadcaster.h" + +XPCListener::XPCListener() +{ +} + +XPCListener::~XPCListener() +{ + while (!mBroadcasters.empty()) + mBroadcasters.front()->RemoveListener(this); +} + +void XPCListener::BroadcasterAdded( + XPCBroadcaster * inBroadcaster) +{ + mBroadcasters.push_back(inBroadcaster); +} + +void XPCListener::BroadcasterRemoved( + XPCBroadcaster * inBroadcaster) +{ + BroadcastVector::iterator iter = std::find(mBroadcasters.begin(), + mBroadcasters.end(), inBroadcaster); + if (iter != mBroadcasters.end()) + mBroadcasters.erase(iter); +} diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.h b/xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.h new file mode 100755 index 0000000..02d5bea --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCListener.h @@ -0,0 +1,36 @@ +#ifndef _XPCListener_h_ +#define _XPCListener_h_ + +#include +#include + +class XPCBroadcaster; + + +class XPCListener { +public: + + XPCListener(); + virtual ~XPCListener(); + + virtual void ListenToMessage( + long inMessage, + void * inParam)=0; + +private: + + typedef std::vector BroadcastVector; + + BroadcastVector mBroadcasters; + + friend class XPCBroadcaster; + + void BroadcasterAdded( + XPCBroadcaster * inBroadcaster); + + void BroadcasterRemoved( + XPCBroadcaster * inBroadcaster); + +}; + +#endif \ No newline at end of file diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.cpp b/xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.cpp new file mode 100755 index 0000000..bb8ebc3 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.cpp @@ -0,0 +1,52 @@ +#include "XPCProcessing.h" +#include "XPLMUtilities.h" + +XPCProcess::XPCProcess() : + mInCallback(false), + mCallbackTime(0) +{ + XPLMRegisterFlightLoopCallback(FlightLoopCB, 0, reinterpret_cast(this)); +} + +XPCProcess::~XPCProcess() +{ + XPLMUnregisterFlightLoopCallback(FlightLoopCB, reinterpret_cast(this)); +} + +void XPCProcess::StartProcessTime(float inSeconds) +{ + mCallbackTime = inSeconds; + if (!mInCallback) + XPLMSetFlightLoopCallbackInterval( + FlightLoopCB, mCallbackTime, 1/*relative to now*/, reinterpret_cast(this)); +} + +void XPCProcess::StartProcessCycles(long inCycles) +{ + mCallbackTime = -inCycles; + if (!mInCallback) + XPLMSetFlightLoopCallbackInterval( + FlightLoopCB, mCallbackTime, 1/*relative to now*/, reinterpret_cast(this)); +} + +void XPCProcess::StopProcess(void) +{ + mCallbackTime = 0; + if (!mInCallback) + XPLMSetFlightLoopCallbackInterval( + FlightLoopCB, mCallbackTime, 1/*relative to now*/, reinterpret_cast(this)); +} + + +float XPCProcess::FlightLoopCB( + float inElapsedSinceLastCall, + float inElapsedTimeSinceLastFlightLoop, + int inCounter, + void * inRefcon) +{ + XPCProcess * me = reinterpret_cast(inRefcon); + me->mInCallback = true; + me->DoProcessing(inElapsedSinceLastCall, inElapsedTimeSinceLastFlightLoop, inCounter); + me->mInCallback = false; + return me->mCallbackTime; +} \ No newline at end of file diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.h b/xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.h new file mode 100755 index 0000000..7d21c4f --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCProcessing.h @@ -0,0 +1,37 @@ +#ifndef _XPCProcessing_h_ +#define _XPCProcessing_h_ + +#include "XPLMProcessing.h" + +class XPCProcess { +public: + + XPCProcess(); + virtual ~XPCProcess(); + + void StartProcessTime(float inSeconds); + void StartProcessCycles(long inCycles); + void StopProcess(void); + + virtual void DoProcessing( + float inElapsedSinceLastCall, + float inElapsedTimeSinceLastFlightLoop, + int inCounter)=0; + +private: + + static float FlightLoopCB( + float inElapsedSinceLastCall, + float inElapsedTimeSinceLastFlightLoop, + int inCounter, + void * inRefcon); + + bool mInCallback; + float mCallbackTime; + + XPCProcess(const XPCProcess&); + XPCProcess& operator=(const XPCProcess&); + +}; + +#endif diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.cpp b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.cpp new file mode 100755 index 0000000..dcb7793 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.cpp @@ -0,0 +1,123 @@ +#include "XPCWidget.h" + +XPCWidget::XPCWidget( + int inLeft, + int inTop, + int inRight, + int inBottom, + bool inVisible, + const char * inDescriptor, + bool inIsRoot, + XPWidgetID inParent, + XPWidgetClass inClass) : + mWidget(NULL), + mOwnsChildren(false), + mOwnsWidget(true) +{ + mWidget = XPCreateWidget( + inLeft, inTop, inRight, inBottom, + inVisible ? 1 : 0, + inDescriptor, + inIsRoot ? 1 : 0, + inIsRoot ? NULL : inParent, + inClass); + + XPSetWidgetProperty(mWidget, xpProperty_Object, reinterpret_cast(this)); + XPAddWidgetCallback(mWidget, WidgetCallback); +} + +XPCWidget::XPCWidget( + XPWidgetID inWidget, + bool inOwnsWidget) : + mWidget(inWidget), + mOwnsChildren(false), + mOwnsWidget(inOwnsWidget) +{ + XPSetWidgetProperty(mWidget, xpProperty_Object, reinterpret_cast(this)); + XPAddWidgetCallback(mWidget, WidgetCallback); +} + +XPCWidget::~XPCWidget() +{ + if (mOwnsWidget) + XPDestroyWidget(mWidget, mOwnsChildren ? 1 : 0); +} + +void XPCWidget::SetOwnsWidget( + bool inOwnsWidget) +{ + mOwnsWidget = inOwnsWidget; +} + +void XPCWidget::SetOwnsChildren( + bool inOwnsChildren) +{ + mOwnsChildren = inOwnsChildren; +} + +XPCWidget::operator XPWidgetID () const +{ + return mWidget; +} + +XPWidgetID XPCWidget::Get(void) const +{ + return mWidget; +} + +void XPCWidget::AddAttachment( + XPCWidgetAttachment * inAttachment, + bool inOwnsAttachment, + bool inPrefilter) +{ + if (inPrefilter) + { + mAttachments.insert(mAttachments.begin(), AttachmentInfo(inAttachment, inOwnsAttachment)); + } else { + mAttachments.push_back(AttachmentInfo(inAttachment, inOwnsAttachment)); + } +} + +void XPCWidget::RemoveAttachment( + XPCWidgetAttachment * inAttachment) +{ + for (AttachmentVector::iterator iter = mAttachments.begin(); + iter != mAttachments.end(); ++iter) + { + if (iter->first == inAttachment) + { + mAttachments.erase(iter); + return; + } + } +} + +int XPCWidget::HandleWidgetMessage( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + return 0; +} + +int XPCWidget::WidgetCallback( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + XPCWidget * me = reinterpret_cast(XPGetWidgetProperty(inWidget, xpProperty_Object, NULL)); + if (me == NULL) + return 0; + + for (AttachmentVector::iterator iter = me->mAttachments.begin(); iter != + me->mAttachments.end(); ++iter) + { + int result = iter->first->HandleWidgetMessage(me, inMessage, inWidget, inParam1, inParam2); + if (result != 0) + return result; + } + + return me->HandleWidgetMessage(inMessage, inWidget, inParam1, inParam2); +} diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.h b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.h new file mode 100755 index 0000000..6ce6a22 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidget.h @@ -0,0 +1,84 @@ +#ifndef _XPCWidget_h_ +#define _XPCWidget_h_ + +#include +#include +#include "XPWidgets.h" + +class XPCWidget; + +class XPCWidgetAttachment { +public: + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2)=0; + +}; + +class XPCWidget { +public: + + XPCWidget( + int inLeft, + int inTop, + int inRight, + int inBottom, + bool inVisible, + const char * inDescriptor, + bool inIsRoot, + XPWidgetID inParent, + XPWidgetClass inClass); + XPCWidget( + XPWidgetID inWidget, + bool inOwnsWidget); + virtual ~XPCWidget(); + + void SetOwnsWidget( + bool inOwnsWidget); + void SetOwnsChildren( + bool inOwnsChildren); + + operator XPWidgetID () const; + + XPWidgetID Get(void) const; + + void AddAttachment( + XPCWidgetAttachment * inAttachment, + bool inOwnsAttachment, + bool inPrefilter); + void RemoveAttachment( + XPCWidgetAttachment * inAttachment); + + virtual int HandleWidgetMessage( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +private: + + static int WidgetCallback( + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + + typedef std::pair AttachmentInfo; + typedef std::vector AttachmentVector; + + AttachmentVector mAttachments; + XPWidgetID mWidget; + bool mOwnsChildren; + bool mOwnsWidget; + + XPCWidget(); + XPCWidget(const XPCWidget&); + XPCWidget& operator=(const XPCWidget&); + +}; + +#endif \ No newline at end of file diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.cpp b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.cpp new file mode 100755 index 0000000..3e13775 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.cpp @@ -0,0 +1,267 @@ +#include "XPCWidgetAttachments.h" +#include "XPStandardWidgets.h" +#include "XPWidgetUtils.h" + +static void XPCGetOrderedSubWidgets( + XPWidgetID inWidget, + std::vector& outChildren); + +XPCKeyFilterAttachment::XPCKeyFilterAttachment( + const char * inValidKeys, + const char * outValidKeys) : + mInput(inValidKeys), + mOutput(outValidKeys) +{ +} + +XPCKeyFilterAttachment::~XPCKeyFilterAttachment() +{ +} + +int XPCKeyFilterAttachment::HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + if (inMessage == xpMsg_KeyPress) + { + char& theKey = KEY_CHAR(inParam1); + std::string::size_type pos = mInput.find(theKey); + if (pos == std::string::npos) + return 1; // Not found; eat the key! + else { + theKey = mOutput[pos]; + return 0; + } // Let it live. + } + return 0; +} + + +XPCKeyMessageAttachment::XPCKeyMessageAttachment( + char inKey, + long inMessage, + void * inParam, + bool inConsume, + bool inVkey, + XPCListener * inListener) : + mKey(inKey), mMsg(inMessage), mParam(inParam), mConsume(inConsume), + mVkey(inVkey) +{ + if (inListener != NULL) + this->AddListener(inListener); +} + +XPCKeyMessageAttachment::~XPCKeyMessageAttachment() +{ +} + +int XPCKeyMessageAttachment::HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + if (inMessage == xpMsg_KeyPress) + { + char theKey = mVkey ? KEY_VKEY(inParam1) : KEY_CHAR(inParam1); + if (theKey != mKey) + return 0; + if (!(KEY_FLAGS(inParam1) & xplm_DownFlag)) + return 0; + + BroadcastMessage(mMsg, mParam); + return mConsume ? 1 : 0; + } + return 0; +} + +XPCPushButtonMessageAttachment::XPCPushButtonMessageAttachment( + XPWidgetID inWidget, + long inMessage, + void * inParam, + XPCListener * inListener) : + mMsg(inMessage), mParam(inParam), mWidget(inWidget) +{ + if (inListener != NULL) + this->AddListener(inListener); +} + +XPCPushButtonMessageAttachment::~XPCPushButtonMessageAttachment() +{ +} + +int XPCPushButtonMessageAttachment::HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + if ((inMessage == xpMsg_PushButtonPressed) && ((XPWidgetID) inParam1 == mWidget)) + { + BroadcastMessage(mMsg, mParam); + return 1; + } + + if ((inMessage == xpMsg_ButtonStateChanged) && ((XPWidgetID) inParam1 == mWidget)) + { + BroadcastMessage(mMsg, mParam); + return 1; + } + return 0; +} + +XPCSliderMessageAttachment::XPCSliderMessageAttachment( + XPWidgetID inWidget, + long inMessage, + void * inParam, + XPCListener * inListener) : + mMsg(inMessage), mParam(inParam), mWidget(inWidget) +{ + if (inListener != NULL) + this->AddListener(inListener); +} + +XPCSliderMessageAttachment::~XPCSliderMessageAttachment() +{ +} + +int XPCSliderMessageAttachment::HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + if ((inMessage == xpMsg_ScrollBarSliderPositionChanged) && ((XPWidgetID) inParam1 == mWidget)) + { + BroadcastMessage(mMsg, mParam); + return 1; + } + + return 0; +} + + +XPCCloseButtonMessageAttachment::XPCCloseButtonMessageAttachment( + XPWidgetID inWidget, + long inMessage, + void * inParam, + XPCListener * inListener) : + mMsg(inMessage), mParam(inParam), mWidget(inWidget) +{ + if (inListener != NULL) + this->AddListener(inListener); +} + +XPCCloseButtonMessageAttachment::~XPCCloseButtonMessageAttachment() +{ +} + +int XPCCloseButtonMessageAttachment::HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + if ((inMessage == xpMessage_CloseButtonPushed) && ((XPWidgetID) inParam1 == mWidget)) + { + BroadcastMessage(mMsg, mParam); + return 1; + } + + return 0; +} + +XPCTabGroupAttachment::XPCTabGroupAttachment() +{ +} + +XPCTabGroupAttachment::~XPCTabGroupAttachment() +{ +} + +int XPCTabGroupAttachment::HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2) +{ + if ((inMessage == xpMsg_KeyPress) && (KEY_CHAR(inParam1) == XPLM_KEY_TAB) && + ((KEY_FLAGS(inParam1) & xplm_UpFlag) == 0)) + { + bool backwards = (KEY_FLAGS(inParam1) & xplm_ShiftFlag) != 0; + std::vector widgets; + XPCGetOrderedSubWidgets(inWidget, widgets); + long n, index = 0; + XPWidgetID focusWidget = XPGetWidgetWithFocus(); + std::vector::iterator iter = std::find(widgets.begin(), widgets.end(), focusWidget); + if (iter != widgets.end()) + { + index = std::distance(widgets.begin(), iter); + if (backwards) + index--; + else + index++; + if (index < 0) + index = widgets.size() - 1; + if (index >= widgets.size()) + index = 0; + } + + if (backwards) + { + for (n = index; n >= 0; --n) + { + if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL)) + if (XPSetKeyboardFocus(widgets[n]) != NULL) + return 1; + } + for (n = widgets.size() - 1; n > index; --n) + { + if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL)) + if (XPSetKeyboardFocus(widgets[n]) != NULL) + return 1; + } + } else { + for (n = index; n < widgets.size(); ++n) + { + if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL)) + if (XPSetKeyboardFocus(widgets[n]) != NULL) + return 1; + } + for (n = 0; n < index; ++n) + { + if (XPGetWidgetProperty(widgets[n], xpProperty_Enabled, NULL)) + if (XPSetKeyboardFocus(widgets[n]) != NULL) + return 1; + } + } + } + return 0; +} + + + +static void XPCGetOrderedSubWidgets( + XPWidgetID inWidget, + std::vector& outChildren) +{ + outChildren.clear(); + long count = XPCountChildWidgets(inWidget); + for (long n = 0; n < count; ++n) + { + XPWidgetID child = XPGetNthChildWidget(inWidget, n); + outChildren.push_back(child); + std::vector grandChildren; + XPCGetOrderedSubWidgets(child, grandChildren); + + outChildren.insert(outChildren.end(), grandChildren.begin(), grandChildren.end()); + } +} diff --git a/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.h b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.h new file mode 100755 index 0000000..a0a82d9 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/Wrappers/XPCWidgetAttachments.h @@ -0,0 +1,146 @@ +#ifndef _XPCWidgetAttachments_h_ +#define _XPCWidgetAttachments_h_ + +#include + +#include "XPCWidget.h" +#include "XPCBroadcaster.h" + +class XPCKeyFilterAttachment : public XPCWidgetAttachment { +public: + + XPCKeyFilterAttachment( + const char * inValidKeys, + const char * outValidKeys); + virtual ~XPCKeyFilterAttachment(); + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +private: + + std::string mInput; + std::string mOutput; + +}; + + +class XPCKeyMessageAttachment : public XPCWidgetAttachment, public XPCBroadcaster { +public: + + XPCKeyMessageAttachment( + char inKey, + long inMessage, + void * inParam, + bool inConsume, + bool inVkey, + XPCListener * inListener); + virtual ~XPCKeyMessageAttachment(); + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +private: + + char mKey; + bool mVkey; + long mMsg; + void * mParam; + bool mConsume; + +}; + +class XPCPushButtonMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster { +public: + + XPCPushButtonMessageAttachment( + XPWidgetID inWidget, + long inMessage, + void * inParam, + XPCListener * inListener); + virtual ~XPCPushButtonMessageAttachment(); + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +private: + XPWidgetID mWidget; + long mMsg; + void * mParam; +}; + +class XPCSliderMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster { +public: + + XPCSliderMessageAttachment( + XPWidgetID inWidget, + long inMessage, + void * inParam, + XPCListener * inListener); + virtual ~XPCSliderMessageAttachment(); + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +private: + XPWidgetID mWidget; + long mMsg; + void * mParam; +}; + + +class XPCCloseButtonMessageAttachment : public XPCWidgetAttachment, XPCBroadcaster { +public: + + XPCCloseButtonMessageAttachment( + XPWidgetID inWidget, + long inMessage, + void * inParam, + XPCListener * inListener); + virtual ~XPCCloseButtonMessageAttachment(); + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +private: + XPWidgetID mWidget; + long mMsg; + void * mParam; +}; + +class XPCTabGroupAttachment : public XPCWidgetAttachment { +public: + + XPCTabGroupAttachment(); + virtual ~XPCTabGroupAttachment(); + + virtual int HandleWidgetMessage( + XPCWidget * inObject, + XPWidgetMessage inMessage, + XPWidgetID inWidget, + long inParam1, + long inParam2); + +}; + +#endif \ No newline at end of file diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMCamera.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMCamera.h new file mode 100755 index 0000000..211db73 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMCamera.h @@ -0,0 +1,168 @@ +#ifndef _XPLMCamera_h_ +#define _XPLMCamera_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * XPLMCamera - THEORY OF OPERATION The XPLMCamera APIs allow plug-ins to + * control the camera angle in X-Plane. This has a number of applications, + * including but not limited to: + * + * - Creating new views (including dynamic/user-controllable views) for the + * user. + * + * - Creating applications that use X-Plane as a renderer of scenery, + * aircrafts, or both. + * + * The camera is controlled via six parameters: a location in OpenGL + * coordinates and pitch, roll and yaw, similar to an airplane's position. + * OpenGL coordinate info is described in detail in the XPLMGraphics + * documentation; generally you should use the XPLMGraphics routines to + * convert from world to local coordinates. The camera's orientation starts + * facing level with the ground directly up the negative-Z axis + * (approximately north) with the horizon horizontal. It is then rotated + * clockwise for yaw, pitched up for positive pitch, and rolled clockwise + * around the vector it is looking along for roll. + * + * You control the camera either either until the user selects a new view or + * permanently (the later being similar to how UDP camera control works). You + * control the camera by registering a callback per frame from which you + * calculate the new camera positions. This guarantees smooth camera motion. + * + * Use the XPLMDataAccess APIs to get information like the position of the + * aircraft, etc. for complex camera positioning. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * CAMERA CONTROL + ***************************************************************************/ +/* + * + * + */ + + +/* + * XPLMCameraControlDuration + * + * This enumeration states how long you want to retain control of the camera. + * You can retain it indefinitely or until the user selects a new view. + * + */ +enum { + /* Control the camera until the user picks a new view. */ + xplm_ControlCameraUntilViewChanges = 1 + + /* Control the camera until your plugin is disabled or another plugin forcably * + * takes control. */ + ,xplm_ControlCameraForever = 2 + + +}; +typedef int XPLMCameraControlDuration; + +/* + * XPLMCameraPosition_t + * + * This structure contains a full specification of the camera. X, Y, and Z + * are the camera's position in OpenGL coordiantes; pitch, roll, and yaw are + * rotations from a camera facing flat north in degrees. Positive pitch means + * nose up, positive roll means roll right, and positive yaw means yaw right, + * all in degrees. Zoom is a zoom factor, with 1.0 meaning normal zoom and 2.0 + * magnifying by 2x (objects appear larger). + * + */ +typedef struct { + float x; + float y; + float z; + float pitch; + float heading; + float roll; + float zoom; +} XPLMCameraPosition_t; + +/* + * XPLMCameraControl_f + * + * You use an XPLMCameraControl function to provide continuous control over + * the camera. You are passed in a structure in which to put the new camera + * position; modify it and return 1 to reposition the camera. Return 0 to + * surrender control of the camera; camera control will be handled by X-Plane + * on this draw loop. The contents of the structure as you are called are + * undefined. + * + * If X-Plane is taking camera control away from you, this function will be + * called with inIsLosingControl set to 1 and ioCameraPosition NULL. + * + */ +typedef int (* XPLMCameraControl_f)( + XPLMCameraPosition_t * outCameraPosition, /* Can be NULL */ + int inIsLosingControl, + void * inRefcon); + +/* + * XPLMControlCamera + * + * This function repositions the camera on the next drawing cycle. You must + * pass a non-null control function. Specify in inHowLong how long you'd like + * control (indefinitely or until a key is pressed). + * + */ +XPLM_API void XPLMControlCamera( + XPLMCameraControlDuration inHowLong, + XPLMCameraControl_f inControlFunc, + void * inRefcon); + +/* + * XPLMDontControlCamera + * + * This function stops you from controlling the camera. If you have a camera + * control function, it will not be called with an inIsLosingControl flag. + * X-Plane will control the camera on the next cycle. + * + * For maximum compatibility you should not use this routine unless you are in + * posession of the camera. + * + */ +XPLM_API void XPLMDontControlCamera(void); + +/* + * XPLMIsCameraBeingControlled + * + * This routine returns 1 if the camera is being controlled, zero if it is + * not. If it is and you pass in a pointer to a camera control duration, the + * current control duration will be returned. + * + */ +XPLM_API int XPLMIsCameraBeingControlled( + XPLMCameraControlDuration * outCameraControlDuration); /* Can be NULL */ + +/* + * XPLMReadCameraPosition + * + * This function reads the current camera position. + * + */ +XPLM_API void XPLMReadCameraPosition( + XPLMCameraPosition_t * outCameraPosition); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMDataAccess.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMDataAccess.h new file mode 100755 index 0000000..10d6698 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMDataAccess.h @@ -0,0 +1,707 @@ +#ifndef _XPLMDataAccess_h_ +#define _XPLMDataAccess_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * XPLM Data Access API - Theory of Operation + * + * The data access API gives you a generic, flexible, high performance way to + * read and write data to and from X-Plane and other plug-ins. For example, + * this API allows you to read and set the nav radios, get the plane location, + * determine the current effective graphics frame rate, etc. + * + * The data access APIs are the way that you read and write data from the sim + * as well as other plugins. + * + * The API works using opaque data references. A data reference is a source + * of data; you do not know where it comes from, but once you have it you can + * read the data quickly and possibly write it. To get a data reference, you + * look it up. + * + * Data references are identified by verbose string names + * (sim/cockpit/radios/nav1_freq_hz). The actual numeric value of the data + * reference is implementation defined and is likely to change each time the + * simulator is run (or the plugin that provides the datareference is + * reloaded). + * + * The task of looking up a data reference is relatively expensive; look up + * your data references once based on verbose strings, and save the opaque + * data reference value for the duration of your plugin's operation. Reading + * and writing data references is relatively fast (the cost is equivalent to + * two function calls through function pointers). + * + * This allows data access to be high performance, while leaving in + * abstraction; since data references are opaque and are searched for, the + * underlying data access system can be rebuilt. + * + * A note on typing: you must know the correct data type to read and write. + * APIs are provided for reading and writing data in a number of ways. You + * can also double check the data type for a data ref. Note that automatic + * conversion is not done for you. + * + * A note for plugins sharing data with other plugins: the load order of + * plugins is not guaranteed. To make sure that every plugin publishing data + * has published their data references before other plugins try to subscribe, + * publish your data references in your start routine but resolve them the + * first time your 'enable' routine is called, or the first time they are + * needed in code. + * + * X-Plane publishes well over 1000 datarefs; a complete list may be found in + * the reference section of the SDK online documentation (from the SDK home + * page, choose Documentation). + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * READING AND WRITING DATA + ***************************************************************************/ +/* + * These routines allow you to access a wide variety of data from within + * x-plane and modify some of it. + * + */ + + + +/* + * XPLMDataRef + * + * A data ref is an opaque handle to data provided by the simulator or another + * plugin. It uniquely identifies one variable (or array of variables) over + * the lifetime of your plugin. You never hard code these values; you always + * get them from XPLMFindDataRef. + * + */ +typedef void * XPLMDataRef; + +/* + * XPLMDataTypeID + * + * This is an enumeration that defines the type of the data behind a data + * reference. This allows you to sanity check that the data type matches what + * you expect. But for the most part, you will know the type of data you are + * expecting from the online documentation. + * + * Data types each take a bit field, so sets of data types may be formed. + * + */ +enum { + /* Data of a type the current XPLM doesn't do. */ + xplmType_Unknown = 0 + + /* A single 4-byte integer, native endian. */ + ,xplmType_Int = 1 + + /* A single 4-byte float, native endian. */ + ,xplmType_Float = 2 + + /* A single 8-byte double, native endian. */ + ,xplmType_Double = 4 + + /* An array of 4-byte floats, native endian. */ + ,xplmType_FloatArray = 8 + + /* An array of 4-byte integers, native endian. */ + ,xplmType_IntArray = 16 + + /* A variable block of data. */ + ,xplmType_Data = 32 + + +}; +typedef int XPLMDataTypeID; + +/* + * XPLMFindDataRef + * + * Given a c-style string that names the data ref, this routine looks up the + * actual opaque XPLMDataRef that you use to read and write the data. The + * string names for datarefs are published on the x-plane SDK web site. + * + * This function returns NULL if the data ref cannot be found. + * + * NOTE: this function is relatively expensive; save the XPLMDataRef this + * function returns for future use. Do not look up your data ref by string + * every time you need to read or write it. + * + */ +XPLM_API XPLMDataRef XPLMFindDataRef( + const char * inDataRefName); + +/* + * XPLMCanWriteDataRef + * + * Given a data ref, this routine returns true if you can successfully set + * the data, false otherwise. Some datarefs are read-only. + * + */ +XPLM_API int XPLMCanWriteDataRef( + XPLMDataRef inDataRef); + +/* + * XPLMIsDataRefGood + * + * WARNING: This function is deprecated and should not be used. Datarefs are + * valid until plugins are reloaded or the sim quits. Plugins sharing + * datarefs should support these semantics by not unregistering datarefs + * during operation. (You should however unregister datarefs when your plugin + * is unloaded, as part of general resource cleanup.) + * + * This function returns whether a data ref is still valid. If it returns + * false, you should refind the data ref from its original string. Calling an + * accessor function on a bad data ref will return a default value, typically + * 0 or 0-length data. + * + */ +XPLM_API int XPLMIsDataRefGood( + XPLMDataRef inDataRef); + +/* + * XPLMGetDataRefTypes + * + * This routine returns the types of the data ref for accessor use. If a data + * ref is available in multiple data types, they will all be returned. + * + */ +XPLM_API XPLMDataTypeID XPLMGetDataRefTypes( + XPLMDataRef inDataRef); + +/*************************************************************************** + * DATA ACCESSORS + ***************************************************************************/ +/* + * These routines read and write the data references. For each supported data + * type there is a reader and a writer. + * + * If the data ref is invalid or the plugin that provides it is disabled or + * there is a type mismatch, the functions that read data will return 0 as a + * default value or not modify the passed in memory. The plugins that write + * data will not write under these circumstances or if the data ref is + * read-only. NOTE: to keep the overhead of reading datarefs low, these + * routines do not do full validation of a dataref; passing a junk value for + * a dataref can result in crashing the sim. + * + * For array-style datarefs, you specify the number of items to read/write and + * the offset into the array; the actual number of items read or written is + * returned. This may be less to prevent an array-out-of-bounds error. + * + */ + + + +/* + * XPLMGetDatai + * + * Read an integer data ref and return its value. The return value is the + * dataref value or 0 if the dataref is invalid/NULL or the plugin is + * disabled. + * + */ +XPLM_API int XPLMGetDatai( + XPLMDataRef inDataRef); + +/* + * XPLMSetDatai + * + * Write a new value to an integer data ref. This routine is a no-op if the + * plugin publishing the dataref is disabled, the dataref is invalid, or the + * dataref is not writable. + * + */ +XPLM_API void XPLMSetDatai( + XPLMDataRef inDataRef, + int inValue); + +/* + * XPLMGetDataf + * + * Read a single precision floating point dataref and return its value. The + * return value is the dataref value or 0.0 if the dataref is invalid/NULL or + * the plugin is disabled. + * + */ +XPLM_API float XPLMGetDataf( + XPLMDataRef inDataRef); + +/* + * XPLMSetDataf + * + * Write a new value to a single precision floating point data ref. This + * routine is a no-op if the plugin publishing the dataref is disabled, the + * dataref is invalid, or the dataref is not writable. + * + */ +XPLM_API void XPLMSetDataf( + XPLMDataRef inDataRef, + float inValue); + +/* + * XPLMGetDatad + * + * Read a double precision floating point dataref and return its value. The + * return value is the dataref value or 0.0 if the dataref is invalid/NULL or + * the plugin is disabled. + * + */ +XPLM_API double XPLMGetDatad( + XPLMDataRef inDataRef); + +/* + * XPLMSetDatad + * + * Write a new value to a double precision floating point data ref. This + * routine is a no-op if the plugin publishing the dataref is disabled, the + * dataref is invalid, or the dataref is not writable. + * + */ +XPLM_API void XPLMSetDatad( + XPLMDataRef inDataRef, + double inValue); + +/* + * XPLMGetDatavi + * + * Read a part of an integer array dataref. If you pass NULL for outVaules, + * the routine will return the size of the array, ignoring inOffset and inMax. + * + * + * If outValues is not NULL, then up to inMax values are copied from the + * dataref into outValues, starting at inOffset in the dataref. If inMax + + * inOffset is larger than the size of the dataref, less than inMax values + * will be copied. The number of values copied is returned. + * + * Note: the semantics of array datarefs are entirely implemented by the + * plugin (or X-Plane) that provides the dataref, not the SDK itself; the + * above description is how these datarefs are intended to work, but a rogue + * plugin may have different behavior. + * + */ +XPLM_API int XPLMGetDatavi( + XPLMDataRef inDataRef, + int * outValues, /* Can be NULL */ + int inOffset, + int inMax); + +/* + * XPLMSetDatavi + * + * Write part or all of an integer array dataref. The values passed by + * inValues are written into the dataref starting at inOffset. Up to inCount + * values are written; however if the values would write "off the end" of the + * dataref array, then fewer values are written. + * + * Note: the semantics of array datarefs are entirely implemented by the + * plugin (or X-Plane) that provides the dataref, not the SDK itself; the + * above description is how these datarefs are intended to work, but a rogue + * plugin may have different behavior. + * + */ +XPLM_API void XPLMSetDatavi( + XPLMDataRef inDataRef, + int * inValues, + int inoffset, + int inCount); + +/* + * XPLMGetDatavf + * + * Read a part of a single precision floating point array dataref. If you + * pass NULL for outVaules, the routine will return the size of the array, + * ignoring inOffset and inMax. + * + * If outValues is not NULL, then up to inMax values are copied from the + * dataref into outValues, starting at inOffset in the dataref. If inMax + + * inOffset is larger than the size of the dataref, less than inMax values + * will be copied. The number of values copied is returned. + * + * Note: the semantics of array datarefs are entirely implemented by the + * plugin (or X-Plane) that provides the dataref, not the SDK itself; the + * above description is how these datarefs are intended to work, but a rogue + * plugin may have different behavior. + * + */ +XPLM_API int XPLMGetDatavf( + XPLMDataRef inDataRef, + float * outValues, /* Can be NULL */ + int inOffset, + int inMax); + +/* + * XPLMSetDatavf + * + * Write part or all of a single precision floating point array dataref. The + * values passed by inValues are written into the dataref starting at + * inOffset. Up to inCount values are written; however if the values would + * write "off the end" of the dataref array, then fewer values are written. + * + * Note: the semantics of array datarefs are entirely implemented by the + * plugin (or X-Plane) that provides the dataref, not the SDK itself; the + * above description is how these datarefs are intended to work, but a rogue + * plugin may have different behavior. + * + */ +XPLM_API void XPLMSetDatavf( + XPLMDataRef inDataRef, + float * inValues, + int inoffset, + int inCount); + +/* + * XPLMGetDatab + * + * Read a part of a byte array dataref. If you pass NULL for outVaules, the + * routine will return the size of the array, ignoring inOffset and inMax. + * + * If outValues is not NULL, then up to inMax values are copied from the + * dataref into outValues, starting at inOffset in the dataref. If inMax + + * inOffset is larger than the size of the dataref, less than inMax values + * will be copied. The number of values copied is returned. + * + * Note: the semantics of array datarefs are entirely implemented by the + * plugin (or X-Plane) that provides the dataref, not the SDK itself; the + * above description is how these datarefs are intended to work, but a rogue + * plugin may have different behavior. + * + */ +XPLM_API int XPLMGetDatab( + XPLMDataRef inDataRef, + void * outValue, /* Can be NULL */ + int inOffset, + int inMaxBytes); + +/* + * XPLMSetDatab + * + * Write part or all of a byte array dataref. The values passed by inValues + * are written into the dataref starting at inOffset. Up to inCount values + * are written; however if the values would write "off the end" of the dataref + * array, then fewer values are written. + * + * Note: the semantics of array datarefs are entirely implemented by the + * plugin (or X-Plane) that provides the dataref, not the SDK itself; the + * above description is how these datarefs are intended to work, but a rogue + * plugin may have different behavior. + * + */ +XPLM_API void XPLMSetDatab( + XPLMDataRef inDataRef, + void * inValue, + int inOffset, + int inLength); + +/*************************************************************************** + * PUBLISHING YOUR PLUGINS DATA + ***************************************************************************/ +/* + * These functions allow you to create data references that other plug-ins can + * access via the above data access APIs. Data references published by other + * plugins operate the same as ones published by x-plane in all manners except + * that your data reference will not be available to other plugins if/when + * your plugin is disabled. + * + * You share data by registering data provider callback functions. When a + * plug-in requests your data, these callbacks are then called. You provide + * one callback to return the value when a plugin 'reads' it and another to + * change the value when a plugin 'writes' it. + * + * Important: you must pick a prefix for your datarefs other than "sim/" - + * this prefix is reserved for X-Plane. The X-Plane SDK website contains a + * registry where authors can select a unique first word for dataref names, to + * prevent dataref collisions between plugins. + * + */ + + + +/* + * XPLMGetDatai_f + * + * Data provider function pointers. + * + * These define the function pointers you provide to get or set data. Note + * that you are passed a generic pointer for each one. This is the same + * pointer you pass in your register routine; you can use it to find global + * variables, etc. + * + * The semantics of your callbacks are the same as the dataref accessor above + * - basically routines like XPLMGetDatai are just pass-throughs from a caller + * to your plugin. Be particularly mindful in implementing array dataref + * read-write accessors; you are responsible for avoiding overruns, supporting + * offset read/writes, and handling a read with a NULL buffer. + * + */ +typedef int (* XPLMGetDatai_f)( + void * inRefcon); + +/* + * XPLMSetDatai_f + * + * + */ +typedef void (* XPLMSetDatai_f)( + void * inRefcon, + int inValue); + +/* + * XPLMGetDataf_f + * + * + */ +typedef float (* XPLMGetDataf_f)( + void * inRefcon); + +/* + * XPLMSetDataf_f + * + * + */ +typedef void (* XPLMSetDataf_f)( + void * inRefcon, + float inValue); + +/* + * XPLMGetDatad_f + * + * + */ +typedef double (* XPLMGetDatad_f)( + void * inRefcon); + +/* + * XPLMSetDatad_f + * + * + */ +typedef void (* XPLMSetDatad_f)( + void * inRefcon, + double inValue); + +/* + * XPLMGetDatavi_f + * + * + */ +typedef int (* XPLMGetDatavi_f)( + void * inRefcon, + int * outValues, /* Can be NULL */ + int inOffset, + int inMax); + +/* + * XPLMSetDatavi_f + * + * + */ +typedef void (* XPLMSetDatavi_f)( + void * inRefcon, + int * inValues, + int inOffset, + int inCount); + +/* + * XPLMGetDatavf_f + * + * + */ +typedef int (* XPLMGetDatavf_f)( + void * inRefcon, + float * outValues, /* Can be NULL */ + int inOffset, + int inMax); + +/* + * XPLMSetDatavf_f + * + * + */ +typedef void (* XPLMSetDatavf_f)( + void * inRefcon, + float * inValues, + int inOffset, + int inCount); + +/* + * XPLMGetDatab_f + * + * + */ +typedef int (* XPLMGetDatab_f)( + void * inRefcon, + void * outValue, /* Can be NULL */ + int inOffset, + int inMaxLength); + +/* + * XPLMSetDatab_f + * + * + */ +typedef void (* XPLMSetDatab_f)( + void * inRefcon, + void * inValue, + int inOffset, + int inLength); + +/* + * XPLMRegisterDataAccessor + * + * This routine creates a new item of data that can be read and written. Pass + * in the data's full name for searching, the type(s) of the data for + * accessing, and whether the data can be written to. For each data type you + * support, pass in a read accessor function and a write accessor function if + * necessary. Pass NULL for data types you do not support or write accessors + * if you are read-only. + * + * You are returned a data ref for the new item of data created. You can use + * this data ref to unregister your data later or read or write from it. + * + */ +XPLM_API XPLMDataRef XPLMRegisterDataAccessor( + const char * inDataName, + XPLMDataTypeID inDataType, + int inIsWritable, + XPLMGetDatai_f inReadInt, + XPLMSetDatai_f inWriteInt, + XPLMGetDataf_f inReadFloat, + XPLMSetDataf_f inWriteFloat, + XPLMGetDatad_f inReadDouble, + XPLMSetDatad_f inWriteDouble, + XPLMGetDatavi_f inReadIntArray, + XPLMSetDatavi_f inWriteIntArray, + XPLMGetDatavf_f inReadFloatArray, + XPLMSetDatavf_f inWriteFloatArray, + XPLMGetDatab_f inReadData, + XPLMSetDatab_f inWriteData, + void * inReadRefcon, + void * inWriteRefcon); + +/* + * XPLMUnregisterDataAccessor + * + * Use this routine to unregister any data accessors you may have registered. + * You unregister a data ref by the XPLMDataRef you get back from + * registration. Once you unregister a data ref, your function pointer will + * not be called anymore. + * + * For maximum compatibility, do not unregister your data accessors until + * final shutdown (when your XPluginStop routine is called). This allows + * other plugins to find your data reference once and use it for their entire + * time of operation. + * + */ +XPLM_API void XPLMUnregisterDataAccessor( + XPLMDataRef inDataRef); + +/*************************************************************************** + * SHARING DATA BETWEEN MULTIPLE PLUGINS + ***************************************************************************/ +/* + * The data reference registration APIs from the previous section allow a + * plugin to publish data in a one-owner manner; the plugin that publishes the + * data reference owns the real memory that the data ref uses. This is + * satisfactory for most cases, but there are also cases where plugnis need to + * share actual data. + * + * With a shared data reference, no one plugin owns the actual memory for the + * data reference; the plugin SDK allocates that for you. When the first + * plugin asks to 'share' the data, the memory is allocated. When the data is + * changed, every plugin that is sharing the data is notified. + * + * Shared data references differ from the 'owned' data references from the + * previous section in a few ways: + * + * - With shared data references, any plugin can create the data reference; + * with owned plugins one plugin must create the data reference and others + * subscribe. (This can be a problem if you don't know which set of plugins + * will be present). + * + * - With shared data references, every plugin that is sharing the data is + * notified when the data is changed. With owned data references, only the + * one owner is notified when the data is changed. + * + * - With shared data references, you cannot access the physical memory of the + * data reference; you must use the XPLMGet... and XPLMSet... APIs. With an + * owned data reference, the one owning data reference can manipulate the + * data reference's memory in any way it sees fit. + * + * Shared data references solve two problems: if you need to have a data + * reference used by several plugins but do not know which plugins will be + * installed, or if all plugins sharing data need to be notified when that + * data is changed, use shared data references. + * + */ + + + +/* + * XPLMDataChanged_f + * + * An XPLMDataChanged_f is a callback that the XPLM calls whenever any other + * plug-in modifies shared data. A refcon you provide is passed back to help + * identify which data is being changed. In response, you may want to call one + * of the XPLMGetDataxxx routines to find the new value of the data. + * + */ +typedef void (* XPLMDataChanged_f)( + void * inRefcon); + +/* + * XPLMShareData + * + * This routine connects a plug-in to shared data, creating the shared data if + * necessary. inDataName is a standard path for the data ref, and inDataType + * specifies the type. This function will create the data if it does not + * exist. If the data already exists but the type does not match, an error is + * returned, so it is important that plug-in authors collaborate to establish + * public standards for shared data. + * + * If a notificationFunc is passed in and is not NULL, that notification + * function will be called whenever the data is modified. The notification + * refcon will be passed to it. This allows your plug-in to know which shared + * data was changed if multiple shared data are handled by one callback, or if + * the plug-in does not use global variables. + * + * A one is returned for successfully creating or finding the shared data; a + * zero if the data already exists but is of the wrong type. + * + */ +XPLM_API int XPLMShareData( + const char * inDataName, + XPLMDataTypeID inDataType, + XPLMDataChanged_f inNotificationFunc, + void * inNotificationRefcon); + +/* + * XPLMUnshareData + * + * This routine removes your notification function for shared data. Call it + * when done with the data to stop receiving change notifications. Arguments + * must match XPLMShareData. The actual memory will not necessarily be freed, + * since other plug-ins could be using it. + * + */ +XPLM_API int XPLMUnshareData( + const char * inDataName, + XPLMDataTypeID inDataType, + XPLMDataChanged_f inNotificationFunc, + void * inNotificationRefcon); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMDefs.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMDefs.h new file mode 100755 index 0000000..acd5f2c --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMDefs.h @@ -0,0 +1,518 @@ +#ifndef _XPLMDefs_h_ +#define _XPLMDefs_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * This file is contains the cross-platform and basic definitions for the + * X-Plane SDK. + * + * The preprocessor macros APL and IBM must be defined to specify the + * compilation target; define APL to 1 and IBM 0 to compile on Macintosh and + * APL to 0 and IBM to 1 for Windows. You must specify these macro definitions + * before including XPLMDefs.h or any other XPLM headers. You can do this + * using the -D command line option or a preprocessor header. + * + */ + + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _WIN32 +#include +#else +#include +#endif +/*************************************************************************** + * DLL Definitions + ***************************************************************************/ +/* + * These definitions control the importing and exporting of functions within + * the DLL. + * + * You can prefix your five required callbacks with the PLUGIN_API macro to + * declare them as exported C functions. The XPLM_API macro identifies + * functions that are provided to you via the plugin SDK. (Link against + * XPLM.lib to use these functions.) + * + */ + + + +#ifdef __cplusplus + #ifdef APL + #if __GNUC__ >= 4 + #define PLUGIN_API extern "C" __attribute__((visibility("default"))) + #elif __MACH__ + #define PLUGIN_API extern "C" + #else + #define PLUGIN_API extern "C" __declspec(dllexport) + #endif + #endif + #ifdef _WIN32 + #define PLUGIN_API extern "C" __declspec(dllexport) + #endif + #ifdef LIN + #if __GNUC__ >= 4 + #define PLUGIN_API extern "C" __attribute__((visibility("default"))) + #else + #define PLUGIN_API extern "C" + #endif + #endif +#else + #if APL + #if __GNUC__ >= 4 + #define PLUGIN_API __attribute__((visibility("default"))) + #elif __MACH__ + #define PLUGIN_API + #else + #define PLUGIN_API __declspec(dllexport) + #endif + #elif IBM + #define PLUGIN_API __declspec(dllexport) + #elif LIN + #if __GNUC__ >= 4 + #define PLUGIN_API __attribute__((visibility("default"))) + #else + #define PLUGIN_API + #endif + #else + #error "Platform not defined!" + #endif +#endif + +#ifdef APL + #if XPLM + #if __GNUC__ >= 4 + #define XPLM_API __attribute__((visibility("default"))) + #elif __MACH__ + #define XPLM_API + #else + #define XPLM_API __declspec(dllexport) + #endif + #else + #define XPLM_API + #endif +#endif +#ifdef _WIN32 + #if XPLM + #define XPLM_API __declspec(dllexport) + #else + #define XPLM_API __declspec(dllimport) + #endif +#endif +#ifdef LIN + #if XPLM + #if __GNUC__ >= 4 + #define XPLM_API __attribute__((visibility("default"))) + #else + #define XPLM_API + #endif + #else + #define XPLM_API + #endif +#endif + +/*************************************************************************** + * GLOBAL DEFINITIONS + ***************************************************************************/ +/* + * These definitions are used in all parts of the SDK. + * + */ + + + +/* + * XPLMPluginID + * + * Each plug-in is identified by a unique integer ID. This ID can be used to + * disable or enable a plug-in, or discover what plug-in is 'running' at the + * time. A plug-in ID is unique within the currently running instance of + * X-Plane unless plug-ins are reloaded. Plug-ins may receive a different + * unique ID each time they are loaded. + * + * For persistent identification of plug-ins, use XPLMFindPluginBySignature in + * XPLMUtiltiies.h + * + * -1 indicates no plug-in. + * + */ +typedef int XPLMPluginID; + +/* No plugin. */ +#define XPLM_NO_PLUGIN_ID (-1) + +/* X-Plane itself */ +#define XPLM_PLUGIN_XPLANE (0) + +/* The current XPLM revision is 2.10 (210). */ +#define kXPLM_Version (210) + +/* + * XPLMKeyFlags + * + * These bitfields define modifier keys in a platform independent way. When a + * key is pressed, a series of messages are sent to your plugin. The down + * flag is set in the first of these messages, and the up flag in the last. + * While the key is held down, messages are sent with neither to indicate that + * the key is being held down as a repeated character. + * + * The control flag is mapped to the control flag on Macintosh and PC. + * Generally X-Plane uses the control key and not the command key on + * Macintosh, providing a consistent interface across platforms that does not + * necessarily match the Macintosh user interface guidelines. There is not + * yet a way for plugins to access the Macintosh control keys without using + * #ifdefed code. + * + */ +enum { + /* The shift key is down */ + xplm_ShiftFlag = 1 + + /* The option or alt key is down */ + ,xplm_OptionAltFlag = 2 + + /* The control key is down* */ + ,xplm_ControlFlag = 4 + + /* The key is being pressed down */ + ,xplm_DownFlag = 8 + + /* The key is being released */ + ,xplm_UpFlag = 16 + + +}; +typedef int XPLMKeyFlags; + +/*************************************************************************** + * ASCII CONTROL KEY CODES + ***************************************************************************/ +/* + * These definitions define how various control keys are mapped to ASCII key + * codes. Not all key presses generate an ASCII value, so plugin code should + * be prepared to see null characters come from the keyboard...this usually + * represents a key stroke that has no equivalent ASCII, like a page-down + * press. Use virtual key codes to find these key strokes. ASCII key codes + * take into account modifier keys; shift keys will affect capitals and + * punctuation; control key combinations may have no vaild ASCII and produce + * NULL. To detect control-key combinations, use virtual key codes, not ASCII + * keys. + * + */ + + + +#define XPLM_KEY_RETURN 13 + +#define XPLM_KEY_ESCAPE 27 + +#define XPLM_KEY_TAB 9 + +#define XPLM_KEY_DELETE 8 + +#define XPLM_KEY_LEFT 28 + +#define XPLM_KEY_RIGHT 29 + +#define XPLM_KEY_UP 30 + +#define XPLM_KEY_DOWN 31 + +#define XPLM_KEY_0 48 + +#define XPLM_KEY_1 49 + +#define XPLM_KEY_2 50 + +#define XPLM_KEY_3 51 + +#define XPLM_KEY_4 52 + +#define XPLM_KEY_5 53 + +#define XPLM_KEY_6 54 + +#define XPLM_KEY_7 55 + +#define XPLM_KEY_8 56 + +#define XPLM_KEY_9 57 + +#define XPLM_KEY_DECIMAL 46 + +/*************************************************************************** + * VIRTUAL KEY CODES + ***************************************************************************/ +/* + * These are cross-platform defines for every distinct keyboard press on the + * computer. Every physical key on the keyboard has a virtual key code. So + * the "two" key on the top row of the main keyboard has a different code + * from the "two" key on the numeric key pad. But the 'w' and 'W' character + * are indistinguishable by virtual key code because they are the same + * physical key (one with and one without the shift key). + * + * Use virtual key codes to detect keystrokes that do not have ASCII + * equivalents, allow the user to map the numeric keypad separately from the + * main keyboard, and detect control key and other modifier-key combinations + * that generate ASCII control key sequences (many of which are not available + * directly via character keys in the SDK). + * + * To assign virtual key codes we started with the Microsoft set but made some + * additions and changes. A few differences: + * + * 1. Modifier keys are not available as virtual key codes. You cannot get + * distinct modifier press and release messages. Please do not try to use + * modifier keys as regular keys; doing so will almost certainly interfere + * with users' abilities to use the native x-plane key bindings. + * + * 2. Some keys that do not exist on both Mac and PC keyboards are removed. + * + * 3. Do not assume that the values of these keystrokes are interchangeable + * with MS v-keys. + * + */ + + + +#define XPLM_VK_BACK 0x08 + +#define XPLM_VK_TAB 0x09 + +#define XPLM_VK_CLEAR 0x0C + +#define XPLM_VK_RETURN 0x0D + +#define XPLM_VK_ESCAPE 0x1B + +#define XPLM_VK_SPACE 0x20 + +#define XPLM_VK_PRIOR 0x21 + +#define XPLM_VK_NEXT 0x22 + +#define XPLM_VK_END 0x23 + +#define XPLM_VK_HOME 0x24 + +#define XPLM_VK_LEFT 0x25 + +#define XPLM_VK_UP 0x26 + +#define XPLM_VK_RIGHT 0x27 + +#define XPLM_VK_DOWN 0x28 + +#define XPLM_VK_SELECT 0x29 + +#define XPLM_VK_PRINT 0x2A + +#define XPLM_VK_EXECUTE 0x2B + +#define XPLM_VK_SNAPSHOT 0x2C + +#define XPLM_VK_INSERT 0x2D + +#define XPLM_VK_DELETE 0x2E + +#define XPLM_VK_HELP 0x2F + +/* XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */ +#define XPLM_VK_0 0x30 + +#define XPLM_VK_1 0x31 + +#define XPLM_VK_2 0x32 + +#define XPLM_VK_3 0x33 + +#define XPLM_VK_4 0x34 + +#define XPLM_VK_5 0x35 + +#define XPLM_VK_6 0x36 + +#define XPLM_VK_7 0x37 + +#define XPLM_VK_8 0x38 + +#define XPLM_VK_9 0x39 + +/* XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */ +#define XPLM_VK_A 0x41 + +#define XPLM_VK_B 0x42 + +#define XPLM_VK_C 0x43 + +#define XPLM_VK_D 0x44 + +#define XPLM_VK_E 0x45 + +#define XPLM_VK_F 0x46 + +#define XPLM_VK_G 0x47 + +#define XPLM_VK_H 0x48 + +#define XPLM_VK_I 0x49 + +#define XPLM_VK_J 0x4A + +#define XPLM_VK_K 0x4B + +#define XPLM_VK_L 0x4C + +#define XPLM_VK_M 0x4D + +#define XPLM_VK_N 0x4E + +#define XPLM_VK_O 0x4F + +#define XPLM_VK_P 0x50 + +#define XPLM_VK_Q 0x51 + +#define XPLM_VK_R 0x52 + +#define XPLM_VK_S 0x53 + +#define XPLM_VK_T 0x54 + +#define XPLM_VK_U 0x55 + +#define XPLM_VK_V 0x56 + +#define XPLM_VK_W 0x57 + +#define XPLM_VK_X 0x58 + +#define XPLM_VK_Y 0x59 + +#define XPLM_VK_Z 0x5A + +#define XPLM_VK_NUMPAD0 0x60 + +#define XPLM_VK_NUMPAD1 0x61 + +#define XPLM_VK_NUMPAD2 0x62 + +#define XPLM_VK_NUMPAD3 0x63 + +#define XPLM_VK_NUMPAD4 0x64 + +#define XPLM_VK_NUMPAD5 0x65 + +#define XPLM_VK_NUMPAD6 0x66 + +#define XPLM_VK_NUMPAD7 0x67 + +#define XPLM_VK_NUMPAD8 0x68 + +#define XPLM_VK_NUMPAD9 0x69 + +#define XPLM_VK_MULTIPLY 0x6A + +#define XPLM_VK_ADD 0x6B + +#define XPLM_VK_SEPARATOR 0x6C + +#define XPLM_VK_SUBTRACT 0x6D + +#define XPLM_VK_DECIMAL 0x6E + +#define XPLM_VK_DIVIDE 0x6F + +#define XPLM_VK_F1 0x70 + +#define XPLM_VK_F2 0x71 + +#define XPLM_VK_F3 0x72 + +#define XPLM_VK_F4 0x73 + +#define XPLM_VK_F5 0x74 + +#define XPLM_VK_F6 0x75 + +#define XPLM_VK_F7 0x76 + +#define XPLM_VK_F8 0x77 + +#define XPLM_VK_F9 0x78 + +#define XPLM_VK_F10 0x79 + +#define XPLM_VK_F11 0x7A + +#define XPLM_VK_F12 0x7B + +#define XPLM_VK_F13 0x7C + +#define XPLM_VK_F14 0x7D + +#define XPLM_VK_F15 0x7E + +#define XPLM_VK_F16 0x7F + +#define XPLM_VK_F17 0x80 + +#define XPLM_VK_F18 0x81 + +#define XPLM_VK_F19 0x82 + +#define XPLM_VK_F20 0x83 + +#define XPLM_VK_F21 0x84 + +#define XPLM_VK_F22 0x85 + +#define XPLM_VK_F23 0x86 + +#define XPLM_VK_F24 0x87 + +/* The following definitions are extended and are not based on the Microsoft * + * key set. */ +#define XPLM_VK_EQUAL 0xB0 + +#define XPLM_VK_MINUS 0xB1 + +#define XPLM_VK_RBRACE 0xB2 + +#define XPLM_VK_LBRACE 0xB3 + +#define XPLM_VK_QUOTE 0xB4 + +#define XPLM_VK_SEMICOLON 0xB5 + +#define XPLM_VK_BACKSLASH 0xB6 + +#define XPLM_VK_COMMA 0xB7 + +#define XPLM_VK_SLASH 0xB8 + +#define XPLM_VK_PERIOD 0xB9 + +#define XPLM_VK_BACKQUOTE 0xBA + +#define XPLM_VK_ENTER 0xBB + +#define XPLM_VK_NUMPAD_ENT 0xBC + +#define XPLM_VK_NUMPAD_EQ 0xBD + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMDisplay.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMDisplay.h new file mode 100755 index 0000000..686c921 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMDisplay.h @@ -0,0 +1,760 @@ +#ifndef _XPLMDisplay_h_ +#define _XPLMDisplay_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * XPLM Display APIs - THEORY OF OPERATION + * + * This API provides the basic hooks to draw in X-Plane and create user + * interface. All X-Plane drawing is done in OpenGL. The X-Plane plug-in + * manager takes care of properly setting up the OpenGL context and matrices. + * You do not decide when in your code's execution to draw; X-Plane tells you + * when it is ready to have your plugin draw. + * + * X-Plane's drawing strategy is straightforward: every "frame" the screen is + * rendered by drawing the 3-d scene (dome, ground, objects, airplanes, etc.) + * and then drawing the cockpit on top of it. Alpha blending is used to + * overlay the cockpit over the world (and the gauges over the panel, etc.). + * + * There are two ways you can draw: directly and in a window. + * + * Direct drawing involves drawing to the screen before or after X-Plane + * finishes a phase of drawing. When you draw directly, you can specify + * whether x-plane is to complete this phase or not. This allows you to do + * three things: draw before x-plane does (under it), draw after x-plane does + * (over it), or draw instead of x-plane. + * + * To draw directly, you register a callback and specify what phase you want + * to intercept. The plug-in manager will call you over and over to draw that + * phase. + * + * Direct drawing allows you to override scenery, panels, or anything. Note + * that you cannot assume that you are the only plug-in drawing at this + * phase. + * + * Window drawing provides slightly higher level functionality. With window + * drawing you create a window that takes up a portion of the screen. Window + * drawing is always two dimensional. Window drawing is front-to-back + * controlled; you can specify that you want your window to be brought on + * top, and other plug-ins may put their window on top of you. Window drawing + * also allows you to sign up for key presses and receive mouse clicks. + * + * There are three ways to get keystrokes: + * + * If you create a window, the window can take keyboard focus. It will then + * receive all keystrokes. If no window has focus, X-Plane receives + * keystrokes. Use this to implement typing in dialog boxes, etc. Only one + * window may have focus at a time; your window will be notified if it loses + * focus. + * + * If you need to associate key strokes with commands/functions in your + * plug-in, use a hot key. A hoy is a key-specific callback. Hotkeys are + * sent based on virtual key strokes, so any key may be distinctly mapped with + * any modifiers. Hot keys can be remapped by other plug-ins. As a plug-in, + * you don't have to worry about what your hot key ends up mapped to; other + * plug-ins may provide a UI for remapping keystrokes. So hotkeys allow a + * user to resolve conflicts and customize keystrokes. + * + * If you need low level access to the keystroke stream, install a key + * sniffer. Key sniffers can be installed above everything or right in front + * of the sim. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * DRAWING CALLBACKS + ***************************************************************************/ +/* + * Basic drawing callbacks, for low level intercepting of render loop. The + * purpose of drawing callbacks is to provide targeted additions or + * replacements to x-plane's graphics environment (for example, to add extra + * custom objects, or replace drawing of the AI aircraft). Do not assume that + * the drawing callbacks will be called in the order implied by the + * enumerations. Also do not assume that each drawing phase ends before + * another begins; they may be nested. + * + */ + + + +/* + * XPLMDrawingPhase + * + * This constant indicates which part of drawing we are in. Drawing is done + * from the back to the front. We get a callback before or after each item. + * Metaphases provide access to the beginning and end of the 3d (scene) and 2d + * (cockpit) drawing in a manner that is independent of new phases added via + * x-plane implementation. + * + * WARNING: As X-Plane's scenery evolves, some drawing phases may cease to + * exist and new ones may be invented. If you need a particularly specific + * use of these codes, consult Austin and/or be prepared to revise your code + * as X-Plane evolves. + * + */ +enum { + /* This is the earliest point at which you can draw in 3-d. */ + xplm_Phase_FirstScene = 0 + + /* Drawing of land and water. */ + ,xplm_Phase_Terrain = 5 + + /* Drawing runways and other airport detail. */ + ,xplm_Phase_Airports = 10 + + /* Drawing roads, trails, trains, etc. */ + ,xplm_Phase_Vectors = 15 + + /* 3-d objects (houses, smokestacks, etc. */ + ,xplm_Phase_Objects = 20 + + /* External views of airplanes, both yours and the AI aircraft. */ + ,xplm_Phase_Airplanes = 25 + + /* This is the last point at which you can draw in 3-d. */ + ,xplm_Phase_LastScene = 30 + + /* This is the first phase where you can draw in 2-d. */ + ,xplm_Phase_FirstCockpit = 35 + + /* The non-moving parts of the aircraft panel. */ + ,xplm_Phase_Panel = 40 + + /* The moving parts of the aircraft panel. */ + ,xplm_Phase_Gauges = 45 + + /* Floating windows from plugins. */ + ,xplm_Phase_Window = 50 + + /* The last change to draw in 2d. */ + ,xplm_Phase_LastCockpit = 55 + +#if defined(XPLM200) + /* 3-d Drawing for the local map. Use regular OpenGL coordinates to draw in * + * this phase. */ + ,xplm_Phase_LocalMap3D = 100 + +#endif /* XPLM200 */ +#if defined(XPLM200) + /* 2-d Drawing of text over the local map. */ + ,xplm_Phase_LocalMap2D = 101 + +#endif /* XPLM200 */ +#if defined(XPLM200) + /* Drawing of the side-profile view in the local map screen. */ + ,xplm_Phase_LocalMapProfile = 102 + +#endif /* XPLM200 */ + +}; +typedef int XPLMDrawingPhase; + +/* + * XPLMDrawCallback_f + * + * This is the prototype for a low level drawing callback. You are passed in + * the phase and whether it is before or after. If you are before the phase, + * return 1 to let x-plane draw or 0 to suppress x-plane drawing. If you are + * after the phase the return value is ignored. + * + * Refcon is a unique value that you specify when registering the callback, + * allowing you to slip a pointer to your own data to the callback. + * + * Upon entry the OpenGL context will be correctly set up for you and OpenGL + * will be in 'local' coordinates for 3d drawing and panel coordinates for 2d + * drawing. The OpenGL state (texturing, etc.) will be unknown. + * + */ +typedef int (* XPLMDrawCallback_f)( + XPLMDrawingPhase inPhase, + int inIsBefore, + void * inRefcon); + +/* + * XPLMKeySniffer_f + * + * This is the prototype for a low level key-sniffing function. Window-based + * UI _should not use this_! The windowing system provides high-level + * mediated keyboard access. By comparison, the key sniffer provides low + * level keyboard access. + * + * Key sniffers are provided to allow libraries to provide non-windowed user + * interaction. For example, the MUI library uses a key sniffer to do pop-up + * text entry. + * + * inKey is the character pressed, inRefCon is a value you supply during + * registration. Return 1 to pass the key on to the next sniffer, the window + * mgr, x-plane, or whomever is down stream. Return 0 to consume the key. + * + * Warning: this API declares virtual keys as a signed character; however the + * VKEY #define macros in XPLMDefs.h define the vkeys using unsigned values + * (that is 0x80 instead of -0x80). So you may need to cast the incoming vkey + * to an unsigned char to get correct comparisons in C. + * + */ +typedef int (* XPLMKeySniffer_f)( + char inChar, + XPLMKeyFlags inFlags, + char inVirtualKey, + void * inRefcon); + +/* + * XPLMRegisterDrawCallback + * + * This routine registers a low level drawing callback. Pass in the phase you + * want to be called for and whether you want to be called before or after. + * This routine returns 1 if the registration was successful, or 0 if the + * phase does not exist in this version of x-plane. You may register a + * callback multiple times for the same or different phases as long as the + * refcon is unique each time. + * + */ +XPLM_API int XPLMRegisterDrawCallback( + XPLMDrawCallback_f inCallback, + XPLMDrawingPhase inPhase, + int inWantsBefore, + void * inRefcon); + +/* + * XPLMUnregisterDrawCallback + * + * This routine unregisters a draw callback. You must unregister a callback + * for each time you register a callback if you have registered it multiple + * times with different refcons. The routine returns 1 if it can find the + * callback to unregister, 0 otherwise. + * + */ +XPLM_API int XPLMUnregisterDrawCallback( + XPLMDrawCallback_f inCallback, + XPLMDrawingPhase inPhase, + int inWantsBefore, + void * inRefcon); + +/* + * XPLMRegisterKeySniffer + * + * This routine registers a key sniffing callback. You specify whether you + * want to sniff before the window system, or only sniff keys the window + * system does not consume. You should ALMOST ALWAYS sniff non-control keys + * after the window system. When the window system consumes a key, it is + * because the user has "focused" a window. Consuming the key or taking + * action based on the key will produce very weird results. Returns 1 if + * successful. + * + */ +XPLM_API int XPLMRegisterKeySniffer( + XPLMKeySniffer_f inCallback, + int inBeforeWindows, + void * inRefcon); + +/* + * XPLMUnregisterKeySniffer + * + * This routine unregisters a key sniffer. You must unregister a key sniffer + * for every time you register one with the exact same signature. Returns 1 + * if successful. + * + */ +XPLM_API int XPLMUnregisterKeySniffer( + XPLMKeySniffer_f inCallback, + int inBeforeWindows, + void * inRefcon); + +/*************************************************************************** + * WINDOW API + ***************************************************************************/ +/* + * Window API, for higher level drawing with UI interaction. + * + * Note: all 2-d (and thus all window drawing) is done in 'cockpit pixels'. + * Even when the OpenGL window contains more than 1024x768 pixels, the cockpit + * drawing is magnified so that only 1024x768 pixels are available. + * + */ + + + +/* + * XPLMMouseStatus + * + * When the mouse is clicked, your mouse click routine is called repeatedly. + * It is first called with the mouse down message. It is then called zero or + * more times with the mouse-drag message, and finally it is called once with + * the mouse up message. All of these messages will be directed to the same + * window. + * + */ +enum { + xplm_MouseDown = 1 + + ,xplm_MouseDrag = 2 + + ,xplm_MouseUp = 3 + + +}; +typedef int XPLMMouseStatus; + +#if defined(XPLM200) +/* + * XPLMCursorStatus + * + * XPLMCursorStatus describes how you would like X-Plane to manage the cursor. + * See XPLMHandleCursor_f for more info. + * + */ +enum { + /* X-Plane manages the cursor normally, plugin does not affect the cusrsor. */ + xplm_CursorDefault = 0 + + /* X-Plane hides the cursor. */ + ,xplm_CursorHidden = 1 + + /* X-Plane shows the cursor as the default arrow. */ + ,xplm_CursorArrow = 2 + + /* X-Plane shows the cursor but lets you select an OS cursor. */ + ,xplm_CursorCustom = 3 + + +}; +typedef int XPLMCursorStatus; +#endif /* XPLM200 */ + +/* + * XPLMWindowID + * + * This is an opaque identifier for a window. You use it to control your + * window. When you create a window, you will specify callbacks to handle + * drawing and mouse interaction, etc. + * + */ +typedef void * XPLMWindowID; + +/* + * XPLMDrawWindow_f + * + * This function handles drawing. You are passed in your window and its + * refcon. Draw the window. You can use XPLM functions to find the current + * dimensions of your window, etc. When this callback is called, the OpenGL + * context will be set properly for cockpit drawing. NOTE: Because you are + * drawing your window over a background, you can make a translucent window + * easily by simply not filling in your entire window's bounds. + * + */ +typedef void (* XPLMDrawWindow_f)( + XPLMWindowID inWindowID, + void * inRefcon); + +/* + * XPLMHandleKey_f + * + * This function is called when a key is pressed or keyboard focus is taken + * away from your window. If losingFocus is 1, you are losign the keyboard + * focus, otherwise a key was pressed and inKey contains its character. You + * are also passewd your window and a refcon. Warning: this API declares + * virtual keys as a signed character; however the VKEY #define macros in + * XPLMDefs.h define the vkeys using unsigned values (that is 0x80 instead of + * -0x80). So you may need to cast the incoming vkey to an unsigned char to + * get correct comparisons in C. + * + */ +typedef void (* XPLMHandleKey_f)( + XPLMWindowID inWindowID, + char inKey, + XPLMKeyFlags inFlags, + char inVirtualKey, + void * inRefcon, + int losingFocus); + +/* + * XPLMHandleMouseClick_f + * + * You receive this call when the mouse button is pressed down or released. + * Between then these two calls is a drag. You receive the x and y of the + * click, your window, and a refcon. Return 1 to consume the click, or 0 to + * pass it through. + * + * WARNING: passing clicks through windows (as of this writing) causes mouse + * tracking problems in X-Plane; do not use this feature! + * + */ +typedef int (* XPLMHandleMouseClick_f)( + XPLMWindowID inWindowID, + int x, + int y, + XPLMMouseStatus inMouse, + void * inRefcon); + +#if defined(XPLM200) +/* + * XPLMHandleCursor_f + * + * The SDK calls your cursor status callback when the mouse is over your + * plugin window. Return a cursor status code to indicate how you would like + * X-Plane to manage the cursor. If you return xplm_CursorDefault, the SDK + * will try lower-Z-order plugin windows, then let the sim manage the cursor. + * + * Note: you should never show or hide the cursor yourself - these APIs are + * typically reference-counted and thus cannot safely and predictably be used + * by the SDK. Instead return one of xplm_CursorHidden to hide the cursor or + * xplm_CursorArrow/xplm_CursorCustom to show the cursor. + * + * If you want to implement a custom cursor by drawing a cursor in OpenGL, use + * xplm_CursorHidden to hide the OS cursor and draw the cursor using a 2-d + * drawing callback (after xplm_Phase_Window is probably a good choice). If + * you want to use a custom OS-based cursor, use xplm_CursorCustom to ask + * X-Plane to show the cursor but not affect its image. You can then use an + * OS specific call like SetThemeCursor (Mac) or SetCursor/LoadCursor + * (Windows). + * + */ +typedef XPLMCursorStatus (* XPLMHandleCursor_f)( + XPLMWindowID inWindowID, + int x, + int y, + void * inRefcon); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMHandleMouseWheel_f + * + * The SDK calls your mouse wheel callback when one of the mouse wheels is + * turned within your window. Return 1 to consume the mouse wheel clicks or + * 0 to pass them on to a lower window. (You should consume mouse wheel + * clicks even if they do nothing if your window appears opaque to the user.) + * The number of clicks indicates how far the wheel was turned since the last + * callback. The wheel is 0 for the vertical axis or 1 for the horizontal axis + * (for OS/mouse combinations that support this). + * + */ +typedef int (* XPLMHandleMouseWheel_f)( + XPLMWindowID inWindowID, + int x, + int y, + int wheel, + int clicks, + void * inRefcon); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMCreateWindow_t + * + * The XPMCreateWindow_t structure defines all of the parameters used to + * create a window using XPLMCreateWindowEx. The structure will be expanded + * in future SDK APIs to include more features. Always set the structSize + * member to the size of your struct in bytes! + * + */ +typedef struct { + int structSize; + int left; + int top; + int right; + int bottom; + int visible; + XPLMDrawWindow_f drawWindowFunc; + XPLMHandleMouseClick_f handleMouseClickFunc; + XPLMHandleKey_f handleKeyFunc; + XPLMHandleCursor_f handleCursorFunc; + XPLMHandleMouseWheel_f handleMouseWheelFunc; + void * refcon; +} XPLMCreateWindow_t; +#endif /* XPLM200 */ + +/* + * XPLMGetScreenSize + * + * This routine returns the size of the size of the X-Plane OpenGL window in + * pixels. Please note that this is not the size of the screen when doing + * 2-d drawing (the 2-d screen is currently always 1024x768, and graphics are + * scaled up by OpenGL when doing 2-d drawing for higher-res monitors). This + * number can be used to get a rough idea of the amount of detail the user + * will be able to see when drawing in 3-d. + * + */ +XPLM_API void XPLMGetScreenSize( + int * outWidth, /* Can be NULL */ + int * outHeight); /* Can be NULL */ + +/* + * XPLMGetMouseLocation + * + * This routine returns the current mouse location in cockpit pixels. The + * bottom left corner of the display is 0,0. Pass NULL to not receive info + * about either parameter. + * + */ +XPLM_API void XPLMGetMouseLocation( + int * outX, /* Can be NULL */ + int * outY); /* Can be NULL */ + +/* + * XPLMCreateWindow + * + * This routine creates a new window. Pass in the dimensions and offsets to + * the window's bottom left corner from the bottom left of the screen. You + * can specify whether the window is initially visible or not. Also, you pass + * in three callbacks to run the window and a refcon. This function returns a + * window ID you can use to refer to the new window. + * + * NOTE: windows do not have "frames"; you are responsible for drawing the + * background and frame of the window. Higher level libraries have routines + * which make this easy. + * + */ +XPLM_API XPLMWindowID XPLMCreateWindow( + int inLeft, + int inTop, + int inRight, + int inBottom, + int inIsVisible, + XPLMDrawWindow_f inDrawCallback, + XPLMHandleKey_f inKeyCallback, + XPLMHandleMouseClick_f inMouseCallback, + void * inRefcon); + +#if defined(XPLM200) +/* + * XPLMCreateWindowEx + * + * This routine creates a new window - you pass in an XPLMCreateWindow_t + * structure with all of the fields set in. You must set the structSize of + * the structure to the size of the actual structure you used. Also, you + * must provide funtions for every callback - you may not leave them null! + * (If you do not support the cursor or mouse wheel, use functions that return + * the default values.) The numeric values of the XPMCreateWindow_t structure + * correspond to the parameters of XPLMCreateWindow. + * + */ +XPLM_API XPLMWindowID XPLMCreateWindowEx( + XPLMCreateWindow_t * inParams); +#endif /* XPLM200 */ + +/* + * XPLMDestroyWindow + * + * This routine destroys a window. The callbacks are not called after this + * call. Keyboard focus is removed from the window before destroying it. + * + */ +XPLM_API void XPLMDestroyWindow( + XPLMWindowID inWindowID); + +/* + * XPLMGetWindowGeometry + * + * This routine returns the position and size of a window in cockpit pixels. + * Pass NULL to not receive any paramter. + * + */ +XPLM_API void XPLMGetWindowGeometry( + XPLMWindowID inWindowID, + int * outLeft, /* Can be NULL */ + int * outTop, /* Can be NULL */ + int * outRight, /* Can be NULL */ + int * outBottom); /* Can be NULL */ + +/* + * XPLMSetWindowGeometry + * + * This routine allows you to set the position or height aspects of a window. + * + */ +XPLM_API void XPLMSetWindowGeometry( + XPLMWindowID inWindowID, + int inLeft, + int inTop, + int inRight, + int inBottom); + +/* + * XPLMGetWindowIsVisible + * + * This routine returns whether a window is visible. + * + */ +XPLM_API int XPLMGetWindowIsVisible( + XPLMWindowID inWindowID); + +/* + * XPLMSetWindowIsVisible + * + * This routine shows or hides a window. + * + */ +XPLM_API void XPLMSetWindowIsVisible( + XPLMWindowID inWindowID, + int inIsVisible); + +/* + * XPLMGetWindowRefCon + * + * This routine returns a windows refcon, the unique value you can use for + * your own purposes. + * + */ +XPLM_API void * XPLMGetWindowRefCon( + XPLMWindowID inWindowID); + +/* + * XPLMSetWindowRefCon + * + * This routine sets a window's reference constant. Use this to pass data to + * yourself in the callbacks. + * + */ +XPLM_API void XPLMSetWindowRefCon( + XPLMWindowID inWindowID, + void * inRefcon); + +/* + * XPLMTakeKeyboardFocus + * + * This routine gives a specific window keyboard focus. Keystrokes will be + * sent to that window. Pass a window ID of 0 to pass keyboard strokes + * directly to X-Plane. + * + */ +XPLM_API void XPLMTakeKeyboardFocus( + XPLMWindowID inWindow); + +/* + * XPLMBringWindowToFront + * + * This routine brings the window to the front of the Z-order. Windows are + * brought to the front when they are created...beyond that you should make + * sure you are front before handling mouse clicks. + * + */ +XPLM_API void XPLMBringWindowToFront( + XPLMWindowID inWindow); + +/* + * XPLMIsWindowInFront + * + * This routine returns true if you pass inthe ID of the frontmost visible + * window. + * + */ +XPLM_API int XPLMIsWindowInFront( + XPLMWindowID inWindow); + +/*************************************************************************** + * HOT KEYS + ***************************************************************************/ +/* + * Hot Keys - keystrokes that can be managed by others. + * + */ + + + +/* + * XPLMHotKey_f + * + * Your hot key callback simply takes a pointer of your choosing. + * + */ +typedef void (* XPLMHotKey_f)( + void * inRefcon); + +/* + * XPLMHotKeyID + * + * Hot keys are identified by opaque IDs. + * + */ +typedef void * XPLMHotKeyID; + +/* + * XPLMRegisterHotKey + * + * This routine registers a hot key. You specify your preferred key stroke + * virtual key/flag combination, a description of what your callback does (so + * other plug-ins can describe the plug-in to the user for remapping) and a + * callback function and opaque pointer to pass in). A new hot key ID is + * returned. During execution, the actual key associated with your hot key + * may change, but you are insulated from this. + * + */ +XPLM_API XPLMHotKeyID XPLMRegisterHotKey( + char inVirtualKey, + XPLMKeyFlags inFlags, + const char * inDescription, + XPLMHotKey_f inCallback, + void * inRefcon); + +/* + * XPLMUnregisterHotKey + * + * This API unregisters a hot key. You can only register your own hot keys. + * + */ +XPLM_API void XPLMUnregisterHotKey( + XPLMHotKeyID inHotKey); + +/* + * XPLMCountHotKeys + * + * Returns the number of current hot keys. + * + */ +XPLM_API int XPLMCountHotKeys(void); + +/* + * XPLMGetNthHotKey + * + * Returns a hot key by index, for iteration on all hot keys. + * + */ +XPLM_API XPLMHotKeyID XPLMGetNthHotKey( + int inIndex); + +/* + * XPLMGetHotKeyInfo + * + * Returns information about the hot key. Return NULL for any parameter you + * don't want info about. The description should be at least 512 chars long. + * + */ +XPLM_API void XPLMGetHotKeyInfo( + XPLMHotKeyID inHotKey, + char * outVirtualKey, /* Can be NULL */ + XPLMKeyFlags * outFlags, /* Can be NULL */ + char * outDescription, /* Can be NULL */ + XPLMPluginID * outPlugin); /* Can be NULL */ + +/* + * XPLMSetHotKeyCombination + * + * XPLMSetHotKeyCombination remaps a hot keys keystrokes. You may remap + * another plugin's keystrokes. + * + */ +XPLM_API void XPLMSetHotKeyCombination( + XPLMHotKeyID inHotKey, + char inVirtualKey, + XPLMKeyFlags inFlags); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMGraphics.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMGraphics.h new file mode 100755 index 0000000..e27bb5b --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMGraphics.h @@ -0,0 +1,408 @@ +#ifndef _XPLMGraphics_h_ +#define _XPLMGraphics_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * Graphics routines for X-Plane and OpenGL. + * + * A few notes on coordinate systems: + * + * X-Plane uses three kinds of coordinates. Global coordinates are specified + * as latitude, longitude and elevation. This coordinate system never changes + * but is not very precise. + * + * OpenGL (or 'local') coordinates are cartesian and shift with the plane. + * They offer more precision and are used for 3-d OpenGL drawing. The X axis + * is aligned east-west with positive X meaning east. The Y axis is aligned + * straight up and down at the point 0,0,0 (but since the earth is round it is + * not truly straight up and down at other points). The Z axis is aligned + * north-south at 0, 0, 0 with positive Z pointing south (but since the earth + * is round it isn't exactly north-south as you move east or west of 0, 0, 0). + * One unit is one meter and the point 0,0,0 is on the surface of the earth + * at sea level for some latitude and longitude picked by the sim such that + * the user's aircraft is reasonably nearby. + * + * Cockpit coordinates are 2d, with the X axis horizontal and the Y axis + * vertical. The point 0,0 is the bottom left and 1024,768 is the upper right + * of the screen. This is true no matter what resolution the user's monitor is + * in; when running in higher resolution, graphics will be scaled. + * + * Use X-Plane's routines to convert between global and local coordinates. Do + * not attempt to do this conversion yourself; the precise 'roundness' of + * X-Plane's physics model may not match your own, and (to make things + * weirder) the user can potentially customize the physics of the current + * planet. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * X-PLANE GRAPHICS + ***************************************************************************/ +/* + * These routines allow you to use OpenGL with X-Plane. + * + */ + + + +/* + * XPLMTextureID + * + * XPLM Texture IDs name well-known textures in the sim for you to use. This + * allows you to recycle textures from X-Plane, saving VRAM. + * + */ +enum { + /* The bitmap that contains window outlines, button outlines, fonts, etc. */ + xplm_Tex_GeneralInterface = 0 + + /* The exterior paint for the user's aircraft (daytime). */ + ,xplm_Tex_AircraftPaint = 1 + + /* The exterior light map for the user's aircraft. */ + ,xplm_Tex_AircraftLiteMap = 2 + + +}; +typedef int XPLMTextureID; + +/* + * XPLMSetGraphicsState + * + * XPLMSetGraphicsState changes OpenGL's graphics state in a number of ways: + * + * inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG); + * + * inNumberTexUnits - enables or disables a number of multitexturing units. If + * the number is 0, 2d texturing is disabled entirely, as in + * glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a + * number of multitexturing units are enabled sequentially, starting with + * unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable + * (GL_TEXTURE_2D); + * + * inEnableLighting - enables or disables OpenGL lighting, e.g. + * glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); + * + * inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g. + * glEnable(GL_ALPHA_TEST); + * + * inEnableAlphaBlending - enables or disables alpha blending per pixel, e.g. + * glEnable(GL_BLEND); + * + * inEnableDepthTesting - enables per pixel depth testing, as in + * glEnable(GL_DEPTH_TEST); + * + * inEnableDepthWriting - enables writing back of depth information to the + * depth bufffer, as in glDepthMask(GL_TRUE); + * + * The purpose of this function is to change OpenGL state while keeping + * X-Plane aware of the state changes; this keeps X-Plane from getting + * surprised by OGL state changes, and prevents X-Plane and plug-ins from + * having to set all state before all draws; XPLMSetGraphicsState internally + * skips calls to change state that is already properly enabled. + * + * X-Plane does not have a 'default' OGL state to plug-ins; plug-ins should + * totally set OGL state before drawing. Use XPLMSetGraphicsState instead of + * any of the above OpenGL calls. + * + * WARNING: Any routine that performs drawing (e.g. XPLMDrawString or widget + * code) may change X-Plane's state. Always set state before drawing after + * unknown code has executed. + * + */ +XPLM_API void XPLMSetGraphicsState( + int inEnableFog, + int inNumberTexUnits, + int inEnableLighting, + int inEnableAlphaTesting, + int inEnableAlphaBlending, + int inEnableDepthTesting, + int inEnableDepthWriting); + +/* + * XPLMBindTexture2d + * + * XPLMBindTexture2d changes what texture is bound to the 2d texturing target. + * This routine caches the current 2d texture across all texturing units in + * the sim and plug-ins, preventing extraneous binding. For example, consider + * several plug-ins running in series; if they all use the 'general interface' + * bitmap to do UI, calling this function will skip the rebinding of the + * general interface texture on all but the first plug-in, which can provide + * better frame rate son some graphics cards. + * + * inTextureID is the ID of the texture object to bind; inTextureUnit is a + * zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4 + * units. (This number may increase in future versions of x-plane.) + * + * Use this routine instead of glBindTexture(GL_TEXTURE_2D, ....); + * + */ +XPLM_API void XPLMBindTexture2d( + int inTextureNum, + int inTextureUnit); + +/* + * XPLMGenerateTextureNumbers + * + * This routine generates unused texture numbers that a plug-in can use to + * safely bind textures. Use this routine instead of glGenTextures; + * glGenTextures will allocate texture numbers in ranges that X-Plane reserves + * for its own use but does not always use; for example, it might provide an + * ID within the range of textures reserved for terrain...loading a new .env + * file as the plane flies might then cause X-Plane to use this texture ID. + * X-Plane will then overwrite the plug-ins texture. This routine returns + * texture IDs that are out of X-Plane's usage range. + * + */ +XPLM_API void XPLMGenerateTextureNumbers( + int * outTextureIDs, + int inCount); + +/* + * XPLMGetTexture + * + * XPLMGetTexture returns the OpenGL texture enumeration of an X-Plane texture + * based on a generic identifying code. For example, you can get the texture + * for X-Plane's UI bitmaps. This allows you to build new gauges that take + * advantage of x-plane's textures, for smooth artwork integration and also + * saving texture memory. Note that the texture might not be loaded yet, + * depending on what the plane's panel contains. + * + * OPEN ISSUE: We really need a way to make sure X-Plane loads this texture if + * it isn't around, or at least a way to find out whether it is loaded or not. + * + */ +XPLM_API int XPLMGetTexture( + XPLMTextureID inTexture); + +/* + * XPLMWorldToLocal + * + * This routine translates coordinates from latitude, longitude, and altitude + * to local scene coordinates. Latitude and longitude are in decimal degrees, + * and altitude is in meters MSL (mean sea level). The XYZ coordinates are in + * meters in the local OpenGL coordinate system. + * + */ +XPLM_API void XPLMWorldToLocal( + double inLatitude, + double inLongitude, + double inAltitude, + double * outX, + double * outY, + double * outZ); + +/* + * XPLMLocalToWorld + * + * This routine translates a local coordinate triplet back into latitude, + * longitude, and altitude. Latitude and longitude are in decimal degrees, + * and altitude is in meters MSL (mean sea level). The XYZ coordinates are in + * meters in the local OpenGL coordinate system. + * + * NOTE: world coordinates are less precise than local coordinates; you should + * try to avoid round tripping from local to world and back. + * + */ +XPLM_API void XPLMLocalToWorld( + double inX, + double inY, + double inZ, + double * outLatitude, + double * outLongitude, + double * outAltitude); + +/* + * XPLMDrawTranslucentDarkBox + * + * This routine draws a translucent dark box, partially obscuring parts of the + * screen but making text easy to read. This is the same graphics primitive + * used by X-Plane to show text files and ATC info. + * + */ +XPLM_API void XPLMDrawTranslucentDarkBox( + int inLeft, + int inTop, + int inRight, + int inBottom); + +/*************************************************************************** + * X-PLANE TEXT + ***************************************************************************/ +/* + * + * + */ + + + +/* + * XPLMFontID + * + * X-Plane features some fixed-character fonts. Each font may have its own + * metrics. + * + * WARNING: Some of these fonts are no longer supported or may have changed + * geometries. For maximum copmatibility, see the comments below. + * + * Note: X-Plane 7 supports proportional-spaced fonts. Since no measuring + * routine is available yet, the SDK will normally draw using a fixed-width + * font. You can use a dataref to enable proportional font drawing on XP7 if + * you want to. + * + */ +enum { + /* Mono-spaced font for user interface. Available in all versions of the SDK. */ + xplmFont_Basic = 0 + + /* Deprecated, do not use. */ + ,xplmFont_Menus = 1 + + /* Deprecated, do not use. */ + ,xplmFont_Metal = 2 + + /* Deprecated, do not use. */ + ,xplmFont_Led = 3 + + /* Deprecated, do not use. */ + ,xplmFont_LedWide = 4 + + /* Deprecated, do not use. */ + ,xplmFont_PanelHUD = 5 + + /* Deprecated, do not use. */ + ,xplmFont_PanelEFIS = 6 + + /* Deprecated, do not use. */ + ,xplmFont_PanelGPS = 7 + + /* Deprecated, do not use. */ + ,xplmFont_RadiosGA = 8 + + /* Deprecated, do not use. */ + ,xplmFont_RadiosBC = 9 + + /* Deprecated, do not use. */ + ,xplmFont_RadiosHM = 10 + + /* Deprecated, do not use. */ + ,xplmFont_RadiosGANarrow = 11 + + /* Deprecated, do not use. */ + ,xplmFont_RadiosBCNarrow = 12 + + /* Deprecated, do not use. */ + ,xplmFont_RadiosHMNarrow = 13 + + /* Deprecated, do not use. */ + ,xplmFont_Timer = 14 + + /* Deprecated, do not use. */ + ,xplmFont_FullRound = 15 + + /* Deprecated, do not use. */ + ,xplmFont_SmallRound = 16 + + /* Deprecated, do not use. */ + ,xplmFont_Menus_Localized = 17 + +#if defined(XPLM200) + /* Proportional UI font. */ + ,xplmFont_Proportional = 18 + +#endif /* XPLM200 */ + +}; +typedef int XPLMFontID; + +/* + * XPLMDrawString + * + * This routine draws a NULL termianted string in a given font. Pass in the + * lower left pixel that the character is to be drawn onto. Also pass the + * character and font ID. This function returns the x offset plus the width of + * all drawn characters. The color to draw in is specified as a pointer to an + * array of three floating point colors, representing RGB intensities from 0.0 + * to 1.0. + * + */ +XPLM_API void XPLMDrawString( + float * inColorRGB, + int inXOffset, + int inYOffset, + char * inChar, + int * inWordWrapWidth, /* Can be NULL */ + XPLMFontID inFontID); + +/* + * XPLMDrawNumber + * + * This routine draws a number similar to the digit editing fields in + * PlaneMaker and data output display in X-Plane. Pass in a color, a + * position, a floating point value, and formatting info. Specify how many + * integer and how many decimal digits to show and whether to show a sign, as + * well as a character set. This routine returns the xOffset plus width of the + * string drawn. + * + */ +XPLM_API void XPLMDrawNumber( + float * inColorRGB, + int inXOffset, + int inYOffset, + double inValue, + int inDigits, + int inDecimals, + int inShowSign, + XPLMFontID inFontID); + +/* + * XPLMGetFontDimensions + * + * This routine returns the width and height of a character in a given font. + * It also tells you if the font only supports numeric digits. Pass NULL if + * you don't need a given field. Note that for a proportional font the width + * will be an arbitrary, hopefully average width. + * + */ +XPLM_API void XPLMGetFontDimensions( + XPLMFontID inFontID, + int * outCharWidth, /* Can be NULL */ + int * outCharHeight, /* Can be NULL */ + int * outDigitsOnly); /* Can be NULL */ + +#if defined(XPLM200) +/* + * XPLMMeasureString + * + * This routine returns the width in pixels of a string using a given font. + * The string is passed as a pointer plus length (and does not need to be null + * terminated); this is used to allow for measuring substrings. The return + * value is floating point; it is possible that future font drawing may allow + * for fractional pixels. + * + */ +XPLM_API float XPLMMeasureString( + XPLMFontID inFontID, + const char * inChar, + int inNumChars); +#endif /* XPLM200 */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMMenus.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMMenus.h new file mode 100755 index 0000000..630a66a --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMMenus.h @@ -0,0 +1,225 @@ +#ifndef _XPLMMenus_h_ +#define _XPLMMenus_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * XPLMMenus - Theory of Operation + * + * Plug-ins can create menus in the menu bar of X-Plane. This is done by + * creating a menu and then creating items. Menus are referred to by an + * opaque ID. Items are referred to by index number. For each menu and item + * you specify a void *. Per menu you specify a handler function that is + * called with each void * when the menu item is picked. Menu item indices + * are zero based. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * XPLM MENUS + ***************************************************************************/ +/* + * + * + */ + + + +/* + * XPLMMenuCheck + * + * These enumerations define the various 'check' states for an X-Plane menu. + * 'checking' in x-plane actually appears as a light which may or may not be + * lit. So there are three possible states. + * + */ +enum { + /* there is no symbol to the left of the menu item. */ + xplm_Menu_NoCheck = 0 + + /* the menu has a mark next to it that is unmarked (not lit). */ + ,xplm_Menu_Unchecked = 1 + + /* the menu has a mark next to it that is checked (lit). */ + ,xplm_Menu_Checked = 2 + + +}; +typedef int XPLMMenuCheck; + +/* + * XPLMMenuID + * + * This is a unique ID for each menu you create. + * + */ +typedef void * XPLMMenuID; + +/* + * XPLMMenuHandler_f + * + * A menu handler function takes two reference pointers, one for the menu + * (specified when the menu was created) and one for the item (specified when + * the item was created). + * + */ +typedef void (* XPLMMenuHandler_f)( + void * inMenuRef, + void * inItemRef); + +/* + * XPLMFindPluginsMenu + * + * This function returns the ID of the plug-ins menu, which is created for you + * at startup. + * + */ +XPLM_API XPLMMenuID XPLMFindPluginsMenu(void); + +/* + * XPLMCreateMenu + * + * This function creates a new menu and returns its ID. It returns NULL if + * the menu cannot be created. Pass in a parent menu ID and an item index to + * create a submenu, or NULL for the parent menu to put the menu in the menu + * bar. The menu's name is only used if the menu is in the menubar. You also + * pass a handler function and a menu reference value. Pass NULL for the + * handler if you do not need callbacks from the menu (for example, if it only + * contains submenus). + * + * Important: you must pass a valid, non-empty menu title even if the menu is + * a submenu where the title is not visible. + * + */ +XPLM_API XPLMMenuID XPLMCreateMenu( + const char * inName, + XPLMMenuID inParentMenu, + int inParentItem, + XPLMMenuHandler_f inHandler, + void * inMenuRef); + +/* + * XPLMDestroyMenu + * + * This function destroys a menu that you have created. Use this to remove a + * submenu if necessary. (Normally this function will not be necessary.) + * + */ +XPLM_API void XPLMDestroyMenu( + XPLMMenuID inMenuID); + +/* + * XPLMClearAllMenuItems + * + * This function removes all menu items from a menu, allowing you to rebuild + * it. Use this function if you need to change the number of items on a menu. + * + */ +XPLM_API void XPLMClearAllMenuItems( + XPLMMenuID inMenuID); + +/* + * XPLMAppendMenuItem + * + * This routine appends a new menu item to the bottom of a menu and returns + * its index. Pass in the menu to add the item to, the items name, and a void + * * ref for this item. If you pass in inForceEnglish, this menu item will be + * drawn using the english character set no matter what language x-plane is + * running in. Otherwise the menu item will be drawn localized. (An example + * of why you'd want to do this is for a proper name.) See XPLMUtilities for + * determining the current langauge. + * + */ +XPLM_API int XPLMAppendMenuItem( + XPLMMenuID inMenu, + const char * inItemName, + void * inItemRef, + int inForceEnglish); + +/* + * XPLMAppendMenuSeparator + * + * This routine adds a seperator to the end of a menu. + * + */ +XPLM_API void XPLMAppendMenuSeparator( + XPLMMenuID inMenu); + +/* + * XPLMSetMenuItemName + * + * This routine changes the name of an existing menu item. Pass in the menu + * ID and the index of the menu item. + * + */ +XPLM_API void XPLMSetMenuItemName( + XPLMMenuID inMenu, + int inIndex, + const char * inItemName, + int inForceEnglish); + +/* + * XPLMCheckMenuItem + * + * Set whether a menu item is checked. Pass in the menu ID and item index. + * + */ +XPLM_API void XPLMCheckMenuItem( + XPLMMenuID inMenu, + int index, + XPLMMenuCheck inCheck); + +/* + * XPLMCheckMenuItemState + * + * This routine returns whether a menu item is checked or not. A menu item's + * check mark may be on or off, or a menu may not have an icon at all. + * + */ +XPLM_API void XPLMCheckMenuItemState( + XPLMMenuID inMenu, + int index, + XPLMMenuCheck * outCheck); + +/* + * XPLMEnableMenuItem + * + * Sets whether this menu item is enabled. Items start out enabled. + * + */ +XPLM_API void XPLMEnableMenuItem( + XPLMMenuID inMenu, + int index, + int enabled); + +#if defined(XPLM210) +/* + * XPLMRemoveMenuItem + * + * Removes one item from a menu. Note that all menu items below are moved up + * one; your plugin must track the change in index numbers. + * + */ +XPLM_API void XPLMRemoveMenuItem( + XPLMMenuID inMenu, + int inIndex); +#endif /* XPLM210 */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMNavigation.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMNavigation.h new file mode 100755 index 0000000..5e08705 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMNavigation.h @@ -0,0 +1,376 @@ +#ifndef _XPLMNavigation_h_ +#define _XPLMNavigation_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * XPLMNavigation - THEORY OF OPERATION + * + * The XPLM Navigation APIs give you some access to the navigation databases + * inside X-Plane. X-Plane stores all navigation information in RAM, so by + * using these APIs you can gain access to most information without having to + * go to disk or parse the files yourself. + * + * You can also use this API to program the FMS. You must use the navigation + * APIs to find the nav-aids you want to program into the FMS, since the FMS + * is powered internally by x-plane's navigation database. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * NAVIGATION DATABASE ACCESS + ***************************************************************************/ +/* + * + * + */ + + + +/* + * XPLMNavType + * + * These enumerations define the different types of navaids. They are each + * defined with a separate bit so that they may be bit-wise added together to + * form sets of nav-aid types. + * + * NOTE: xplm_Nav_LatLon is a specific lat-lon coordinate entered into the + * FMS. It will not exist in the database, and cannot be programmed into the + * FMS. Querying the FMS for navaids will return it. Use + * XPLMSetFMSEntryLatLon to set a lat/lon waypoint. + * + */ +enum { + xplm_Nav_Unknown = 0 + + ,xplm_Nav_Airport = 1 + + ,xplm_Nav_NDB = 2 + + ,xplm_Nav_VOR = 4 + + ,xplm_Nav_ILS = 8 + + ,xplm_Nav_Localizer = 16 + + ,xplm_Nav_GlideSlope = 32 + + ,xplm_Nav_OuterMarker = 64 + + ,xplm_Nav_MiddleMarker = 128 + + ,xplm_Nav_InnerMarker = 256 + + ,xplm_Nav_Fix = 512 + + ,xplm_Nav_DME = 1024 + + ,xplm_Nav_LatLon = 2048 + + +}; +typedef int XPLMNavType; + +/* + * XPLMNavRef + * + * XPLMNavRef is an iterator into the navigation database. The navigation + * database is essentially an array, but it is not necessarily densely + * populated. The only assumption you can safely make is that like-typed + * nav-aids are grouped together. + * + * Use XPLMNavRef to refer to a nav-aid. + * + * XPLM_NAV_NOT_FOUND is returned by functions that return an XPLMNavRef when + * the iterator must be invalid. + * + */ +typedef int XPLMNavRef; + +#define XPLM_NAV_NOT_FOUND -1 + +/* + * XPLMGetFirstNavAid + * + * This returns the very first navaid in the database. Use this to traverse + * the entire database. Returns XPLM_NAV_NOT_FOUND if the nav database is + * empty. + * + */ +XPLM_API XPLMNavRef XPLMGetFirstNavAid(void); + +/* + * XPLMGetNextNavAid + * + * Given a nav aid ref, this routine returns the next navaid. It returns + * XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the navaid + * passed in was the last one in the database. Use this routine to iterate + * across all like-typed navaids or the entire database. + * + * WARNING: due to a bug in the SDK, when fix loading is disabled in the + * rendering settings screen, calling this routine with the last airport + * returns a bogus nav aid. Using this nav aid can crash x-plane. + * + */ +XPLM_API XPLMNavRef XPLMGetNextNavAid( + XPLMNavRef inNavAidRef); + +/* + * XPLMFindFirstNavAidOfType + * + * This routine returns the ref of the first navaid of the given type in the + * database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the + * database. You must pass exactly one nav aid type to this routine. + * + * WARNING: due to a bug in the SDK, when fix loading is disabled in the + * rendering settings screen, calling this routine with fixes returns a bogus + * nav aid. Using this nav aid can crash x-plane. + * + */ +XPLM_API XPLMNavRef XPLMFindFirstNavAidOfType( + XPLMNavType inType); + +/* + * XPLMFindLastNavAidOfType + * + * This routine returns the ref of the last navaid of the given type in the + * database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the + * database. You must pass exactly one nav aid type to this routine. + * + * WARNING: due to a bug in the SDK, when fix loading is disabled in the + * rendering settings screen, calling this routine with fixes returns a bogus + * nav aid. Using this nav aid can crash x-plane. + * + */ +XPLM_API XPLMNavRef XPLMFindLastNavAidOfType( + XPLMNavType inType); + +/* + * XPLMFindNavAid + * + * This routine provides a number of searching capabilities for the nav + * database. XPLMFindNavAid will search through every nav aid whose type is + * within inType (multiple types may be added together) and return any + * nav-aids found based on the following rules: + * + * If inLat and inLon are not NULL, the navaid nearest to that lat/lon will be + * returned, otherwise the last navaid found will be returned. + * + * If inFrequency is not NULL, then any navaids considered must match this + * frequency. Note that this will screen out radio beacons that do not have + * frequency data published (like inner markers) but not fixes and airports. + * + * If inNameFragment is not NULL, only navaids that contain the fragment in + * their name will be returned. + * + * If inIDFragment is not NULL, only navaids that contain the fragment in + * their IDs will be returned. + * + * This routine provides a simple way to do a number of useful searches: + * + * Find the nearest navaid on this frequency. Find the nearest airport. Find + * the VOR whose ID is "KBOS". Find the nearest airport whose name contains + * "Chicago". + * + */ +XPLM_API XPLMNavRef XPLMFindNavAid( + const char * inNameFragment, /* Can be NULL */ + const char * inIDFragment, /* Can be NULL */ + float * inLat, /* Can be NULL */ + float * inLon, /* Can be NULL */ + int * inFrequency, /* Can be NULL */ + XPLMNavType inType); + +/* + * XPLMGetNavAidInfo + * + * This routine returns information about a navaid. Any non-null field is + * filled out with information if it is available. + * + * Frequencies are in the nav.dat convention as described in the X-Plane nav + * database FAQ: NDB frequencies are exact, all others are multiplied by 100. + * + * The buffer for IDs should be at least 6 chars and the buffer for names + * should be at least 41 chars, but since these values are likely to go up, I + * recommend passing at least 32 chars for IDs and 256 chars for names when + * possible. + * + * The outReg parameter tells if the navaid is within the local "region" of + * loaded DSFs. (This information may not be particularly useful to plugins.) + * The parameter is a single byte value 1 for true or 0 for false, not a C + * string. + * + */ +XPLM_API void XPLMGetNavAidInfo( + XPLMNavRef inRef, + XPLMNavType * outType, /* Can be NULL */ + float * outLatitude, /* Can be NULL */ + float * outLongitude, /* Can be NULL */ + float * outHeight, /* Can be NULL */ + int * outFrequency, /* Can be NULL */ + float * outHeading, /* Can be NULL */ + char * outID, /* Can be NULL */ + char * outName, /* Can be NULL */ + char * outReg); /* Can be NULL */ + +/*************************************************************************** + * FLIGHT MANAGEMENT COMPUTER + ***************************************************************************/ +/* + * Note: the FMS works based on an array of entries. Indices into the array + * are zero-based. Each entry is a nav-aid plus an altitude. The FMS tracks + * the currently displayed entry and the entry that it is flying to. + * + * The FMS must be programmed with contiguous entries, so clearing an entry at + * the end shortens the effective flight plan. There is a max of 100 + * waypoints in the flight plan. + * + */ + + + +/* + * XPLMCountFMSEntries + * + * This routine returns the number of entries in the FMS. + * + */ +XPLM_API int XPLMCountFMSEntries(void); + +/* + * XPLMGetDisplayedFMSEntry + * + * This routine returns the index of the entry the pilot is viewing. + * + */ +XPLM_API int XPLMGetDisplayedFMSEntry(void); + +/* + * XPLMGetDestinationFMSEntry + * + * This routine returns the index of the entry the FMS is flying to. + * + */ +XPLM_API int XPLMGetDestinationFMSEntry(void); + +/* + * XPLMSetDisplayedFMSEntry + * + * This routine changes which entry the FMS is showing to the index specified. + * * + */ +XPLM_API void XPLMSetDisplayedFMSEntry( + int inIndex); + +/* + * XPLMSetDestinationFMSEntry + * + * This routine changes which entry the FMS is flying the aircraft toward. + * + */ +XPLM_API void XPLMSetDestinationFMSEntry( + int inIndex); + +/* + * XPLMGetFMSEntryInfo + * + * This routine returns information about a given FMS entry. A reference to a + * navaid can be returned allowing you to find additional information (such as + * a frequency, ILS heading, name, etc.). Some information is available + * immediately. For a lat/lon entry, the lat/lon is returned by this routine + * but the navaid cannot be looked up (and the reference will be + * XPLM_NAV_NOT_FOUND. FMS name entry buffers should be at least 256 chars in + * length. + * + */ +XPLM_API void XPLMGetFMSEntryInfo( + int inIndex, + XPLMNavType * outType, /* Can be NULL */ + char * outID, /* Can be NULL */ + XPLMNavRef * outRef, /* Can be NULL */ + int * outAltitude, /* Can be NULL */ + float * outLat, /* Can be NULL */ + float * outLon); /* Can be NULL */ + +/* + * XPLMSetFMSEntryInfo + * + * This routine changes an entry in the FMS to have the destination navaid + * passed in and the altitude specified. Use this only for airports, fixes, + * and radio-beacon navaids. Currently of radio beacons, the FMS can only + * support VORs and NDBs. Use the routines below to clear or fly to a lat/lon. + * + */ +XPLM_API void XPLMSetFMSEntryInfo( + int inIndex, + XPLMNavRef inRef, + int inAltitude); + +/* + * XPLMSetFMSEntryLatLon + * + * This routine changes the entry in the FMS to a lat/lon entry with the given + * coordinates. + * + */ +XPLM_API void XPLMSetFMSEntryLatLon( + int inIndex, + float inLat, + float inLon, + int inAltitude); + +/* + * XPLMClearFMSEntry + * + * This routine clears the given entry, potentially shortening the flight + * plan. + * + */ +XPLM_API void XPLMClearFMSEntry( + int inIndex); + +/*************************************************************************** + * GPS RECEIVER + ***************************************************************************/ +/* + * These APIs let you read data from the GPS unit. + * + */ + + + +/* + * XPLMGetGPSDestinationType + * + * This routine returns the type of the currently selected GPS destination, + * one of fix, airport, VOR or NDB. + * + */ +XPLM_API XPLMNavType XPLMGetGPSDestinationType(void); + +/* + * XPLMGetGPSDestination + * + * This routine returns the current GPS destination. + * + */ +XPLM_API XPLMNavRef XPLMGetGPSDestination(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMPlanes.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMPlanes.h new file mode 100755 index 0000000..cbc58f4 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMPlanes.h @@ -0,0 +1,258 @@ +#ifndef _XPLMPlanes_h_ +#define _XPLMPlanes_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * The XPLMPlanes APIs allow you to control the various aircraft in x-plane, + * both the user's and the sim's. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * USER AIRCRAFT ACCESS + ***************************************************************************/ +/* + * + * + */ + + +/* + * XPLMSetUsersAircraft + * + * This routine changes the user's aircraft. Note that this will reinitialize + * the user to be on the nearest airport's first runway. Pass in a full path + * (hard drive and everything including the .acf extension) to the .acf file. + * + */ +XPLM_API void XPLMSetUsersAircraft( + const char * inAircraftPath); +/* + * XPLMPlaceUserAtAirport + * + * This routine places the user at a given airport. Specify the airport by + * its ICAO code (e.g. 'KBOS'). + * + */ +XPLM_API void XPLMPlaceUserAtAirport( + const char * inAirportCode); +/*************************************************************************** + * GLOBAL AIRCRAFT ACCESS + ***************************************************************************/ +/* + * + * + */ + + +/* The user's aircraft is always index 0. */ +#define XPLM_USER_AIRCRAFT 0 +/* + * XPLMPlaneDrawState_t + * + * This structure contains additional plane parameter info to be passed to + * draw plane. Make sure to fill in the size of the structure field with + * sizeof(XPLMDrawPlaneState_t) so that the XPLM can tell how many fields you + * knew about when compiling your plugin (since more fields may be added + * later). + * + * Most of these fields are ratios from 0 to 1 for control input. X-Plane + * calculates what the actual controls look like based on the .acf file for + * that airplane. Note for the yoke inputs, this is what the pilot of the + * plane has commanded (post artificial stability system if there were one) + * and affects aelerons, rudder, etc. It is not necessarily related to the + * actual position of the plane! + * + */ +typedef struct { + /* The size of the draw state struct. */ + int structSize; + /* A ratio from [0..1] describing how far the landing gear is extended. */ + float gearPosition; + /* Ratio of flap deployment, 0 = up, 1 = full deploy. */ + float flapRatio; + /* Ratio of spoiler deployment, 0 = none, 1 = full deploy. */ + float spoilerRatio; + /* Ratio of speed brake deployment, 0 = none, 1 = full deploy. */ + float speedBrakeRatio; + /* Ratio of slat deployment, 0 = none, 1 = full deploy. */ + float slatRatio; + /* Wing sweep ratio, 0 = forward, 1 = swept. */ + float wingSweep; + /* Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. */ + float thrust; + /* Total pitch input for this plane. */ + float yokePitch; + /* Total Heading input for this plane. */ + float yokeHeading; + /* Total Roll input for this plane. */ + float yokeRoll; +} XPLMPlaneDrawState_t; +/* + * XPLMCountAircraft + * + * This function returns the number of aircraft X-Plane is capable of having, + * as well as the number of aircraft that are currently active. These numbers + * count the user's aircraft. It can also return the plugin that is currently + * controlling aircraft. In X-Plane 7, this routine reflects the number of + * aircraft the user has enabled in the rendering options window. + * + */ +XPLM_API void XPLMCountAircraft( + int * outTotalAircraft, + int * outActiveAircraft, + XPLMPluginID * outController); +/* + * XPLMGetNthAircraftModel + * + * This function returns the aircraft model for the Nth aircraft. Indices are + * zero based, with zero being the user's aircraft. The file name should be + * at least 256 chars in length; the path should be at least 512 chars in + * length. + * + */ +XPLM_API void XPLMGetNthAircraftModel( + int inIndex, + char * outFileName, + char * outPath); +/*************************************************************************** + * EXCLUSIVE AIRCRAFT ACCESS + ***************************************************************************/ +/* + * The following routines require exclusive access to the airplane APIs. Only + * one plugin may have this access at a time. + * + */ + + + +/* + * XPLMPlanesAvailable_f + * + * Your airplanes available callback is called when another plugin gives up + * access to the multiplayer planes. Use this to wait for access to + * multiplayer. + * + */ +typedef void (* XPLMPlanesAvailable_f)( + void * inRefcon); + +/* + * XPLMAcquirePlanes + * + * XPLMAcquirePlanes grants your plugin exclusive access to the aircraft. It + * returns 1 if you gain access, 0 if you do not. inAircraft - pass in an + * array of pointers to strings specifying the planes you want loaded. For + * any plane index you do not want loaded, pass a 0-length string. Other + * strings should be full paths with the .acf extension. NULL terminates this + * array, or pass NULL if there are no planes you want loaded. If you pass in + * a callback and do not receive access to the planes your callback will be + * called when the airplanes are available. If you do receive airplane access, + * your callback will not be called. + * + */ +XPLM_API int XPLMAcquirePlanes( + char ** inAircraft, /* Can be NULL */ + XPLMPlanesAvailable_f inCallback, + void * inRefcon); + +/* + * XPLMReleasePlanes + * + * Call this function to release access to the planes. Note that if you are + * disabled, access to planes is released for you and you must reacquire it. + * + */ +XPLM_API void XPLMReleasePlanes(void); + +/* + * XPLMSetActiveAircraftCount + * + * This routine sets the number of active planes. If you pass in a number + * higher than the total number of planes availables, only the total number of + * planes available is actually used. + * + */ +XPLM_API void XPLMSetActiveAircraftCount( + int inCount); + +/* + * XPLMSetAircraftModel + * + * This routine loads an aircraft model. It may only be called if you have + * exclusive access to the airplane APIs. Pass in the path of the model with + * the .acf extension. The index is zero based, but you may not pass in 0 + * (use XPLMSetUsersAircraft to load the user's aircracft). + * + */ +XPLM_API void XPLMSetAircraftModel( + int inIndex, + const char * inAircraftPath); + +/* + * XPLMDisableAIForPlane + * + * This routine turns off X-Plane's AI for a given plane. The plane will + * continue to draw and be a real plane in X-Plane, but will not move itself. + * + */ +XPLM_API void XPLMDisableAIForPlane( + int inPlaneIndex); + +/* + * XPLMDrawAircraft + * + * This routine draws an aircraft. It can only be called from a 3-d drawing + * callback. Pass in the position of the plane in OpenGL local coordinates + * and the orientation of the plane. A 1 for full drawing indicates that the + * whole plane must be drawn; a 0 indicates you only need the nav lights + * drawn. (This saves rendering time when planes are far away.) + * + */ +XPLM_API void XPLMDrawAircraft( + int inPlaneIndex, + float inX, + float inY, + float inZ, + float inPitch, + float inRoll, + float inYaw, + int inFullDraw, + XPLMPlaneDrawState_t * inDrawStateInfo); + +/* + * XPLMReinitUsersPlane + * + * This function recomputes the derived flight model data from the aircraft + * structure in memory. If you have used the data access layer to modify the + * aircraft structure, use this routine to resynchronize x-plane; since + * X-plane works at least partly from derived values, the sim will not behave + * properly until this is called. + * + * WARNING: this routine does not necessarily place the airplane at the + * airport; use XPLMSetUsersAircraft to be compatible. This routine is + * provided to do special experimentation with flight models without resetting + * flight. + * + */ +XPLM_API void XPLMReinitUsersPlane(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMPlugin.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMPlugin.h new file mode 100755 index 0000000..576d157 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMPlugin.h @@ -0,0 +1,331 @@ +#ifndef _XPLMPlugin_h_ +#define _XPLMPlugin_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * These APIs provide facilities to find and work with other plugins and + * manage other plugins. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * FINDING PLUGINS + ***************************************************************************/ +/* + * These APIs allow you to find another plugin or yourself, or iterate across + * all plugins. For example, if you wrote an FMS plugin that needed to talk + * to an autopilot plugin, you could use these APIs to locate the autopilot + * plugin. + * + */ + + + +/* + * XPLMGetMyID + * + * This routine returns the plugin ID of the calling plug-in. Call this to + * get your own ID. + * + */ +XPLM_API XPLMPluginID XPLMGetMyID(void); + +/* + * XPLMCountPlugins + * + * This routine returns the total number of plug-ins that are loaded, both + * disabled and enabled. + * + */ +XPLM_API int XPLMCountPlugins(void); + +/* + * XPLMGetNthPlugin + * + * This routine returns the ID of a plug-in by index. Index is 0 based from 0 + * to XPLMCountPlugins-1, inclusive. Plugins may be returned in any arbitrary + * order. + * + */ +XPLM_API XPLMPluginID XPLMGetNthPlugin( + int inIndex); + +/* + * XPLMFindPluginByPath + * + * This routine returns the plug-in ID of the plug-in whose file exists at the + * passed in absolute file system path. XPLM_NO_PLUGIN_ID is returned if the + * path does not point to a currently loaded plug-in. + * + */ +XPLM_API XPLMPluginID XPLMFindPluginByPath( + const char * inPath); + +/* + * XPLMFindPluginBySignature + * + * This routine returns the plug-in ID of the plug-in whose signature matches + * what is passed in or XPLM_NO_PLUGIN_ID if no running plug-in has this + * signature. Signatures are the best way to identify another plug-in as they + * are independent of the file system path of a plug-in or the human-readable + * plug-in name, and should be unique for all plug-ins. Use this routine to + * locate another plugin that your plugin interoperates with + * + */ +XPLM_API XPLMPluginID XPLMFindPluginBySignature( + const char * inSignature); + +/* + * XPLMGetPluginInfo + * + * This routine returns information about a plug-in. Each parameter should be + * a pointer to a buffer of at least 256 characters, or NULL to not receive + * the information. + * + * outName - the human-readable name of the plug-in. outFilePath - the + * absolute file path to the file that contains this plug-in. outSignature - a + * unique string that identifies this plug-in. outDescription - a + * human-readable description of this plug-in. + * + */ +XPLM_API void XPLMGetPluginInfo( + XPLMPluginID inPlugin, + char * outName, /* Can be NULL */ + char * outFilePath, /* Can be NULL */ + char * outSignature, /* Can be NULL */ + char * outDescription); /* Can be NULL */ + +/*************************************************************************** + * ENABLING/DISABLING PLUG-INS + ***************************************************************************/ +/* + * These routines are used to work with plug-ins and manage them. Most + * plugins will not need to use these APIs. + * + */ + + + +/* + * XPLMIsPluginEnabled + * + * Returns whether the specified plug-in is enabled for running. + * + */ +XPLM_API int XPLMIsPluginEnabled( + XPLMPluginID inPluginID); + +/* + * XPLMEnablePlugin + * + * This routine enables a plug-in if it is not already enabled. It returns 1 + * if the plugin was enabled or successfully enables itself, 0 if it does not. + * Plugins may fail to enable (for example, if resources cannot be acquired) + * by returning 0 from their XPluginEnable callback. + * + */ +XPLM_API int XPLMEnablePlugin( + XPLMPluginID inPluginID); + +/* + * XPLMDisablePlugin + * + * This routine disableds an enabled plug-in. + * + */ +XPLM_API void XPLMDisablePlugin( + XPLMPluginID inPluginID); + +/* + * XPLMReloadPlugins + * + * This routine reloads all plug-ins. Once this routine is called and you + * return from the callback you were within (e.g. a menu select callback) you + * will receive your XPluginDisable and XPluginStop callbacks and your DLL + * will be unloaded, then the start process happens as if the sim was starting + * up. + * + */ +XPLM_API void XPLMReloadPlugins(void); + +/*************************************************************************** + * INTERPLUGIN MESSAGING + ***************************************************************************/ +/* + * Plugin messages are defined as 32-bit integers. Messages below 0x00FFFFFF + * are reserved for X-Plane and the plugin SDK. + * + * Messages have two conceptual uses: notifications and commands. Commands + * are sent from one plugin to another to induce behavior; notifications are + * sent from one plugin to all others for informational purposes. It is + * important that commands and notifications not have the same values because + * this could cause a notification sent by one plugin to accidentally induce a + * command in another. + * + * By convention, plugin-defined notifications should have the high bit set + * (e.g. be greater or equal to unsigned 0x8000000) while commands should have + * this bit be cleared. + * + * The following messages are sent to your plugin by x-plane. + * + */ + + + +/* This message is sent to your plugin whenever the user's plane crashes. */ +#define XPLM_MSG_PLANE_CRASHED 101 + +/* This message is sent to your plugin whenever a new plane is loaded. The * + * parameter is the number of the plane being loaded; 0 indicates the user's * + * plane. */ +#define XPLM_MSG_PLANE_LOADED 102 + +/* This messages is called whenever the user's plane is positioned at a new * + * airport. */ +#define XPLM_MSG_AIRPORT_LOADED 103 + +/* This message is sent whenever new scenery is loaded. Use datarefs to * + * determine the new scenery files that were loaded. */ +#define XPLM_MSG_SCENERY_LOADED 104 + +/* This message is sent whenever the user adjusts the number of X-Plane * + * aircraft models. You must use XPLMCountPlanes to find out how many planes * + * are now available. This message will only be sent in XP7 and higher * + * because in XP6 the number of aircraft is not user-adjustable. */ +#define XPLM_MSG_AIRPLANE_COUNT_CHANGED 105 + +#if defined(XPLM200) +/* This message is sent to your plugin whenever a plane is unloaded. The * + * parameter is the number of the plane being unloaded; 0 indicates the user's * + * plane. The parameter is of type int, passed as the value of the pointer. * + * (That is: the parameter is an int, not a pointer to an int.) */ +#define XPLM_MSG_PLANE_UNLOADED 106 +#endif /* XPLM200 */ + +#if defined(XPLM210) +/* This message is sent to your plugin right before X-Plane writes its * + * preferences file. You can use this for two purposes: to write your own * + * preferences, and to modify any datarefs to influence preferences output. * + * For example, if your plugin temporarily modifies saved preferences, you can * + * put them back to their default values here to avoid having the tweaks be * + * persisted if your plugin is not loaded on the next invocation of X-Plane. */ +#define XPLM_MSG_WILL_WRITE_PREFS 107 +#endif /* XPLM210 */ + +#if defined(XPLM210) +/* This message is sent to your plugin right after a livery is loaded for an * + * airplane. You can use this to check the new livery (via datarefs) and * + * react accordingly. The parameter is of type int, passed as the value of a * + * pointer and represents the aicraft plane number - 0 is the user's plane. */ +#define XPLM_MSG_LIVERY_LOADED 108 +#endif /* XPLM210 */ + +/* + * XPLMSendMessageToPlugin + * + * This function sends a message to another plug-in or X-Plane. Pass + * XPLM_NO_PLUGIN_ID to broadcast to all plug-ins. Only enabled plug-ins with + * a message receive function receive the message. + * + */ +XPLM_API void XPLMSendMessageToPlugin( + XPLMPluginID inPlugin, + int inMessage, + void * inParam); + +#if defined(XPLM200) +/*************************************************************************** + * Plugin Features API + ***************************************************************************/ +/* + * The plugin features API allows your plugin to "sign up" for additional + * capabilities and plugin system features that are normally disabled for + * backward compatibility. This allows advanced plugins to "opt-in" to new + * behavior. + * + * Each feature is defined by a permanent string name. The feature string + * names will vary with the particular installation of X-Plane, so plugins + * should not expect a feature to be guaranteed present. + * + */ + + + + +/* + * XPLMFeatureEnumerator_f + * + * You pass an XPLMFeatureEnumerator_f to get a list of all features supported + * by a given version running version of X-Plane. This routine is called once + * for each feature. + * + */ +typedef void (* XPLMFeatureEnumerator_f)( + const char * inFeature, + void * inRef); + +/* + * XPLMHasFeature + * + * This returns 1 if the given installation of X-Plane supports a feature, or + * 0 if it does not. + * + */ +XPLM_API int XPLMHasFeature( + const char * inFeature); + +/* + * XPLMIsFeatureEnabled + * + * This returns 1 if a feature is currently enabled for your plugin, or 0 if + * it is not enabled. It is an error to call this routine with an unsupported + * feature. + * + */ +XPLM_API int XPLMIsFeatureEnabled( + const char * inFeature); + +/* + * XPLMEnableFeature + * + * This routine enables or disables a feature for your plugin. This will + * change the running behavior of X-Plane and your plugin in some way, + * depending on the feature. + * + */ +XPLM_API void XPLMEnableFeature( + const char * inFeature, + int inEnable); + +/* + * XPLMEnumerateFeatures + * + * This routine calls your enumerator callback once for each feature that this + * running version of X-Plane supports. Use this routine to determine all of + * the features that X-Plane can support. + * + */ +XPLM_API void XPLMEnumerateFeatures( + XPLMFeatureEnumerator_f inEnumerator, + void * inRef); + +#endif /* XPLM200 */ +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMProcessing.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMProcessing.h new file mode 100755 index 0000000..99fb6ea --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMProcessing.h @@ -0,0 +1,254 @@ +#ifndef _XPLMProcessing_h_ +#define _XPLMProcessing_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * This API allows you to get regular callbacks during the flight loop, the + * part of X-Plane where the plane's position calculates the physics of + * flight, etc. Use these APIs to accomplish periodic tasks like logging data + * and performing I/O. + * + * WARNING: Do NOT use these callbacks to draw! You cannot draw during flight + * loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info) + * for graphics. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * FLIGHT LOOP CALLBACKS + ***************************************************************************/ +/* + * + * + */ + + + +#if defined(XPLM210) +/* + * XPLMFlightLoopPhaseType + * + * You can register a flight loop callback to run either before or after the + * flight model is integrated by X-Plane. + * + */ +enum { + /* Your callback runs before X-Plane integrates the flight model. */ + xplm_FlightLoop_Phase_BeforeFlightModel = 0 + + /* Your callback runs after X-Plane integrates the flight model. */ + ,xplm_FlightLoop_Phase_AfterFlightModel = 1 + + +}; +typedef int XPLMFlightLoopPhaseType; +#endif /* XPLM210 */ + +#if defined(XPLM210) +/* + * XPLMFlightLoopID + * + * This is an opaque identifier for a flight loop callback. You can use this + * identifier to easily track and remove your callbacks, or to use the new + * flight loop APIs. + * + */ +typedef void * XPLMFlightLoopID; +#endif /* XPLM210 */ + +/* + * XPLMFlightLoop_f + * + * This is your flight loop callback. Each time the flight loop is iterated + * through, you receive this call at the end. You receive a time since you + * were last called and a time since the last loop, as well as a loop counter. + * The 'phase' parameter is deprecated and should be ignored. + * + * Your return value controls when you will next be called. Return 0 to stop + * receiving callbacks. Pass a positive number to specify how many seconds + * until the next callback. (You will be called at or after this time, not + * before.) Pass a negative number to specify how many loops must go by until + * you are called. For example, -1.0 means call me the very next loop. Try + * to run your flight loop as infrequently as is practical, and suspend it + * (using return value 0) when you do not need it; lots of flight loop + * callbacks that do nothing lowers x-plane's frame rate. + * + * Your callback will NOT be unregistered if you return 0; it will merely be + * inactive. + * + * The reference constant you passed to your loop is passed back to you. + * + */ +typedef float (* XPLMFlightLoop_f)( + float inElapsedSinceLastCall, + float inElapsedTimeSinceLastFlightLoop, + int inCounter, + void * inRefcon); + +#if defined(XPLM210) +/* + * XPLMCreateFlightLoop_t + * + * XPLMCreateFlightLoop_t contains the parameters to create a new flight loop + * callback. The strsucture can be expanded in future SDKs - always set + * structSize to the size of your structure in bytes. + * + */ +typedef struct { + int structSize; + XPLMFlightLoopPhaseType phase; + XPLMFlightLoop_f callbackFunc; + void * refcon; +} XPLMCreateFlightLoop_t; +#endif /* XPLM210 */ + +/* + * XPLMGetElapsedTime + * + * This routine returns the elapsed time since the sim started up in decimal + * seconds. + * + */ +XPLM_API float XPLMGetElapsedTime(void); + +/* + * XPLMGetCycleNumber + * + * This routine returns a counter starting at zero for each sim cycle + * computed/video frame rendered. + * + */ +XPLM_API int XPLMGetCycleNumber(void); + +/* + * XPLMRegisterFlightLoopCallback + * + * This routine registers your flight loop callback. Pass in a pointer to a + * flight loop function and a refcon. inInterval defines when you will be + * called. Pass in a positive number to specify seconds from registration + * time to the next callback. Pass in a negative number to indicate when you + * will be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to + * not be called; your callback will be inactive. + * + */ +XPLM_API void XPLMRegisterFlightLoopCallback( + XPLMFlightLoop_f inFlightLoop, + float inInterval, + void * inRefcon); + +/* + * XPLMUnregisterFlightLoopCallback + * + * This routine unregisters your flight loop callback. Do NOT call it from + * your flight loop callback. Once your flight loop callback is + * unregistered, it will not be called again. + * + */ +XPLM_API void XPLMUnregisterFlightLoopCallback( + XPLMFlightLoop_f inFlightLoop, + void * inRefcon); + +/* + * XPLMSetFlightLoopCallbackInterval + * + * This routine sets when a callback will be called. Do NOT call it from your + * callback; use the return value of the callback to change your callback + * interval from inside your callback. + * + * inInterval is formatted the same way as in XPLMRegisterFlightLoopCallback; + * positive for seconds, negative for cycles, and 0 for deactivating the + * callback. If inRelativeToNow is 1, times are from the time of this call; + * otherwise they are from the time the callback was last called (or the time + * it was registered if it has never been called. + * + */ +XPLM_API void XPLMSetFlightLoopCallbackInterval( + XPLMFlightLoop_f inFlightLoop, + float inInterval, + int inRelativeToNow, + void * inRefcon); + +#if defined(XPLM210) +/* + * XPLMCreateFlightLoop + * + * This routine creates a flight loop callback and returns its ID. The flight + * loop callback is created using the input param struct, and is inited to be + * unscheduled. + * + */ +XPLM_API XPLMFlightLoopID XPLMCreateFlightLoop( + XPLMCreateFlightLoop_t * inParams); +#endif /* XPLM210 */ + +#if defined(XPLM210) +/* + * XPLMDestroyFlightLoop + * + * This routine destroys a flight loop callback by ID. + * + */ +XPLM_API void XPLMDestroyFlightLoop( + XPLMFlightLoopID inFlightLoopID); +#endif /* XPLM210 */ + +#if defined(XPLM210) +/* + * XPLMScheduleFlightLoop + * + * This routine schedules a flight loop callback for future execution. If + * inInterval is negative, it is run in a certain number of frames based on + * the absolute value of the input. If the interval is positive, it is a + * duration in seconds. + * + * If inRelativeToNow is true, ties are interpretted relative to the time this + * routine is called; otherwise they are relative to the last call time or the + * time the flight loop was registered (if never called). + * + * THREAD SAFETY: it is legal to call this routine from any thread under the + * following conditions: + * + * 1. The call must be between the beginning of an XPLMEnable and the end of + * an XPLMDisable sequence. (That is, you must not call this routine from + * thread activity when your plugin was supposed to be disabled. Since + * plugins are only enabled while loaded, this also implies you cannot run + * this routine outside an XPLMStart/XPLMStop sequence.) + * + * 2. You may not call this routine re-entrantly for a single flight loop ID. + * (That is, you can't enable from multiple threads at the same time.) + * + * 3. You must call this routine between the time after XPLMCreateFlightLoop + * returns a value and the time you call XPLMDestroyFlightLoop. (That is, you + * must ensure that your threaded activity is within the life of the object. + * The SDK does not check this for you, nor does it synchronize destruction of + * the object.) + * + * 4. The object must be unscheduled if this routine is to be called from a + * thread other than the main thread. + * + */ +XPLM_API void XPLMScheduleFlightLoop( + XPLMFlightLoopID inFlightLoopID, + float inInterval, + int inRelativeToNow); +#endif /* XPLM210 */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMScenery.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMScenery.h new file mode 100755 index 0000000..1cc5186 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMScenery.h @@ -0,0 +1,400 @@ +#ifndef _XPLMScenery_h_ +#define _XPLMScenery_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * This package contains APIs to interact with X-Plane's scenery system. + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(XPLM200) +/*************************************************************************** + * Terrain Y-Testing + ***************************************************************************/ +/* + * The Y-testing API allows you to locate the physical scenery mesh. This + * would be used to place dynamic graphics on top of the ground in a + * plausible way or do physics interactions. + * + * The Y-test API works via probe objects, which are allocated by your plugin + * and used to query terrain. Probe objects exist both to capture which + * algorithm you have requested (see probe types) and also to cache query + * information. + * + * Performance guidelines: It is generally faster to use the same probe for + * nearby points and different probes for different points. Try not to + * allocate more than "hundreds" of probes at most. Share probes if you need + * more. Generally, probing operations are expensive, and should be avoided + * via caching when possible. + * + * Y testing returns a location on the terrain, a normal vectory, and a + * velocity vector. The normal vector tells you the slope of the terrain at + * that point. The velocity vector tells you if that terrain is moving (and + * is in meters/second). For example, if your Y test hits the aircraft carrier + * deck, this tells you the velocity of that point on the deck. + * + * Note: the Y-testing API is limited to probing the loaded scenery area, + * which is approximately 300x300 km in X-Plane 9. Probes outside this area + * will return the height of a 0 MSL sphere. + * + */ + + + + +/* + * XPLMProbeType + * + * XPLMProbeType defines the type of terrain probe - each probe has a + * different algorithm. (Only one type of probe is provided right now, but + * future APIs will expose more flexible or poewrful or useful probes. + * + */ +enum { + /* The Y probe gives you the location of the tallest physical scenery along * + * the Y axis going through the queried point. */ + xplm_ProbeY = 0 + + +}; +typedef int XPLMProbeType; + +/* + * XPLMProbeResult + * + * Probe results - possible results from a probe query. + * + */ +enum { + /* The probe hit terrain and returned valid values. */ + xplm_ProbeHitTerrain = 0 + + /* An error in the API call. Either the probe struct size is bad, or the * + * probe is invalid or the type is mismatched for the specific query call. */ + ,xplm_ProbeError = 1 + + /* The probe call succeeded but there is no terrain under this point (perhaps * + * it is off the side of the planet?) */ + ,xplm_ProbeMissed = 2 + + +}; +typedef int XPLMProbeResult; + +/* + * XPLMProbeRef + * + * An XPLMProbeRef is an opaque handle to a probe, used for querying the + * terrain. + * + */ +typedef void * XPLMProbeRef; + +/* + * XPLMProbeInfo_t + * + * XPLMProbeInfo_t contains the results of a probe call. Make sure to set + * structSize to the size of the struct before using it. + * + */ +typedef struct { + /* Size of structure in bytes - always set this before calling the XPLM. */ + int structSize; + /* Resulting X location of the terrain point we hit, in local OpenGL * + * coordinates. */ + float locationX; + /* Resulting Y location of the terrain point we hit, in local OpenGL * + * coordinates. */ + float locationY; + /* Resulting Z location of the terrain point we hit, in local OpenGL * + * coordinates. */ + float locationZ; + /* X component of the normal vector to the terrain we found. */ + float normalX; + /* Y component of the normal vector to the terrain we found. */ + float normalY; + /* Z component of the normal vector to the terrain we found. */ + float normalZ; + /* X component of the velocity vector of the terrain we found. */ + float velocityX; + /* Y component of the velocity vector of the terrain we found. */ + float velocityY; + /* Z component of the velocity vector of the terrain we found. */ + float velocityZ; + /* Tells if the surface we hit is water (otherwise it is land). */ + int is_wet; +} XPLMProbeInfo_t; + +/* + * XPLMCreateProbe + * + * Creates a new probe object of a given type and returns. + * + */ +XPLM_API XPLMProbeRef XPLMCreateProbe( + XPLMProbeType inProbeType); + +/* + * XPLMDestroyProbe + * + * Deallocates an existing probe object. + * + */ +XPLM_API void XPLMDestroyProbe( + XPLMProbeRef inProbe); + +/* + * XPLMProbeTerrainXYZ + * + * Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe + * object, and an XPLMProbeInfo_t struct that has its structSize member set + * properly. Other fields are filled in if we hit terrain, and a probe result + * is returned. + * + */ +XPLM_API XPLMProbeResult XPLMProbeTerrainXYZ( + XPLMProbeRef inProbe, + float inX, + float inY, + float inZ, + XPLMProbeInfo_t * outInfo); + +#endif /* XPLM200 */ +/*************************************************************************** + * Object Drawing + ***************************************************************************/ +/* + * The object drawing routines let you load and draw X-Plane OBJ files. + * Objects are loaded by file path and managed via an opaque handle. X-Plane + * naturally reference counts objects, so it is important that you balance + * every successful call to XPLMLoadObject with a call to XPLMUnloadObject! + * + */ + + + +#if defined(XPLM200) +/* + * XPLMObjectRef + * + * An XPLMObjectRef is a opaque handle to an .obj file that has been loaded + * into memory. + * + */ +typedef void * XPLMObjectRef; +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMDrawInfo_t + * + * The XPLMDrawInfo_t structure contains positioning info for one object that + * is to be drawn. Be sure to set structSize to the size of the structure for + * future expansion. + * + */ +typedef struct { + /* Set this to the size of this structure! */ + int structSize; + /* X location of the object in local coordinates. */ + float x; + /* Y location of the object in local coordinates. */ + float y; + /* Z location of the object in local coordinates. */ + float z; + /* Pitch in degres to rotate the object, positive is up. */ + float pitch; + /* Heading in local coordinates to rotate the object, clockwise. */ + float heading; + /* Roll to rotate the object. */ + float roll; +} XPLMDrawInfo_t; +#endif /* XPLM200 */ + +#if defined(XPLM210) +/* + * XPLMObjectLoaded_f + * + * You provide this callback when loading an object asynchronously; it will be + * called once the object is loaded. Your refcon is passed back. The object + * ref passed in is the newly loaded object (ready for use) or NULL if an + * error occured. + * + * If your plugin is disabled, this callback will be delivered as soon as the + * plugin is re-enabled. If your plugin is unloaded before this callback is + * ever called, the SDK will release the object handle for you. + * + */ +typedef void (* XPLMObjectLoaded_f)( + XPLMObjectRef inObject, + void * inRefcon); +#endif /* XPLM210 */ + +#if defined(XPLM200) +/* + * XPLMLoadObject + * + * This routine loads an OBJ file and returns a handle to it. If X-plane has + * already loaded the object, the handle to the existing object is returned. + * Do not assume you will get the same handle back twice, but do make sure to + * call unload once for every load to avoid "leaking" objects. The object + * will be purged from memory when no plugins and no scenery are using it. + * + * The path for the object must be relative to the X-System base folder. If + * the path is in the root of the X-System folder you may need to prepend ./ + * to it; loading objects in the root of the X-System folder is STRONGLY + * discouraged - your plugin should not dump art resources in the root folder! + * + * + * XPLMLoadObject will return NULL if the object cannot be loaded (either + * because it is not found or the file is misformatted). This routine will + * load any object that can be used in the X-Plane scenery system. + * + * It is important that the datarefs an object uses for animation already be + * loaded before you load the object. For this reason it may be necessary to + * defer object loading until the sim has fully started. + * + */ +XPLM_API XPLMObjectRef XPLMLoadObject( + const char * inPath); +#endif /* XPLM200 */ + +#if defined(XPLM210) +/* + * XPLMLoadObjectAsync + * + * This routine loads an object asynchronously; control is returned to you + * immediately while X-Plane loads the object. The sim will not stop flying + * while the object loads. For large objects, it may be several seconds + * before the load finishes. + * + * You provide a callback function that is called once the load has completed. + * Note that if the object cannot be loaded, you will not find out until the + * callback function is called with a NULL object handle. + * + * There is no way to cancel an asynchronous object load; you must wait for + * the load to complete and then release the object if it is no longer + * desired. + * + */ +XPLM_API void XPLMLoadObjectAsync( + const char * inPath, + XPLMObjectLoaded_f inCallback, + void * inRefcon); +#endif /* XPLM210 */ + +#if defined(XPLM200) +/* + * XPLMDrawObjects + * + * XPLMDrawObjects draws an object from an OBJ file one or more times. You + * pass in the object and an array of XPLMDrawInfo_t structs, one for each + * place you would like the object to be drawn. + * + * X-Plane will attempt to cull the objects based on LOD and visibility, and + * will pick the appropriate LOD. + * + * Lighting is a boolean; pass 1 to show the night version of object with + * night-only lights lit up. Pass 0 to show the daytime version of the + * object. + * + * earth_relative controls the coordinate system. If this is 1, the rotations + * you specify are applied to the object after its coordinate system is + * transformed from local to earth-relative coordinates -- that is, an object + * with no rotations will point toward true north and the Y axis will be up + * against gravity. If this is 0, the object is drawn with your rotations + * from local coordanates -- that is, an object with no rotations is drawn + * pointing down the -Z axis and the Y axis of the object matches the local + * coordinate Y axis. + * + */ +XPLM_API void XPLMDrawObjects( + XPLMObjectRef inObject, + int inCount, + XPLMDrawInfo_t * inLocations, + int lighting, + int earth_relative); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMUnloadObject + * + * This routine marks an object as no longer being used by your plugin. + * Objects are reference counted: once no plugins are using an object, it is + * purged from memory. Make sure to call XPLMUnloadObject once for each + * successful call to XPLMLoadObject. + * + */ +XPLM_API void XPLMUnloadObject( + XPLMObjectRef inObject); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/*************************************************************************** + * Library Access + ***************************************************************************/ +/* + * The library access routines allow you to locate scenery objects via the + * X-Plane library system. Right now library access is only provided for + * objects, allowing plugin-drawn objects to be extended using the library + * system. + * + */ + + + + +/* + * XPLMLibraryEnumerator_f + * + * An XPLMLibraryEnumerator_f is a callback you provide that is called once + * for each library element that is located. The returned paths will be + * relative to the X-System folder. + * + */ +typedef void (* XPLMLibraryEnumerator_f)( + const char * inFilePath, + void * inRef); + +/* + * XPLMLookupObjects + * + * This routine looks up a virtual path in the library system and returns all + * matching elements. You provide a callback - one virtual path may match + * many objects in the library. XPLMLookupObjects returns the number of + * objects found. + * + * The latitude and longitude parameters specify the location the object will + * be used. The library system allows for scenery packages to only provide + * objects to certain local locations. Only objects that are allowed at the + * latitude/longitude you provide will be returned. + * + */ +XPLM_API int XPLMLookupObjects( + const char * inPath, + float inLatitude, + float inLongitude, + XPLMLibraryEnumerator_f enumerator, + void * ref); + +#endif /* XPLM200 */ +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/CHeaders/XPLM/XPLMUtilities.h b/xpcPlugin/SDK/CHeaders/XPLM/XPLMUtilities.h new file mode 100755 index 0000000..5588c66 --- /dev/null +++ b/xpcPlugin/SDK/CHeaders/XPLM/XPLMUtilities.h @@ -0,0 +1,839 @@ +#ifndef _XPLMUtilities_h_ +#define _XPLMUtilities_h_ + +/* + * Copyright 2005-2012 Sandy Barbour and Ben Supnik + * + * All rights reserved. See license.txt for usage. + * + * X-Plane SDK Version: 2.1.1 + * + */ + +/* + * + * + */ + +#include "XPLMDefs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************************** + * X-PLANE USER INTERACTION + ***************************************************************************/ +/* + * The user interaction APIs let you simulate commands the user can do with a + * joystick, keyboard etc. Note that it is generally safer for future + * compatibility to use one of these commands than to manipulate the + * underlying sim data. + * + */ + + + +/* + * XPLMCommandKeyID + * + * These enums represent all the keystrokes available within x-plane. They + * can be sent to x-plane directly. For example, you can reverse thrust using + * these enumerations. + * + */ +enum { + xplm_key_pause=0, + xplm_key_revthrust, + xplm_key_jettison, + xplm_key_brakesreg, + xplm_key_brakesmax, + xplm_key_gear, + xplm_key_timedn, + xplm_key_timeup, + xplm_key_fadec, + xplm_key_otto_dis, + xplm_key_otto_atr, + xplm_key_otto_asi, + xplm_key_otto_hdg, + xplm_key_otto_gps, + xplm_key_otto_lev, + xplm_key_otto_hnav, + xplm_key_otto_alt, + xplm_key_otto_vvi, + xplm_key_otto_vnav, + xplm_key_otto_nav1, + xplm_key_otto_nav2, + xplm_key_targ_dn, + xplm_key_targ_up, + xplm_key_hdgdn, + xplm_key_hdgup, + xplm_key_barodn, + xplm_key_baroup, + xplm_key_obs1dn, + xplm_key_obs1up, + xplm_key_obs2dn, + xplm_key_obs2up, + xplm_key_com1_1, + xplm_key_com1_2, + xplm_key_com1_3, + xplm_key_com1_4, + xplm_key_nav1_1, + xplm_key_nav1_2, + xplm_key_nav1_3, + xplm_key_nav1_4, + xplm_key_com2_1, + xplm_key_com2_2, + xplm_key_com2_3, + xplm_key_com2_4, + xplm_key_nav2_1, + xplm_key_nav2_2, + xplm_key_nav2_3, + xplm_key_nav2_4, + xplm_key_adf_1, + xplm_key_adf_2, + xplm_key_adf_3, + xplm_key_adf_4, + xplm_key_adf_5, + xplm_key_adf_6, + xplm_key_transpon_1, + xplm_key_transpon_2, + xplm_key_transpon_3, + xplm_key_transpon_4, + xplm_key_transpon_5, + xplm_key_transpon_6, + xplm_key_transpon_7, + xplm_key_transpon_8, + xplm_key_flapsup, + xplm_key_flapsdn, + xplm_key_cheatoff, + xplm_key_cheaton, + xplm_key_sbrkoff, + xplm_key_sbrkon, + xplm_key_ailtrimL, + xplm_key_ailtrimR, + xplm_key_rudtrimL, + xplm_key_rudtrimR, + xplm_key_elvtrimD, + xplm_key_elvtrimU, + xplm_key_forward, + xplm_key_down, + xplm_key_left, + xplm_key_right, + xplm_key_back, + xplm_key_tower, + xplm_key_runway, + xplm_key_chase, + xplm_key_free1, + xplm_key_free2, + xplm_key_spot, + xplm_key_fullscrn1, + xplm_key_fullscrn2, + xplm_key_tanspan, + xplm_key_smoke, + xplm_key_map, + xplm_key_zoomin, + xplm_key_zoomout, + xplm_key_cycledump, + xplm_key_replay, + xplm_key_tranID, + xplm_key_max +}; +typedef int XPLMCommandKeyID; + +/* + * XPLMCommandButtonID + * + * These are enumerations for all of the things you can do with a joystick + * button in X-Plane. They currently match the buttons menu in the equipment + * setup dialog, but these enums will be stable even if they change in + * X-Plane. + * + */ +enum { + xplm_joy_nothing=0, + xplm_joy_start_all, + xplm_joy_start_0, + xplm_joy_start_1, + xplm_joy_start_2, + xplm_joy_start_3, + xplm_joy_start_4, + xplm_joy_start_5, + xplm_joy_start_6, + xplm_joy_start_7, + xplm_joy_throt_up, + xplm_joy_throt_dn, + xplm_joy_prop_up, + xplm_joy_prop_dn, + xplm_joy_mixt_up, + xplm_joy_mixt_dn, + xplm_joy_carb_tog, + xplm_joy_carb_on, + xplm_joy_carb_off, + xplm_joy_trev, + xplm_joy_trm_up, + xplm_joy_trm_dn, + xplm_joy_rot_trm_up, + xplm_joy_rot_trm_dn, + xplm_joy_rud_lft, + xplm_joy_rud_cntr, + xplm_joy_rud_rgt, + xplm_joy_ail_lft, + xplm_joy_ail_cntr, + xplm_joy_ail_rgt, + xplm_joy_B_rud_lft, + xplm_joy_B_rud_rgt, + xplm_joy_look_up, + xplm_joy_look_dn, + xplm_joy_look_lft, + xplm_joy_look_rgt, + xplm_joy_glance_l, + xplm_joy_glance_r, + xplm_joy_v_fnh, + xplm_joy_v_fwh, + xplm_joy_v_tra, + xplm_joy_v_twr, + xplm_joy_v_run, + xplm_joy_v_cha, + xplm_joy_v_fr1, + xplm_joy_v_fr2, + xplm_joy_v_spo, + xplm_joy_flapsup, + xplm_joy_flapsdn, + xplm_joy_vctswpfwd, + xplm_joy_vctswpaft, + xplm_joy_gear_tog, + xplm_joy_gear_up, + xplm_joy_gear_down, + xplm_joy_lft_brake, + xplm_joy_rgt_brake, + xplm_joy_brakesREG, + xplm_joy_brakesMAX, + xplm_joy_speedbrake, + xplm_joy_ott_dis, + xplm_joy_ott_atr, + xplm_joy_ott_asi, + xplm_joy_ott_hdg, + xplm_joy_ott_alt, + xplm_joy_ott_vvi, + xplm_joy_tim_start, + xplm_joy_tim_reset, + xplm_joy_ecam_up, + xplm_joy_ecam_dn, + xplm_joy_fadec, + xplm_joy_yaw_damp, + xplm_joy_art_stab, + xplm_joy_chute, + xplm_joy_JATO, + xplm_joy_arrest, + xplm_joy_jettison, + xplm_joy_fuel_dump, + xplm_joy_puffsmoke, + xplm_joy_prerotate, + xplm_joy_UL_prerot, + xplm_joy_UL_collec, + xplm_joy_TOGA, + xplm_joy_shutdown, + xplm_joy_con_atc, + xplm_joy_fail_now, + xplm_joy_pause, + xplm_joy_rock_up, + xplm_joy_rock_dn, + xplm_joy_rock_lft, + xplm_joy_rock_rgt, + xplm_joy_rock_for, + xplm_joy_rock_aft, + xplm_joy_idle_hilo, + xplm_joy_lanlights, + xplm_joy_max +}; +typedef int XPLMCommandButtonID; + +/* + * XPLMHostApplicationID + * + * The plug-in system is based on Austin's cross-platform OpenGL framework and + * could theoretically be adapted to run in other apps like WorldMaker. The + * plug-in system also runs against a test harness for internal development + * and could be adapted to another flight sim (in theory at least). So an ID + * is providing allowing plug-ins to indentify what app they are running + * under. + * + */ +enum { + xplm_Host_Unknown = 0 + + ,xplm_Host_XPlane = 1 + + ,xplm_Host_PlaneMaker = 2 + + ,xplm_Host_WorldMaker = 3 + + ,xplm_Host_Briefer = 4 + + ,xplm_Host_PartMaker = 5 + + ,xplm_Host_YoungsMod = 6 + + ,xplm_Host_XAuto = 7 + + +}; +typedef int XPLMHostApplicationID; + +/* + * XPLMLanguageCode + * + * These enums define what language the sim is running in. These enumerations + * do not imply that the sim can or does run in all of these languages; they + * simply provide a known encoding in the event that a given sim version is + * localized to a certain language. + * + */ +enum { + xplm_Language_Unknown = 0 + + ,xplm_Language_English = 1 + + ,xplm_Language_French = 2 + + ,xplm_Language_German = 3 + + ,xplm_Language_Italian = 4 + + ,xplm_Language_Spanish = 5 + + ,xplm_Language_Korean = 6 + +#if defined(XPLM200) + ,xplm_Language_Russian = 7 + +#endif /* XPLM200 */ +#if defined(XPLM200) + ,xplm_Language_Greek = 8 + +#endif /* XPLM200 */ +#if defined(XPLM200) + ,xplm_Language_Japanese = 9 + +#endif /* XPLM200 */ +#if defined(XPLM200) + ,xplm_Language_Chinese = 10 + +#endif /* XPLM200 */ + +}; +typedef int XPLMLanguageCode; + +#if defined(XPLM200) +/* + * XPLMDataFileType + * + * These enums define types of data files you can load or unload using the + * SDK. + * + */ +enum { + /* A situation (.sit) file, which starts off a flight in a given * + * configuration. */ + xplm_DataFile_Situation = 1 + + /* A situation movie (.smo) file, which replays a past flight. */ + ,xplm_DataFile_ReplayMovie = 2 + + +}; +typedef int XPLMDataFileType; +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMError_f + * + * An XPLM error callback is a function that you provide to receive debugging + * information from the plugin SDK. See XPLMSetErrorCallback for more + * information. NOTE: for the sake of debugging, your error callback will be + * called even if your plugin is not enabled, allowing you to receive debug + * info in your XPluginStart and XPluginStop callbacks. To avoid causing + * logic errors in the management code, do not call any other plugin routines + * from your error callback - it is only meant for logging! + * + */ +typedef void (* XPLMError_f)( + const char * inMessage); +#endif /* XPLM200 */ + +/* + * XPLMSimulateKeyPress + * + * This function simulates a key being pressed for x-plane. The keystroke + * goes directly to x-plane; it is never sent to any plug-ins. However, since + * this is a raw key stroke it may be mapped by the keys file or enter text + * into a field. + * + * WARNING: This function will be deprecated; do not use it. Instead use + * XPLMCommandKeyStroke. + * + */ +XPLM_API void XPLMSimulateKeyPress( + int inKeyType, + int inKey); + +/* + * XPLMSpeakString + * + * This function displays the string in a translucent overlay over the current + * display and also speaks the string if text-to-speech is enabled. The + * string is spoken asynchronously, this function returns immediately. + * + */ +XPLM_API void XPLMSpeakString( + const char * inString); + +/* + * XPLMCommandKeyStroke + * + * This routine simulates a command-key stroke. However, the keys are done by + * function, not by actual letter, so this function works even if the user has + * remapped their keyboard. Examples of things you might do with this include + * pausing the simulator. + * + */ +XPLM_API void XPLMCommandKeyStroke( + XPLMCommandKeyID inKey); + +/* + * XPLMCommandButtonPress + * + * This function simulates any of the actions that might be taken by pressing + * a joystick button. However, this lets you call the command directly rather + * than have to know which button is mapped where. Important: you must + * release each button you press. The APIs are separate so that you can 'hold + * down' a button for a fixed amount of time. + * + */ +XPLM_API void XPLMCommandButtonPress( + XPLMCommandButtonID inButton); + +/* + * XPLMCommandButtonRelease + * + * This function simulates any of the actions that might be taken by pressing + * a joystick button. See XPLMCommandButtonPress + * + */ +XPLM_API void XPLMCommandButtonRelease( + XPLMCommandButtonID inButton); + +/* + * XPLMGetVirtualKeyDescription + * + * Given a virtual key code (as defined in XPLMDefs.h) this routine returns a + * human-readable string describing the character. This routine is provided + * for showing users what keyboard mappings they have set up. The string may + * read 'unknown' or be a blank or NULL string if the virtual key is unknown. + * + */ +XPLM_API const char * XPLMGetVirtualKeyDescription( + char inVirtualKey); + +/*************************************************************************** + * X-PLANE MISC + ***************************************************************************/ +/* + * + * + */ + + + +/* + * XPLMReloadScenery + * + * XPLMReloadScenery reloads the current set of scenery. You can use this + * function in two typical ways: simply call it to reload the scenery, picking + * up any new installed scenery, .env files, etc. from disk. Or, change the + * lat/ref and lon/ref data refs and then call this function to shift the + * scenery environment. + * + */ +XPLM_API void XPLMReloadScenery(void); + +/* + * XPLMGetSystemPath + * + * This function returns the full path to the X-System folder. Note that this + * is a directory path, so it ends in a trailing : or /. The buffer you pass + * should be at least 512 characters long. + * + */ +XPLM_API void XPLMGetSystemPath( + char * outSystemPath); + +/* + * XPLMGetPrefsPath + * + * This routine returns a full path to the proper directory to store + * preferences in. It ends in a : or /. The buffer you pass should be at + * least 512 characters long. + * + */ +XPLM_API void XPLMGetPrefsPath( + char * outPrefsPath); + +/* + * XPLMGetDirectorySeparator + * + * This routine returns a string with one char and a null terminator that is + * the directory separator for the current platform. This allows you to write + * code that concatinates directory paths without having to #ifdef for + * platform. + * + */ +XPLM_API const char * XPLMGetDirectorySeparator(void); + +/* + * XPLMExtractFileAndPath + * + * Given a full path to a file, this routine separates the path from the file. + * If the path is a partial directory (e.g. ends in : or \) the trailing + * directory separator is removed. This routine works in-place; a pointer to + * the file part of the buffer is returned; the original buffer still starts + * with the path. + * + */ +XPLM_API char * XPLMExtractFileAndPath( + char * inFullPath); + +/* + * XPLMGetDirectoryContents + * + * This routine returns a list of files in a directory (specified by a full + * path, no trailing : or \). The output is returned as a list of NULL + * terminated strings. An index array (if specified) is filled with pointers + * into the strings. This routine The last file is indicated by a zero-length + * string (and NULL in the indices). This routine will return 1 if you had + * capacity for all files or 0 if you did not. You can also skip a given + * number of files. + * + * inDirectoryPath - a null terminated C string containing the full path to + * the directory with no trailing directory char. + * + * inFirstReturn - the zero-based index of the first file in the directory to + * return. (Usually zero to fetch all in one pass.) + * + * outFileNames - a buffer to receive a series of sequential null terminated + * C-string file names. A zero-length C string will be appended to the very + * end. + * + * inFileNameBufSize - the size of the file name buffer in bytes. + * + * outIndices - a pointer to an array of character pointers that will become + * an index into the directory. The last file will be followed by a NULL + * value. Pass NULL if you do not want indexing information. + * + * inIndexCount - the max size of the index in entries. + * + * outTotalFiles - if not NULL, this is filled in with the number of files in + * the directory. + * + * outReturnedFiles - if not NULL, the number of files returned by this + * iteration. + * + * Return value - 1 if all info could be returned, 0 if there was a buffer + * overrun. + * + * WARNING: Before X-Plane 7 this routine did not properly iterate through + * directories. If X-Plane 6 compatibility is needed, use your own code to + * iterate directories. + * + */ +XPLM_API int XPLMGetDirectoryContents( + const char * inDirectoryPath, + int inFirstReturn, + char * outFileNames, + int inFileNameBufSize, + char ** outIndices, /* Can be NULL */ + int inIndexCount, + int * outTotalFiles, /* Can be NULL */ + int * outReturnedFiles); /* Can be NULL */ + +/* + * XPLMInitialized + * + * This function returns 1 if X-Plane has properly initialized the plug-in + * system. If this routine returns 0, many XPLM functions will not work. + * + * NOTE: Under normal circumstances a plug-in should never be running while + * the plug-in manager is not initialized. + * + * WARNING: This function is generally not needed and may be deprecated in the + * future. + * + */ +XPLM_API int XPLMInitialized(void); + +/* + * XPLMGetVersions + * + * This routine returns the revision of both X-Plane and the XPLM DLL. All + * versions are three-digit decimal numbers (e.g. 606 for version 6.06 of + * X-Plane); the current revision of the XPLM is 200 (2.00). This routine + * also returns the host ID of the app running us. + * + * The most common use of this routine is to special-case around x-plane + * version-specific behavior. + * + */ +XPLM_API void XPLMGetVersions( + int * outXPlaneVersion, + int * outXPLMVersion, + XPLMHostApplicationID * outHostID); + +/* + * XPLMGetLanguage + * + * This routine returns the langauge the sim is running in. + * + */ +XPLM_API XPLMLanguageCode XPLMGetLanguage(void); + +/* + * XPLMDebugString + * + * This routine outputs a C-style string to the Log.txt file. The file is + * immediately flushed so you will not lose data. (This does cause a + * performance penalty.) + * + */ +XPLM_API void XPLMDebugString( + const char * inString); + +#if defined(XPLM200) +/* + * XPLMSetErrorCallback + * + * XPLMSetErrorCallback installs an error-reporting callback for your plugin. + * Normally the plugin system performs minimum diagnostics to maximize + * performance. When you install an error callback, you will receive calls + * due to certain plugin errors, such as passing bad parameters or incorrect + * data. + * + * The intention is for you to install the error callback during debug + * sections and put a break-point inside your callback. This will cause you + * to break into the debugger from within the SDK at the point in your plugin + * where you made an illegal call. + * + * Installing an error callback may activate error checking code that would + * not normally run, and this may adversely affect performance, so do not + * leave error callbacks installed in shipping plugins. + * + */ +XPLM_API void XPLMSetErrorCallback( + XPLMError_f inCallback); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMFindSymbol + * + * This routine will attempt to find the symbol passed in the inString + * parameter. If the symbol is found a pointer the function is returned, + * othewise the function will return NULL. + * + */ +XPLM_API void * XPLMFindSymbol( + const char * inString); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMLoadDataFile + * + * Loads a data file of a given type. Paths must be relative to the X-System + * folder. To clear the replay, pass a NULL file name (this is only valid with + * replay movies, not sit files). + * + */ +XPLM_API int XPLMLoadDataFile( + XPLMDataFileType inFileType, + const char * inFilePath); /* Can be NULL */ +#endif /* XPLM200 */ + +#if defined(XPLM200) +/* + * XPLMSaveDataFile + * + * Saves the current situation or replay; paths are relative to the X-System + * folder. + * + */ +XPLM_API int XPLMSaveDataFile( + XPLMDataFileType inFileType, + const char * inFilePath); +#endif /* XPLM200 */ + +#if defined(XPLM200) +/*************************************************************************** + * X-PLANE COMMAND MANAGEMENT + ***************************************************************************/ +/* + * The command management APIs let plugins interact with the command-system in + * X-Plane, the abstraction behind keyboard presses and joystick buttons. + * This API lets you create new commands and modify the behavior (or get + * notification) of existing ones. + * + * An X-Plane command consists of three phases: a beginning, continuous + * repetition, and an ending. The command may be repeated zero times in the + * event that the user presses a button only momentarily. + * + */ + + + + +/* + * XPLMCommandPhase + * + * The phases of a command. + * + */ +enum { + /* The command is being started. */ + xplm_CommandBegin = 0 + + /* The command is continuing to execute. */ + ,xplm_CommandContinue = 1 + + /* The command has ended. */ + ,xplm_CommandEnd = 2 + + +}; +typedef int XPLMCommandPhase; + +/* + * XPLMCommandRef + * + * A command ref is an opaque identifier for an X-Plane command. Command + * references stay the same for the life of your plugin but not between + * executions of X-Plane. Command refs are used to execute commands, create + * commands, and create callbacks for particular commands. + * + * Note that a command is not "owned" by a particular plugin. Since many + * plugins may participate in a command's execution, the command does not go + * away if the plugin that created it is unloaded. + * + */ +typedef void * XPLMCommandRef; + +/* + * XPLMCommandCallback_f + * + * A command callback is a function in your plugin that is called when a + * command is pressed. Your callback receives the commadn reference for the + * particular command, the phase of the command that is executing, and a + * reference pointer that you specify when registering the callback. + * + * Your command handler should return 1 to let processing of the command + * continue to other plugins and X-Plane, or 0 to halt processing, + * potentially bypassing X-Plane code. + * + */ +typedef int (* XPLMCommandCallback_f)( + XPLMCommandRef inCommand, + XPLMCommandPhase inPhase, + void * inRefcon); + +/* + * XPLMFindCommand + * + * XPLMFindCommand looks up a command by name, and returns its command + * reference or NULL if the command does not exist. + * + */ +XPLM_API XPLMCommandRef XPLMFindCommand( + const char * inName); + +/* + * XPLMCommandBegin + * + * XPLMCommandBegin starts the execution of a command, specified by its + * command reference. The command is "held down" until XPLMCommandEnd is + * called. + * + */ +XPLM_API void XPLMCommandBegin( + XPLMCommandRef inCommand); + +/* + * XPLMCommandEnd + * + * XPLMCommandEnd ends the execution of a given command that was started with + * XPLMCommandBegin. + * + */ +XPLM_API void XPLMCommandEnd( + XPLMCommandRef inCommand); + +/* + * XPLMCommandOnce + * + * This executes a given command momentarily, that is, the command begins and + * ends immediately. + * + */ +XPLM_API void XPLMCommandOnce( + XPLMCommandRef inCommand); + +/* + * XPLMCreateCommand + * + * XPLMCreateCommand creates a new command for a given string. If the command + * already exists, the existing command reference is returned. The + * description may appear in user interface contexts, such as the joystick + * configuration screen. + * + */ +XPLM_API XPLMCommandRef XPLMCreateCommand( + const char * inName, + const char * inDescription); + +/* + * XPLMRegisterCommandHandler + * + * XPLMRegisterCommandHandler registers a callback to be called when a command + * is executed. You provide a callback with a reference pointer. + * + * If inBefore is true, your command handler callback will be executed before + * X-Plane executes the command, and returning 0 from your callback will + * disable X-Plane's processing of the command. If inBefore is false, your + * callback will run after X-Plane. (You can register a single callback both + * before and after a command.) + * + */ +XPLM_API void XPLMRegisterCommandHandler( + XPLMCommandRef inComand, + XPLMCommandCallback_f inHandler, + int inBefore, + void * inRefcon); + +/* + * XPLMUnregisterCommandHandler + * + * XPLMUnregisterCommandHandler removes a command callback registered with + * XPLMRegisterCommandHandler. + * + */ +XPLM_API void XPLMUnregisterCommandHandler( + XPLMCommandRef inComand, + XPLMCommandCallback_f inHandler, + int inBefore, + void * inRefcon); + +#endif /* XPLM200 */ +#ifdef __cplusplus +} +#endif + +#endif diff --git a/xpcPlugin/SDK/Delphi/Widgets/XPStandardWidgets.pas b/xpcPlugin/SDK/Delphi/Widgets/XPStandardWidgets.pas new file mode 100755 index 0000000..bde7c77 --- /dev/null +++ b/xpcPlugin/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/xpcPlugin/SDK/Delphi/Widgets/XPUIGraphics.pas b/xpcPlugin/SDK/Delphi/Widgets/XPUIGraphics.pas new file mode 100755 index 0000000..f06806a --- /dev/null +++ b/xpcPlugin/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/xpcPlugin/SDK/Delphi/Widgets/XPWidgetDefs.pas b/xpcPlugin/SDK/Delphi/Widgets/XPWidgetDefs.pas new file mode 100755 index 0000000..2e55830 --- /dev/null +++ b/xpcPlugin/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/xpcPlugin/SDK/Delphi/Widgets/XPWidgetUtils.pas b/xpcPlugin/SDK/Delphi/Widgets/XPWidgetUtils.pas new file mode 100755 index 0000000..9dcb1d2 --- /dev/null +++ b/xpcPlugin/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/xpcPlugin/SDK/Delphi/Widgets/XPWidgets.pas b/xpcPlugin/SDK/Delphi/Widgets/XPWidgets.pas new file mode 100755 index 0000000..44623dc --- /dev/null +++ b/xpcPlugin/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. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMCamera.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMCamera.pas new file mode 100755 index 0000000..44b121c --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMCamera.pas @@ -0,0 +1,174 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMCamera; +INTERFACE +{ + XPLMCamera - THEORY OF OPERATION The XPLMCamera APIs allow plug-ins to + control the camera angle in X-Plane. This has a number of applications, + including but not limited to: + + - Creating new views (including dynamic/user-controllable views) for the + user. + + - Creating applications that use X-Plane as a renderer of scenery, + aircrafts, or both. + + The camera is controlled via six parameters: a location in OpenGL + coordinates and pitch, roll and yaw, similar to an airplane's position. + OpenGL coordinate info is described in detail in the XPLMGraphics + documentation; generally you should use the XPLMGraphics routines to + convert from world to local coordinates. The camera's orientation starts + facing level with the ground directly up the negative-Z axis + (approximately north) with the horizon horizontal. It is then rotated + clockwise for yaw, pitched up for positive pitch, and rolled clockwise + around the vector it is looking along for roll. + + You control the camera either either until the user selects a new view or + permanently (the later being similar to how UDP camera control works). You + control the camera by registering a callback per frame from which you + calculate the new camera positions. This guarantees smooth camera motion. + + Use the XPLMDataAccess APIs to get information like the position of the + aircraft, etc. for complex camera positioning. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * CAMERA CONTROL + ___________________________________________________________________________} +{ + +} + + + { + XPLMCameraControlDuration + + This enumeration states how long you want to retain control of the camera. + You can retain it indefinitely or until the user selects a new view. + } +TYPE + XPLMCameraControlDuration = ( + { Control the camera until the user picks a new view. } + xplm_ControlCameraUntilViewChanges = 1 + + { Control the camera until your plugin is disabled or another plugin forcably } + { takes control. } + ,xplm_ControlCameraForever = 2 + + ); + PXPLMCameraControlDuration = ^XPLMCameraControlDuration; + + { + XPLMCameraPosition_t + + This structure contains a full specification of the camera. X, Y, and Z + are the camera's position in OpenGL coordiantes; pitch, roll, and yaw are + rotations from a camera facing flat north in degrees. Positive pitch means + nose up, positive roll means roll right, and positive yaw means yaw right, + all in degrees. Zoom is a zoom factor, with 1.0 meaning normal zoom and 2.0 + magnifying by 2x (objects appear larger). + } + XPLMCameraPosition_t = RECORD + x : single; + y : single; + z : single; + pitch : single; + heading : single; + roll : single; + zoom : single; + END; + PXPLMCameraPosition_t = ^XPLMCameraPosition_t; + + { + XPLMCameraControl_f + + You use an XPLMCameraControl function to provide continuous control over + the camera. You are passed in a structure in which to put the new camera + position; modify it and return 1 to reposition the camera. Return 0 to + surrender control of the camera; camera control will be handled by X-Plane + on this draw loop. The contents of the structure as you are called are + undefined. + + If X-Plane is taking camera control away from you, this function will be + called with inIsLosingControl set to 1 and ioCameraPosition NULL. + } + XPLMCameraControl_f = FUNCTION( + outCameraPosition : PXPLMCameraPosition_t; { Can be nil } + inIsLosingControl : integer; + inRefcon : pointer) : integer; cdecl; + + { + XPLMControlCamera + + This function repositions the camera on the next drawing cycle. You must + pass a non-null control function. Specify in inHowLong how long you'd like + control (indefinitely or until a key is pressed). + } + PROCEDURE XPLMControlCamera( + inHowLong : XPLMCameraControlDuration; + inControlFunc : XPLMCameraControl_f; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDontControlCamera + + This function stops you from controlling the camera. If you have a camera + control function, it will not be called with an inIsLosingControl flag. + X-Plane will control the camera on the next cycle. + + For maximum compatibility you should not use this routine unless you are in + posession of the camera. + } + PROCEDURE XPLMDontControlCamera; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMIsCameraBeingControlled + + This routine returns 1 if the camera is being controlled, zero if it is + not. If it is and you pass in a pointer to a camera control duration, the + current control duration will be returned. + } + FUNCTION XPLMIsCameraBeingControlled( + outCameraControlDuration: PXPLMCameraControlDuration) : integer; { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMReadCameraPosition + + This function reads the current camera position. + } + PROCEDURE XPLMReadCameraPosition( + outCameraPosition : PXPLMCameraPosition_t); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMDataAccess.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMDataAccess.pas new file mode 100755 index 0000000..e82ded4 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMDataAccess.pas @@ -0,0 +1,764 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMDataAccess; +INTERFACE +{ + XPLM Data Access API - Theory of Operation + + The data access API gives you a generic, flexible, high performance way to + read and write data to and from X-Plane and other plug-ins. For example, + this API allows you to read and set the nav radios, get the plane location, + determine the current effective graphics frame rate, etc. + + The data access APIs are the way that you read and write data from the sim + as well as other plugins. + + The API works using opaque data references. A data reference is a source + of data; you do not know where it comes from, but once you have it you can + read the data quickly and possibly write it. To get a data reference, you + look it up. + + Data references are identified by verbose string names + (sim/cockpit/radios/nav1_freq_hz). The actual numeric value of the data + reference is implementation defined and is likely to change each time the + simulator is run (or the plugin that provides the datareference is + reloaded). + + The task of looking up a data reference is relatively expensive; look up + your data references once based on verbose strings, and save the opaque + data reference value for the duration of your plugin's operation. Reading + and writing data references is relatively fast (the cost is equivalent to + two function calls through function pointers). + + This allows data access to be high performance, while leaving in + abstraction; since data references are opaque and are searched for, the + underlying data access system can be rebuilt. + + A note on typing: you must know the correct data type to read and write. + APIs are provided for reading and writing data in a number of ways. You + can also double check the data type for a data ref. Note that automatic + conversion is not done for you. + + A note for plugins sharing data with other plugins: the load order of + plugins is not guaranteed. To make sure that every plugin publishing data + has published their data references before other plugins try to subscribe, + publish your data references in your start routine but resolve them the + first time your 'enable' routine is called, or the first time they are + needed in code. + + X-Plane publishes well over 1000 datarefs; a complete list may be found in + the reference section of the SDK online documentation (from the SDK home + page, choose Documentation). +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * READING AND WRITING DATA + ___________________________________________________________________________} +{ + These routines allow you to access a wide variety of data from within + x-plane and modify some of it. +} + + + +TYPE + { + XPLMDataRef + + A data ref is an opaque handle to data provided by the simulator or another + plugin. It uniquely identifies one variable (or array of variables) over + the lifetime of your plugin. You never hard code these values; you always + get them from XPLMFindDataRef. + } + XPLMDataRef = pointer; + PXPLMDataRef = ^XPLMDataRef; + + { + XPLMDataTypeID + + This is an enumeration that defines the type of the data behind a data + reference. This allows you to sanity check that the data type matches what + you expect. But for the most part, you will know the type of data you are + expecting from the online documentation. + + Data types each take a bit field, so sets of data types may be formed. + } + XPLMDataTypeID = ( + { Data of a type the current XPLM doesn't do. } + xplmType_Unknown = 0 + + { A single 4-byte integer, native endian. } + ,xplmType_Int = 1 + + { A single 4-byte float, native endian. } + ,xplmType_Float = 2 + + { A single 8-byte double, native endian. } + ,xplmType_Double = 4 + + { An array of 4-byte floats, native endian. } + ,xplmType_FloatArray = 8 + + { An array of 4-byte integers, native endian. } + ,xplmType_IntArray = 16 + + { A variable block of data. } + ,xplmType_Data = 32 + + ); + PXPLMDataTypeID = ^XPLMDataTypeID; + + { + XPLMFindDataRef + + Given a c-style string that names the data ref, this routine looks up the + actual opaque XPLMDataRef that you use to read and write the data. The + string names for datarefs are published on the x-plane SDK web site. + + This function returns NULL if the data ref cannot be found. + + NOTE: this function is relatively expensive; save the XPLMDataRef this + function returns for future use. Do not look up your data ref by string + every time you need to read or write it. + } + FUNCTION XPLMFindDataRef( + inDataRefName : Pchar) : XPLMDataRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCanWriteDataRef + + Given a data ref, this routine returns true if you can successfully set + the data, false otherwise. Some datarefs are read-only. + } + FUNCTION XPLMCanWriteDataRef( + inDataRef : XPLMDataRef) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMIsDataRefGood + + WARNING: This function is deprecated and should not be used. Datarefs are + valid until plugins are reloaded or the sim quits. Plugins sharing + datarefs should support these semantics by not unregistering datarefs + during operation. (You should however unregister datarefs when your plugin + is unloaded, as part of general resource cleanup.) + + This function returns whether a data ref is still valid. If it returns + false, you should refind the data ref from its original string. Calling an + accessor function on a bad data ref will return a default value, typically + 0 or 0-length data. + } + FUNCTION XPLMIsDataRefGood( + inDataRef : XPLMDataRef) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDataRefTypes + + This routine returns the types of the data ref for accessor use. If a data + ref is available in multiple data types, they will all be returned. + } + FUNCTION XPLMGetDataRefTypes( + inDataRef : XPLMDataRef) : XPLMDataTypeID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * DATA ACCESSORS + ___________________________________________________________________________} +{ + These routines read and write the data references. For each supported data + type there is a reader and a writer. + + If the data ref is invalid or the plugin that provides it is disabled or + there is a type mismatch, the functions that read data will return 0 as a + default value or not modify the passed in memory. The plugins that write + data will not write under these circumstances or if the data ref is + read-only. NOTE: to keep the overhead of reading datarefs low, these + routines do not do full validation of a dataref; passing a junk value for + a dataref can result in crashing the sim. + + For array-style datarefs, you specify the number of items to read/write and + the offset into the array; the actual number of items read or written is + returned. This may be less to prevent an array-out-of-bounds error. +} + + + + { + XPLMGetDatai + + Read an integer data ref and return its value. The return value is the + dataref value or 0 if the dataref is invalid/NULL or the plugin is + disabled. + } + FUNCTION XPLMGetDatai( + inDataRef : XPLMDataRef) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDatai + + Write a new value to an integer data ref. This routine is a no-op if the + plugin publishing the dataref is disabled, the dataref is invalid, or the + dataref is not writable. + } + PROCEDURE XPLMSetDatai( + inDataRef : XPLMDataRef; + inValue : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDataf + + Read a single precision floating point dataref and return its value. The + return value is the dataref value or 0.0 if the dataref is invalid/NULL or + the plugin is disabled. + } + FUNCTION XPLMGetDataf( + inDataRef : XPLMDataRef) : single; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDataf + + Write a new value to a single precision floating point data ref. This + routine is a no-op if the plugin publishing the dataref is disabled, the + dataref is invalid, or the dataref is not writable. + } + PROCEDURE XPLMSetDataf( + inDataRef : XPLMDataRef; + inValue : single); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDatad + + Read a double precision floating point dataref and return its value. The + return value is the dataref value or 0.0 if the dataref is invalid/NULL or + the plugin is disabled. + } + FUNCTION XPLMGetDatad( + inDataRef : XPLMDataRef) : real; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDatad + + Write a new value to a double precision floating point data ref. This + routine is a no-op if the plugin publishing the dataref is disabled, the + dataref is invalid, or the dataref is not writable. + } + PROCEDURE XPLMSetDatad( + inDataRef : XPLMDataRef; + inValue : real); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDatavi + + Read a part of an integer array dataref. If you pass NULL for outVaules, + the routine will return the size of the array, ignoring inOffset and inMax. + + + If outValues is not NULL, then up to inMax values are copied from the + dataref into outValues, starting at inOffset in the dataref. If inMax + + inOffset is larger than the size of the dataref, less than inMax values + will be copied. The number of values copied is returned. + + Note: the semantics of array datarefs are entirely implemented by the + plugin (or X-Plane) that provides the dataref, not the SDK itself; the + above description is how these datarefs are intended to work, but a rogue + plugin may have different behavior. + } + FUNCTION XPLMGetDatavi( + inDataRef : XPLMDataRef; + outValues : Pinteger; { Can be nil } + inOffset : integer; + inMax : integer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDatavi + + Write part or all of an integer array dataref. The values passed by + inValues are written into the dataref starting at inOffset. Up to inCount + values are written; however if the values would write "off the end" of the + dataref array, then fewer values are written. + + Note: the semantics of array datarefs are entirely implemented by the + plugin (or X-Plane) that provides the dataref, not the SDK itself; the + above description is how these datarefs are intended to work, but a rogue + plugin may have different behavior. + } + PROCEDURE XPLMSetDatavi( + inDataRef : XPLMDataRef; + inValues : Pinteger; + inoffset : integer; + inCount : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDatavf + + Read a part of a single precision floating point array dataref. If you + pass NULL for outVaules, the routine will return the size of the array, + ignoring inOffset and inMax. + + If outValues is not NULL, then up to inMax values are copied from the + dataref into outValues, starting at inOffset in the dataref. If inMax + + inOffset is larger than the size of the dataref, less than inMax values + will be copied. The number of values copied is returned. + + Note: the semantics of array datarefs are entirely implemented by the + plugin (or X-Plane) that provides the dataref, not the SDK itself; the + above description is how these datarefs are intended to work, but a rogue + plugin may have different behavior. + } + FUNCTION XPLMGetDatavf( + inDataRef : XPLMDataRef; + outValues : Psingle; { Can be nil } + inOffset : integer; + inMax : integer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDatavf + + Write part or all of a single precision floating point array dataref. The + values passed by inValues are written into the dataref starting at + inOffset. Up to inCount values are written; however if the values would + write "off the end" of the dataref array, then fewer values are written. + + Note: the semantics of array datarefs are entirely implemented by the + plugin (or X-Plane) that provides the dataref, not the SDK itself; the + above description is how these datarefs are intended to work, but a rogue + plugin may have different behavior. + } + PROCEDURE XPLMSetDatavf( + inDataRef : XPLMDataRef; + inValues : Psingle; + inoffset : integer; + inCount : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDatab + + Read a part of a byte array dataref. If you pass NULL for outVaules, the + routine will return the size of the array, ignoring inOffset and inMax. + + If outValues is not NULL, then up to inMax values are copied from the + dataref into outValues, starting at inOffset in the dataref. If inMax + + inOffset is larger than the size of the dataref, less than inMax values + will be copied. The number of values copied is returned. + + Note: the semantics of array datarefs are entirely implemented by the + plugin (or X-Plane) that provides the dataref, not the SDK itself; the + above description is how these datarefs are intended to work, but a rogue + plugin may have different behavior. + } + FUNCTION XPLMGetDatab( + inDataRef : XPLMDataRef; + outValue : pointer; { Can be nil } + inOffset : integer; + inMaxBytes : integer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDatab + + Write part or all of a byte array dataref. The values passed by inValues + are written into the dataref starting at inOffset. Up to inCount values + are written; however if the values would write "off the end" of the dataref + array, then fewer values are written. + + Note: the semantics of array datarefs are entirely implemented by the + plugin (or X-Plane) that provides the dataref, not the SDK itself; the + above description is how these datarefs are intended to work, but a rogue + plugin may have different behavior. + } + PROCEDURE XPLMSetDatab( + inDataRef : XPLMDataRef; + inValue : pointer; + inOffset : integer; + inLength : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * PUBLISHING YOUR PLUGINS DATA + ___________________________________________________________________________} +{ + These functions allow you to create data references that other plug-ins can + access via the above data access APIs. Data references published by other + plugins operate the same as ones published by x-plane in all manners except + that your data reference will not be available to other plugins if/when + your plugin is disabled. + + You share data by registering data provider callback functions. When a + plug-in requests your data, these callbacks are then called. You provide + one callback to return the value when a plugin 'reads' it and another to + change the value when a plugin 'writes' it. + + Important: you must pick a prefix for your datarefs other than "sim/" - + this prefix is reserved for X-Plane. The X-Plane SDK website contains a + registry where authors can select a unique first word for dataref names, to + prevent dataref collisions between plugins. +} + + + + { + XPLMGetDatai_f + + Data provider function pointers. + + These define the function pointers you provide to get or set data. Note + that you are passed a generic pointer for each one. This is the same + pointer you pass in your register routine; you can use it to find global + variables, etc. + + The semantics of your callbacks are the same as the dataref accessor above + - basically routines like XPLMGetDatai are just pass-throughs from a caller + to your plugin. Be particularly mindful in implementing array dataref + read-write accessors; you are responsible for avoiding overruns, supporting + offset read/writes, and handling a read with a NULL buffer. + } +TYPE + XPLMGetDatai_f = FUNCTION( + inRefcon : pointer) : integer; cdecl; + + { + XPLMSetDatai_f + + } + XPLMSetDatai_f = PROCEDURE( + inRefcon : pointer; + inValue : integer); cdecl; + + { + XPLMGetDataf_f + + } + XPLMGetDataf_f = FUNCTION( + inRefcon : pointer) : single; cdecl; + + { + XPLMSetDataf_f + + } + XPLMSetDataf_f = PROCEDURE( + inRefcon : pointer; + inValue : single); cdecl; + + { + XPLMGetDatad_f + + } + XPLMGetDatad_f = FUNCTION( + inRefcon : pointer) : real; cdecl; + + { + XPLMSetDatad_f + + } + XPLMSetDatad_f = PROCEDURE( + inRefcon : pointer; + inValue : real); cdecl; + + { + XPLMGetDatavi_f + + } + XPLMGetDatavi_f = FUNCTION( + inRefcon : pointer; + outValues : Pinteger; { Can be nil } + inOffset : integer; + inMax : integer) : integer; cdecl; + + { + XPLMSetDatavi_f + + } + XPLMSetDatavi_f = PROCEDURE( + inRefcon : pointer; + inValues : Pinteger; + inOffset : integer; + inCount : integer); cdecl; + + { + XPLMGetDatavf_f + + } + XPLMGetDatavf_f = FUNCTION( + inRefcon : pointer; + outValues : Psingle; { Can be nil } + inOffset : integer; + inMax : integer) : integer; cdecl; + + { + XPLMSetDatavf_f + + } + XPLMSetDatavf_f = PROCEDURE( + inRefcon : pointer; + inValues : Psingle; + inOffset : integer; + inCount : integer); cdecl; + + { + XPLMGetDatab_f + + } + XPLMGetDatab_f = FUNCTION( + inRefcon : pointer; + outValue : pointer; { Can be nil } + inOffset : integer; + inMaxLength : integer) : integer; cdecl; + + { + XPLMSetDatab_f + + } + XPLMSetDatab_f = PROCEDURE( + inRefcon : pointer; + inValue : pointer; + inOffset : integer; + inLength : integer); cdecl; + + { + XPLMRegisterDataAccessor + + This routine creates a new item of data that can be read and written. Pass + in the data's full name for searching, the type(s) of the data for + accessing, and whether the data can be written to. For each data type you + support, pass in a read accessor function and a write accessor function if + necessary. Pass NULL for data types you do not support or write accessors + if you are read-only. + + You are returned a data ref for the new item of data created. You can use + this data ref to unregister your data later or read or write from it. + } + FUNCTION XPLMRegisterDataAccessor( + inDataName : Pchar; + inDataType : XPLMDataTypeID; + inIsWritable : integer; + inReadInt : XPLMGetDatai_f; + inWriteInt : XPLMSetDatai_f; + inReadFloat : XPLMGetDataf_f; + inWriteFloat : XPLMSetDataf_f; + inReadDouble : XPLMGetDatad_f; + inWriteDouble : XPLMSetDatad_f; + inReadIntArray : XPLMGetDatavi_f; + inWriteIntArray : XPLMSetDatavi_f; + inReadFloatArray : XPLMGetDatavf_f; + inWriteFloatArray : XPLMSetDatavf_f; + inReadData : XPLMGetDatab_f; + inWriteData : XPLMSetDatab_f; + inReadRefcon : pointer; + inWriteRefcon : pointer) : XPLMDataRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnregisterDataAccessor + + Use this routine to unregister any data accessors you may have registered. + You unregister a data ref by the XPLMDataRef you get back from + registration. Once you unregister a data ref, your function pointer will + not be called anymore. + + For maximum compatibility, do not unregister your data accessors until + final shutdown (when your XPluginStop routine is called). This allows + other plugins to find your data reference once and use it for their entire + time of operation. + } + PROCEDURE XPLMUnregisterDataAccessor( + inDataRef : XPLMDataRef); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * SHARING DATA BETWEEN MULTIPLE PLUGINS + ___________________________________________________________________________} +{ + The data reference registration APIs from the previous section allow a + plugin to publish data in a one-owner manner; the plugin that publishes the + data reference owns the real memory that the data ref uses. This is + satisfactory for most cases, but there are also cases where plugnis need to + share actual data. + + With a shared data reference, no one plugin owns the actual memory for the + data reference; the plugin SDK allocates that for you. When the first + plugin asks to 'share' the data, the memory is allocated. When the data is + changed, every plugin that is sharing the data is notified. + + Shared data references differ from the 'owned' data references from the + previous section in a few ways: + + - With shared data references, any plugin can create the data reference; + with owned plugins one plugin must create the data reference and others + subscribe. (This can be a problem if you don't know which set of plugins + will be present). + + - With shared data references, every plugin that is sharing the data is + notified when the data is changed. With owned data references, only the + one owner is notified when the data is changed. + + - With shared data references, you cannot access the physical memory of the + data reference; you must use the XPLMGet... and XPLMSet... APIs. With an + owned data reference, the one owning data reference can manipulate the + data reference's memory in any way it sees fit. + + Shared data references solve two problems: if you need to have a data + reference used by several plugins but do not know which plugins will be + installed, or if all plugins sharing data need to be notified when that + data is changed, use shared data references. +} + + + + { + XPLMDataChanged_f + + An XPLMDataChanged_f is a callback that the XPLM calls whenever any other + plug-in modifies shared data. A refcon you provide is passed back to help + identify which data is being changed. In response, you may want to call one + of the XPLMGetDataxxx routines to find the new value of the data. + } +TYPE + XPLMDataChanged_f = PROCEDURE( + inRefcon : pointer); cdecl; + + { + XPLMShareData + + This routine connects a plug-in to shared data, creating the shared data if + necessary. inDataName is a standard path for the data ref, and inDataType + specifies the type. This function will create the data if it does not + exist. If the data already exists but the type does not match, an error is + returned, so it is important that plug-in authors collaborate to establish + public standards for shared data. + + If a notificationFunc is passed in and is not NULL, that notification + function will be called whenever the data is modified. The notification + refcon will be passed to it. This allows your plug-in to know which shared + data was changed if multiple shared data are handled by one callback, or if + the plug-in does not use global variables. + + A one is returned for successfully creating or finding the shared data; a + zero if the data already exists but is of the wrong type. + } + FUNCTION XPLMShareData( + inDataName : Pchar; + inDataType : XPLMDataTypeID; + inNotificationFunc : XPLMDataChanged_f; + inNotificationRefcon: pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnshareData + + This routine removes your notification function for shared data. Call it + when done with the data to stop receiving change notifications. Arguments + must match XPLMShareData. The actual memory will not necessarily be freed, + since other plug-ins could be using it. + } + FUNCTION XPLMUnshareData( + inDataName : Pchar; + inDataType : XPLMDataTypeID; + inNotificationFunc : XPLMDataChanged_f; + inNotificationRefcon: pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMDefs.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMDefs.pas new file mode 100755 index 0000000..57ffba1 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMDefs.pas @@ -0,0 +1,446 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMDefs; +INTERFACE +{ + This file is contains the cross-platform and basic definitions for the + X-Plane SDK. + + The preprocessor macros APL and IBM must be defined to specify the + compilation target; define APL to 1 and IBM 0 to compile on Macintosh and + APL to 0 and IBM to 1 for Windows. You must specify these macro definitions + before including XPLMDefs.h or any other XPLM headers. You can do this + using the -D command line option or a preprocessor header. +} + + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{$IFDEF LINUX} + {$DEFINE KYLIX} +{$ENDIF} +TYPE +{$IFNDEF DELPHI} +{$IFNDEF KYLIX} + Pchar = ^char; + Ppchar = ^Pchar; + Psingle = ^single; + Pinteger = ^integer; +{$ENDIF} +{$ENDIF} + Preal = ^real; + Plongint = ^longint; +{___________________________________________________________________________ + * DLL Definitions + ___________________________________________________________________________} +{ + These definitions control the importing and exporting of functions within + the DLL. + + You can prefix your five required callbacks with the PLUGIN_API macro to + declare them as exported C functions. The XPLM_API macro identifies + functions that are provided to you via the plugin SDK. (Link against + XPLM.lib to use these functions.) +} + + + + +{___________________________________________________________________________ + * GLOBAL DEFINITIONS + ___________________________________________________________________________} +{ + These definitions are used in all parts of the SDK. +} + + + +TYPE + { + XPLMPluginID + + Each plug-in is identified by a unique integer ID. This ID can be used to + disable or enable a plug-in, or discover what plug-in is 'running' at the + time. A plug-in ID is unique within the currently running instance of + X-Plane unless plug-ins are reloaded. Plug-ins may receive a different + unique ID each time they are loaded. + + For persistent identification of plug-ins, use XPLMFindPluginBySignature in + XPLMUtiltiies.h + + -1 indicates no plug-in. + } + XPLMPluginID = integer; + PXPLMPluginID = ^XPLMPluginID; + +CONST + { No plugin. } + XPLM_NO_PLUGIN_ID = (-1); + + { X-Plane itself } + XPLM_PLUGIN_XPLANE = (0); + + { The current XPLM revision is 2.10 (210). } + kXPLM_Version = (210); + + { + XPLMKeyFlags + + These bitfields define modifier keys in a platform independent way. When a + key is pressed, a series of messages are sent to your plugin. The down + flag is set in the first of these messages, and the up flag in the last. + While the key is held down, messages are sent with neither to indicate that + the key is being held down as a repeated character. + + The control flag is mapped to the control flag on Macintosh and PC. + Generally X-Plane uses the control key and not the command key on + Macintosh, providing a consistent interface across platforms that does not + necessarily match the Macintosh user interface guidelines. There is not + yet a way for plugins to access the Macintosh control keys without using + #ifdefed code. + } +TYPE + XPLMKeyFlags = ( + { The shift key is down } + xplm_ShiftFlag = 1 + + { The option or alt key is down } + ,xplm_OptionAltFlag = 2 + + { The control key is down* } + ,xplm_ControlFlag = 4 + + { The key is being pressed down } + ,xplm_DownFlag = 8 + + { The key is being released } + ,xplm_UpFlag = 16 + + ); + PXPLMKeyFlags = ^XPLMKeyFlags; + +{___________________________________________________________________________ + * ASCII CONTROL KEY CODES + ___________________________________________________________________________} +{ + These definitions define how various control keys are mapped to ASCII key + codes. Not all key presses generate an ASCII value, so plugin code should + be prepared to see null characters come from the keyboard...this usually + represents a key stroke that has no equivalent ASCII, like a page-down + press. Use virtual key codes to find these key strokes. ASCII key codes + take into account modifier keys; shift keys will affect capitals and + punctuation; control key combinations may have no vaild ASCII and produce + NULL. To detect control-key combinations, use virtual key codes, not ASCII + keys. +} + + + +CONST + XPLM_KEY_RETURN = 13; + + XPLM_KEY_ESCAPE = 27; + + XPLM_KEY_TAB = 9; + + XPLM_KEY_DELETE = 8; + + XPLM_KEY_LEFT = 28; + + XPLM_KEY_RIGHT = 29; + + XPLM_KEY_UP = 30; + + XPLM_KEY_DOWN = 31; + + XPLM_KEY_0 = 48; + + XPLM_KEY_1 = 49; + + XPLM_KEY_2 = 50; + + XPLM_KEY_3 = 51; + + XPLM_KEY_4 = 52; + + XPLM_KEY_5 = 53; + + XPLM_KEY_6 = 54; + + XPLM_KEY_7 = 55; + + XPLM_KEY_8 = 56; + + XPLM_KEY_9 = 57; + + XPLM_KEY_DECIMAL = 46; + +{___________________________________________________________________________ + * VIRTUAL KEY CODES + ___________________________________________________________________________} +{ + These are cross-platform defines for every distinct keyboard press on the + computer. Every physical key on the keyboard has a virtual key code. So + the "two" key on the top row of the main keyboard has a different code + from the "two" key on the numeric key pad. But the 'w' and 'W' character + are indistinguishable by virtual key code because they are the same + physical key (one with and one without the shift key). + + Use virtual key codes to detect keystrokes that do not have ASCII + equivalents, allow the user to map the numeric keypad separately from the + main keyboard, and detect control key and other modifier-key combinations + that generate ASCII control key sequences (many of which are not available + directly via character keys in the SDK). + + To assign virtual key codes we started with the Microsoft set but made some + additions and changes. A few differences: + + 1. Modifier keys are not available as virtual key codes. You cannot get + distinct modifier press and release messages. Please do not try to use + modifier keys as regular keys; doing so will almost certainly interfere + with users' abilities to use the native x-plane key bindings. + + 2. Some keys that do not exist on both Mac and PC keyboards are removed. + + 3. Do not assume that the values of these keystrokes are interchangeable + with MS v-keys. +} + + + +CONST + XPLM_VK_BACK = $08; + + XPLM_VK_TAB = $09; + + XPLM_VK_CLEAR = $0C; + + XPLM_VK_RETURN = $0D; + + XPLM_VK_ESCAPE = $1B; + + XPLM_VK_SPACE = $20; + + XPLM_VK_PRIOR = $21; + + XPLM_VK_NEXT = $22; + + XPLM_VK_END = $23; + + XPLM_VK_HOME = $24; + + XPLM_VK_LEFT = $25; + + XPLM_VK_UP = $26; + + XPLM_VK_RIGHT = $27; + + XPLM_VK_DOWN = $28; + + XPLM_VK_SELECT = $29; + + XPLM_VK_PRINT = $2A; + + XPLM_VK_EXECUTE = $2B; + + XPLM_VK_SNAPSHOT = $2C; + + XPLM_VK_INSERT = $2D; + + XPLM_VK_DELETE = $2E; + + XPLM_VK_HELP = $2F; + + { XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) } + XPLM_VK_0 = $30; + + XPLM_VK_1 = $31; + + XPLM_VK_2 = $32; + + XPLM_VK_3 = $33; + + XPLM_VK_4 = $34; + + XPLM_VK_5 = $35; + + XPLM_VK_6 = $36; + + XPLM_VK_7 = $37; + + XPLM_VK_8 = $38; + + XPLM_VK_9 = $39; + + { XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) } + XPLM_VK_A = $41; + + XPLM_VK_B = $42; + + XPLM_VK_C = $43; + + XPLM_VK_D = $44; + + XPLM_VK_E = $45; + + XPLM_VK_F = $46; + + XPLM_VK_G = $47; + + XPLM_VK_H = $48; + + XPLM_VK_I = $49; + + XPLM_VK_J = $4A; + + XPLM_VK_K = $4B; + + XPLM_VK_L = $4C; + + XPLM_VK_M = $4D; + + XPLM_VK_N = $4E; + + XPLM_VK_O = $4F; + + XPLM_VK_P = $50; + + XPLM_VK_Q = $51; + + XPLM_VK_R = $52; + + XPLM_VK_S = $53; + + XPLM_VK_T = $54; + + XPLM_VK_U = $55; + + XPLM_VK_V = $56; + + XPLM_VK_W = $57; + + XPLM_VK_X = $58; + + XPLM_VK_Y = $59; + + XPLM_VK_Z = $5A; + + XPLM_VK_NUMPAD0 = $60; + + XPLM_VK_NUMPAD1 = $61; + + XPLM_VK_NUMPAD2 = $62; + + XPLM_VK_NUMPAD3 = $63; + + XPLM_VK_NUMPAD4 = $64; + + XPLM_VK_NUMPAD5 = $65; + + XPLM_VK_NUMPAD6 = $66; + + XPLM_VK_NUMPAD7 = $67; + + XPLM_VK_NUMPAD8 = $68; + + XPLM_VK_NUMPAD9 = $69; + + XPLM_VK_MULTIPLY = $6A; + + XPLM_VK_ADD = $6B; + + XPLM_VK_SEPARATOR = $6C; + + XPLM_VK_SUBTRACT = $6D; + + XPLM_VK_DECIMAL = $6E; + + XPLM_VK_DIVIDE = $6F; + + XPLM_VK_F1 = $70; + + XPLM_VK_F2 = $71; + + XPLM_VK_F3 = $72; + + XPLM_VK_F4 = $73; + + XPLM_VK_F5 = $74; + + XPLM_VK_F6 = $75; + + XPLM_VK_F7 = $76; + + XPLM_VK_F8 = $77; + + XPLM_VK_F9 = $78; + + XPLM_VK_F10 = $79; + + XPLM_VK_F11 = $7A; + + XPLM_VK_F12 = $7B; + + XPLM_VK_F13 = $7C; + + XPLM_VK_F14 = $7D; + + XPLM_VK_F15 = $7E; + + XPLM_VK_F16 = $7F; + + XPLM_VK_F17 = $80; + + XPLM_VK_F18 = $81; + + XPLM_VK_F19 = $82; + + XPLM_VK_F20 = $83; + + XPLM_VK_F21 = $84; + + XPLM_VK_F22 = $85; + + XPLM_VK_F23 = $86; + + XPLM_VK_F24 = $87; + + { The following definitions are extended and are not based on the Microsoft } + { key set. } + XPLM_VK_EQUAL = $B0; + + XPLM_VK_MINUS = $B1; + + XPLM_VK_RBRACE = $B2; + + XPLM_VK_LBRACE = $B3; + + XPLM_VK_QUOTE = $B4; + + XPLM_VK_SEMICOLON = $B5; + + XPLM_VK_BACKSLASH = $B6; + + XPLM_VK_COMMA = $B7; + + XPLM_VK_SLASH = $B8; + + XPLM_VK_PERIOD = $B9; + + XPLM_VK_BACKQUOTE = $BA; + + XPLM_VK_ENTER = $BB; + + XPLM_VK_NUMPAD_ENT = $BC; + + XPLM_VK_NUMPAD_EQ = $BD; + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMDisplay.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMDisplay.pas new file mode 100755 index 0000000..751b5b5 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMDisplay.pas @@ -0,0 +1,835 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMDisplay; +INTERFACE +{ + XPLM Display APIs - THEORY OF OPERATION + + This API provides the basic hooks to draw in X-Plane and create user + interface. All X-Plane drawing is done in OpenGL. The X-Plane plug-in + manager takes care of properly setting up the OpenGL context and matrices. + You do not decide when in your code's execution to draw; X-Plane tells you + when it is ready to have your plugin draw. + + X-Plane's drawing strategy is straightforward: every "frame" the screen is + rendered by drawing the 3-d scene (dome, ground, objects, airplanes, etc.) + and then drawing the cockpit on top of it. Alpha blending is used to + overlay the cockpit over the world (and the gauges over the panel, etc.). + + There are two ways you can draw: directly and in a window. + + Direct drawing involves drawing to the screen before or after X-Plane + finishes a phase of drawing. When you draw directly, you can specify + whether x-plane is to complete this phase or not. This allows you to do + three things: draw before x-plane does (under it), draw after x-plane does + (over it), or draw instead of x-plane. + + To draw directly, you register a callback and specify what phase you want + to intercept. The plug-in manager will call you over and over to draw that + phase. + + Direct drawing allows you to override scenery, panels, or anything. Note + that you cannot assume that you are the only plug-in drawing at this + phase. + + Window drawing provides slightly higher level functionality. With window + drawing you create a window that takes up a portion of the screen. Window + drawing is always two dimensional. Window drawing is front-to-back + controlled; you can specify that you want your window to be brought on + top, and other plug-ins may put their window on top of you. Window drawing + also allows you to sign up for key presses and receive mouse clicks. + + There are three ways to get keystrokes: + + If you create a window, the window can take keyboard focus. It will then + receive all keystrokes. If no window has focus, X-Plane receives + keystrokes. Use this to implement typing in dialog boxes, etc. Only one + window may have focus at a time; your window will be notified if it loses + focus. + + If you need to associate key strokes with commands/functions in your + plug-in, use a hot key. A hoy is a key-specific callback. Hotkeys are + sent based on virtual key strokes, so any key may be distinctly mapped with + any modifiers. Hot keys can be remapped by other plug-ins. As a plug-in, + you don't have to worry about what your hot key ends up mapped to; other + plug-ins may provide a UI for remapping keystrokes. So hotkeys allow a + user to resolve conflicts and customize keystrokes. + + If you need low level access to the keystroke stream, install a key + sniffer. Key sniffers can be installed above everything or right in front + of the sim. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * DRAWING CALLBACKS + ___________________________________________________________________________} +{ + Basic drawing callbacks, for low level intercepting of render loop. The + purpose of drawing callbacks is to provide targeted additions or + replacements to x-plane's graphics environment (for example, to add extra + custom objects, or replace drawing of the AI aircraft). Do not assume that + the drawing callbacks will be called in the order implied by the + enumerations. Also do not assume that each drawing phase ends before + another begins; they may be nested. +} + + + + { + XPLMDrawingPhase + + This constant indicates which part of drawing we are in. Drawing is done + from the back to the front. We get a callback before or after each item. + Metaphases provide access to the beginning and end of the 3d (scene) and 2d + (cockpit) drawing in a manner that is independent of new phases added via + x-plane implementation. + + WARNING: As X-Plane's scenery evolves, some drawing phases may cease to + exist and new ones may be invented. If you need a particularly specific + use of these codes, consult Austin and/or be prepared to revise your code + as X-Plane evolves. + } +TYPE + XPLMDrawingPhase = ( + { This is the earliest point at which you can draw in 3-d. } + xplm_Phase_FirstScene = 0 + + { Drawing of land and water. } + ,xplm_Phase_Terrain = 5 + + { Drawing runways and other airport detail. } + ,xplm_Phase_Airports = 10 + + { Drawing roads, trails, trains, etc. } + ,xplm_Phase_Vectors = 15 + + { 3-d objects (houses, smokestacks, etc. } + ,xplm_Phase_Objects = 20 + + { External views of airplanes, both yours and the AI aircraft. } + ,xplm_Phase_Airplanes = 25 + + { This is the last point at which you can draw in 3-d. } + ,xplm_Phase_LastScene = 30 + + { This is the first phase where you can draw in 2-d. } + ,xplm_Phase_FirstCockpit = 35 + + { The non-moving parts of the aircraft panel. } + ,xplm_Phase_Panel = 40 + + { The moving parts of the aircraft panel. } + ,xplm_Phase_Gauges = 45 + + { Floating windows from plugins. } + ,xplm_Phase_Window = 50 + + { The last change to draw in 2d. } + ,xplm_Phase_LastCockpit = 55 + +{$IFDEF XPLM200} + { 3-d Drawing for the local map. Use regular OpenGL coordinates to draw in } + { this phase. } + ,xplm_Phase_LocalMap3D = 100 +{$ENDIF} + +{$IFDEF XPLM200} + { 2-d Drawing of text over the local map. } + ,xplm_Phase_LocalMap2D = 101 +{$ENDIF} + +{$IFDEF XPLM200} + { Drawing of the side-profile view in the local map screen. } + ,xplm_Phase_LocalMapProfile = 102 +{$ENDIF} + + ); + PXPLMDrawingPhase = ^XPLMDrawingPhase; + + { + XPLMDrawCallback_f + + This is the prototype for a low level drawing callback. You are passed in + the phase and whether it is before or after. If you are before the phase, + return 1 to let x-plane draw or 0 to suppress x-plane drawing. If you are + after the phase the return value is ignored. + + Refcon is a unique value that you specify when registering the callback, + allowing you to slip a pointer to your own data to the callback. + + Upon entry the OpenGL context will be correctly set up for you and OpenGL + will be in 'local' coordinates for 3d drawing and panel coordinates for 2d + drawing. The OpenGL state (texturing, etc.) will be unknown. + } + XPLMDrawCallback_f = FUNCTION( + inPhase : XPLMDrawingPhase; + inIsBefore : integer; + inRefcon : pointer) : integer; cdecl; + + { + XPLMKeySniffer_f + + This is the prototype for a low level key-sniffing function. Window-based + UI _should not use this_! The windowing system provides high-level + mediated keyboard access. By comparison, the key sniffer provides low + level keyboard access. + + Key sniffers are provided to allow libraries to provide non-windowed user + interaction. For example, the MUI library uses a key sniffer to do pop-up + text entry. + + inKey is the character pressed, inRefCon is a value you supply during + registration. Return 1 to pass the key on to the next sniffer, the window + mgr, x-plane, or whomever is down stream. Return 0 to consume the key. + + Warning: this API declares virtual keys as a signed character; however the + VKEY #define macros in XPLMDefs.h define the vkeys using unsigned values + (that is 0x80 instead of -0x80). So you may need to cast the incoming vkey + to an unsigned char to get correct comparisons in C. + } + XPLMKeySniffer_f = FUNCTION( + inChar : char; + inFlags : XPLMKeyFlags; + inVirtualKey : char; + inRefcon : pointer) : integer; cdecl; + + { + XPLMRegisterDrawCallback + + This routine registers a low level drawing callback. Pass in the phase you + want to be called for and whether you want to be called before or after. + This routine returns 1 if the registration was successful, or 0 if the + phase does not exist in this version of x-plane. You may register a + callback multiple times for the same or different phases as long as the + refcon is unique each time. + } + FUNCTION XPLMRegisterDrawCallback( + inCallback : XPLMDrawCallback_f; + inPhase : XPLMDrawingPhase; + inWantsBefore : integer; + inRefcon : pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnregisterDrawCallback + + This routine unregisters a draw callback. You must unregister a callback + for each time you register a callback if you have registered it multiple + times with different refcons. The routine returns 1 if it can find the + callback to unregister, 0 otherwise. + } + FUNCTION XPLMUnregisterDrawCallback( + inCallback : XPLMDrawCallback_f; + inPhase : XPLMDrawingPhase; + inWantsBefore : integer; + inRefcon : pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMRegisterKeySniffer + + This routine registers a key sniffing callback. You specify whether you + want to sniff before the window system, or only sniff keys the window + system does not consume. You should ALMOST ALWAYS sniff non-control keys + after the window system. When the window system consumes a key, it is + because the user has "focused" a window. Consuming the key or taking + action based on the key will produce very weird results. Returns 1 if + successful. + } + FUNCTION XPLMRegisterKeySniffer( + inCallback : XPLMKeySniffer_f; + inBeforeWindows : integer; + inRefcon : pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnregisterKeySniffer + + This routine unregisters a key sniffer. You must unregister a key sniffer + for every time you register one with the exact same signature. Returns 1 + if successful. + } + FUNCTION XPLMUnregisterKeySniffer( + inCallback : XPLMKeySniffer_f; + inBeforeWindows : integer; + inRefcon : pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * WINDOW API + ___________________________________________________________________________} +{ + Window API, for higher level drawing with UI interaction. + + Note: all 2-d (and thus all window drawing) is done in 'cockpit pixels'. + Even when the OpenGL window contains more than 1024x768 pixels, the cockpit + drawing is magnified so that only 1024x768 pixels are available. +} + + + + { + XPLMMouseStatus + + When the mouse is clicked, your mouse click routine is called repeatedly. + It is first called with the mouse down message. It is then called zero or + more times with the mouse-drag message, and finally it is called once with + the mouse up message. All of these messages will be directed to the same + window. + } +TYPE + XPLMMouseStatus = ( + xplm_MouseDown = 1 + + ,xplm_MouseDrag = 2 + + ,xplm_MouseUp = 3 + + ); + PXPLMMouseStatus = ^XPLMMouseStatus; + +{$IFDEF XPLM200} + { + XPLMCursorStatus + + XPLMCursorStatus describes how you would like X-Plane to manage the cursor. + See XPLMHandleCursor_f for more info. + } + XPLMCursorStatus = ( + { X-Plane manages the cursor normally, plugin does not affect the cusrsor. } + xplm_CursorDefault = 0 + + { X-Plane hides the cursor. } + ,xplm_CursorHidden = 1 + + { X-Plane shows the cursor as the default arrow. } + ,xplm_CursorArrow = 2 + + { X-Plane shows the cursor but lets you select an OS cursor. } + ,xplm_CursorCustom = 3 + + ); + PXPLMCursorStatus = ^XPLMCursorStatus; +{$ENDIF} + + { + XPLMWindowID + + This is an opaque identifier for a window. You use it to control your + window. When you create a window, you will specify callbacks to handle + drawing and mouse interaction, etc. + } + XPLMWindowID = pointer; + PXPLMWindowID = ^XPLMWindowID; + + { + XPLMDrawWindow_f + + This function handles drawing. You are passed in your window and its + refcon. Draw the window. You can use XPLM functions to find the current + dimensions of your window, etc. When this callback is called, the OpenGL + context will be set properly for cockpit drawing. NOTE: Because you are + drawing your window over a background, you can make a translucent window + easily by simply not filling in your entire window's bounds. + } + XPLMDrawWindow_f = PROCEDURE( + inWindowID : XPLMWindowID; + inRefcon : pointer); cdecl; + + { + XPLMHandleKey_f + + This function is called when a key is pressed or keyboard focus is taken + away from your window. If losingFocus is 1, you are losign the keyboard + focus, otherwise a key was pressed and inKey contains its character. You + are also passewd your window and a refcon. Warning: this API declares + virtual keys as a signed character; however the VKEY #define macros in + XPLMDefs.h define the vkeys using unsigned values (that is 0x80 instead of + -0x80). So you may need to cast the incoming vkey to an unsigned char to + get correct comparisons in C. + } + XPLMHandleKey_f = PROCEDURE( + inWindowID : XPLMWindowID; + inKey : char; + inFlags : XPLMKeyFlags; + inVirtualKey : char; + inRefcon : pointer; + losingFocus : integer); cdecl; + + { + XPLMHandleMouseClick_f + + You receive this call when the mouse button is pressed down or released. + Between then these two calls is a drag. You receive the x and y of the + click, your window, and a refcon. Return 1 to consume the click, or 0 to + pass it through. + + WARNING: passing clicks through windows (as of this writing) causes mouse + tracking problems in X-Plane; do not use this feature! + } + XPLMHandleMouseClick_f = FUNCTION( + inWindowID : XPLMWindowID; + x : integer; + y : integer; + inMouse : XPLMMouseStatus; + inRefcon : pointer) : integer; cdecl; + +{$IFDEF XPLM200} + { + XPLMHandleCursor_f + + The SDK calls your cursor status callback when the mouse is over your + plugin window. Return a cursor status code to indicate how you would like + X-Plane to manage the cursor. If you return xplm_CursorDefault, the SDK + will try lower-Z-order plugin windows, then let the sim manage the cursor. + + Note: you should never show or hide the cursor yourself - these APIs are + typically reference-counted and thus cannot safely and predictably be used + by the SDK. Instead return one of xplm_CursorHidden to hide the cursor or + xplm_CursorArrow/xplm_CursorCustom to show the cursor. + + If you want to implement a custom cursor by drawing a cursor in OpenGL, use + xplm_CursorHidden to hide the OS cursor and draw the cursor using a 2-d + drawing callback (after xplm_Phase_Window is probably a good choice). If + you want to use a custom OS-based cursor, use xplm_CursorCustom to ask + X-Plane to show the cursor but not affect its image. You can then use an + OS specific call like SetThemeCursor (Mac) or SetCursor/LoadCursor + (Windows). + } + XPLMHandleCursor_f = FUNCTION( + inWindowID : XPLMWindowID; + x : integer; + y : integer; + inRefcon : pointer) : XPLMCursorStatus; cdecl; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMHandleMouseWheel_f + + The SDK calls your mouse wheel callback when one of the mouse wheels is + turned within your window. Return 1 to consume the mouse wheel clicks or + 0 to pass them on to a lower window. (You should consume mouse wheel + clicks even if they do nothing if your window appears opaque to the user.) + The number of clicks indicates how far the wheel was turned since the last + callback. The wheel is 0 for the vertical axis or 1 for the horizontal axis + (for OS/mouse combinations that support this). + } + XPLMHandleMouseWheel_f = FUNCTION( + inWindowID : XPLMWindowID; + x : integer; + y : integer; + wheel : integer; + clicks : integer; + inRefcon : pointer) : integer; cdecl; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMCreateWindow_t + + The XPMCreateWindow_t structure defines all of the parameters used to + create a window using XPLMCreateWindowEx. The structure will be expanded + in future SDK APIs to include more features. Always set the structSize + member to the size of your struct in bytes! + } + XPLMCreateWindow_t = RECORD + structSize : integer; + left : integer; + top : integer; + right : integer; + bottom : integer; + visible : integer; + drawWindowFunc : XPLMDrawWindow_f; + handleMouseClickFunc : XPLMHandleMouseClick_f; + handleKeyFunc : XPLMHandleKey_f; + handleCursorFunc : XPLMHandleCursor_f; + handleMouseWheelFunc : XPLMHandleMouseWheel_f; + refcon : pointer; + END; + PXPLMCreateWindow_t = ^XPLMCreateWindow_t; +{$ENDIF} + + { + XPLMGetScreenSize + + This routine returns the size of the size of the X-Plane OpenGL window in + pixels. Please note that this is not the size of the screen when doing + 2-d drawing (the 2-d screen is currently always 1024x768, and graphics are + scaled up by OpenGL when doing 2-d drawing for higher-res monitors). This + number can be used to get a rough idea of the amount of detail the user + will be able to see when drawing in 3-d. + } + PROCEDURE XPLMGetScreenSize( + outWidth : Pinteger; { Can be nil } + outHeight : Pinteger); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetMouseLocation + + This routine returns the current mouse location in cockpit pixels. The + bottom left corner of the display is 0,0. Pass NULL to not receive info + about either parameter. + } + PROCEDURE XPLMGetMouseLocation( + outX : Pinteger; { Can be nil } + outY : Pinteger); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCreateWindow + + This routine creates a new window. Pass in the dimensions and offsets to + the window's bottom left corner from the bottom left of the screen. You + can specify whether the window is initially visible or not. Also, you pass + in three callbacks to run the window and a refcon. This function returns a + window ID you can use to refer to the new window. + + NOTE: windows do not have "frames"; you are responsible for drawing the + background and frame of the window. Higher level libraries have routines + which make this easy. + } + FUNCTION XPLMCreateWindow( + inLeft : integer; + inTop : integer; + inRight : integer; + inBottom : integer; + inIsVisible : integer; + inDrawCallback : XPLMDrawWindow_f; + inKeyCallback : XPLMHandleKey_f; + inMouseCallback : XPLMHandleMouseClick_f; + inRefcon : pointer) : XPLMWindowID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMCreateWindowEx + + This routine creates a new window - you pass in an XPLMCreateWindow_t + structure with all of the fields set in. You must set the structSize of + the structure to the size of the actual structure you used. Also, you + must provide funtions for every callback - you may not leave them null! + (If you do not support the cursor or mouse wheel, use functions that return + the default values.) The numeric values of the XPMCreateWindow_t structure + correspond to the parameters of XPLMCreateWindow. + } + FUNCTION XPLMCreateWindowEx( + inParams : PXPLMCreateWindow_t) : XPLMWindowID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + + { + XPLMDestroyWindow + + This routine destroys a window. The callbacks are not called after this + call. Keyboard focus is removed from the window before destroying it. + } + PROCEDURE XPLMDestroyWindow( + inWindowID : XPLMWindowID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetWindowGeometry + + This routine returns the position and size of a window in cockpit pixels. + Pass NULL to not receive any paramter. + } + PROCEDURE XPLMGetWindowGeometry( + inWindowID : XPLMWindowID; + outLeft : Pinteger; { Can be nil } + outTop : Pinteger; { Can be nil } + outRight : Pinteger; { Can be nil } + outBottom : Pinteger); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetWindowGeometry + + This routine allows you to set the position or height aspects of a window. + } + PROCEDURE XPLMSetWindowGeometry( + inWindowID : XPLMWindowID; + inLeft : integer; + inTop : integer; + inRight : integer; + inBottom : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetWindowIsVisible + + This routine returns whether a window is visible. + } + FUNCTION XPLMGetWindowIsVisible( + inWindowID : XPLMWindowID) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetWindowIsVisible + + This routine shows or hides a window. + } + PROCEDURE XPLMSetWindowIsVisible( + inWindowID : XPLMWindowID; + inIsVisible : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetWindowRefCon + + This routine returns a windows refcon, the unique value you can use for + your own purposes. + } + FUNCTION XPLMGetWindowRefCon( + inWindowID : XPLMWindowID) : pointer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetWindowRefCon + + This routine sets a window's reference constant. Use this to pass data to + yourself in the callbacks. + } + PROCEDURE XPLMSetWindowRefCon( + inWindowID : XPLMWindowID; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMTakeKeyboardFocus + + This routine gives a specific window keyboard focus. Keystrokes will be + sent to that window. Pass a window ID of 0 to pass keyboard strokes + directly to X-Plane. + } + PROCEDURE XPLMTakeKeyboardFocus( + inWindow : XPLMWindowID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMBringWindowToFront + + This routine brings the window to the front of the Z-order. Windows are + brought to the front when they are created...beyond that you should make + sure you are front before handling mouse clicks. + } + PROCEDURE XPLMBringWindowToFront( + inWindow : XPLMWindowID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMIsWindowInFront + + This routine returns true if you pass inthe ID of the frontmost visible + window. + } + FUNCTION XPLMIsWindowInFront( + inWindow : XPLMWindowID) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * HOT KEYS + ___________________________________________________________________________} +{ + Hot Keys - keystrokes that can be managed by others. +} + + + + { + XPLMHotKey_f + + Your hot key callback simply takes a pointer of your choosing. + } +TYPE + XPLMHotKey_f = PROCEDURE( + inRefcon : pointer); cdecl; + + { + XPLMHotKeyID + + Hot keys are identified by opaque IDs. + } + XPLMHotKeyID = pointer; + PXPLMHotKeyID = ^XPLMHotKeyID; + + { + XPLMRegisterHotKey + + This routine registers a hot key. You specify your preferred key stroke + virtual key/flag combination, a description of what your callback does (so + other plug-ins can describe the plug-in to the user for remapping) and a + callback function and opaque pointer to pass in). A new hot key ID is + returned. During execution, the actual key associated with your hot key + may change, but you are insulated from this. + } + FUNCTION XPLMRegisterHotKey( + inVirtualKey : char; + inFlags : XPLMKeyFlags; + inDescription : Pchar; + inCallback : XPLMHotKey_f; + inRefcon : pointer) : XPLMHotKeyID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnregisterHotKey + + This API unregisters a hot key. You can only register your own hot keys. + } + PROCEDURE XPLMUnregisterHotKey( + inHotKey : XPLMHotKeyID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCountHotKeys + + Returns the number of current hot keys. + } + FUNCTION XPLMCountHotKeys: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetNthHotKey + + Returns a hot key by index, for iteration on all hot keys. + } + FUNCTION XPLMGetNthHotKey( + inIndex : integer) : XPLMHotKeyID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetHotKeyInfo + + Returns information about the hot key. Return NULL for any parameter you + don't want info about. The description should be at least 512 chars long. + } + PROCEDURE XPLMGetHotKeyInfo( + inHotKey : XPLMHotKeyID; + outVirtualKey : Pchar; { Can be nil } + outFlags : PXPLMKeyFlags; { Can be nil } + outDescription : Pchar; { Can be nil } + outPlugin : PXPLMPluginID); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetHotKeyCombination + + XPLMSetHotKeyCombination remaps a hot keys keystrokes. You may remap + another plugin's keystrokes. + } + PROCEDURE XPLMSetHotKeyCombination( + inHotKey : XPLMHotKeyID; + inVirtualKey : char; + inFlags : XPLMKeyFlags); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMGraphics.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMGraphics.pas new file mode 100755 index 0000000..713f14a --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMGraphics.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 XPLMGraphics; +INTERFACE +{ + Graphics routines for X-Plane and OpenGL. + + A few notes on coordinate systems: + + X-Plane uses three kinds of coordinates. Global coordinates are specified + as latitude, longitude and elevation. This coordinate system never changes + but is not very precise. + + OpenGL (or 'local') coordinates are cartesian and shift with the plane. + They offer more precision and are used for 3-d OpenGL drawing. The X axis + is aligned east-west with positive X meaning east. The Y axis is aligned + straight up and down at the point 0,0,0 (but since the earth is round it is + not truly straight up and down at other points). The Z axis is aligned + north-south at 0, 0, 0 with positive Z pointing south (but since the earth + is round it isn't exactly north-south as you move east or west of 0, 0, 0). + One unit is one meter and the point 0,0,0 is on the surface of the earth + at sea level for some latitude and longitude picked by the sim such that + the user's aircraft is reasonably nearby. + + Cockpit coordinates are 2d, with the X axis horizontal and the Y axis + vertical. The point 0,0 is the bottom left and 1024,768 is the upper right + of the screen. This is true no matter what resolution the user's monitor is + in; when running in higher resolution, graphics will be scaled. + + Use X-Plane's routines to convert between global and local coordinates. Do + not attempt to do this conversion yourself; the precise 'roundness' of + X-Plane's physics model may not match your own, and (to make things + weirder) the user can potentially customize the physics of the current + planet. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * X-PLANE GRAPHICS + ___________________________________________________________________________} +{ + These routines allow you to use OpenGL with X-Plane. +} + + + + { + XPLMTextureID + + XPLM Texture IDs name well-known textures in the sim for you to use. This + allows you to recycle textures from X-Plane, saving VRAM. + } +TYPE + XPLMTextureID = ( + { The bitmap that contains window outlines, button outlines, fonts, etc. } + xplm_Tex_GeneralInterface = 0 + + { The exterior paint for the user's aircraft (daytime). } + ,xplm_Tex_AircraftPaint = 1 + + { The exterior light map for the user's aircraft. } + ,xplm_Tex_AircraftLiteMap = 2 + + ); + PXPLMTextureID = ^XPLMTextureID; + + { + XPLMSetGraphicsState + + XPLMSetGraphicsState changes OpenGL's graphics state in a number of ways: + + inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG); + + inNumberTexUnits - enables or disables a number of multitexturing units. If + the number is 0, 2d texturing is disabled entirely, as in + glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a + number of multitexturing units are enabled sequentially, starting with + unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable + (GL_TEXTURE_2D); + + inEnableLighting - enables or disables OpenGL lighting, e.g. + glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); + + inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g. + glEnable(GL_ALPHA_TEST); + + inEnableAlphaBlending - enables or disables alpha blending per pixel, e.g. + glEnable(GL_BLEND); + + inEnableDepthTesting - enables per pixel depth testing, as in + glEnable(GL_DEPTH_TEST); + + inEnableDepthWriting - enables writing back of depth information to the + depth bufffer, as in glDepthMask(GL_TRUE); + + The purpose of this function is to change OpenGL state while keeping + X-Plane aware of the state changes; this keeps X-Plane from getting + surprised by OGL state changes, and prevents X-Plane and plug-ins from + having to set all state before all draws; XPLMSetGraphicsState internally + skips calls to change state that is already properly enabled. + + X-Plane does not have a 'default' OGL state to plug-ins; plug-ins should + totally set OGL state before drawing. Use XPLMSetGraphicsState instead of + any of the above OpenGL calls. + + WARNING: Any routine that performs drawing (e.g. XPLMDrawString or widget + code) may change X-Plane's state. Always set state before drawing after + unknown code has executed. + } + PROCEDURE XPLMSetGraphicsState( + inEnableFog : integer; + inNumberTexUnits : integer; + inEnableLighting : integer; + inEnableAlphaTesting: integer; + inEnableAlphaBlending: integer; + inEnableDepthTesting: integer; + inEnableDepthWriting: integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMBindTexture2d + + XPLMBindTexture2d changes what texture is bound to the 2d texturing target. + This routine caches the current 2d texture across all texturing units in + the sim and plug-ins, preventing extraneous binding. For example, consider + several plug-ins running in series; if they all use the 'general interface' + bitmap to do UI, calling this function will skip the rebinding of the + general interface texture on all but the first plug-in, which can provide + better frame rate son some graphics cards. + + inTextureID is the ID of the texture object to bind; inTextureUnit is a + zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4 + units. (This number may increase in future versions of x-plane.) + + Use this routine instead of glBindTexture(GL_TEXTURE_2D, ....); + } + PROCEDURE XPLMBindTexture2d( + inTextureNum : integer; + inTextureUnit : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGenerateTextureNumbers + + This routine generates unused texture numbers that a plug-in can use to + safely bind textures. Use this routine instead of glGenTextures; + glGenTextures will allocate texture numbers in ranges that X-Plane reserves + for its own use but does not always use; for example, it might provide an + ID within the range of textures reserved for terrain...loading a new .env + file as the plane flies might then cause X-Plane to use this texture ID. + X-Plane will then overwrite the plug-ins texture. This routine returns + texture IDs that are out of X-Plane's usage range. + } + PROCEDURE XPLMGenerateTextureNumbers( + outTextureIDs : Pinteger; + inCount : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetTexture + + XPLMGetTexture returns the OpenGL texture enumeration of an X-Plane texture + based on a generic identifying code. For example, you can get the texture + for X-Plane's UI bitmaps. This allows you to build new gauges that take + advantage of x-plane's textures, for smooth artwork integration and also + saving texture memory. Note that the texture might not be loaded yet, + depending on what the plane's panel contains. + + OPEN ISSUE: We really need a way to make sure X-Plane loads this texture if + it isn't around, or at least a way to find out whether it is loaded or not. + } + FUNCTION XPLMGetTexture( + inTexture : XPLMTextureID) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMWorldToLocal + + This routine translates coordinates from latitude, longitude, and altitude + to local scene coordinates. Latitude and longitude are in decimal degrees, + and altitude is in meters MSL (mean sea level). The XYZ coordinates are in + meters in the local OpenGL coordinate system. + } + PROCEDURE XPLMWorldToLocal( + inLatitude : real; + inLongitude : real; + inAltitude : real; + outX : Preal; + outY : Preal; + outZ : Preal); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMLocalToWorld + + This routine translates a local coordinate triplet back into latitude, + longitude, and altitude. Latitude and longitude are in decimal degrees, + and altitude is in meters MSL (mean sea level). The XYZ coordinates are in + meters in the local OpenGL coordinate system. + + NOTE: world coordinates are less precise than local coordinates; you should + try to avoid round tripping from local to world and back. + } + PROCEDURE XPLMLocalToWorld( + inX : real; + inY : real; + inZ : real; + outLatitude : Preal; + outLongitude : Preal; + outAltitude : Preal); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDrawTranslucentDarkBox + + This routine draws a translucent dark box, partially obscuring parts of the + screen but making text easy to read. This is the same graphics primitive + used by X-Plane to show text files and ATC info. + } + PROCEDURE XPLMDrawTranslucentDarkBox( + inLeft : integer; + inTop : integer; + inRight : integer; + inBottom : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * X-PLANE TEXT + ___________________________________________________________________________} +{ + +} + + + + { + XPLMFontID + + X-Plane features some fixed-character fonts. Each font may have its own + metrics. + + WARNING: Some of these fonts are no longer supported or may have changed + geometries. For maximum copmatibility, see the comments below. + + Note: X-Plane 7 supports proportional-spaced fonts. Since no measuring + routine is available yet, the SDK will normally draw using a fixed-width + font. You can use a dataref to enable proportional font drawing on XP7 if + you want to. + } +TYPE + XPLMFontID = ( + { Mono-spaced font for user interface. Available in all versions of the SDK. } + xplmFont_Basic = 0 + + { Deprecated, do not use. } + ,xplmFont_Menus = 1 + + { Deprecated, do not use. } + ,xplmFont_Metal = 2 + + { Deprecated, do not use. } + ,xplmFont_Led = 3 + + { Deprecated, do not use. } + ,xplmFont_LedWide = 4 + + { Deprecated, do not use. } + ,xplmFont_PanelHUD = 5 + + { Deprecated, do not use. } + ,xplmFont_PanelEFIS = 6 + + { Deprecated, do not use. } + ,xplmFont_PanelGPS = 7 + + { Deprecated, do not use. } + ,xplmFont_RadiosGA = 8 + + { Deprecated, do not use. } + ,xplmFont_RadiosBC = 9 + + { Deprecated, do not use. } + ,xplmFont_RadiosHM = 10 + + { Deprecated, do not use. } + ,xplmFont_RadiosGANarrow = 11 + + { Deprecated, do not use. } + ,xplmFont_RadiosBCNarrow = 12 + + { Deprecated, do not use. } + ,xplmFont_RadiosHMNarrow = 13 + + { Deprecated, do not use. } + ,xplmFont_Timer = 14 + + { Deprecated, do not use. } + ,xplmFont_FullRound = 15 + + { Deprecated, do not use. } + ,xplmFont_SmallRound = 16 + + { Deprecated, do not use. } + ,xplmFont_Menus_Localized = 17 + +{$IFDEF XPLM200} + { Proportional UI font. } + ,xplmFont_Proportional = 18 +{$ENDIF} + + ); + PXPLMFontID = ^XPLMFontID; + + { + XPLMDrawString + + This routine draws a NULL termianted string in a given font. Pass in the + lower left pixel that the character is to be drawn onto. Also pass the + character and font ID. This function returns the x offset plus the width of + all drawn characters. The color to draw in is specified as a pointer to an + array of three floating point colors, representing RGB intensities from 0.0 + to 1.0. + } + PROCEDURE XPLMDrawString( + inColorRGB : Psingle; + inXOffset : integer; + inYOffset : integer; + inChar : Pchar; + inWordWrapWidth : Pinteger; { Can be nil } + inFontID : XPLMFontID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDrawNumber + + This routine draws a number similar to the digit editing fields in + PlaneMaker and data output display in X-Plane. Pass in a color, a + position, a floating point value, and formatting info. Specify how many + integer and how many decimal digits to show and whether to show a sign, as + well as a character set. This routine returns the xOffset plus width of the + string drawn. + } + PROCEDURE XPLMDrawNumber( + inColorRGB : Psingle; + inXOffset : integer; + inYOffset : integer; + inValue : real; + inDigits : integer; + inDecimals : integer; + inShowSign : integer; + inFontID : XPLMFontID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetFontDimensions + + This routine returns the width and height of a character in a given font. + It also tells you if the font only supports numeric digits. Pass NULL if + you don't need a given field. Note that for a proportional font the width + will be an arbitrary, hopefully average width. + } + PROCEDURE XPLMGetFontDimensions( + inFontID : XPLMFontID; + outCharWidth : Pinteger; { Can be nil } + outCharHeight : Pinteger; { Can be nil } + outDigitsOnly : Pinteger); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMMeasureString + + This routine returns the width in pixels of a string using a given font. + The string is passed as a pointer plus length (and does not need to be null + terminated); this is used to allow for measuring substrings. The return + value is floating point; it is possible that future font drawing may allow + for fractional pixels. + } + FUNCTION XPLMMeasureString( + inFontID : XPLMFontID; + inChar : Pchar; + inNumChars : integer) : single; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMMenus.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMMenus.pas new file mode 100755 index 0000000..d113952 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMMenus.pas @@ -0,0 +1,259 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMMenus; +INTERFACE +{ + XPLMMenus - Theory of Operation + + Plug-ins can create menus in the menu bar of X-Plane. This is done by + creating a menu and then creating items. Menus are referred to by an + opaque ID. Items are referred to by index number. For each menu and item + you specify a void *. Per menu you specify a handler function that is + called with each void * when the menu item is picked. Menu item indices + are zero based. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * XPLM MENUS + ___________________________________________________________________________} +{ + +} + + + + { + XPLMMenuCheck + + These enumerations define the various 'check' states for an X-Plane menu. + 'checking' in x-plane actually appears as a light which may or may not be + lit. So there are three possible states. + } +TYPE + XPLMMenuCheck = ( + { there is no symbol to the left of the menu item. } + xplm_Menu_NoCheck = 0 + + { the menu has a mark next to it that is unmarked (not lit). } + ,xplm_Menu_Unchecked = 1 + + { the menu has a mark next to it that is checked (lit). } + ,xplm_Menu_Checked = 2 + + ); + PXPLMMenuCheck = ^XPLMMenuCheck; + + { + XPLMMenuID + + This is a unique ID for each menu you create. + } + XPLMMenuID = pointer; + PXPLMMenuID = ^XPLMMenuID; + + { + XPLMMenuHandler_f + + A menu handler function takes two reference pointers, one for the menu + (specified when the menu was created) and one for the item (specified when + the item was created). + } + XPLMMenuHandler_f = PROCEDURE( + inMenuRef : pointer; + inItemRef : pointer); cdecl; + + { + XPLMFindPluginsMenu + + This function returns the ID of the plug-ins menu, which is created for you + at startup. + } + FUNCTION XPLMFindPluginsMenu: XPLMMenuID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCreateMenu + + This function creates a new menu and returns its ID. It returns NULL if + the menu cannot be created. Pass in a parent menu ID and an item index to + create a submenu, or NULL for the parent menu to put the menu in the menu + bar. The menu's name is only used if the menu is in the menubar. You also + pass a handler function and a menu reference value. Pass NULL for the + handler if you do not need callbacks from the menu (for example, if it only + contains submenus). + + Important: you must pass a valid, non-empty menu title even if the menu is + a submenu where the title is not visible. + } + FUNCTION XPLMCreateMenu( + inName : Pchar; + inParentMenu : XPLMMenuID; + inParentItem : integer; + inHandler : XPLMMenuHandler_f; + inMenuRef : pointer) : XPLMMenuID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDestroyMenu + + This function destroys a menu that you have created. Use this to remove a + submenu if necessary. (Normally this function will not be necessary.) + } + PROCEDURE XPLMDestroyMenu( + inMenuID : XPLMMenuID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMClearAllMenuItems + + This function removes all menu items from a menu, allowing you to rebuild + it. Use this function if you need to change the number of items on a menu. + } + PROCEDURE XPLMClearAllMenuItems( + inMenuID : XPLMMenuID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMAppendMenuItem + + This routine appends a new menu item to the bottom of a menu and returns + its index. Pass in the menu to add the item to, the items name, and a void + * ref for this item. If you pass in inForceEnglish, this menu item will be + drawn using the english character set no matter what language x-plane is + running in. Otherwise the menu item will be drawn localized. (An example + of why you'd want to do this is for a proper name.) See XPLMUtilities for + determining the current langauge. + } + FUNCTION XPLMAppendMenuItem( + inMenu : XPLMMenuID; + inItemName : Pchar; + inItemRef : pointer; + inForceEnglish : integer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMAppendMenuSeparator + + This routine adds a seperator to the end of a menu. + } + PROCEDURE XPLMAppendMenuSeparator( + inMenu : XPLMMenuID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetMenuItemName + + This routine changes the name of an existing menu item. Pass in the menu + ID and the index of the menu item. + } + PROCEDURE XPLMSetMenuItemName( + inMenu : XPLMMenuID; + inIndex : integer; + inItemName : Pchar; + inForceEnglish : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCheckMenuItem + + Set whether a menu item is checked. Pass in the menu ID and item index. + } + PROCEDURE XPLMCheckMenuItem( + inMenu : XPLMMenuID; + index : integer; + inCheck : XPLMMenuCheck); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCheckMenuItemState + + This routine returns whether a menu item is checked or not. A menu item's + check mark may be on or off, or a menu may not have an icon at all. + } + PROCEDURE XPLMCheckMenuItemState( + inMenu : XPLMMenuID; + index : integer; + outCheck : PXPLMMenuCheck); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMEnableMenuItem + + Sets whether this menu item is enabled. Items start out enabled. + } + PROCEDURE XPLMEnableMenuItem( + inMenu : XPLMMenuID; + index : integer; + enabled : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMRemoveMenuItem + + Removes one item from a menu. Note that all menu items below are moved up + one; your plugin must track the change in index numbers. + } + PROCEDURE XPLMRemoveMenuItem( + inMenu : XPLMMenuID; + inIndex : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMNavigation.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMNavigation.pas new file mode 100755 index 0000000..993ef58 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMNavigation.pas @@ -0,0 +1,434 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMNavigation; +INTERFACE +{ + XPLMNavigation - THEORY OF OPERATION + + The XPLM Navigation APIs give you some access to the navigation databases + inside X-Plane. X-Plane stores all navigation information in RAM, so by + using these APIs you can gain access to most information without having to + go to disk or parse the files yourself. + + You can also use this API to program the FMS. You must use the navigation + APIs to find the nav-aids you want to program into the FMS, since the FMS + is powered internally by x-plane's navigation database. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * NAVIGATION DATABASE ACCESS + ___________________________________________________________________________} +{ + +} + + + + { + XPLMNavType + + These enumerations define the different types of navaids. They are each + defined with a separate bit so that they may be bit-wise added together to + form sets of nav-aid types. + + NOTE: xplm_Nav_LatLon is a specific lat-lon coordinate entered into the + FMS. It will not exist in the database, and cannot be programmed into the + FMS. Querying the FMS for navaids will return it. Use + XPLMSetFMSEntryLatLon to set a lat/lon waypoint. + } +TYPE + XPLMNavType = ( + xplm_Nav_Unknown = 0 + + ,xplm_Nav_Airport = 1 + + ,xplm_Nav_NDB = 2 + + ,xplm_Nav_VOR = 4 + + ,xplm_Nav_ILS = 8 + + ,xplm_Nav_Localizer = 16 + + ,xplm_Nav_GlideSlope = 32 + + ,xplm_Nav_OuterMarker = 64 + + ,xplm_Nav_MiddleMarker = 128 + + ,xplm_Nav_InnerMarker = 256 + + ,xplm_Nav_Fix = 512 + + ,xplm_Nav_DME = 1024 + + ,xplm_Nav_LatLon = 2048 + + ); + PXPLMNavType = ^XPLMNavType; + + { + XPLMNavRef + + XPLMNavRef is an iterator into the navigation database. The navigation + database is essentially an array, but it is not necessarily densely + populated. The only assumption you can safely make is that like-typed + nav-aids are grouped together. + + Use XPLMNavRef to refer to a nav-aid. + + XPLM_NAV_NOT_FOUND is returned by functions that return an XPLMNavRef when + the iterator must be invalid. + } + XPLMNavRef = integer; + PXPLMNavRef = ^XPLMNavRef; + +CONST + XPLM_NAV_NOT_FOUND = -1; + + { + XPLMGetFirstNavAid + + This returns the very first navaid in the database. Use this to traverse + the entire database. Returns XPLM_NAV_NOT_FOUND if the nav database is + empty. + } + FUNCTION XPLMGetFirstNavAid: XPLMNavRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetNextNavAid + + Given a nav aid ref, this routine returns the next navaid. It returns + XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the navaid + passed in was the last one in the database. Use this routine to iterate + across all like-typed navaids or the entire database. + + WARNING: due to a bug in the SDK, when fix loading is disabled in the + rendering settings screen, calling this routine with the last airport + returns a bogus nav aid. Using this nav aid can crash x-plane. + } + FUNCTION XPLMGetNextNavAid( + inNavAidRef : XPLMNavRef) : XPLMNavRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMFindFirstNavAidOfType + + This routine returns the ref of the first navaid of the given type in the + database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the + database. You must pass exactly one nav aid type to this routine. + + WARNING: due to a bug in the SDK, when fix loading is disabled in the + rendering settings screen, calling this routine with fixes returns a bogus + nav aid. Using this nav aid can crash x-plane. + } + FUNCTION XPLMFindFirstNavAidOfType( + inType : XPLMNavType) : XPLMNavRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMFindLastNavAidOfType + + This routine returns the ref of the last navaid of the given type in the + database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the + database. You must pass exactly one nav aid type to this routine. + + WARNING: due to a bug in the SDK, when fix loading is disabled in the + rendering settings screen, calling this routine with fixes returns a bogus + nav aid. Using this nav aid can crash x-plane. + } + FUNCTION XPLMFindLastNavAidOfType( + inType : XPLMNavType) : XPLMNavRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMFindNavAid + + This routine provides a number of searching capabilities for the nav + database. XPLMFindNavAid will search through every nav aid whose type is + within inType (multiple types may be added together) and return any + nav-aids found based on the following rules: + + If inLat and inLon are not NULL, the navaid nearest to that lat/lon will be + returned, otherwise the last navaid found will be returned. + + If inFrequency is not NULL, then any navaids considered must match this + frequency. Note that this will screen out radio beacons that do not have + frequency data published (like inner markers) but not fixes and airports. + + If inNameFragment is not NULL, only navaids that contain the fragment in + their name will be returned. + + If inIDFragment is not NULL, only navaids that contain the fragment in + their IDs will be returned. + + This routine provides a simple way to do a number of useful searches: + + Find the nearest navaid on this frequency. Find the nearest airport. Find + the VOR whose ID is "KBOS". Find the nearest airport whose name contains + "Chicago". + } + FUNCTION XPLMFindNavAid( + inNameFragment : Pchar; { Can be nil } + inIDFragment : Pchar; { Can be nil } + inLat : Psingle; { Can be nil } + inLon : Psingle; { Can be nil } + inFrequency : Pinteger; { Can be nil } + inType : XPLMNavType) : XPLMNavRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetNavAidInfo + + This routine returns information about a navaid. Any non-null field is + filled out with information if it is available. + + Frequencies are in the nav.dat convention as described in the X-Plane nav + database FAQ: NDB frequencies are exact, all others are multiplied by 100. + + The buffer for IDs should be at least 6 chars and the buffer for names + should be at least 41 chars, but since these values are likely to go up, I + recommend passing at least 32 chars for IDs and 256 chars for names when + possible. + + The outReg parameter tells if the navaid is within the local "region" of + loaded DSFs. (This information may not be particularly useful to plugins.) + The parameter is a single byte value 1 for true or 0 for false, not a C + string. + } + PROCEDURE XPLMGetNavAidInfo( + inRef : XPLMNavRef; + outType : PXPLMNavType; { Can be nil } + outLatitude : Psingle; { Can be nil } + outLongitude : Psingle; { Can be nil } + outHeight : Psingle; { Can be nil } + outFrequency : Pinteger; { Can be nil } + outHeading : Psingle; { Can be nil } + outID : Pchar; { Can be nil } + outName : Pchar; { Can be nil } + outReg : Pchar); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * FLIGHT MANAGEMENT COMPUTER + ___________________________________________________________________________} +{ + Note: the FMS works based on an array of entries. Indices into the array + are zero-based. Each entry is a nav-aid plus an altitude. The FMS tracks + the currently displayed entry and the entry that it is flying to. + + The FMS must be programmed with contiguous entries, so clearing an entry at + the end shortens the effective flight plan. There is a max of 100 + waypoints in the flight plan. +} + + + + { + XPLMCountFMSEntries + + This routine returns the number of entries in the FMS. + } + FUNCTION XPLMCountFMSEntries: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDisplayedFMSEntry + + This routine returns the index of the entry the pilot is viewing. + } + FUNCTION XPLMGetDisplayedFMSEntry: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDestinationFMSEntry + + This routine returns the index of the entry the FMS is flying to. + } + FUNCTION XPLMGetDestinationFMSEntry: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDisplayedFMSEntry + + This routine changes which entry the FMS is showing to the index specified. + } + PROCEDURE XPLMSetDisplayedFMSEntry( + inIndex : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetDestinationFMSEntry + + This routine changes which entry the FMS is flying the aircraft toward. + } + PROCEDURE XPLMSetDestinationFMSEntry( + inIndex : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetFMSEntryInfo + + This routine returns information about a given FMS entry. A reference to a + navaid can be returned allowing you to find additional information (such as + a frequency, ILS heading, name, etc.). Some information is available + immediately. For a lat/lon entry, the lat/lon is returned by this routine + but the navaid cannot be looked up (and the reference will be + XPLM_NAV_NOT_FOUND. FMS name entry buffers should be at least 256 chars in + length. + } + PROCEDURE XPLMGetFMSEntryInfo( + inIndex : integer; + outType : PXPLMNavType; { Can be nil } + outID : Pchar; { Can be nil } + outRef : PXPLMNavRef; { Can be nil } + outAltitude : Pinteger; { Can be nil } + outLat : Psingle; { Can be nil } + outLon : Psingle); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetFMSEntryInfo + + This routine changes an entry in the FMS to have the destination navaid + passed in and the altitude specified. Use this only for airports, fixes, + and radio-beacon navaids. Currently of radio beacons, the FMS can only + support VORs and NDBs. Use the routines below to clear or fly to a lat/lon. + } + PROCEDURE XPLMSetFMSEntryInfo( + inIndex : integer; + inRef : XPLMNavRef; + inAltitude : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetFMSEntryLatLon + + This routine changes the entry in the FMS to a lat/lon entry with the given + coordinates. + } + PROCEDURE XPLMSetFMSEntryLatLon( + inIndex : integer; + inLat : single; + inLon : single; + inAltitude : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMClearFMSEntry + + This routine clears the given entry, potentially shortening the flight + plan. + } + PROCEDURE XPLMClearFMSEntry( + inIndex : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * GPS RECEIVER + ___________________________________________________________________________} +{ + These APIs let you read data from the GPS unit. +} + + + + { + XPLMGetGPSDestinationType + + This routine returns the type of the currently selected GPS destination, + one of fix, airport, VOR or NDB. + } + FUNCTION XPLMGetGPSDestinationType: XPLMNavType; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetGPSDestination + + This routine returns the current GPS destination. + } + FUNCTION XPLMGetGPSDestination: XPLMNavRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMPlanes.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMPlanes.pas new file mode 100755 index 0000000..b5d19a2 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMPlanes.pas @@ -0,0 +1,294 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMPlanes; +INTERFACE +{ + The XPLMPlanes APIs allow you to control the various aircraft in x-plane, + both the user's and the sim's. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * USER AIRCRAFT ACCESS + ___________________________________________________________________________} +{ + +} + + + { + XPLMSetUsersAircraft + + This routine changes the user's aircraft. Note that this will reinitialize + the user to be on the nearest airport's first runway. Pass in a full path + (hard drive and everything including the .acf extension) to the .acf file. + } + PROCEDURE XPLMSetUsersAircraft( + inAircraftPath : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + { + XPLMPlaceUserAtAirport + + This routine places the user at a given airport. Specify the airport by + its ICAO code (e.g. 'KBOS'). + } + PROCEDURE XPLMPlaceUserAtAirport( + inAirportCode : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{___________________________________________________________________________ + * GLOBAL AIRCRAFT ACCESS + ___________________________________________________________________________} +{ + +} + + +CONST + { The user's aircraft is always index 0. } + XPLM_USER_AIRCRAFT = 0; + { + XPLMPlaneDrawState_t + + This structure contains additional plane parameter info to be passed to + draw plane. Make sure to fill in the size of the structure field with + sizeof(XPLMDrawPlaneState_t) so that the XPLM can tell how many fields you + knew about when compiling your plugin (since more fields may be added + later). + + Most of these fields are ratios from 0 to 1 for control input. X-Plane + calculates what the actual controls look like based on the .acf file for + that airplane. Note for the yoke inputs, this is what the pilot of the + plane has commanded (post artificial stability system if there were one) + and affects aelerons, rudder, etc. It is not necessarily related to the + actual position of the plane! + } +TYPE + XPLMPlaneDrawState_t = RECORD + { The size of the draw state struct. } + structSize : integer; + { A ratio from [0..1] describing how far the landing gear is extended. } + gearPosition : single; + { Ratio of flap deployment, 0 = up, 1 = full deploy. } + flapRatio : single; + { Ratio of spoiler deployment, 0 = none, 1 = full deploy. } + spoilerRatio : single; + { Ratio of speed brake deployment, 0 = none, 1 = full deploy. } + speedBrakeRatio : single; + { Ratio of slat deployment, 0 = none, 1 = full deploy. } + slatRatio : single; + { Wing sweep ratio, 0 = forward, 1 = swept. } + wingSweep : single; + { Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. } + thrust : single; + { Total pitch input for this plane. } + yokePitch : single; + { Total Heading input for this plane. } + yokeHeading : single; + { Total Roll input for this plane. } + yokeRoll : single; + END; + PXPLMPlaneDrawState_t = ^XPLMPlaneDrawState_t; + { + XPLMCountAircraft + + This function returns the number of aircraft X-Plane is capable of having, + as well as the number of aircraft that are currently active. These numbers + count the user's aircraft. It can also return the plugin that is currently + controlling aircraft. In X-Plane 7, this routine reflects the number of + aircraft the user has enabled in the rendering options window. + } + PROCEDURE XPLMCountAircraft( + outTotalAircraft : Pinteger; + outActiveAircraft : Pinteger; + outController : PXPLMPluginID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + { + XPLMGetNthAircraftModel + + This function returns the aircraft model for the Nth aircraft. Indices are + zero based, with zero being the user's aircraft. The file name should be + at least 256 chars in length; the path should be at least 512 chars in + length. + } + PROCEDURE XPLMGetNthAircraftModel( + inIndex : integer; + outFileName : Pchar; + outPath : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{___________________________________________________________________________ + * EXCLUSIVE AIRCRAFT ACCESS + ___________________________________________________________________________} +{ + The following routines require exclusive access to the airplane APIs. Only + one plugin may have this access at a time. +} + + + + { + XPLMPlanesAvailable_f + + Your airplanes available callback is called when another plugin gives up + access to the multiplayer planes. Use this to wait for access to + multiplayer. + } +TYPE + XPLMPlanesAvailable_f = PROCEDURE( + inRefcon : pointer); cdecl; + + { + XPLMAcquirePlanes + + XPLMAcquirePlanes grants your plugin exclusive access to the aircraft. It + returns 1 if you gain access, 0 if you do not. inAircraft - pass in an + array of pointers to strings specifying the planes you want loaded. For + any plane index you do not want loaded, pass a 0-length string. Other + strings should be full paths with the .acf extension. NULL terminates this + array, or pass NULL if there are no planes you want loaded. If you pass in + a callback and do not receive access to the planes your callback will be + called when the airplanes are available. If you do receive airplane access, + your callback will not be called. + } + FUNCTION XPLMAcquirePlanes( + inAircraft : PPchar; { Can be nil } + inCallback : XPLMPlanesAvailable_f; + inRefcon : pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMReleasePlanes + + Call this function to release access to the planes. Note that if you are + disabled, access to planes is released for you and you must reacquire it. + } + PROCEDURE XPLMReleasePlanes; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetActiveAircraftCount + + This routine sets the number of active planes. If you pass in a number + higher than the total number of planes availables, only the total number of + planes available is actually used. + } + PROCEDURE XPLMSetActiveAircraftCount( + inCount : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetAircraftModel + + This routine loads an aircraft model. It may only be called if you have + exclusive access to the airplane APIs. Pass in the path of the model with + the .acf extension. The index is zero based, but you may not pass in 0 + (use XPLMSetUsersAircraft to load the user's aircracft). + } + PROCEDURE XPLMSetAircraftModel( + inIndex : integer; + inAircraftPath : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDisableAIForPlane + + This routine turns off X-Plane's AI for a given plane. The plane will + continue to draw and be a real plane in X-Plane, but will not move itself. + } + PROCEDURE XPLMDisableAIForPlane( + inPlaneIndex : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDrawAircraft + + This routine draws an aircraft. It can only be called from a 3-d drawing + callback. Pass in the position of the plane in OpenGL local coordinates + and the orientation of the plane. A 1 for full drawing indicates that the + whole plane must be drawn; a 0 indicates you only need the nav lights + drawn. (This saves rendering time when planes are far away.) + } + PROCEDURE XPLMDrawAircraft( + inPlaneIndex : integer; + inX : single; + inY : single; + inZ : single; + inPitch : single; + inRoll : single; + inYaw : single; + inFullDraw : integer; + inDrawStateInfo : PXPLMPlaneDrawState_t); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMReinitUsersPlane + + This function recomputes the derived flight model data from the aircraft + structure in memory. If you have used the data access layer to modify the + aircraft structure, use this routine to resynchronize x-plane; since + X-plane works at least partly from derived values, the sim will not behave + properly until this is called. + + WARNING: this routine does not necessarily place the airplane at the + airport; use XPLMSetUsersAircraft to be compatible. This routine is + provided to do special experimentation with flight models without resetting + flight. + } + PROCEDURE XPLMReinitUsersPlane; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMPlugin.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMPlugin.pas new file mode 100755 index 0000000..f053f80 --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMPlugin.pas @@ -0,0 +1,381 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMPlugin; +INTERFACE +{ + These APIs provide facilities to find and work with other plugins and + manage other plugins. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * FINDING PLUGINS + ___________________________________________________________________________} +{ + These APIs allow you to find another plugin or yourself, or iterate across + all plugins. For example, if you wrote an FMS plugin that needed to talk + to an autopilot plugin, you could use these APIs to locate the autopilot + plugin. +} + + + + { + XPLMGetMyID + + This routine returns the plugin ID of the calling plug-in. Call this to + get your own ID. + } + FUNCTION XPLMGetMyID: XPLMPluginID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCountPlugins + + This routine returns the total number of plug-ins that are loaded, both + disabled and enabled. + } + FUNCTION XPLMCountPlugins: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetNthPlugin + + This routine returns the ID of a plug-in by index. Index is 0 based from 0 + to XPLMCountPlugins-1, inclusive. Plugins may be returned in any arbitrary + order. + } + FUNCTION XPLMGetNthPlugin( + inIndex : integer) : XPLMPluginID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMFindPluginByPath + + This routine returns the plug-in ID of the plug-in whose file exists at the + passed in absolute file system path. XPLM_NO_PLUGIN_ID is returned if the + path does not point to a currently loaded plug-in. + } + FUNCTION XPLMFindPluginByPath( + inPath : Pchar) : XPLMPluginID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMFindPluginBySignature + + This routine returns the plug-in ID of the plug-in whose signature matches + what is passed in or XPLM_NO_PLUGIN_ID if no running plug-in has this + signature. Signatures are the best way to identify another plug-in as they + are independent of the file system path of a plug-in or the human-readable + plug-in name, and should be unique for all plug-ins. Use this routine to + locate another plugin that your plugin interoperates with + } + FUNCTION XPLMFindPluginBySignature( + inSignature : Pchar) : XPLMPluginID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetPluginInfo + + This routine returns information about a plug-in. Each parameter should be + a pointer to a buffer of at least 256 characters, or NULL to not receive + the information. + + outName - the human-readable name of the plug-in. outFilePath - the + absolute file path to the file that contains this plug-in. outSignature - a + unique string that identifies this plug-in. outDescription - a + human-readable description of this plug-in. + } + PROCEDURE XPLMGetPluginInfo( + inPlugin : XPLMPluginID; + outName : Pchar; { Can be nil } + outFilePath : Pchar; { Can be nil } + outSignature : Pchar; { Can be nil } + outDescription : Pchar); { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * ENABLING/DISABLING PLUG-INS + ___________________________________________________________________________} +{ + These routines are used to work with plug-ins and manage them. Most + plugins will not need to use these APIs. +} + + + + { + XPLMIsPluginEnabled + + Returns whether the specified plug-in is enabled for running. + } + FUNCTION XPLMIsPluginEnabled( + inPluginID : XPLMPluginID) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMEnablePlugin + + This routine enables a plug-in if it is not already enabled. It returns 1 + if the plugin was enabled or successfully enables itself, 0 if it does not. + Plugins may fail to enable (for example, if resources cannot be acquired) + by returning 0 from their XPluginEnable callback. + } + FUNCTION XPLMEnablePlugin( + inPluginID : XPLMPluginID) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDisablePlugin + + This routine disableds an enabled plug-in. + } + PROCEDURE XPLMDisablePlugin( + inPluginID : XPLMPluginID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMReloadPlugins + + This routine reloads all plug-ins. Once this routine is called and you + return from the callback you were within (e.g. a menu select callback) you + will receive your XPluginDisable and XPluginStop callbacks and your DLL + will be unloaded, then the start process happens as if the sim was starting + up. + } + PROCEDURE XPLMReloadPlugins; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * INTERPLUGIN MESSAGING + ___________________________________________________________________________} +{ + Plugin messages are defined as 32-bit integers. Messages below 0x00FFFFFF + are reserved for X-Plane and the plugin SDK. + + Messages have two conceptual uses: notifications and commands. Commands + are sent from one plugin to another to induce behavior; notifications are + sent from one plugin to all others for informational purposes. It is + important that commands and notifications not have the same values because + this could cause a notification sent by one plugin to accidentally induce a + command in another. + + By convention, plugin-defined notifications should have the high bit set + (e.g. be greater or equal to unsigned 0x8000000) while commands should have + this bit be cleared. + + The following messages are sent to your plugin by x-plane. +} + + + +CONST + { This message is sent to your plugin whenever the user's plane crashes. } + XPLM_MSG_PLANE_CRASHED = 101; + + { This message is sent to your plugin whenever a new plane is loaded. The } + { parameter is the number of the plane being loaded; 0 indicates the user's } + { plane. } + XPLM_MSG_PLANE_LOADED = 102; + + { This messages is called whenever the user's plane is positioned at a new } + { airport. } + XPLM_MSG_AIRPORT_LOADED = 103; + + { This message is sent whenever new scenery is loaded. Use datarefs to } + { determine the new scenery files that were loaded. } + XPLM_MSG_SCENERY_LOADED = 104; + + { This message is sent whenever the user adjusts the number of X-Plane } + { aircraft models. You must use XPLMCountPlanes to find out how many planes } + { are now available. This message will only be sent in XP7 and higher } + { because in XP6 the number of aircraft is not user-adjustable. } + XPLM_MSG_AIRPLANE_COUNT_CHANGED = 105; + +{$IFDEF XPLM200} + { This message is sent to your plugin whenever a plane is unloaded. The } + { parameter is the number of the plane being unloaded; 0 indicates the user's } + { plane. The parameter is of type int, passed as the value of the pointer. } + { (That is: the parameter is an int, not a pointer to an int.) } + XPLM_MSG_PLANE_UNLOADED = 106; +{$ENDIF} + +{$IFDEF XPLM210} + { This message is sent to your plugin right before X-Plane writes its } + { preferences file. You can use this for two purposes: to write your own } + { preferences, and to modify any datarefs to influence preferences output. } + { For example, if your plugin temporarily modifies saved preferences, you can } + { put them back to their default values here to avoid having the tweaks be } + { persisted if your plugin is not loaded on the next invocation of X-Plane. } + XPLM_MSG_WILL_WRITE_PREFS = 107; +{$ENDIF} + +{$IFDEF XPLM210} + { This message is sent to your plugin right after a livery is loaded for an } + { airplane. You can use this to check the new livery (via datarefs) and } + { react accordingly. The parameter is of type int, passed as the value of a } + { pointer and represents the aicraft plane number - 0 is the user's plane. } + XPLM_MSG_LIVERY_LOADED = 108; +{$ENDIF} + + { + XPLMSendMessageToPlugin + + This function sends a message to another plug-in or X-Plane. Pass + XPLM_NO_PLUGIN_ID to broadcast to all plug-ins. Only enabled plug-ins with + a message receive function receive the message. + } + PROCEDURE XPLMSendMessageToPlugin( + inPlugin : XPLMPluginID; + inMessage : integer; + inParam : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$IFDEF XPLM200} +{___________________________________________________________________________ + * Plugin Features API + ___________________________________________________________________________} +{ + The plugin features API allows your plugin to "sign up" for additional + capabilities and plugin system features that are normally disabled for + backward compatibility. This allows advanced plugins to "opt-in" to new + behavior. + + Each feature is defined by a permanent string name. The feature string + names will vary with the particular installation of X-Plane, so plugins + should not expect a feature to be guaranteed present. +} + + + + + { + XPLMFeatureEnumerator_f + + You pass an XPLMFeatureEnumerator_f to get a list of all features supported + by a given version running version of X-Plane. This routine is called once + for each feature. + } +TYPE + XPLMFeatureEnumerator_f = PROCEDURE( + inFeature : Pchar; + inRef : pointer); cdecl; + + { + XPLMHasFeature + + This returns 1 if the given installation of X-Plane supports a feature, or + 0 if it does not. + } + FUNCTION XPLMHasFeature( + inFeature : Pchar) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMIsFeatureEnabled + + This returns 1 if a feature is currently enabled for your plugin, or 0 if + it is not enabled. It is an error to call this routine with an unsupported + feature. + } + FUNCTION XPLMIsFeatureEnabled( + inFeature : Pchar) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMEnableFeature + + This routine enables or disables a feature for your plugin. This will + change the running behavior of X-Plane and your plugin in some way, + depending on the feature. + } + PROCEDURE XPLMEnableFeature( + inFeature : Pchar; + inEnable : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMEnumerateFeatures + + This routine calls your enumerator callback once for each feature that this + running version of X-Plane supports. Use this routine to determine all of + the features that X-Plane can support. + } + PROCEDURE XPLMEnumerateFeatures( + inEnumerator : XPLMFeatureEnumerator_f; + inRef : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$ENDIF} +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMProcessing.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMProcessing.pas new file mode 100755 index 0000000..79c7b2e --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMProcessing.pas @@ -0,0 +1,276 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMProcessing; +INTERFACE +{ + This API allows you to get regular callbacks during the flight loop, the + part of X-Plane where the plane's position calculates the physics of + flight, etc. Use these APIs to accomplish periodic tasks like logging data + and performing I/O. + + WARNING: Do NOT use these callbacks to draw! You cannot draw during flight + loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info) + for graphics. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * FLIGHT LOOP CALLBACKS + ___________________________________________________________________________} +{ + +} + + + +{$IFDEF XPLM210} + { + XPLMFlightLoopPhaseType + + You can register a flight loop callback to run either before or after the + flight model is integrated by X-Plane. + } +TYPE + XPLMFlightLoopPhaseType = ( + { Your callback runs before X-Plane integrates the flight model. } + xplm_FlightLoop_Phase_BeforeFlightModel = 0 + + { Your callback runs after X-Plane integrates the flight model. } + ,xplm_FlightLoop_Phase_AfterFlightModel = 1 + + ); + PXPLMFlightLoopPhaseType = ^XPLMFlightLoopPhaseType; +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMFlightLoopID + + This is an opaque identifier for a flight loop callback. You can use this + identifier to easily track and remove your callbacks, or to use the new + flight loop APIs. + } + XPLMFlightLoopID = pointer; + PXPLMFlightLoopID = ^XPLMFlightLoopID; +{$ENDIF} + + { + XPLMFlightLoop_f + + This is your flight loop callback. Each time the flight loop is iterated + through, you receive this call at the end. You receive a time since you + were last called and a time since the last loop, as well as a loop counter. + The 'phase' parameter is deprecated and should be ignored. + + Your return value controls when you will next be called. Return 0 to stop + receiving callbacks. Pass a positive number to specify how many seconds + until the next callback. (You will be called at or after this time, not + before.) Pass a negative number to specify how many loops must go by until + you are called. For example, -1.0 means call me the very next loop. Try + to run your flight loop as infrequently as is practical, and suspend it + (using return value 0) when you do not need it; lots of flight loop + callbacks that do nothing lowers x-plane's frame rate. + + Your callback will NOT be unregistered if you return 0; it will merely be + inactive. + + The reference constant you passed to your loop is passed back to you. + } + XPLMFlightLoop_f = FUNCTION( + inElapsedSinceLastCall: single; + inElapsedTimeSinceLastFlightLoop: single; + inCounter : integer; + inRefcon : pointer) : single; cdecl; + +{$IFDEF XPLM210} + { + XPLMCreateFlightLoop_t + + XPLMCreateFlightLoop_t contains the parameters to create a new flight loop + callback. The strsucture can be expanded in future SDKs - always set + structSize to the size of your structure in bytes. + } + XPLMCreateFlightLoop_t = RECORD + structSize : integer; + phase : XPLMFlightLoopPhaseType; + callbackFunc : XPLMFlightLoop_f; + refcon : pointer; + END; + PXPLMCreateFlightLoop_t = ^XPLMCreateFlightLoop_t; +{$ENDIF} + + { + XPLMGetElapsedTime + + This routine returns the elapsed time since the sim started up in decimal + seconds. + } + FUNCTION XPLMGetElapsedTime: single; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetCycleNumber + + This routine returns a counter starting at zero for each sim cycle + computed/video frame rendered. + } + FUNCTION XPLMGetCycleNumber: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMRegisterFlightLoopCallback + + This routine registers your flight loop callback. Pass in a pointer to a + flight loop function and a refcon. inInterval defines when you will be + called. Pass in a positive number to specify seconds from registration + time to the next callback. Pass in a negative number to indicate when you + will be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to + not be called; your callback will be inactive. + } + PROCEDURE XPLMRegisterFlightLoopCallback( + inFlightLoop : XPLMFlightLoop_f; + inInterval : single; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnregisterFlightLoopCallback + + This routine unregisters your flight loop callback. Do NOT call it from + your flight loop callback. Once your flight loop callback is + unregistered, it will not be called again. + } + PROCEDURE XPLMUnregisterFlightLoopCallback( + inFlightLoop : XPLMFlightLoop_f; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSetFlightLoopCallbackInterval + + This routine sets when a callback will be called. Do NOT call it from your + callback; use the return value of the callback to change your callback + interval from inside your callback. + + inInterval is formatted the same way as in XPLMRegisterFlightLoopCallback; + positive for seconds, negative for cycles, and 0 for deactivating the + callback. If inRelativeToNow is 1, times are from the time of this call; + otherwise they are from the time the callback was last called (or the time + it was registered if it has never been called. + } + PROCEDURE XPLMSetFlightLoopCallbackInterval( + inFlightLoop : XPLMFlightLoop_f; + inInterval : single; + inRelativeToNow : integer; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMCreateFlightLoop + + This routine creates a flight loop callback and returns its ID. The flight + loop callback is created using the input param struct, and is inited to be + unscheduled. + } + FUNCTION XPLMCreateFlightLoop( + inParams : PXPLMCreateFlightLoop_t) : XPLMFlightLoopID; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMDestroyFlightLoop + + This routine destroys a flight loop callback by ID. + } + PROCEDURE XPLMDestroyFlightLoop( + inFlightLoopID : XPLMFlightLoopID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMScheduleFlightLoop + + This routine schedules a flight loop callback for future execution. If + inInterval is negative, it is run in a certain number of frames based on + the absolute value of the input. If the interval is positive, it is a + duration in seconds. + + If inRelativeToNow is true, ties are interpretted relative to the time this + routine is called; otherwise they are relative to the last call time or the + time the flight loop was registered (if never called). + + THREAD SAFETY: it is legal to call this routine from any thread under the + following conditions: + + 1. The call must be between the beginning of an XPLMEnable and the end of + an XPLMDisable sequence. (That is, you must not call this routine from + thread activity when your plugin was supposed to be disabled. Since + plugins are only enabled while loaded, this also implies you cannot run + this routine outside an XPLMStart/XPLMStop sequence.) + + 2. You may not call this routine re-entrantly for a single flight loop ID. + (That is, you can't enable from multiple threads at the same time.) + + 3. You must call this routine between the time after XPLMCreateFlightLoop + returns a value and the time you call XPLMDestroyFlightLoop. (That is, you + must ensure that your threaded activity is within the life of the object. + The SDK does not check this for you, nor does it synchronize destruction of + the object.) + + 4. The object must be unscheduled if this routine is to be called from a + thread other than the main thread. + } + PROCEDURE XPLMScheduleFlightLoop( + inFlightLoopID : XPLMFlightLoopID; + inInterval : single; + inRelativeToNow : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMScenery.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMScenery.pas new file mode 100755 index 0000000..e0c51ac --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMScenery.pas @@ -0,0 +1,419 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMScenery; +INTERFACE +{ + This package contains APIs to interact with X-Plane's scenery system. +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{$IFDEF XPLM200} +{___________________________________________________________________________ + * Terrain Y-Testing + ___________________________________________________________________________} +{ + The Y-testing API allows you to locate the physical scenery mesh. This + would be used to place dynamic graphics on top of the ground in a + plausible way or do physics interactions. + + The Y-test API works via probe objects, which are allocated by your plugin + and used to query terrain. Probe objects exist both to capture which + algorithm you have requested (see probe types) and also to cache query + information. + + Performance guidelines: It is generally faster to use the same probe for + nearby points and different probes for different points. Try not to + allocate more than "hundreds" of probes at most. Share probes if you need + more. Generally, probing operations are expensive, and should be avoided + via caching when possible. + + Y testing returns a location on the terrain, a normal vectory, and a + velocity vector. The normal vector tells you the slope of the terrain at + that point. The velocity vector tells you if that terrain is moving (and + is in meters/second). For example, if your Y test hits the aircraft carrier + deck, this tells you the velocity of that point on the deck. + + Note: the Y-testing API is limited to probing the loaded scenery area, + which is approximately 300x300 km in X-Plane 9. Probes outside this area + will return the height of a 0 MSL sphere. +} + + + + + { + XPLMProbeType + + XPLMProbeType defines the type of terrain probe - each probe has a + different algorithm. (Only one type of probe is provided right now, but + future APIs will expose more flexible or poewrful or useful probes. + } +TYPE + XPLMProbeType = ( + { The Y probe gives you the location of the tallest physical scenery along } + { the Y axis going through the queried point. } + xplm_ProbeY = 0 + + ); + PXPLMProbeType = ^XPLMProbeType; + + { + XPLMProbeResult + + Probe results - possible results from a probe query. + } + XPLMProbeResult = ( + { The probe hit terrain and returned valid values. } + xplm_ProbeHitTerrain = 0 + + { An error in the API call. Either the probe struct size is bad, or the } + { probe is invalid or the type is mismatched for the specific query call. } + ,xplm_ProbeError = 1 + + { The probe call succeeded but there is no terrain under this point (perhaps } + { it is off the side of the planet?) } + ,xplm_ProbeMissed = 2 + + ); + PXPLMProbeResult = ^XPLMProbeResult; + + { + XPLMProbeRef + + An XPLMProbeRef is an opaque handle to a probe, used for querying the + terrain. + } + XPLMProbeRef = pointer; + PXPLMProbeRef = ^XPLMProbeRef; + + { + XPLMProbeInfo_t + + XPLMProbeInfo_t contains the results of a probe call. Make sure to set + structSize to the size of the struct before using it. + } + XPLMProbeInfo_t = RECORD + { Size of structure in bytes - always set this before calling the XPLM. } + structSize : integer; + { Resulting X location of the terrain point we hit, in local OpenGL } + { coordinates. } + locationX : single; + { Resulting Y location of the terrain point we hit, in local OpenGL } + { coordinates. } + locationY : single; + { Resulting Z location of the terrain point we hit, in local OpenGL } + { coordinates. } + locationZ : single; + { X component of the normal vector to the terrain we found. } + normalX : single; + { Y component of the normal vector to the terrain we found. } + normalY : single; + { Z component of the normal vector to the terrain we found. } + normalZ : single; + { X component of the velocity vector of the terrain we found. } + velocityX : single; + { Y component of the velocity vector of the terrain we found. } + velocityY : single; + { Z component of the velocity vector of the terrain we found. } + velocityZ : single; + { Tells if the surface we hit is water (otherwise it is land). } + is_wet : integer; + END; + PXPLMProbeInfo_t = ^XPLMProbeInfo_t; + + { + XPLMCreateProbe + + Creates a new probe object of a given type and returns. + } + FUNCTION XPLMCreateProbe( + inProbeType : XPLMProbeType) : XPLMProbeRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDestroyProbe + + Deallocates an existing probe object. + } + PROCEDURE XPLMDestroyProbe( + inProbe : XPLMProbeRef); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMProbeTerrainXYZ + + Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe + object, and an XPLMProbeInfo_t struct that has its structSize member set + properly. Other fields are filled in if we hit terrain, and a probe result + is returned. + } + FUNCTION XPLMProbeTerrainXYZ( + inProbe : XPLMProbeRef; + inX : single; + inY : single; + inZ : single; + outInfo : PXPLMProbeInfo_t) : XPLMProbeResult; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$ENDIF} +{___________________________________________________________________________ + * Object Drawing + ___________________________________________________________________________} +{ + The object drawing routines let you load and draw X-Plane OBJ files. + Objects are loaded by file path and managed via an opaque handle. X-Plane + naturally reference counts objects, so it is important that you balance + every successful call to XPLMLoadObject with a call to XPLMUnloadObject! +} + + + +{$IFDEF XPLM200} +TYPE + { + XPLMObjectRef + + An XPLMObjectRef is a opaque handle to an .obj file that has been loaded + into memory. + } + XPLMObjectRef = pointer; + PXPLMObjectRef = ^XPLMObjectRef; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMDrawInfo_t + + The XPLMDrawInfo_t structure contains positioning info for one object that + is to be drawn. Be sure to set structSize to the size of the structure for + future expansion. + } + XPLMDrawInfo_t = RECORD + { Set this to the size of this structure! } + structSize : integer; + { X location of the object in local coordinates. } + x : single; + { Y location of the object in local coordinates. } + y : single; + { Z location of the object in local coordinates. } + z : single; + { Pitch in degres to rotate the object, positive is up. } + pitch : single; + { Heading in local coordinates to rotate the object, clockwise. } + heading : single; + { Roll to rotate the object. } + roll : single; + END; + PXPLMDrawInfo_t = ^XPLMDrawInfo_t; +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMObjectLoaded_f + + You provide this callback when loading an object asynchronously; it will be + called once the object is loaded. Your refcon is passed back. The object + ref passed in is the newly loaded object (ready for use) or NULL if an + error occured. + + If your plugin is disabled, this callback will be delivered as soon as the + plugin is re-enabled. If your plugin is unloaded before this callback is + ever called, the SDK will release the object handle for you. + } + XPLMObjectLoaded_f = PROCEDURE( + inObject : XPLMObjectRef; + inRefcon : pointer); cdecl; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMLoadObject + + This routine loads an OBJ file and returns a handle to it. If X-plane has + already loaded the object, the handle to the existing object is returned. + Do not assume you will get the same handle back twice, but do make sure to + call unload once for every load to avoid "leaking" objects. The object + will be purged from memory when no plugins and no scenery are using it. + + The path for the object must be relative to the X-System base folder. If + the path is in the root of the X-System folder you may need to prepend ./ + to it; loading objects in the root of the X-System folder is STRONGLY + discouraged - your plugin should not dump art resources in the root folder! + + + XPLMLoadObject will return NULL if the object cannot be loaded (either + because it is not found or the file is misformatted). This routine will + load any object that can be used in the X-Plane scenery system. + + It is important that the datarefs an object uses for animation already be + loaded before you load the object. For this reason it may be necessary to + defer object loading until the sim has fully started. + } + FUNCTION XPLMLoadObject( + inPath : Pchar) : XPLMObjectRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM210} + { + XPLMLoadObjectAsync + + This routine loads an object asynchronously; control is returned to you + immediately while X-Plane loads the object. The sim will not stop flying + while the object loads. For large objects, it may be several seconds + before the load finishes. + + You provide a callback function that is called once the load has completed. + Note that if the object cannot be loaded, you will not find out until the + callback function is called with a NULL object handle. + + There is no way to cancel an asynchronous object load; you must wait for + the load to complete and then release the object if it is no longer + desired. + } + PROCEDURE XPLMLoadObjectAsync( + inPath : Pchar; + inCallback : XPLMObjectLoaded_f; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMDrawObjects + + XPLMDrawObjects draws an object from an OBJ file one or more times. You + pass in the object and an array of XPLMDrawInfo_t structs, one for each + place you would like the object to be drawn. + + X-Plane will attempt to cull the objects based on LOD and visibility, and + will pick the appropriate LOD. + + Lighting is a boolean; pass 1 to show the night version of object with + night-only lights lit up. Pass 0 to show the daytime version of the + object. + + earth_relative controls the coordinate system. If this is 1, the rotations + you specify are applied to the object after its coordinate system is + transformed from local to earth-relative coordinates -- that is, an object + with no rotations will point toward true north and the Y axis will be up + against gravity. If this is 0, the object is drawn with your rotations + from local coordanates -- that is, an object with no rotations is drawn + pointing down the -Z axis and the Y axis of the object matches the local + coordinate Y axis. + } + PROCEDURE XPLMDrawObjects( + inObject : XPLMObjectRef; + inCount : integer; + inLocations : PXPLMDrawInfo_t; + lighting : integer; + earth_relative : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMUnloadObject + + This routine marks an object as no longer being used by your plugin. + Objects are reference counted: once no plugins are using an object, it is + purged from memory. Make sure to call XPLMUnloadObject once for each + successful call to XPLMLoadObject. + } + PROCEDURE XPLMUnloadObject( + inObject : XPLMObjectRef); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} +{___________________________________________________________________________ + * Library Access + ___________________________________________________________________________} +{ + The library access routines allow you to locate scenery objects via the + X-Plane library system. Right now library access is only provided for + objects, allowing plugin-drawn objects to be extended using the library + system. +} + + + + + { + XPLMLibraryEnumerator_f + + An XPLMLibraryEnumerator_f is a callback you provide that is called once + for each library element that is located. The returned paths will be + relative to the X-System folder. + } +TYPE + XPLMLibraryEnumerator_f = PROCEDURE( + inFilePath : Pchar; + inRef : pointer); cdecl; + + { + XPLMLookupObjects + + This routine looks up a virtual path in the library system and returns all + matching elements. You provide a callback - one virtual path may match + many objects in the library. XPLMLookupObjects returns the number of + objects found. + + The latitude and longitude parameters specify the location the object will + be used. The library system allows for scenery packages to only provide + objects to certain local locations. Only objects that are allowed at the + latitude/longitude you provide will be returned. + } + FUNCTION XPLMLookupObjects( + inPath : Pchar; + inLatitude : single; + inLongitude : single; + enumerator : XPLMLibraryEnumerator_f; + ref : pointer) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$ENDIF} +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Delphi/XPLM/XPLMUtilities.pas b/xpcPlugin/SDK/Delphi/XPLM/XPLMUtilities.pas new file mode 100755 index 0000000..0595d1c --- /dev/null +++ b/xpcPlugin/SDK/Delphi/XPLM/XPLMUtilities.pas @@ -0,0 +1,927 @@ +{ + Copyright 2005-2012 Sandy Barbour and Ben Supnik + + All rights reserved. See license.txt for usage. + + X-Plane SDK Version: 2.1.1 +} + +UNIT XPLMUtilities; +INTERFACE +{ + +} + +USES XPLMDefs; + {$A4} +{$IFDEF MSWINDOWS} + {$DEFINE DELPHI} +{$ENDIF} +{___________________________________________________________________________ + * X-PLANE USER INTERACTION + ___________________________________________________________________________} +{ + The user interaction APIs let you simulate commands the user can do with a + joystick, keyboard etc. Note that it is generally safer for future + compatibility to use one of these commands than to manipulate the + underlying sim data. +} + + + + { + XPLMCommandKeyID + + These enums represent all the keystrokes available within x-plane. They + can be sent to x-plane directly. For example, you can reverse thrust using + these enumerations. + } +TYPE + XPLMCommandKeyID = ( + xplm_key_pause=0, + xplm_key_revthrust, + xplm_key_jettison, + xplm_key_brakesreg, + xplm_key_brakesmax, + xplm_key_gear, + xplm_key_timedn, + xplm_key_timeup, + xplm_key_fadec, + xplm_key_otto_dis, + xplm_key_otto_atr, + xplm_key_otto_asi, + xplm_key_otto_hdg, + xplm_key_otto_gps, + xplm_key_otto_lev, + xplm_key_otto_hnav, + xplm_key_otto_alt, + xplm_key_otto_vvi, + xplm_key_otto_vnav, + xplm_key_otto_nav1, + xplm_key_otto_nav2, + xplm_key_targ_dn, + xplm_key_targ_up, + xplm_key_hdgdn, + xplm_key_hdgup, + xplm_key_barodn, + xplm_key_baroup, + xplm_key_obs1dn, + xplm_key_obs1up, + xplm_key_obs2dn, + xplm_key_obs2up, + xplm_key_com1_1, + xplm_key_com1_2, + xplm_key_com1_3, + xplm_key_com1_4, + xplm_key_nav1_1, + xplm_key_nav1_2, + xplm_key_nav1_3, + xplm_key_nav1_4, + xplm_key_com2_1, + xplm_key_com2_2, + xplm_key_com2_3, + xplm_key_com2_4, + xplm_key_nav2_1, + xplm_key_nav2_2, + xplm_key_nav2_3, + xplm_key_nav2_4, + xplm_key_adf_1, + xplm_key_adf_2, + xplm_key_adf_3, + xplm_key_adf_4, + xplm_key_adf_5, + xplm_key_adf_6, + xplm_key_transpon_1, + xplm_key_transpon_2, + xplm_key_transpon_3, + xplm_key_transpon_4, + xplm_key_transpon_5, + xplm_key_transpon_6, + xplm_key_transpon_7, + xplm_key_transpon_8, + xplm_key_flapsup, + xplm_key_flapsdn, + xplm_key_cheatoff, + xplm_key_cheaton, + xplm_key_sbrkoff, + xplm_key_sbrkon, + xplm_key_ailtrimL, + xplm_key_ailtrimR, + xplm_key_rudtrimL, + xplm_key_rudtrimR, + xplm_key_elvtrimD, + xplm_key_elvtrimU, + xplm_key_forward, + xplm_key_down, + xplm_key_left, + xplm_key_right, + xplm_key_back, + xplm_key_tower, + xplm_key_runway, + xplm_key_chase, + xplm_key_free1, + xplm_key_free2, + xplm_key_spot, + xplm_key_fullscrn1, + xplm_key_fullscrn2, + xplm_key_tanspan, + xplm_key_smoke, + xplm_key_map, + xplm_key_zoomin, + xplm_key_zoomout, + xplm_key_cycledump, + xplm_key_replay, + xplm_key_tranID, + xplm_key_max + ); + PXPLMCommandKeyID = ^XPLMCommandKeyID; + + { + XPLMCommandButtonID + + These are enumerations for all of the things you can do with a joystick + button in X-Plane. They currently match the buttons menu in the equipment + setup dialog, but these enums will be stable even if they change in + X-Plane. + } + XPLMCommandButtonID = ( + xplm_joy_nothing=0, + xplm_joy_start_all, + xplm_joy_start_0, + xplm_joy_start_1, + xplm_joy_start_2, + xplm_joy_start_3, + xplm_joy_start_4, + xplm_joy_start_5, + xplm_joy_start_6, + xplm_joy_start_7, + xplm_joy_throt_up, + xplm_joy_throt_dn, + xplm_joy_prop_up, + xplm_joy_prop_dn, + xplm_joy_mixt_up, + xplm_joy_mixt_dn, + xplm_joy_carb_tog, + xplm_joy_carb_on, + xplm_joy_carb_off, + xplm_joy_trev, + xplm_joy_trm_up, + xplm_joy_trm_dn, + xplm_joy_rot_trm_up, + xplm_joy_rot_trm_dn, + xplm_joy_rud_lft, + xplm_joy_rud_cntr, + xplm_joy_rud_rgt, + xplm_joy_ail_lft, + xplm_joy_ail_cntr, + xplm_joy_ail_rgt, + xplm_joy_B_rud_lft, + xplm_joy_B_rud_rgt, + xplm_joy_look_up, + xplm_joy_look_dn, + xplm_joy_look_lft, + xplm_joy_look_rgt, + xplm_joy_glance_l, + xplm_joy_glance_r, + xplm_joy_v_fnh, + xplm_joy_v_fwh, + xplm_joy_v_tra, + xplm_joy_v_twr, + xplm_joy_v_run, + xplm_joy_v_cha, + xplm_joy_v_fr1, + xplm_joy_v_fr2, + xplm_joy_v_spo, + xplm_joy_flapsup, + xplm_joy_flapsdn, + xplm_joy_vctswpfwd, + xplm_joy_vctswpaft, + xplm_joy_gear_tog, + xplm_joy_gear_up, + xplm_joy_gear_down, + xplm_joy_lft_brake, + xplm_joy_rgt_brake, + xplm_joy_brakesREG, + xplm_joy_brakesMAX, + xplm_joy_speedbrake, + xplm_joy_ott_dis, + xplm_joy_ott_atr, + xplm_joy_ott_asi, + xplm_joy_ott_hdg, + xplm_joy_ott_alt, + xplm_joy_ott_vvi, + xplm_joy_tim_start, + xplm_joy_tim_reset, + xplm_joy_ecam_up, + xplm_joy_ecam_dn, + xplm_joy_fadec, + xplm_joy_yaw_damp, + xplm_joy_art_stab, + xplm_joy_chute, + xplm_joy_JATO, + xplm_joy_arrest, + xplm_joy_jettison, + xplm_joy_fuel_dump, + xplm_joy_puffsmoke, + xplm_joy_prerotate, + xplm_joy_UL_prerot, + xplm_joy_UL_collec, + xplm_joy_TOGA, + xplm_joy_shutdown, + xplm_joy_con_atc, + xplm_joy_fail_now, + xplm_joy_pause, + xplm_joy_rock_up, + xplm_joy_rock_dn, + xplm_joy_rock_lft, + xplm_joy_rock_rgt, + xplm_joy_rock_for, + xplm_joy_rock_aft, + xplm_joy_idle_hilo, + xplm_joy_lanlights, + xplm_joy_max + ); + PXPLMCommandButtonID = ^XPLMCommandButtonID; + + { + XPLMHostApplicationID + + The plug-in system is based on Austin's cross-platform OpenGL framework and + could theoretically be adapted to run in other apps like WorldMaker. The + plug-in system also runs against a test harness for internal development + and could be adapted to another flight sim (in theory at least). So an ID + is providing allowing plug-ins to indentify what app they are running + under. + } + XPLMHostApplicationID = ( + xplm_Host_Unknown = 0 + + ,xplm_Host_XPlane = 1 + + ,xplm_Host_PlaneMaker = 2 + + ,xplm_Host_WorldMaker = 3 + + ,xplm_Host_Briefer = 4 + + ,xplm_Host_PartMaker = 5 + + ,xplm_Host_YoungsMod = 6 + + ,xplm_Host_XAuto = 7 + + ); + PXPLMHostApplicationID = ^XPLMHostApplicationID; + + { + XPLMLanguageCode + + These enums define what language the sim is running in. These enumerations + do not imply that the sim can or does run in all of these languages; they + simply provide a known encoding in the event that a given sim version is + localized to a certain language. + } + XPLMLanguageCode = ( + xplm_Language_Unknown = 0 + + ,xplm_Language_English = 1 + + ,xplm_Language_French = 2 + + ,xplm_Language_German = 3 + + ,xplm_Language_Italian = 4 + + ,xplm_Language_Spanish = 5 + + ,xplm_Language_Korean = 6 + +{$IFDEF XPLM200} + ,xplm_Language_Russian = 7 +{$ENDIF} + +{$IFDEF XPLM200} + ,xplm_Language_Greek = 8 +{$ENDIF} + +{$IFDEF XPLM200} + ,xplm_Language_Japanese = 9 +{$ENDIF} + +{$IFDEF XPLM200} + ,xplm_Language_Chinese = 10 +{$ENDIF} + + ); + PXPLMLanguageCode = ^XPLMLanguageCode; + +{$IFDEF XPLM200} + { + XPLMDataFileType + + These enums define types of data files you can load or unload using the + SDK. + } + XPLMDataFileType = ( + { A situation (.sit) file, which starts off a flight in a given } + { configuration. } + xplm_DataFile_Situation = 1 + + { A situation movie (.smo) file, which replays a past flight. } + ,xplm_DataFile_ReplayMovie = 2 + + ); + PXPLMDataFileType = ^XPLMDataFileType; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMError_f + + An XPLM error callback is a function that you provide to receive debugging + information from the plugin SDK. See XPLMSetErrorCallback for more + information. NOTE: for the sake of debugging, your error callback will be + called even if your plugin is not enabled, allowing you to receive debug + info in your XPluginStart and XPluginStop callbacks. To avoid causing + logic errors in the management code, do not call any other plugin routines + from your error callback - it is only meant for logging! + } + XPLMError_f = PROCEDURE( + inMessage : Pchar); cdecl; +{$ENDIF} + + { + XPLMSimulateKeyPress + + This function simulates a key being pressed for x-plane. The keystroke + goes directly to x-plane; it is never sent to any plug-ins. However, since + this is a raw key stroke it may be mapped by the keys file or enter text + into a field. + + WARNING: This function will be deprecated; do not use it. Instead use + XPLMCommandKeyStroke. + } + PROCEDURE XPLMSimulateKeyPress( + inKeyType : integer; + inKey : integer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMSpeakString + + This function displays the string in a translucent overlay over the current + display and also speaks the string if text-to-speech is enabled. The + string is spoken asynchronously, this function returns immediately. + } + PROCEDURE XPLMSpeakString( + inString : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCommandKeyStroke + + This routine simulates a command-key stroke. However, the keys are done by + function, not by actual letter, so this function works even if the user has + remapped their keyboard. Examples of things you might do with this include + pausing the simulator. + } + PROCEDURE XPLMCommandKeyStroke( + inKey : XPLMCommandKeyID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCommandButtonPress + + This function simulates any of the actions that might be taken by pressing + a joystick button. However, this lets you call the command directly rather + than have to know which button is mapped where. Important: you must + release each button you press. The APIs are separate so that you can 'hold + down' a button for a fixed amount of time. + } + PROCEDURE XPLMCommandButtonPress( + inButton : XPLMCommandButtonID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCommandButtonRelease + + This function simulates any of the actions that might be taken by pressing + a joystick button. See XPLMCommandButtonPress + } + PROCEDURE XPLMCommandButtonRelease( + inButton : XPLMCommandButtonID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetVirtualKeyDescription + + Given a virtual key code (as defined in XPLMDefs.h) this routine returns a + human-readable string describing the character. This routine is provided + for showing users what keyboard mappings they have set up. The string may + read 'unknown' or be a blank or NULL string if the virtual key is unknown. + } + FUNCTION XPLMGetVirtualKeyDescription( + inVirtualKey : char) : Pchar; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{___________________________________________________________________________ + * X-PLANE MISC + ___________________________________________________________________________} +{ + +} + + + + { + XPLMReloadScenery + + XPLMReloadScenery reloads the current set of scenery. You can use this + function in two typical ways: simply call it to reload the scenery, picking + up any new installed scenery, .env files, etc. from disk. Or, change the + lat/ref and lon/ref data refs and then call this function to shift the + scenery environment. + } + PROCEDURE XPLMReloadScenery; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetSystemPath + + This function returns the full path to the X-System folder. Note that this + is a directory path, so it ends in a trailing : or /. The buffer you pass + should be at least 512 characters long. + } + PROCEDURE XPLMGetSystemPath( + outSystemPath : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetPrefsPath + + This routine returns a full path to the proper directory to store + preferences in. It ends in a : or /. The buffer you pass should be at + least 512 characters long. + } + PROCEDURE XPLMGetPrefsPath( + outPrefsPath : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDirectorySeparator + + This routine returns a string with one char and a null terminator that is + the directory separator for the current platform. This allows you to write + code that concatinates directory paths without having to #ifdef for + platform. + } + FUNCTION XPLMGetDirectorySeparator: Pchar; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMExtractFileAndPath + + Given a full path to a file, this routine separates the path from the file. + If the path is a partial directory (e.g. ends in : or \) the trailing + directory separator is removed. This routine works in-place; a pointer to + the file part of the buffer is returned; the original buffer still starts + with the path. + } + FUNCTION XPLMExtractFileAndPath( + inFullPath : Pchar) : Pchar; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetDirectoryContents + + This routine returns a list of files in a directory (specified by a full + path, no trailing : or \). The output is returned as a list of NULL + terminated strings. An index array (if specified) is filled with pointers + into the strings. This routine The last file is indicated by a zero-length + string (and NULL in the indices). This routine will return 1 if you had + capacity for all files or 0 if you did not. You can also skip a given + number of files. + + inDirectoryPath - a null terminated C string containing the full path to + the directory with no trailing directory char. + + inFirstReturn - the zero-based index of the first file in the directory to + return. (Usually zero to fetch all in one pass.) + + outFileNames - a buffer to receive a series of sequential null terminated + C-string file names. A zero-length C string will be appended to the very + end. + + inFileNameBufSize - the size of the file name buffer in bytes. + + outIndices - a pointer to an array of character pointers that will become + an index into the directory. The last file will be followed by a NULL + value. Pass NULL if you do not want indexing information. + + inIndexCount - the max size of the index in entries. + + outTotalFiles - if not NULL, this is filled in with the number of files in + the directory. + + outReturnedFiles - if not NULL, the number of files returned by this + iteration. + + Return value - 1 if all info could be returned, 0 if there was a buffer + overrun. + + WARNING: Before X-Plane 7 this routine did not properly iterate through + directories. If X-Plane 6 compatibility is needed, use your own code to + iterate directories. + } + FUNCTION XPLMGetDirectoryContents( + inDirectoryPath : Pchar; + inFirstReturn : integer; + outFileNames : Pchar; + inFileNameBufSize : integer; + outIndices : PPchar; { Can be nil } + inIndexCount : integer; + outTotalFiles : Pinteger; { Can be nil } + outReturnedFiles : Pinteger) : integer; { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMInitialized + + This function returns 1 if X-Plane has properly initialized the plug-in + system. If this routine returns 0, many XPLM functions will not work. + + NOTE: Under normal circumstances a plug-in should never be running while + the plug-in manager is not initialized. + + WARNING: This function is generally not needed and may be deprecated in the + future. + } + FUNCTION XPLMInitialized: integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetVersions + + This routine returns the revision of both X-Plane and the XPLM DLL. All + versions are three-digit decimal numbers (e.g. 606 for version 6.06 of + X-Plane); the current revision of the XPLM is 200 (2.00). This routine + also returns the host ID of the app running us. + + The most common use of this routine is to special-case around x-plane + version-specific behavior. + } + PROCEDURE XPLMGetVersions( + outXPlaneVersion : Pinteger; + outXPLMVersion : Pinteger; + outHostID : PXPLMHostApplicationID); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMGetLanguage + + This routine returns the langauge the sim is running in. + } + FUNCTION XPLMGetLanguage: XPLMLanguageCode; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMDebugString + + This routine outputs a C-style string to the Log.txt file. The file is + immediately flushed so you will not lose data. (This does cause a + performance penalty.) + } + PROCEDURE XPLMDebugString( + inString : Pchar); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMSetErrorCallback + + XPLMSetErrorCallback installs an error-reporting callback for your plugin. + Normally the plugin system performs minimum diagnostics to maximize + performance. When you install an error callback, you will receive calls + due to certain plugin errors, such as passing bad parameters or incorrect + data. + + The intention is for you to install the error callback during debug + sections and put a break-point inside your callback. This will cause you + to break into the debugger from within the SDK at the point in your plugin + where you made an illegal call. + + Installing an error callback may activate error checking code that would + not normally run, and this may adversely affect performance, so do not + leave error callbacks installed in shipping plugins. + } + PROCEDURE XPLMSetErrorCallback( + inCallback : XPLMError_f); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMFindSymbol + + This routine will attempt to find the symbol passed in the inString + parameter. If the symbol is found a pointer the function is returned, + othewise the function will return NULL. + } + FUNCTION XPLMFindSymbol( + inString : Pchar) : pointer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMLoadDataFile + + Loads a data file of a given type. Paths must be relative to the X-System + folder. To clear the replay, pass a NULL file name (this is only valid with + replay movies, not sit files). + } + FUNCTION XPLMLoadDataFile( + inFileType : XPLMDataFileType; + inFilePath : Pchar) : integer; { Can be nil } +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} + { + XPLMSaveDataFile + + Saves the current situation or replay; paths are relative to the X-System + folder. + } + FUNCTION XPLMSaveDataFile( + inFileType : XPLMDataFileType; + inFilePath : Pchar) : integer; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} +{$ENDIF} + +{$IFDEF XPLM200} +{___________________________________________________________________________ + * X-PLANE COMMAND MANAGEMENT + ___________________________________________________________________________} +{ + The command management APIs let plugins interact with the command-system in + X-Plane, the abstraction behind keyboard presses and joystick buttons. + This API lets you create new commands and modify the behavior (or get + notification) of existing ones. + + An X-Plane command consists of three phases: a beginning, continuous + repetition, and an ending. The command may be repeated zero times in the + event that the user presses a button only momentarily. +} + + + + + { + XPLMCommandPhase + + The phases of a command. + } +TYPE + XPLMCommandPhase = ( + { The command is being started. } + xplm_CommandBegin = 0 + + { The command is continuing to execute. } + ,xplm_CommandContinue = 1 + + { The command has ended. } + ,xplm_CommandEnd = 2 + + ); + PXPLMCommandPhase = ^XPLMCommandPhase; + + { + XPLMCommandRef + + A command ref is an opaque identifier for an X-Plane command. Command + references stay the same for the life of your plugin but not between + executions of X-Plane. Command refs are used to execute commands, create + commands, and create callbacks for particular commands. + + Note that a command is not "owned" by a particular plugin. Since many + plugins may participate in a command's execution, the command does not go + away if the plugin that created it is unloaded. + } + XPLMCommandRef = pointer; + PXPLMCommandRef = ^XPLMCommandRef; + + { + XPLMCommandCallback_f + + A command callback is a function in your plugin that is called when a + command is pressed. Your callback receives the commadn reference for the + particular command, the phase of the command that is executing, and a + reference pointer that you specify when registering the callback. + + Your command handler should return 1 to let processing of the command + continue to other plugins and X-Plane, or 0 to halt processing, + potentially bypassing X-Plane code. + } + XPLMCommandCallback_f = FUNCTION( + inCommand : XPLMCommandRef; + inPhase : XPLMCommandPhase; + inRefcon : pointer) : integer; cdecl; + + { + XPLMFindCommand + + XPLMFindCommand looks up a command by name, and returns its command + reference or NULL if the command does not exist. + } + FUNCTION XPLMFindCommand( + inName : Pchar) : XPLMCommandRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCommandBegin + + XPLMCommandBegin starts the execution of a command, specified by its + command reference. The command is "held down" until XPLMCommandEnd is + called. + } + PROCEDURE XPLMCommandBegin( + inCommand : XPLMCommandRef); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCommandEnd + + XPLMCommandEnd ends the execution of a given command that was started with + XPLMCommandBegin. + } + PROCEDURE XPLMCommandEnd( + inCommand : XPLMCommandRef); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCommandOnce + + This executes a given command momentarily, that is, the command begins and + ends immediately. + } + PROCEDURE XPLMCommandOnce( + inCommand : XPLMCommandRef); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMCreateCommand + + XPLMCreateCommand creates a new command for a given string. If the command + already exists, the existing command reference is returned. The + description may appear in user interface contexts, such as the joystick + configuration screen. + } + FUNCTION XPLMCreateCommand( + inName : Pchar; + inDescription : Pchar) : XPLMCommandRef; +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMRegisterCommandHandler + + XPLMRegisterCommandHandler registers a callback to be called when a command + is executed. You provide a callback with a reference pointer. + + If inBefore is true, your command handler callback will be executed before + X-Plane executes the command, and returning 0 from your callback will + disable X-Plane's processing of the command. If inBefore is false, your + callback will run after X-Plane. (You can register a single callback both + before and after a command.) + } + PROCEDURE XPLMRegisterCommandHandler( + inComand : XPLMCommandRef; + inHandler : XPLMCommandCallback_f; + inBefore : integer; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + + { + XPLMUnregisterCommandHandler + + XPLMUnregisterCommandHandler removes a command callback registered with + XPLMRegisterCommandHandler. + } + PROCEDURE XPLMUnregisterCommandHandler( + inComand : XPLMCommandRef; + inHandler : XPLMCommandCallback_f; + inBefore : integer; + inRefcon : pointer); +{$IFDEF DELPHI} + cdecl; external 'XPLM.DLL'; +{$ELSE} + cdecl; external ''; +{$ENDIF} + +{$ENDIF} +IMPLEMENTATION +END. diff --git a/xpcPlugin/SDK/Libraries/Mac/XPLM.framework/XPLM b/xpcPlugin/SDK/Libraries/Mac/XPLM.framework/XPLM new file mode 100755 index 0000000000000000000000000000000000000000..c03cf48cfdd294b169567f086fbd4ca180a0f1c8 GIT binary patch literal 650652 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

Y1?-`;RfmXH(_$3 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
l=tw))A4NMlP8@r2z<;Bhc61y6 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 GjsFjNt8Y#K literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/Libraries/Mac/XPWidgets.framework/XPWidgets b/xpcPlugin/SDK/Libraries/Mac/XPWidgets.framework/XPWidgets new file mode 100755 index 0000000000000000000000000000000000000000..aba93db6a058120fe014641b395c679aa30a8827 GIT binary patch literal 210904 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�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�V403WGmiRHX5ue;jwMztd;Q);o%y(dtXYE50 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 literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/Libraries/Win/XPLM.lib b/xpcPlugin/SDK/Libraries/Win/XPLM.lib new file mode 100755 index 0000000000000000000000000000000000000000..c7b00b10f0a9d20583e0f4c37081aa2545a04fa4 GIT binary patch literal 39362 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 a^q-$?)%vcS!TLX+gf&nA literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/Libraries/Win/XPLM_64.lib b/xpcPlugin/SDK/Libraries/Win/XPLM_64.lib new file mode 100755 index 0000000000000000000000000000000000000000..51fdf7011bde4bbc015cdef5159af7166eb6417f GIT binary patch literal 39060 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 E0YsuO1^@s6 literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/Libraries/Win/XPWidgets.lib b/xpcPlugin/SDK/Libraries/Win/XPWidgets.lib new file mode 100755 index 0000000000000000000000000000000000000000..1eac5bf707a8ee4a8adc9b8d671f9d24b338df27 GIT binary patch literal 10524 zcmcgxOKcQJ5G~u`XABsy@!wwm4I~a2ulXcO3^oP}+lFJ*Co}OWsH5sWqJ5|;F`cqY1UGDxd z<78KUs{KA8KZlPT8A~RQjvhZE^AGu-BO}Mg=+CRQ0B`|d&k{hxeSpSS0Nwj2wcQ0E z)c&4QM*)CP>r+ZCuK@_PPEkrc1|Zb&hEnef07A`sD7DvNKZI^m8mI>#)P0Xq&l&)s zwoXb-4*&>tf27p)41iGo5T&k3{6^|bQA!LWK2qN}rJlFgA5!lnN}V_sLQMmd`X6FH zNPRdTLd|z5wXER0keWYG8n}t$L>f9lY49Zgp`j;~2Hv3@Y48f6g@x%^^D0v!K}jXOc66?7`{(#BaUXQ~<^FKtX0sr-^vv=;Mb&{0T` zHm1}sYeZ?o$Y-*?*$@x2gh^{e!st(5Uqh%|u;vVgZ%0TY zZJf;ct~8O!=NB=E1*@eI3A-392!r9f7>ERYamhn1L?L>)V`f})V!i0vtE&I#WEjuP zqU+c7_Z-%$d1hCqe?$#lwcgWoB7|a!5k7oy;8|1y{#oVeHpbm9zBh_Q>aSz+A^Z0F}cR=xahNonHrZBM`RsI?kF-fi9B;nrl#hI zjE_bd?WTf~>a2oDPKyOWl;f%@{Bk1*=#mId9FmEy91?~cI;0`Fbx0bRcSsbtct|8T zx+IHmccvrW2pBJvZmR+w0GL3NN-~iqYh)sANC<>#GAl^v4(WD*$Aj=Ha#45{#hVj@ zQNsr3hccW%qRVrnK*Ck!aKhP2P`MRdf8dhgTt1Hp)aR;8$wPy7zr%y$5)5Rd5*{x~F_SL3?@vmo;9kR~+gseqeKT8z;%)VhwyvIAO9h}1N`8BkykZfWegMQFFHJNxk8#A3dZC6uzecqhOWk0=6`y>7?E zb)%m44+7Aw)~{QPrzP1^5rZV2CO(3vjWRyb`XR1gH>-A>1RexKNK%i_77-OY*1rx7xc<1skBXTntSo$i#^Wx@OO>x6Hp9E6= zT$BEdI-$(959eCrV}_GS8C3czWu6i1i`Qxl+1~n!xw{g!%SK}dpfW>ZsGBI7ocu}v z<*(@IalOToV6)lB6E3-xq8-(vVL1a2JZ~*Y4o}ndO0kaVv9OeaNF2+*2gqR3S1C5a zf~m4=3B=k)v6TCTgdp2Y33y`>appV3Bb6GwKE~Z!Wbm>hPMqg&=jh6Xs8US+|42Eq zcH@leIHq*dst|E30+H16c5uXqD_n)x$p~yR+nq8tyBk)D7!z4{aYXgfDT7L1C0KDX zA{t2Q!KR}BLkLiK`{}qMMh+Wo=OoT&Qy}Sw^GD#1?ekdwo%M* zX{u7pn5f%MF?BVsN>L*`g_IdO7^+fClOd(A5_~i6bm`=X8-2ROMcXa~_5X;r2?cYb zqHSFC>Gm;$e{e{9S9YZ1B_2(7-9xdII%tJ>F}B+4{s%vmUO4~& literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/Libraries/Win/XPWidgets_64.lib b/xpcPlugin/SDK/Libraries/Win/XPWidgets_64.lib new file mode 100755 index 0000000000000000000000000000000000000000..32c3ae4991a082681f66f655479e97b574cb4932 GIT binary patch literal 10564 zcmcgxOLH7W5>Crcv<8G9dRrR3h4IQr)`)e)hF7*^fv_ZZ$TFV8hUL+8TbkI>v|^^U zU?03UPWuBK#B$@raf1T~g5W@KCicL=#|>hS`~VKHUv+g=*Q2}TW+XZy)#}Ww`s$IH zm6bE}=W?U6bEExgL4T&NU7ITw-;r(oLb9vRdyS}lx zc>CVM`m(cecYU+uJgBKE_#p4`?X-Py6e@ORlnXupVi$xz+|X|!rL_uZGy}WQgy-}HX7y1-!j{$XvD2o zy`WL8XoC*h2!6>~Y?MFbQ?rQ&SK;t`T;s$vG!lCbl6Ds=>~ZU)k3N!}lr{ zDf$bwa)1Pemz*&sn*=cQl!2u z3CFV*>?rC|8^bXqp|(?QVB3w6Kv&~q+&ezjoy|sesIW@TdsWvngDpcAmdd*6sx)=BjyNM!GS~v}V&uat; zGmw&S26wzCTYkCW>XwfQ=z@~7;x|2=CuVC)N{&-2S0eLZ&Qp!2YD<(+-~MP1Fs@u= z0U?*)R46$&-N;QA%C*`S0+L)ITcYflTm=Ck_e@F@ZDoxueMJV}ZFuFtTi9;~{;uI2 z2_nQMuNgG_Cx)ud6}=ityuXN9a_+0&aSSuq&|CHY9_`Gn*gAABw3ezLdG1R2iN7Cv zn8t+8J+J0fg5}3+p67b5Tz8WXO&k&|vI_f&RZRiYZIri-sj9sE`OS>XZ{9+JQ#eQT z@B+~%7m=w95k2iA`mvvA>k@dqL|^p~UBUY^WI;cG_hN+Tr!JzOp|=OU%i~1PS-WAP zGvEb~ox=ZL4ieoMBbvv1Wq@c3?bk=q7BUxod<)($okU+i=R5G-Zld>r^#bqb==0$u zbSH?u$GaWxXCNeFRG^FW8ja8xjnXUBPG{%>out>PgHF+DI!nDYNIld=ee?%9LFcHG z&eJ6tpjWA%hN+u|=nWdD%k&ma(geLp$EfYl`#g?}B+1)SLvqqVmgpa5UTN)Z9RZH7$lnt{v>8DCL}xfl~og;+br2 zB{a#Yq;|^N2WiX^hkVj8k#rca&}yee2?tVg3|6?xj1wbxoW&rtsMgekIazT@4?p-) z!yrDj*oki|0{+%~Uz{qo7YRvJE*J`*uS4vgmPqkZOJ@42rJ#DOC6rcdNu>8$lGukeQL-ls z6(vO%EHe!@`NFpa-%j_0#7^ymB+1)jnUQNM0=^{)>n?rWS~)4PR!+IT2nZu0NVb`l z#Daw6M2!(rQHvCkYs8D}TmDre)j6n=GyRUJ@H}c)%Lh|#tw!xvMZqUhI;gke^lYU0 zsNMbeIQ{!CpWp2~hMWgE345koZ)<;hl%*))vxL9@jQ$s|dFr?|Rdvfjd2~kbkb2R7 zK>v#v$MK%0x4((><{~yS8KM)w6MBq4Pla#V@a{q;#GVdwniF)s<1_@Q#)J>6X!U)1 zZnauz_)Y(DP?%hQv#_$fb|;c+ue11KqhSQ>@V^fHJsJLILSZx&e|HbV?)&s#^y{x` zJ2W6R&NdRWpC<}Oz9Tr{JULpVGs|?)h@?(2<}f}INBOYck#EXxhV@r`9aY6Cul39n zi;DHMh1T;m#>dB-0V>&bX5?wyu+qN3iamlUNh>t2Ea3bGF|J9)V`;Bs4wNOKGu zWijWK5Y4#3Sj(9gaW2IduL7|>M9jJzS@8L-Ck3CyK2}3YE`S)zoF7#r1jag#0QIau z)h>0d&vY&Y^N+xMRbZxE7+Xh|DNw?UU(?XVW%Lj*Ga~Nm0+VlLe9^UF^ICK9^sxQ`p(g7&W=j(lUD1>DLvaD>aaQ$DqL_O}Q_ggjj}M1vM$xu)8_KZT5sqlqgImYUxWSD^m~pAug3BLsGw#G= k98WD{TY$NDG2>1=&hfMgxdoVih8d^I1V=Qg?>6TD0S!6a{Qv*} literal 0 HcmV?d00001 diff --git a/xpcPlugin/SDK/README.txt b/xpcPlugin/SDK/README.txt new file mode 100755 index 0000000..2773a35 --- /dev/null +++ b/xpcPlugin/SDK/README.txt @@ -0,0 +1,192 @@ +------------------------------------------------------------------------------- + THE X-PLANE PLUGIN SDK +------------------------------------------------------------------------------- + +This download contains the files necessary to build plugins for X-Plane. The +X-Plane plugin website is: + +http://www.xsquawkbox.net/xpsdk/ + +The website contains full documentation on the SDK including tech notes, sample +plugins, sample code, contact information, and links to the latest versions of +this SDK. + +The X-Plane SDK authors can be reached at: + +xplanesdk@xsquawkbox.net + +Please do not email Austin or Laminar Research for SDK questions or support; +the SDK is a third party effort. + +the X-Plane developer mailing list is an unlisted yahoo group frequented by +many X-Plane developers. + +x-plane-dev@yahoogroups.com + +------------------------------------------------------------------------------- + SDK FILES +------------------------------------------------------------------------------- + +license.txt Copyright information for this download. +README.txt This document +CHeaders Header files for compiling C/C++ plugins +Delphi Interfaces for compiling Pascal plugins +Libraries Import libraries for linking on Windows + and frameworks for linking on Mac. + +Note: there are no import/link-time libraries for Linux; on Linux, plugins +simply leave SDK symbols undefined and they are discovered at runtime. The +SDK website explains this process in more detail. + +Mac CFM plugins are not supported by the SDK versions 2.0 and higher; the +2.0 SDK requires X-Plane 9.0 or newer, and X-Plane 9 will not run on +Mac OS 9. Therefore CFM plugins are not useful (and are probably +counterproductive since they cannot support x86 code). If you have a CFM +plugin, continue to use the 1.0 SDK to build it. You will have to port to +Mach-O if you want to use 2.0 features. + +------------------------------------------------------------------------------- + RELEASE NOTES +------------------------------------------------------------------------------- + +This section contains per-release notes for the history of the X-Plane SDK. + +X-Plane SDK Release 2.1.2 RC2 1/15/13 + +Removed headers from frameworks, as they don't work; updated README. + +X-Plane SDK Release 2.1.2 RC1 1/12/13 + +The 2.1.2 SDK adds frameworks for the XPLM and XPWidgets; Mac developers +can link directly against these frameworks and avoid unresolved symbols +and flat namespace problems. The frameworks produce plugins that will +work on X-Plane 8, 9, and 10 depending on the plugin CPU architecture, +minimum system SDK, and XPLM API revision number. + +X-Plane SDK Release 2.1.1 RC1 10/29/12 + +The 2.1.1 update to the SDK provides 64-bit build materials. + +X-Plane SDK Release 2.1.0 RC1 3/31/12 + +This is the first release of the version 2.1 X-Plane SDK. This version of the +SDK exposes new APIs. + +This API also replaces all references to "long" with int or intptr_t, +depending on whether the integer needs to be wide enough to hold coerced +pointers. Most of the time, int is used; the notable exception is the widgets +library where params and properties can contain pointers to user data. + +This change is not an ABI change - compiled plugins will work unmodified. +However for some compilers, you may need to replace long with int or intptr_t +in your code. + +X-Plane SDK Release 2.0.1 RC1 7/21/10 + +This release adds symbol visibility macros for GCC 4 on Linux and corrects a few +function documentation comments. + +X-Plane SDK Release 2.0 RC1 7/11/08 + +This release includes a corrected XPLM.lib for windows with exports for some of +the new 2.0 APIs. + +X-Plane SDK Release 2.0 Beta 2 4/23/08 + +This release includes new APIs for reading and writing data files and drawing +hooks for the local map screen, as well as some minor tweaks: + +- Sim version is 2.0 in the headers. +- unload plane msg marked as 2.0 only. +- New enumerations for additional languages. +- Function level docs improved. + +X-Plane SDK Release 2.0 Beta 1 1/19/08 + +This is the first release of the version 2.0 X-Plane SDK. CFM support has +been removed, and the license has been simplified, reflecting that it only has +to cover the SDK include/import lib files and not the sample code or examples. + +X-Plane SDK Release 1.0.2 1/5/05 + +The headers of the SDK are modified to support Kylix. No changes for Mac, +Windows, or C users. Headers now have SDK version numbers. + +X-Plane SDK Release 1.0.1 12/29/04 + +The headers of this SDK are modified to support Linux complication. No changes +for Mac and Windows users. + +X-Plane SDK Release Candidate 1 + +Only one slight change in the enums: the enum xpProperty_SubWindowHasCloseBoxes +in XPStandardWidgets.h has been changed to xpProperty_MainWindowHasCloseBoxes. +Its value has not been changed, so you will need to search-and-replace your code +when using this version of the SDK, but already-compiled plugins will experience +no different operation. + +The documentation has been revised for all headers to revise changes made to the +SDK over the course of beta. + +X-Plane SDK Beta 5 + +This version of the SDK features a number of enumeration changes to reflect the +X-Plane interface more correctly. This became crucial when X-Plane 7's new user +interface was released. With X-Plane in release candidates hopefully beta 5 of +the SDK could be the last one. Please see: + +www.xsquawkbox.net/xpsdk/newui.html + +For a comprehensive description of all the enumeration changes. For most +plugins (no developers reported using the deprecated enumerations), a simple +search and replace should suffice. Plugins compiled against the beta 4 SDK that +do not use now-unsupported graphics will continue to work correctly. + +X-Plane SDK Beta 4 + +This release corrects two problems with the Pascal headers: function pointer +types are now declared cdecl (since this is how the SDK calls them), and the +import library for the widget callbacks is now XPWIDGETS.DLL as it should be. + +X-Plane SDK Beta 3 + +This release finally features full documentation and a stable widgets API, as +well as a few other minor bug fixes. + +Starting with beta 3, the DLLs necessary to run plugins ship with X-Plane 660. +The SDK will work with X-Plane 660 RC3 and later. The XPWidgets DLL now lives +in the Resources/plugins folder. + +Starting with beta 3, extra plugins, documentation, sample code, and sample +projects are now featured directly on the web in the new X-Plane SDK library. +They are not included in the SDK zip file; the zip file only contains headers +and lib files for the SDK. + +X-Plane SDK Beta 2 + +You must recompile your plugin for the beta 2 plugin SDK! Plugins compiled +against the beta 1 SDK will not work with X-Plane 660 or the new XPLM.DLL. + +A huge number of data refs have been added. Unfortunately the documentation +is thin. Use the data ref tester plugin to view the data refs in real time +and find what you need. + +The data ref APIs have also changed to allow for arrays of integers as well +as floats. Some sim variables are now arrays that were previously many +individual items. + +A new drawing phase is available for replacing aircraft graphics. The +texturing APIs in XPLMGraphics have been revised. The most notable change is +that you cannot use the SDK to load your textures. (This functionality was +broken and never worked in beta 1.) See the x-plane-dev list for sample code +on how to load your own bitmaps. + +X-Plane can reload plugins on the fly. Use the Plugin Enabler plugin to reload +your plugin. On the Mac you can throw the old DLL in the trash and put a new +one in its place to reload a new version of the plugin. On the PC, an alert +comes up; while this alert is up you can swap your plugins' DLL. This allows +you to recompile your plugin without rebooting the sim. + +Delphi Pascal interfaces and sample code are in the SDK. Thanks to Billy +Verreynne for his hard work on this. + diff --git a/xpcPlugin/SDK/license.txt b/xpcPlugin/SDK/license.txt new file mode 100755 index 0000000..8b9cbfc --- /dev/null +++ b/xpcPlugin/SDK/license.txt @@ -0,0 +1,27 @@ +Copyright (c) 2008, Sandy Barbour and Ben Supnik +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Neither the names of the authors nor that of X-Plane or Laminar Research + may be used to endorse or promote products derived from this software + without specific prior written permission from the authors or + Laminar Research, respectively. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/xpcPlugin/Win/xpcPlugin.xpl b/xpcPlugin/Win/xpcPlugin.xpl new file mode 100755 index 0000000000000000000000000000000000000000..a14d7b966ce7da86abef12baf2b84efa93753878 GIT binary patch literal 84992 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

AHl$Nw)@!p3awu=VLLWKhZ3)d{rkEA-ioXDQ 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