-
Notifications
You must be signed in to change notification settings - Fork 1
/
PI_SharedData1.py
161 lines (130 loc) · 7.17 KB
/
PI_SharedData1.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
"""
ShareData.py
Ported to Python by Sandy Barbour - 03/05/2005
Ported to XPPython3 by Peter Buckner - 2-Aug-2020
This is an example plugin that demonstrates how to share data, both owned
by a plugin and shared.
Data can be published in two ways: a plugin can publish data it owns.
In this case, it provides callbacks to read (and optionally write) the
data. As other plugins access the data ref, the SDK calls back the
accessors.
Data can also be shared. In this case, the SDK allocates the memory
for the data. Each plugin that shares it registers a callback that is
called by the SDK when any plugin writes the data.
We use the xppython3 namespace to allocate unique data refs. When creating
your own datarefs, make sure to prefix the data ref with a domain unique to
your organization. 'sim' is the domain for the main simulator.
This plugin "owns" dataref 'xppython3/demos/sharedata/number1'
a) we register it, indicating it's of type float and double
b) we provide Callbacks for it: My(Get|Set)Data(d|f)Callback
This plugin also "declares" the existence of a second dataref
'xppython3/demos/sharedata/sharedint1'. By calling xp.shareData()
we indicate this dataref exists, and the SDK will set aside space
for it, to live beyond the existence of this plugin (that is, if
this plugin become disabled, the dataref is still available to
other plugins.)
This is in contrast with the 'owned' dataref: when this plugin
becomes disabled, the dataref is no longer available to others.
Execute this plugin *with* PI_SharedData2.py and you'll see they're
sharing data.
Clicking on the window of this plugin, we'll get and print (to XPPython3.log)
the current value of the shared data.
"""
from XPPython3 import xp
class PythonInterface:
def XPluginStart(self):
self.Name = "SharedData1 v1.0"
self.Sig = "sharedData1.demos.xppython3"
self.Desc = "A plugin that shares a data ref."
self.Window = xp.createWindowEx(50, 600, 300, 400, 1,
self.DrawWindowCallback,
self.MouseClickCallback,
self.KeyCallback,
self.CursorCallback,
self.MouseWheelCallback,
0,
xp.WindowDecorationRoundRectangle,
xp.WindowLayerFloatingWindows,
None)
self.OwnedFloatData = 1.5
self.OwnedDoubleData = 2.5
# Register our owned data. Note that we pass two sets of
# function callbacks for two data types and leave the rest blank.
self.OwnedDataRef = xp.registerDataAccessor(
"xppython3/demos/sharedata/number1",
xp.Type_Float + xp.Type_Double, # The types we support
1, # Writable
None, None, # No accessors for ints
self.MyGetDatafCallback, self.MySetDatafCallback, # Accessors for floats
self.MyGetDatadCallback, self.MySetDatadCallback, # Accessors for doubles
None, None, # No accessors for int arrays
None, None, # No accessors for float arrays
None, None, # No accessors for raw data
None, None) # Refcons not used
# Subscribe to shared data. If no one else has made it, this will
# cause the SDK to allocate the data.
xp.shareData("xppython3/demos/sharedata/sharedint1", xp.Type_Int, self.MyDataChangedCallback, 0)
self.SharedDataRef = xp.findDataRef("xppython3/demos/sharedata/sharedint1")
self.Buffer = "ShareData 1 - SharedDataRef := {}\n".format(self.SharedDataRef)
print(self.Buffer)
return self.Name, self.Sig, self.Desc
def XPluginStop(self):
xp.destroyWindow(self.Window)
if (self.OwnedDataRef):
xp.unregisterDataAccessor(self.OwnedDataRef)
xp.unshareData("xppython3/demos/sharedata/sharedint1", xp.Type_Int, self.MyDataChangedCallback, 0)
def XPluginEnable(self):
# Register datarefs with datareftool, to make debugging easier!
for sig in ('com.leecbaker.datareftool', 'xplanesdk.examples.DataRefEditor'):
dre = xp.findPluginBySignature(sig)
if dre != xp.NO_PLUGIN_ID:
xp.sendMessageToPlugin(dre, 0x01000000, 'xppython3/demos/sharedata/number1')
xp.sendMessageToPlugin(dre, 0x01000000, 'xppython3/demos/sharedata/sharedint1')
return 1
def XPluginDisable(self):
pass
def XPluginReceiveMessage(self, inFromWho, inMessage, inParam):
pass
def DrawWindowCallback(self, inWindowID, inRefcon):
left, top, right, bottom = xp.getWindowGeometry(inWindowID)
xp.drawTranslucentDarkBox(int(left), int(top), int(right), int(bottom))
color = 1.0, 1.0, 1.0
xp.drawString(color, left + 5, top - 20, "Click Here", 0, xp.Font_Basic)
def KeyCallback(self, inWindowID, inKey, inFlags, inVirtualKey, inRefcon, losingFocus):
pass
def MouseClickCallback(self, inWindowID, x, y, inMouse, inRefcon):
if (inMouse == xp.MouseDown):
AccessorDataRef = xp.findDataRef("xppython3/demos/sharedata/number1")
xp.setDataf(AccessorDataRef, 1.2345)
DataRefFloat = xp.getDataf(AccessorDataRef)
print("PI_SharedData1: Shared DataRefFloat 1 = {}".format(DataRefFloat))
xp.setDatad(AccessorDataRef, 9.87654321234)
DataRefDouble = xp.getDatad(AccessorDataRef)
print("PI_SharedData1: Shared DataRefDouble 1 = {}".format(DataRefDouble))
return 1
def CursorCallback(self, inWindowID, x, y, inRefcon):
return xp.CursorDefault
def MouseWheelCallback(self, inWindowID, x, y, wheel, clicks, inRefcon):
return 1
def MyDataChangedCallback(self, inRefcon):
"""
This is the callback for our shared data. Right now we do not react
to our shared data being chagned. (For "owned" data, we don't
get a callback like this -- instead, our Accessors are called: MySetData(f|d)Callback.
"""
pass
# These callbacks are called by the SDK to read and write the sim.
# We provide two sets of callbacks allowing our data to appear as
# float and double. This is done for didactic purposes; multityped
# data is provided as a backward compatibility solution and probably
# should not be used in initial designs as a convenience to client
# code.
def MyGetDatafCallback(self, inRefcon):
return self.OwnedFloatData
def MySetDatafCallback(self, inRefcon, inValue):
self.OwnedFloatData = inValue
pass
def MyGetDatadCallback(self, inRefcon):
return self.OwnedDoubleData
def MySetDatadCallback(self, inRefcon, inValue):
self.OwnedDoubleData = inValue