~tuomasjjrasanen/python-uinput/master : revision 14

1

/*

2

pysuinput - Simple Python wrapper for libsuinput

3

4

5

This library is free software; you can redistribute it and/or

6

modify it under the terms of the GNU Lesser General Public

7

License as published by the Free Software Foundation; either

8

version 3 of the License, or (at your option) any later version.

9

10

This library is distributed in the hope that it will be useful,

11

but WITHOUT ANY WARRANTY; without even the implied warranty of

12

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13

Lesser General Public License for more details.

14

15

You should have received a copy of the GNU Lesser General Public

16

License along with this library; if not, write to the Free Software

17

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

18

*/

19

20

#include <Python.h>

21

22

#include "suinput.h"

23

24

static PyObject *pysuinput_open(PyObject *self, PyObject *args)

25

{

26

const char *name = NULL;

27

uint16_t bustype;

28

uint16_t vendor;

29

uint16_t product;

30

uint16_t version;

31

if (!PyArg_ParseTuple(args, "sHHHH", &name, &bustype, &vendor, &product,

32

&version))

33

return NULL;

34

struct input_id id = {bustype, vendor, product, version};

35

struct suinput_driver *c_driver = suinput_open(name, &id);

36

if (c_driver == NULL)

37

return PyErr_SetFromErrno(PyExc_IOError);

38

return PyCObject_FromVoidPtr((void *)c_driver, NULL);

39

}

40

41

static PyObject *pysuinput_close(PyObject *self, PyObject *args)

42

{

43

PyObject *py_driver;

44

struct suinput_driver *c_driver;

45

if (!PyArg_ParseTuple(args, "O", &py_driver))

46

return NULL;

47

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

48

if (suinput_close(c_driver) == -1)

49

return PyErr_SetFromErrno(PyExc_IOError);

50

Py_RETURN_NONE;

51

}

52

53

static PyObject *pysuinput_press(PyObject *self, PyObject *args)

54

{

55

PyObject *py_driver;

56

struct suinput_driver *c_driver;

57

uint16_t keycode;

58

if (!PyArg_ParseTuple(args, "OH", &py_driver, &keycode))

59

return NULL;

60

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

61

if (suinput_press(c_driver, keycode) == -1)

62

return PyErr_SetFromErrno(PyExc_IOError);

63

Py_RETURN_NONE;

64

}

65

66

static PyObject *pysuinput_release(PyObject *self, PyObject *args)

67

{

68

PyObject *py_driver;

69

struct suinput_driver *c_driver;

70

uint16_t keycode;

71

if (!PyArg_ParseTuple(args, "OH", &py_driver, &keycode))

72

return NULL;

73

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

74

if (suinput_release(c_driver, keycode) == -1)

75

return PyErr_SetFromErrno(PyExc_IOError);

76

Py_RETURN_NONE;

77

}

78

79

static PyObject *pysuinput_click(PyObject *self, PyObject *args)

80

{

81

PyObject *py_driver;

82

struct suinput_driver *c_driver;

83

uint16_t keycode;

84

if (!PyArg_ParseTuple(args, "OH", &py_driver, &keycode))

85

return NULL;

86

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

87

if (suinput_click(c_driver, keycode) == -1)

88

return PyErr_SetFromErrno(PyExc_IOError);

89

Py_RETURN_NONE;

90

}

91

92

static PyObject *pysuinput_move_pointer(PyObject *self, PyObject *args)

93

{

94

PyObject *py_driver;

95

struct suinput_driver *c_driver;

96

int32_t x;

97

int32_t y;

98

if (!PyArg_ParseTuple(args, "Oii", &py_driver, &x, &y)) {

99

return NULL;

100

}

101

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

102

if (suinput_move_pointer(c_driver, x, y) == -1)

103

return PyErr_SetFromErrno(PyExc_IOError);

104

Py_RETURN_NONE;

105

}

106

107

static PyObject *pysuinput_press_release(PyObject *self, PyObject *args)

108

{

109

PyObject *py_driver;

110

struct suinput_driver *c_driver;

111

int16_t keycode;

112

if (!PyArg_ParseTuple(args, "Oh", &py_driver, &keycode))

113

return NULL;

114

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

115

if (suinput_press_release(c_driver, keycode) == -1)

116

return PyErr_SetFromErrno(PyExc_IOError);

117

Py_RETURN_NONE;

118

}

119

120

static PyObject *pysuinput_toggle(PyObject *self, PyObject *args)

121

{

122

PyObject *py_driver;

123

struct suinput_driver *c_driver;

124

uint16_t keycode;

125

if (!PyArg_ParseTuple(args, "OH", &py_driver, &keycode))

126

return NULL;

127

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

128

if (suinput_toggle(c_driver, keycode) == -1)

129

return PyErr_SetFromErrno(PyExc_IOError);

130

Py_RETURN_NONE;

131

}

132

133

static PyObject *pysuinput_is_pressed(PyObject *self, PyObject *args)

134

{

135

PyObject *py_driver;

136

struct suinput_driver *c_driver;

137

uint16_t keycode;

138

if (!PyArg_ParseTuple(args, "OH", &py_driver, &keycode))

139

return NULL;

140

c_driver = (struct suinput_driver *)PyCObject_AsVoidPtr(py_driver);

141

return PyBool_FromLong(suinput_is_pressed(c_driver, keycode));

142

}

143

144

static PyMethodDef pysuinputMethods[] = {

145

{"open", pysuinput_open, METH_VARARGS,

146

"open(name, bustype, vendor, product, version)\n\n"

147

"Return an input driver.\n"

148

"All possible values of bustype are defined as constants prefixed\n"

149

"by BUS_, vendor, product and version are unsigned 16 bit integers."

150

"close() must be called for every object returned by this function."

151

},

152

153

{"close", pysuinput_close, METH_VARARGS,

154

"close(driver)\n\n"

155

"Close and destroy the driver."

156

},

157

158

{"click", pysuinput_click, METH_VARARGS,

159

"click(driver, keycode)\n\n"

160

"Send a press and a release event."

161

},

162

163

{"press", pysuinput_press, METH_VARARGS,

164

"press(driver, keycode)\n\n"

165

"Send a press event.\n"

166

"Event is repeated after a short delay until a release event is sent."

167

},

168

169

{"release", pysuinput_release, METH_VARARGS,

170

"release(driver, keycode)\n\n"

171

"Send a release event."

172

},

173

174

{"move_pointer", pysuinput_move_pointer, METH_VARARGS,

175

"move_pointer(driver, x, y)\n\n"

176

"Move pointer towards bottom-right."

177

},

178

179

{"press_release", pysuinput_press_release, METH_VARARGS,

180

"press_release(driver, signed_keycode)\n\n"

181

"Send a press event if signed_keycode > 0, otherwise send\n"

182

"a release event."

183

},

184

185

{"toggle", pysuinput_toggle, METH_VARARGS,

186

"toggle(driver, keycode)\n\n"

187

"Press button if it is not pressed currently, release it otherwise."

188

},

189

190

{"is_pressed", pysuinput_is_pressed, METH_VARARGS,

191

"is_pressed(driver, keycode)\n\n"

192

"Return True if button is pressed, False otherwise.\n"

193

"keycode must be one of the constant values defined in\n"

194

"uinput.keycodes -module."

195

},

196

197

{NULL, NULL, 0, NULL}

198

};

199

200

PyMODINIT_FUNC init_suinput(void)

201

{

202

PyObject *module;

203

module = Py_InitModule3("_suinput", pysuinputMethods,

204

"Simple C-like Python API to the Linux uinput-system\n\n"

205

"Provides a high-level API for the Linux input subsystem\n"

206

"through the user space event device.");

207

PyModule_AddIntMacro(module, BUS_PCI);

208

PyModule_AddIntMacro(module, BUS_ISAPNP);

209

PyModule_AddIntMacro(module, BUS_USB);

210

PyModule_AddIntMacro(module, BUS_HIL);

211

PyModule_AddIntMacro(module, BUS_BLUETOOTH);

212

PyModule_AddIntMacro(module, BUS_VIRTUAL);

213

PyModule_AddIntMacro(module, BUS_ISA);

214

PyModule_AddIntMacro(module, BUS_I8042);

215

PyModule_AddIntMacro(module, BUS_XTKBD);

216

PyModule_AddIntMacro(module, BUS_RS232);

217

PyModule_AddIntMacro(module, BUS_GAMEPORT);

218

PyModule_AddIntMacro(module, BUS_PARPORT);

219

PyModule_AddIntMacro(module, BUS_AMIGA);

220

PyModule_AddIntMacro(module, BUS_ADB);

221

PyModule_AddIntMacro(module, BUS_I2C);

222

PyModule_AddIntMacro(module, BUS_HOST);

223

PyModule_AddIntMacro(module, BUS_GSC);

224

PyModule_AddIntMacro(module, BUS_ATARI);

225

}