-
Notifications
You must be signed in to change notification settings - Fork 1
/
PI_KeySniffer1.py
140 lines (113 loc) · 5.24 KB
/
PI_KeySniffer1.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
"""
KeySniffer.c
Ported to Python by Sandy Barbour - 28/04/2005
Ported to XPPython3 by Peter Buckner - 2-Aug-2020
KeySniffer shows the use of key sniffers to intercept and process raw
keystrokes. This one creates a window where all data about the keystroke
is displayed.
Key strokes have two sets of character data. The ASCII key code is a valid
ASCII value. This value discriminates between the A key with and without shift
(e.g. 'A' and 'a') but does not discriminate between numbers on the main
keyboard vs. numeric keypad. Virtual key codes tell exactly what physical key
was pressed (e.g. top-row-0 vs. num-pad-0) but do not change by modifier keys.
Modifier keys are returned separately.
ASCII codes are good for handling text entry; virtual key codes are good for
setting up key commands (since they allow for separate binding of the numeric
key pad).
"""
from XPPython3 import xp
class PythonInterface:
def XPluginStart(self):
# First set up our plugin info.
self.Name = "KeySniffer1 v1.0"
self.Sig = "keySniffer1.demos.xppython3"
self.Desc = "An example sniffing keys."
self.Char = 65
self.VirtualKey = 0
self.Flags = 0
# Now create a new window. Pass in our callbacks.
self.Window = xp.createWindowEx(50, 750, 350, 700,
1,
self.MyDrawWindowCallback,
self.MyHandleMouseClickCallback,
self.MyHandleKeyCallback,
self.MyHandleCursorCallback,
self.MyHandleMouseWheelCallback,
0,
xp.WindowDecorationRoundRectangle,
xp.WindowLayerFloatingWindows,
None)
# Finally register our key sniffer.
xp.registerKeySniffer(self.MyKeySniffer, 1, 0)
return self.Name, self.Sig, self.Desc
def XPluginStop(self):
xp.unregisterKeySniffer(self.MyKeySniffer, 1, 0)
xp.destroyWindow(self.Window)
def XPluginEnable(self):
return 1
def XPluginDisable(self):
pass
def XPluginReceiveMessage(self, inFromWho, inMessage, inParam):
pass
def MyHandleCursorCallback(self, inWindowID, x, y, inRefcon):
return xp.CursorDefault
def MyHandleMouseWheelCallback(self, inWindowID, x, y, wheel, clicks, inRefcon):
return 1
# MyDrawWindowCallback
# This routine draws the window, showing the last keyboard stroke to be
# recorded by our sniffer.
def MyDrawWindowCallback(self, inWindowID, inRefcon):
# First get our window's location.
left, top, right, bottom = xp.getWindowGeometry(inWindowID)
# Draw a translucent dark box as our window outline.
xp.drawTranslucentDarkBox(int(left), int(top), int(right), int(bottom))
color = 1.0, 1.0, 1.0
if (self.Flags & xp.ShiftFlag):
Shift = 'S'
else:
Shift = ' '
if (self.Flags & xp.OptionAltFlag):
OptionAlt = 'A'
else:
OptionAlt = ' '
if (self.Flags & xp.ControlFlag):
Control = 'C'
else:
Control = ' '
if (self.Flags & xp.DownFlag):
Down = 'D'
else:
Down = ' '
if (self.Flags & xp.UpFlag):
Up = 'U'
else:
Up = ' '
# Take the last key stroke and form a descriptive string.
# Note that ASCII values may be printed directly. Virtual key
# codes are not ASCII and cannot be, but the utility function
# XPLMGetVirtualKeyDescription provides a human-readable string
# for each key. These strings may be multicharacter, e.g. 'ENTER'
# or 'NUMPAD-0'.
Desc = xp.getVirtualKeyDescription(self.VirtualKey)
if (self.Char == 0):
MyString = "%d %c | %d %s (%c %c %c %c %c)" % (self.Char, '0', self.VirtualKey, Desc, Shift, OptionAlt, Control, Down, Up)
else:
MyString = "%d %c | %d %s (%c %c %c %c %c)" % (self.Char, self.Char, self.VirtualKey, Desc, Shift, OptionAlt, Control, Down, Up)
# Draw the string into the window.
xp.drawString(color, left + 5, top - 20, MyString, 0, xp.Font_Basic)
def MyHandleKeyCallback(self, inWindowID, inKey, inFlags, inVirtualKey, inRefcon, losingFocus):
pass
def MyHandleMouseClickCallback(self, inWindowID, x, y, inMouse, inRefcon):
return 1
# MyKeySniffer
# This routine receives keystrokes from the simulator as they are pressed.
# A separate message is received for each key press and release as well as
# keys being held down.
def MyKeySniffer(self, inChar, inFlags, inVirtualKey, inRefcon):
# First record the key data.
self.VirtualKey = inVirtualKey
self.Flags = inFlags
self.Char = inChar
# Return 1 to pass the keystroke to plugin windows and X-Plane.
# Returning 0 would consume the keystroke.
return 1