diff --git a/_xdo_cffi.c b/_xdo_cffi.c new file mode 100644 index 0000000..1dc264e --- /dev/null +++ b/_xdo_cffi.c @@ -0,0 +1,5425 @@ +#define _CFFI_ + +/* We try to define Py_LIMITED_API before including Python.h. + + Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and + Py_REF_DEBUG are not defined. This is a best-effort approximation: + we can learn about Py_DEBUG from pyconfig.h, but it is unclear if + the same works for the other two macros. Py_DEBUG implies them, + but not the other way around. + + The implementation is messy (issue #350): on Windows, with _MSC_VER, + we have to define Py_LIMITED_API even before including pyconfig.h. + In that case, we guess what pyconfig.h will do to the macros above, + and check our guess after the #include. + + Note that on Windows, with CPython 3.x, you need >= 3.5 and virtualenv + version >= 16.0.0. With older versions of either, you don't get a + copy of PYTHON3.DLL in the virtualenv. We can't check the version of + CPython *before* we even include pyconfig.h. ffi.set_source() puts + a ``#define _CFFI_NO_LIMITED_API'' at the start of this file if it is + running on Windows < 3.5, as an attempt at fixing it, but that's + arguably wrong because it may not be the target version of Python. + Still better than nothing I guess. As another workaround, you can + remove the definition of Py_LIMITED_API here. + + See also 'py_limited_api' in cffi/setuptools_ext.py. +*/ +#if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API) +# ifdef _MSC_VER +# if !defined(_DEBUG) && !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API) +# define Py_LIMITED_API +# endif +# include + /* sanity-check: Py_LIMITED_API will cause crashes if any of these + are also defined. Normally, the Python file PC/pyconfig.h does not + cause any of these to be defined, with the exception that _DEBUG + causes Py_DEBUG. Double-check that. */ +# ifdef Py_LIMITED_API +# if defined(Py_DEBUG) +# error "pyconfig.h unexpectedly defines Py_DEBUG, but Py_LIMITED_API is set" +# endif +# if defined(Py_TRACE_REFS) +# error "pyconfig.h unexpectedly defines Py_TRACE_REFS, but Py_LIMITED_API is set" +# endif +# if defined(Py_REF_DEBUG) +# error "pyconfig.h unexpectedly defines Py_REF_DEBUG, but Py_LIMITED_API is set" +# endif +# endif +# else +# include +# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API) +# define Py_LIMITED_API +# endif +# endif +#endif + +#include +#ifdef __cplusplus +extern "C" { +#endif +#include + +/* This part is from file 'cffi/parse_c_type.h'. It is copied at the + beginning of C sources generated by CFFI's ffi.set_source(). */ + +typedef void *_cffi_opcode_t; + +#define _CFFI_OP(opcode, arg) (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8)) +#define _CFFI_GETOP(cffi_opcode) ((unsigned char)(uintptr_t)cffi_opcode) +#define _CFFI_GETARG(cffi_opcode) (((intptr_t)cffi_opcode) >> 8) + +#define _CFFI_OP_PRIMITIVE 1 +#define _CFFI_OP_POINTER 3 +#define _CFFI_OP_ARRAY 5 +#define _CFFI_OP_OPEN_ARRAY 7 +#define _CFFI_OP_STRUCT_UNION 9 +#define _CFFI_OP_ENUM 11 +#define _CFFI_OP_FUNCTION 13 +#define _CFFI_OP_FUNCTION_END 15 +#define _CFFI_OP_NOOP 17 +#define _CFFI_OP_BITFIELD 19 +#define _CFFI_OP_TYPENAME 21 +#define _CFFI_OP_CPYTHON_BLTN_V 23 // varargs +#define _CFFI_OP_CPYTHON_BLTN_N 25 // noargs +#define _CFFI_OP_CPYTHON_BLTN_O 27 // O (i.e. a single arg) +#define _CFFI_OP_CONSTANT 29 +#define _CFFI_OP_CONSTANT_INT 31 +#define _CFFI_OP_GLOBAL_VAR 33 +#define _CFFI_OP_DLOPEN_FUNC 35 +#define _CFFI_OP_DLOPEN_CONST 37 +#define _CFFI_OP_GLOBAL_VAR_F 39 +#define _CFFI_OP_EXTERN_PYTHON 41 + +#define _CFFI_PRIM_VOID 0 +#define _CFFI_PRIM_BOOL 1 +#define _CFFI_PRIM_CHAR 2 +#define _CFFI_PRIM_SCHAR 3 +#define _CFFI_PRIM_UCHAR 4 +#define _CFFI_PRIM_SHORT 5 +#define _CFFI_PRIM_USHORT 6 +#define _CFFI_PRIM_INT 7 +#define _CFFI_PRIM_UINT 8 +#define _CFFI_PRIM_LONG 9 +#define _CFFI_PRIM_ULONG 10 +#define _CFFI_PRIM_LONGLONG 11 +#define _CFFI_PRIM_ULONGLONG 12 +#define _CFFI_PRIM_FLOAT 13 +#define _CFFI_PRIM_DOUBLE 14 +#define _CFFI_PRIM_LONGDOUBLE 15 + +#define _CFFI_PRIM_WCHAR 16 +#define _CFFI_PRIM_INT8 17 +#define _CFFI_PRIM_UINT8 18 +#define _CFFI_PRIM_INT16 19 +#define _CFFI_PRIM_UINT16 20 +#define _CFFI_PRIM_INT32 21 +#define _CFFI_PRIM_UINT32 22 +#define _CFFI_PRIM_INT64 23 +#define _CFFI_PRIM_UINT64 24 +#define _CFFI_PRIM_INTPTR 25 +#define _CFFI_PRIM_UINTPTR 26 +#define _CFFI_PRIM_PTRDIFF 27 +#define _CFFI_PRIM_SIZE 28 +#define _CFFI_PRIM_SSIZE 29 +#define _CFFI_PRIM_INT_LEAST8 30 +#define _CFFI_PRIM_UINT_LEAST8 31 +#define _CFFI_PRIM_INT_LEAST16 32 +#define _CFFI_PRIM_UINT_LEAST16 33 +#define _CFFI_PRIM_INT_LEAST32 34 +#define _CFFI_PRIM_UINT_LEAST32 35 +#define _CFFI_PRIM_INT_LEAST64 36 +#define _CFFI_PRIM_UINT_LEAST64 37 +#define _CFFI_PRIM_INT_FAST8 38 +#define _CFFI_PRIM_UINT_FAST8 39 +#define _CFFI_PRIM_INT_FAST16 40 +#define _CFFI_PRIM_UINT_FAST16 41 +#define _CFFI_PRIM_INT_FAST32 42 +#define _CFFI_PRIM_UINT_FAST32 43 +#define _CFFI_PRIM_INT_FAST64 44 +#define _CFFI_PRIM_UINT_FAST64 45 +#define _CFFI_PRIM_INTMAX 46 +#define _CFFI_PRIM_UINTMAX 47 +#define _CFFI_PRIM_FLOATCOMPLEX 48 +#define _CFFI_PRIM_DOUBLECOMPLEX 49 +#define _CFFI_PRIM_CHAR16 50 +#define _CFFI_PRIM_CHAR32 51 + +#define _CFFI__NUM_PRIM 52 +#define _CFFI__UNKNOWN_PRIM (-1) +#define _CFFI__UNKNOWN_FLOAT_PRIM (-2) +#define _CFFI__UNKNOWN_LONG_DOUBLE (-3) + +#define _CFFI__IO_FILE_STRUCT (-1) + + +struct _cffi_global_s { + const char *name; + void *address; + _cffi_opcode_t type_op; + void *size_or_direct_fn; // OP_GLOBAL_VAR: size, or 0 if unknown + // OP_CPYTHON_BLTN_*: addr of direct function +}; + +struct _cffi_getconst_s { + unsigned long long value; + const struct _cffi_type_context_s *ctx; + int gindex; +}; + +struct _cffi_struct_union_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_STRUCT_UNION + int flags; // _CFFI_F_* flags below + size_t size; + int alignment; + int first_field_index; // -> _cffi_fields array + int num_fields; +}; +#define _CFFI_F_UNION 0x01 // is a union, not a struct +#define _CFFI_F_CHECK_FIELDS 0x02 // complain if fields are not in the + // "standard layout" or if some are missing +#define _CFFI_F_PACKED 0x04 // for CHECK_FIELDS, assume a packed struct +#define _CFFI_F_EXTERNAL 0x08 // in some other ffi.include() +#define _CFFI_F_OPAQUE 0x10 // opaque + +struct _cffi_field_s { + const char *name; + size_t field_offset; + size_t field_size; + _cffi_opcode_t field_type_op; +}; + +struct _cffi_enum_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_ENUM + int type_prim; // _CFFI_PRIM_xxx + const char *enumerators; // comma-delimited string +}; + +struct _cffi_typename_s { + const char *name; + int type_index; /* if opaque, points to a possibly artificial + OP_STRUCT which is itself opaque */ +}; + +struct _cffi_type_context_s { + _cffi_opcode_t *types; + const struct _cffi_global_s *globals; + const struct _cffi_field_s *fields; + const struct _cffi_struct_union_s *struct_unions; + const struct _cffi_enum_s *enums; + const struct _cffi_typename_s *typenames; + int num_globals; + int num_struct_unions; + int num_enums; + int num_typenames; + const char *const *includes; + int num_types; + int flags; /* future extension */ +}; + +struct _cffi_parse_info_s { + const struct _cffi_type_context_s *ctx; + _cffi_opcode_t *output; + unsigned int output_size; + size_t error_location; + const char *error_message; +}; + +struct _cffi_externpy_s { + const char *name; + size_t size_of_result; + void *reserved1, *reserved2; +}; + +#ifdef _CFFI_INTERNAL +static int parse_c_type(struct _cffi_parse_info_s *info, const char *input); +static int search_in_globals(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +static int search_in_struct_unions(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +#endif + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +#endif + +#ifdef __GNUC__ +# define _CFFI_UNUSED_FN __attribute__((unused)) +#else +# define _CFFI_UNUSED_FN /* nothing */ +#endif + +#ifdef __cplusplus +# ifndef _Bool + typedef bool _Bool; /* semi-hackish: C++ has no _Bool; bool is builtin */ +# endif +#endif + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong +#define _cffi_from_c__Bool PyBool_FromLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + not used any more +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((_cffi_wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(_cffi_wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(struct _cffi_ctypedescr *, \ + PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24]) +#define _CFFI_CPIDX 25 +#define _cffi_call_python \ + ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX]) +#define _cffi_to_c_wchar3216_t \ + ((int(*)(PyObject *))_cffi_exports[26]) +#define _cffi_from_c_wchar3216_t \ + ((PyObject *(*)(int))_cffi_exports[27]) +#define _CFFI_NUM_EXPORTS 28 + +struct _cffi_ctypedescr; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; + +#define _cffi_type(index) ( \ + assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \ + (struct _cffi_ctypedescr *)_cffi_types[index]) + +static PyObject *_cffi_init(const char *module_name, Py_ssize_t version, + const struct _cffi_type_context_s *ctx) +{ + PyObject *module, *o_arg, *new_module; + void *raw[] = { + (void *)module_name, + (void *)version, + (void *)_cffi_exports, + (void *)ctx, + }; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + o_arg = PyLong_FromVoidPtr((void *)raw); + if (o_arg == NULL) + goto failure; + + new_module = PyObject_CallMethod( + module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg); + + Py_DECREF(o_arg); + Py_DECREF(module); + return new_module; + + failure: + Py_XDECREF(module); + return NULL; +} + + +#ifdef HAVE_WCHAR_H +typedef wchar_t _cffi_wchar_t; +#else +typedef uint16_t _cffi_wchar_t; /* same random pick as _cffi_backend.c */ +#endif + +_CFFI_UNUSED_FN static uint16_t _cffi_to_c_char16_t(PyObject *o) +{ + if (sizeof(_cffi_wchar_t) == 2) + return (uint16_t)_cffi_to_c_wchar_t(o); + else + return (uint16_t)_cffi_to_c_wchar3216_t(o); +} + +_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char16_t(uint16_t x) +{ + if (sizeof(_cffi_wchar_t) == 2) + return _cffi_from_c_wchar_t((_cffi_wchar_t)x); + else + return _cffi_from_c_wchar3216_t((int)x); +} + +_CFFI_UNUSED_FN static int _cffi_to_c_char32_t(PyObject *o) +{ + if (sizeof(_cffi_wchar_t) == 4) + return (int)_cffi_to_c_wchar_t(o); + else + return (int)_cffi_to_c_wchar3216_t(o); +} + +_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char32_t(unsigned int x) +{ + if (sizeof(_cffi_wchar_t) == 4) + return _cffi_from_c_wchar_t((_cffi_wchar_t)x); + else + return _cffi_from_c_wchar3216_t((int)x); +} + +union _cffi_union_alignment_u { + unsigned char m_char; + unsigned short m_short; + unsigned int m_int; + unsigned long m_long; + unsigned long long m_longlong; + float m_float; + double m_double; + long double m_longdouble; +}; + +struct _cffi_freeme_s { + struct _cffi_freeme_s *next; + union _cffi_union_alignment_u alignment; +}; + +_CFFI_UNUSED_FN static int +_cffi_convert_array_argument(struct _cffi_ctypedescr *ctptr, PyObject *arg, + char **output_data, Py_ssize_t datasize, + struct _cffi_freeme_s **freeme) +{ + char *p; + if (datasize < 0) + return -1; + + p = *output_data; + if (p == NULL) { + struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc( + offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize); + if (fp == NULL) + return -1; + fp->next = *freeme; + *freeme = fp; + p = *output_data = (char *)&fp->alignment; + } + memset((void *)p, 0, (size_t)datasize); + return _cffi_convert_array_from_object(p, ctptr, arg); +} + +_CFFI_UNUSED_FN static void +_cffi_free_array_arguments(struct _cffi_freeme_s *freeme) +{ + do { + void *p = (void *)freeme; + freeme = freeme->next; + PyObject_Free(p); + } while (freeme != NULL); +} + +/********** end CPython-specific section **********/ +#else +_CFFI_UNUSED_FN +static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *); +# define _cffi_call_python _cffi_call_python_org +#endif + + +#define _cffi_array_len(array) (sizeof(array) / sizeof((array)[0])) + +#define _cffi_prim_int(size, sign) \ + ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8 : _CFFI_PRIM_UINT8) : \ + (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) : \ + (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) : \ + (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) : \ + _CFFI__UNKNOWN_PRIM) + +#define _cffi_prim_float(size) \ + ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT : \ + (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE : \ + (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE : \ + _CFFI__UNKNOWN_FLOAT_PRIM) + +#define _cffi_check_int(got, got_nonpos, expected) \ + ((got_nonpos) == (expected <= 0) && \ + (got) == (unsigned long long)expected) + +#ifdef MS_WIN32 +# define _cffi_stdcall __stdcall +#else +# define _cffi_stdcall /* nothing */ +#endif + +#ifdef __cplusplus +} +#endif + +/************************************************************/ + + + #include "xdo.h" // the C header of the library + + +/************************************************************/ + +static void *_cffi_types[] = { +/* 0 */ _CFFI_OP(_CFFI_OP_FUNCTION, 219), // char const * *()(void) +/* 1 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2 */ _CFFI_OP(_CFFI_OP_FUNCTION, 67), // char const *()(void) +/* 3 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 4 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t *, int) +/* 5 */ _CFFI_OP(_CFFI_OP_POINTER, 229), // xdo_t * +/* 6 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), // int +/* 7 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 8 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t *, unsigned int *, unsigned int *, int) +/* 9 */ _CFFI_OP(_CFFI_OP_NOOP, 5), +/* 10 */ _CFFI_OP(_CFFI_OP_POINTER, 158), // unsigned int * +/* 11 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 12 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 13 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 14 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, charcodemap_t * *, int *) +/* 15 */ _CFFI_OP(_CFFI_OP_POINTER, 229), // xdo_t const * +/* 16 */ _CFFI_OP(_CFFI_OP_POINTER, 88), // charcodemap_t * * +/* 17 */ _CFFI_OP(_CFFI_OP_POINTER, 6), // int * +/* 18 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 19 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, int *, int *) +/* 20 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 21 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 22 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 23 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 24 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, int *, int *, int *) +/* 25 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 26 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 27 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 28 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 29 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 30 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, int *, int *, int *, unsigned long *) +/* 31 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 32 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 33 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 34 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 35 */ _CFFI_OP(_CFFI_OP_POINTER, 62), // unsigned long * +/* 36 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 37 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, int, int) +/* 38 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 39 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 40 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 41 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 42 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, int, int, int) +/* 43 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 44 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 45 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 46 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 47 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 48 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, long *) +/* 49 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 50 */ _CFFI_OP(_CFFI_OP_POINTER, 54), // long * +/* 51 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 52 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, long) +/* 53 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 54 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), // long +/* 55 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 56 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long *) +/* 57 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 58 */ _CFFI_OP(_CFFI_OP_NOOP, 35), +/* 59 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 60 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long) +/* 61 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 62 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), // unsigned long +/* 63 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 64 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, char const *, char const *) +/* 65 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 66 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 67 */ _CFFI_OP(_CFFI_OP_POINTER, 220), // char const * +/* 68 */ _CFFI_OP(_CFFI_OP_NOOP, 67), +/* 69 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 70 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, char const *, uint32_t) +/* 71 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 72 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 73 */ _CFFI_OP(_CFFI_OP_NOOP, 67), +/* 74 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 22), // uint32_t +/* 75 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 76 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, char const *, unsigned char * *, long *, unsigned long *, int *) +/* 77 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 78 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 79 */ _CFFI_OP(_CFFI_OP_NOOP, 67), +/* 80 */ _CFFI_OP(_CFFI_OP_POINTER, 224), // unsigned char * * +/* 81 */ _CFFI_OP(_CFFI_OP_NOOP, 50), +/* 82 */ _CFFI_OP(_CFFI_OP_NOOP, 35), +/* 83 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 84 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 85 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, charcodemap_t *, int) +/* 86 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 87 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 88 */ _CFFI_OP(_CFFI_OP_POINTER, 221), // charcodemap_t * +/* 89 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 90 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 91 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, charcodemap_t *, int, int, int *, uint32_t) +/* 92 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 93 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 94 */ _CFFI_OP(_CFFI_OP_NOOP, 88), +/* 95 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 96 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 97 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 98 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 22), +/* 99 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 100 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, int *, int *, int * *) +/* 101 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 102 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 103 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 104 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 105 */ _CFFI_OP(_CFFI_OP_POINTER, 17), // int * * +/* 106 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 107 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, int) +/* 108 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 109 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 110 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 111 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 112 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, int, int) +/* 113 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 114 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 115 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 116 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 117 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 118 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, int, int, int) +/* 119 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 120 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 121 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 122 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 123 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 124 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 125 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, int, int, uint32_t) +/* 126 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 127 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 128 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 129 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 130 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 22), +/* 131 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 132 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, long *) +/* 133 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 134 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 135 */ _CFFI_OP(_CFFI_OP_NOOP, 50), +/* 136 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 137 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, long) +/* 138 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 139 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 140 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 141 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 142 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, unsigned char * *, int *, int *) +/* 143 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 144 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 145 */ _CFFI_OP(_CFFI_OP_NOOP, 80), +/* 146 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 147 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 148 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 149 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, unsigned int *, unsigned int *) +/* 150 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 151 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 152 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 153 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 154 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 155 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, unsigned int, unsigned int, int, int) +/* 156 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 157 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 158 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), // unsigned int +/* 159 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 160 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 161 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 162 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 163 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, unsigned int, unsigned int, unsigned int *, unsigned int *) +/* 164 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 165 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 166 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 167 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 168 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 169 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 170 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 171 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, unsigned long *, int) +/* 172 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 173 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 174 */ _CFFI_OP(_CFFI_OP_NOOP, 35), +/* 175 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 176 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 177 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, unsigned long, unsigned long) +/* 178 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 179 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 180 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 181 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 182 */ _CFFI_OP(_CFFI_OP_FUNCTION, 6), // int()(xdo_t const *, xdo_search_t const *, unsigned long * *, unsigned int *) +/* 183 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 184 */ _CFFI_OP(_CFFI_OP_POINTER, 228), // xdo_search_t const * +/* 185 */ _CFFI_OP(_CFFI_OP_POINTER, 35), // unsigned long * * +/* 186 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 187 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 188 */ _CFFI_OP(_CFFI_OP_FUNCTION, 224), // unsigned char *()(xdo_t const *, unsigned long, unsigned long, long *, unsigned long *, int *) +/* 189 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 190 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 191 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 192 */ _CFFI_OP(_CFFI_OP_NOOP, 50), +/* 193 */ _CFFI_OP(_CFFI_OP_NOOP, 35), +/* 194 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 195 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 196 */ _CFFI_OP(_CFFI_OP_FUNCTION, 158), // unsigned int()(xdo_t const *) +/* 197 */ _CFFI_OP(_CFFI_OP_NOOP, 15), +/* 198 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 199 */ _CFFI_OP(_CFFI_OP_FUNCTION, 226), // void()(xdo_t *) +/* 200 */ _CFFI_OP(_CFFI_OP_NOOP, 5), +/* 201 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 202 */ _CFFI_OP(_CFFI_OP_FUNCTION, 226), // void()(xdo_t *, int) +/* 203 */ _CFFI_OP(_CFFI_OP_NOOP, 5), +/* 204 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 205 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 206 */ _CFFI_OP(_CFFI_OP_FUNCTION, 5), // xdo_t *()(Display *, char const *, int) +/* 207 */ _CFFI_OP(_CFFI_OP_POINTER, 214), // Display * +/* 208 */ _CFFI_OP(_CFFI_OP_NOOP, 67), +/* 209 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 210 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 211 */ _CFFI_OP(_CFFI_OP_FUNCTION, 5), // xdo_t *()(char const *) +/* 212 */ _CFFI_OP(_CFFI_OP_NOOP, 67), +/* 213 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 214 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 2), // Display +/* 215 */ _CFFI_OP(_CFFI_OP_ENUM, 1), // XDO_FEATURES +/* 216 */ _CFFI_OP(_CFFI_OP_POINTER, 217), // XModifierKeymap * +/* 217 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 0), // XModifierKeymap +/* 218 */ _CFFI_OP(_CFFI_OP_POINTER, 220), // char * +/* 219 */ _CFFI_OP(_CFFI_OP_POINTER, 67), // char const * * +/* 220 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 2), // char +/* 221 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 3), // charcodemap_t +/* 222 */ _CFFI_OP(_CFFI_OP_ENUM, 0), // enum $1 +/* 223 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 1), // struct Screen +/* 224 */ _CFFI_OP(_CFFI_OP_POINTER, 225), // unsigned char * +/* 225 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 4), // unsigned char +/* 226 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 0), // void +/* 227 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 16), // wchar_t +/* 228 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 5), // xdo_search_t +/* 229 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 4), // xdo_t +}; + +static int _cffi_const_SEARCH_ANY(unsigned long long *o) +{ + int n = (SEARCH_ANY) <= 0; + *o = (unsigned long long)((SEARCH_ANY) | 0); /* check that SEARCH_ANY is an integer */ + return n; +} + +static int _cffi_const_SEARCH_ALL(unsigned long long *o) +{ + int n = (SEARCH_ALL) <= 0; + *o = (unsigned long long)((SEARCH_ALL) | 0); /* check that SEARCH_ALL is an integer */ + return n; +} + +static int _cffi_const_XDO_FEATURE_XTEST(unsigned long long *o) +{ + int n = (XDO_FEATURE_XTEST) <= 0; + *o = (unsigned long long)((XDO_FEATURE_XTEST) | 0); /* check that XDO_FEATURE_XTEST is an integer */ + return n; +} + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_XModifierKeymap(XModifierKeymap *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->max_keypermod) | 0); /* check that 'XModifierKeymap.max_keypermod' is an integer */ + { unsigned char * *tmp = &p->modifiermap; (void)tmp; } +} +struct _cffi_align_typedef_XModifierKeymap { char x; XModifierKeymap y; }; + +static int _cffi_d_xdo_activate_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_activate_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_activate_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_activate_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_activate_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_activate_window _cffi_d_xdo_activate_window +#endif + +static int _cffi_d_xdo_clear_active_modifiers(xdo_t const * x0, unsigned long x1, charcodemap_t * x2, int x3) +{ + return xdo_clear_active_modifiers(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_clear_active_modifiers(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + charcodemap_t * x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_clear_active_modifiers", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(88), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (charcodemap_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(88), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_clear_active_modifiers(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_clear_active_modifiers _cffi_d_xdo_clear_active_modifiers +#endif + +static int _cffi_d_xdo_click_window(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_click_window(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_click_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_click_window", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_click_window(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_click_window _cffi_d_xdo_click_window +#endif + +static int _cffi_d_xdo_click_window_multiple(xdo_t const * x0, unsigned long x1, int x2, int x3, uint32_t x4) +{ + return xdo_click_window_multiple(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_click_window_multiple(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + int x3; + uint32_t x4; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "xdo_click_window_multiple", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, uint32_t); + if (x4 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_click_window_multiple(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_click_window_multiple _cffi_d_xdo_click_window_multiple +#endif + +static int _cffi_d_xdo_close_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_close_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_close_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_close_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_close_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_close_window _cffi_d_xdo_close_window +#endif + +static void _cffi_d_xdo_disable_feature(xdo_t * x0, int x1) +{ + xdo_disable_feature(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_disable_feature(PyObject *self, PyObject *args) +{ + xdo_t * x0; + int x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_disable_feature", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(5), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(5), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { xdo_disable_feature(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_xdo_disable_feature _cffi_d_xdo_disable_feature +#endif + +static void _cffi_d_xdo_enable_feature(xdo_t * x0, int x1) +{ + xdo_enable_feature(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_enable_feature(PyObject *self, PyObject *args) +{ + xdo_t * x0; + int x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_enable_feature", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(5), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(5), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { xdo_enable_feature(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_xdo_enable_feature _cffi_d_xdo_enable_feature +#endif + +static int _cffi_d_xdo_enter_text_window(xdo_t const * x0, unsigned long x1, char const * x2, uint32_t x3) +{ + return xdo_enter_text_window(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_enter_text_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + uint32_t x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_enter_text_window", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, uint32_t); + if (x3 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_enter_text_window(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_enter_text_window _cffi_d_xdo_enter_text_window +#endif + +static int _cffi_d_xdo_find_window_client(xdo_t const * x0, unsigned long x1, unsigned long * x2, int x3) +{ + return xdo_find_window_client(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_find_window_client(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned long * x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_find_window_client", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_find_window_client(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_find_window_client _cffi_d_xdo_find_window_client +#endif + +static int _cffi_d_xdo_focus_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_focus_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_focus_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_focus_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_focus_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_focus_window _cffi_d_xdo_focus_window +#endif + +static void _cffi_d_xdo_free(xdo_t * x0) +{ + xdo_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_free(PyObject *self, PyObject *arg0) +{ + xdo_t * x0; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(5), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(5), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { xdo_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_xdo_free _cffi_d_xdo_free +#endif + +static int _cffi_d_xdo_get_active_modifiers(xdo_t const * x0, charcodemap_t * * x1, int * x2) +{ + return xdo_get_active_modifiers(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_active_modifiers(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + charcodemap_t * * x1; + int * x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_get_active_modifiers", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(16), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (charcodemap_t * *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(16), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_active_modifiers(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_active_modifiers _cffi_d_xdo_get_active_modifiers +#endif + +static int _cffi_d_xdo_get_active_window(xdo_t const * x0, unsigned long * x1) +{ + return xdo_get_active_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_active_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_active_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_active_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_active_window _cffi_d_xdo_get_active_window +#endif + +static int _cffi_d_xdo_get_current_desktop(xdo_t const * x0, long * x1) +{ + return xdo_get_current_desktop(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_current_desktop(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_current_desktop", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(50), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(50), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_current_desktop(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_current_desktop _cffi_d_xdo_get_current_desktop +#endif + +static int _cffi_d_xdo_get_desktop_for_window(xdo_t const * x0, unsigned long x1, long * x2) +{ + return xdo_get_desktop_for_window(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_desktop_for_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + long * x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_get_desktop_for_window", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(50), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(50), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_desktop_for_window(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_desktop_for_window _cffi_d_xdo_get_desktop_for_window +#endif + +static int _cffi_d_xdo_get_desktop_viewport(xdo_t const * x0, int * x1, int * x2) +{ + return xdo_get_desktop_viewport(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_desktop_viewport(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int * x1; + int * x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_get_desktop_viewport", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_desktop_viewport(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_desktop_viewport _cffi_d_xdo_get_desktop_viewport +#endif + +static int _cffi_d_xdo_get_focused_window(xdo_t const * x0, unsigned long * x1) +{ + return xdo_get_focused_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_focused_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_focused_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_focused_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_focused_window _cffi_d_xdo_get_focused_window +#endif + +static int _cffi_d_xdo_get_focused_window_sane(xdo_t const * x0, unsigned long * x1) +{ + return xdo_get_focused_window_sane(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_focused_window_sane(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_focused_window_sane", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_focused_window_sane(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_focused_window_sane _cffi_d_xdo_get_focused_window_sane +#endif + +static unsigned int _cffi_d_xdo_get_input_state(xdo_t const * x0) +{ + return xdo_get_input_state(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_input_state(PyObject *self, PyObject *arg0) +{ + xdo_t const * x0; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + unsigned int result; + PyObject *pyresult; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_input_state(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, unsigned int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_input_state _cffi_d_xdo_get_input_state +#endif + +static int _cffi_d_xdo_get_mouse_location(xdo_t const * x0, int * x1, int * x2, int * x3) +{ + return xdo_get_mouse_location(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_mouse_location(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int * x1; + int * x2; + int * x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_get_mouse_location", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_mouse_location(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_mouse_location _cffi_d_xdo_get_mouse_location +#endif + +static int _cffi_d_xdo_get_mouse_location2(xdo_t const * x0, int * x1, int * x2, int * x3, unsigned long * x4) +{ + return xdo_get_mouse_location2(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_mouse_location2(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int * x1; + int * x2; + int * x3; + unsigned long * x4; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "xdo_get_mouse_location2", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg4, (char **)&x4); + if (datasize != 0) { + x4 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg4, (char **)&x4, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_mouse_location2(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_mouse_location2 _cffi_d_xdo_get_mouse_location2 +#endif + +static int _cffi_d_xdo_get_number_of_desktops(xdo_t const * x0, long * x1) +{ + return xdo_get_number_of_desktops(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_number_of_desktops(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_number_of_desktops", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(50), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(50), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_number_of_desktops(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_number_of_desktops _cffi_d_xdo_get_number_of_desktops +#endif + +static int _cffi_d_xdo_get_pid_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_get_pid_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_pid_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_pid_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_pid_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_pid_window _cffi_d_xdo_get_pid_window +#endif + +static char const * * _cffi_d_xdo_get_symbol_map(void) +{ + return xdo_get_symbol_map(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_symbol_map(PyObject *self, PyObject *noarg) +{ + char const * * result; + PyObject *pyresult; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_symbol_map(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + pyresult = _cffi_from_c_pointer((char *)result, _cffi_type(219)); + return pyresult; +} +#else +# define _cffi_f_xdo_get_symbol_map _cffi_d_xdo_get_symbol_map +#endif + +static int _cffi_d_xdo_get_viewport_dimensions(xdo_t * x0, unsigned int * x1, unsigned int * x2, int x3) +{ + return xdo_get_viewport_dimensions(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_viewport_dimensions(PyObject *self, PyObject *args) +{ + xdo_t * x0; + unsigned int * x1; + unsigned int * x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_get_viewport_dimensions", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(5), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(5), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_viewport_dimensions(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_viewport_dimensions _cffi_d_xdo_get_viewport_dimensions +#endif + +static int _cffi_d_xdo_get_window_at_mouse(xdo_t const * x0, unsigned long * x1) +{ + return xdo_get_window_at_mouse(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_window_at_mouse(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_get_window_at_mouse", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_window_at_mouse(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_window_at_mouse _cffi_d_xdo_get_window_at_mouse +#endif + +static int _cffi_d_xdo_get_window_location(xdo_t const * x0, unsigned long x1, int * x2, int * x3, int * * x4) +{ + return xdo_get_window_location(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_window_location(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int * x2; + int * x3; + int * * x4; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "xdo_get_window_location", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(105), arg4, (char **)&x4); + if (datasize != 0) { + x4 = ((size_t)datasize) <= 640 ? (int * *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(105), arg4, (char **)&x4, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_window_location(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_window_location _cffi_d_xdo_get_window_location +#endif + +static int _cffi_d_xdo_get_window_name(xdo_t const * x0, unsigned long x1, unsigned char * * x2, int * x3, int * x4) +{ + return xdo_get_window_name(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_window_name(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned char * * x2; + int * x3; + int * x4; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "xdo_get_window_name", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(80), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (unsigned char * *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(80), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg4, (char **)&x4); + if (datasize != 0) { + x4 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg4, (char **)&x4, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_window_name(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_window_name _cffi_d_xdo_get_window_name +#endif + +static int _cffi_d_xdo_get_window_property(xdo_t const * x0, unsigned long x1, char const * x2, unsigned char * * x3, long * x4, unsigned long * x5, int * x6) +{ + return xdo_get_window_property(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_window_property(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + unsigned char * * x3; + long * x4; + unsigned long * x5; + int * x6; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "xdo_get_window_property", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(80), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (unsigned char * *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(80), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(50), arg4, (char **)&x4); + if (datasize != 0) { + x4 = ((size_t)datasize) <= 640 ? (long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(50), arg4, (char **)&x4, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg5, (char **)&x5); + if (datasize != 0) { + x5 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg5, (char **)&x5, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg6, (char **)&x6); + if (datasize != 0) { + x6 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg6, (char **)&x6, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_window_property(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_window_property _cffi_d_xdo_get_window_property +#endif + +static unsigned char * _cffi_d_xdo_get_window_property_by_atom(xdo_t const * x0, unsigned long x1, unsigned long x2, long * x3, unsigned long * x4, int * x5) +{ + return xdo_get_window_property_by_atom(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_window_property_by_atom(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned long x2; + long * x3; + unsigned long * x4; + int * x5; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + unsigned char * result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "xdo_get_window_property_by_atom", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, unsigned long); + if (x2 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(50), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(50), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg4, (char **)&x4); + if (datasize != 0) { + x4 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg4, (char **)&x4, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg5, (char **)&x5); + if (datasize != 0) { + x5 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg5, (char **)&x5, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_window_property_by_atom(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_pointer((char *)result, _cffi_type(224)); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_window_property_by_atom _cffi_d_xdo_get_window_property_by_atom +#endif + +static int _cffi_d_xdo_get_window_size(xdo_t const * x0, unsigned long x1, unsigned int * x2, unsigned int * x3) +{ + return xdo_get_window_size(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_get_window_size(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned int * x2; + unsigned int * x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_get_window_size", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_get_window_size(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_get_window_size _cffi_d_xdo_get_window_size +#endif + +static int _cffi_d_xdo_has_feature(xdo_t * x0, int x1) +{ + return xdo_has_feature(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_has_feature(PyObject *self, PyObject *args) +{ + xdo_t * x0; + int x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_has_feature", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(5), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(5), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_has_feature(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_has_feature _cffi_d_xdo_has_feature +#endif + +static int _cffi_d_xdo_kill_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_kill_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_kill_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_kill_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_kill_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_kill_window _cffi_d_xdo_kill_window +#endif + +static int _cffi_d_xdo_map_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_map_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_map_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_map_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_map_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_map_window _cffi_d_xdo_map_window +#endif + +static int _cffi_d_xdo_minimize_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_minimize_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_minimize_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_minimize_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_minimize_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_minimize_window _cffi_d_xdo_minimize_window +#endif + +static int _cffi_d_xdo_mouse_down(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_mouse_down(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_mouse_down(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_mouse_down", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_mouse_down(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_mouse_down _cffi_d_xdo_mouse_down +#endif + +static int _cffi_d_xdo_mouse_up(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_mouse_up(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_mouse_up(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_mouse_up", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_mouse_up(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_mouse_up _cffi_d_xdo_mouse_up +#endif + +static int _cffi_d_xdo_move_mouse(xdo_t const * x0, int x1, int x2, int x3) +{ + return xdo_move_mouse(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_move_mouse(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int x1; + int x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_move_mouse", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_move_mouse(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_move_mouse _cffi_d_xdo_move_mouse +#endif + +static int _cffi_d_xdo_move_mouse_relative(xdo_t const * x0, int x1, int x2) +{ + return xdo_move_mouse_relative(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_move_mouse_relative(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_move_mouse_relative", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_move_mouse_relative(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_move_mouse_relative _cffi_d_xdo_move_mouse_relative +#endif + +static int _cffi_d_xdo_move_mouse_relative_to_window(xdo_t const * x0, unsigned long x1, int x2, int x3) +{ + return xdo_move_mouse_relative_to_window(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_move_mouse_relative_to_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_move_mouse_relative_to_window", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_move_mouse_relative_to_window(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_move_mouse_relative_to_window _cffi_d_xdo_move_mouse_relative_to_window +#endif + +static int _cffi_d_xdo_move_window(xdo_t const * x0, unsigned long x1, int x2, int x3) +{ + return xdo_move_window(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_move_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_move_window", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_move_window(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_move_window _cffi_d_xdo_move_window +#endif + +static xdo_t * _cffi_d_xdo_new(char const * x0) +{ + return xdo_new(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_new(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + xdo_t * result; + PyObject *pyresult; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_new(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_pointer((char *)result, _cffi_type(5)); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_new _cffi_d_xdo_new +#endif + +static xdo_t * _cffi_d_xdo_new_with_opened_display(Display * x0, char const * x1, int x2) +{ + return xdo_new_with_opened_display(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_new_with_opened_display(PyObject *self, PyObject *args) +{ + Display * x0; + char const * x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + xdo_t * result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_new_with_opened_display", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(207), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (Display *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(207), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_new_with_opened_display(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_pointer((char *)result, _cffi_type(5)); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_new_with_opened_display _cffi_d_xdo_new_with_opened_display +#endif + +static int _cffi_d_xdo_raise_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_raise_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_raise_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_raise_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_raise_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_raise_window _cffi_d_xdo_raise_window +#endif + +static int _cffi_d_xdo_reparent_window(xdo_t const * x0, unsigned long x1, unsigned long x2) +{ + return xdo_reparent_window(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_reparent_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned long x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_reparent_window", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, unsigned long); + if (x2 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_reparent_window(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_reparent_window _cffi_d_xdo_reparent_window +#endif + +static int _cffi_d_xdo_search_windows(xdo_t const * x0, xdo_search_t const * x1, unsigned long * * x2, unsigned int * x3) +{ + return xdo_search_windows(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_search_windows(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + xdo_search_t const * x1; + unsigned long * * x2; + unsigned int * x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_search_windows", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(184), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (xdo_search_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(184), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(185), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (unsigned long * *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(185), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_search_windows(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_search_windows _cffi_d_xdo_search_windows +#endif + +static int _cffi_d_xdo_select_window_with_click(xdo_t const * x0, unsigned long * x1) +{ + return xdo_select_window_with_click(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_select_window_with_click(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long * x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_select_window_with_click", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(35), arg1, (char **)&x1); + if (datasize != 0) { + x1 = ((size_t)datasize) <= 640 ? (unsigned long *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(35), arg1, (char **)&x1, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_select_window_with_click(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_select_window_with_click _cffi_d_xdo_select_window_with_click +#endif + +static int _cffi_d_xdo_send_keysequence_window(xdo_t const * x0, unsigned long x1, char const * x2, uint32_t x3) +{ + return xdo_send_keysequence_window(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_send_keysequence_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + uint32_t x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_send_keysequence_window", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, uint32_t); + if (x3 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_send_keysequence_window(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_send_keysequence_window _cffi_d_xdo_send_keysequence_window +#endif + +static int _cffi_d_xdo_send_keysequence_window_down(xdo_t const * x0, unsigned long x1, char const * x2, uint32_t x3) +{ + return xdo_send_keysequence_window_down(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_send_keysequence_window_down(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + uint32_t x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_send_keysequence_window_down", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, uint32_t); + if (x3 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_send_keysequence_window_down(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_send_keysequence_window_down _cffi_d_xdo_send_keysequence_window_down +#endif + +static int _cffi_d_xdo_send_keysequence_window_list_do(xdo_t const * x0, unsigned long x1, charcodemap_t * x2, int x3, int x4, int * x5, uint32_t x6) +{ + return xdo_send_keysequence_window_list_do(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_send_keysequence_window_list_do(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + charcodemap_t * x2; + int x3; + int x4; + int * x5; + uint32_t x6; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "xdo_send_keysequence_window_list_do", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(88), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (charcodemap_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(88), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg5, (char **)&x5); + if (datasize != 0) { + x5 = ((size_t)datasize) <= 640 ? (int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(17), arg5, (char **)&x5, + datasize, &large_args_free) < 0) + return NULL; + } + + x6 = _cffi_to_c_int(arg6, uint32_t); + if (x6 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_send_keysequence_window_list_do(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_send_keysequence_window_list_do _cffi_d_xdo_send_keysequence_window_list_do +#endif + +static int _cffi_d_xdo_send_keysequence_window_up(xdo_t const * x0, unsigned long x1, char const * x2, uint32_t x3) +{ + return xdo_send_keysequence_window_up(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_send_keysequence_window_up(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + uint32_t x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_send_keysequence_window_up", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, uint32_t); + if (x3 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_send_keysequence_window_up(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_send_keysequence_window_up _cffi_d_xdo_send_keysequence_window_up +#endif + +static int _cffi_d_xdo_set_active_modifiers(xdo_t const * x0, unsigned long x1, charcodemap_t * x2, int x3) +{ + return xdo_set_active_modifiers(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_active_modifiers(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + charcodemap_t * x2; + int x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_set_active_modifiers", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(88), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (charcodemap_t *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(88), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_active_modifiers(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_active_modifiers _cffi_d_xdo_set_active_modifiers +#endif + +static int _cffi_d_xdo_set_current_desktop(xdo_t const * x0, long x1) +{ + return xdo_set_current_desktop(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_current_desktop(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_set_current_desktop", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_current_desktop(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_current_desktop _cffi_d_xdo_set_current_desktop +#endif + +static int _cffi_d_xdo_set_desktop_for_window(xdo_t const * x0, unsigned long x1, long x2) +{ + return xdo_set_desktop_for_window(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_desktop_for_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + long x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_set_desktop_for_window", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, long); + if (x2 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_desktop_for_window(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_desktop_for_window _cffi_d_xdo_set_desktop_for_window +#endif + +static int _cffi_d_xdo_set_desktop_viewport(xdo_t const * x0, int x1, int x2) +{ + return xdo_set_desktop_viewport(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_desktop_viewport(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_set_desktop_viewport", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_desktop_viewport(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_desktop_viewport _cffi_d_xdo_set_desktop_viewport +#endif + +static int _cffi_d_xdo_set_number_of_desktops(xdo_t const * x0, long x1) +{ + return xdo_set_number_of_desktops(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_number_of_desktops(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_set_number_of_desktops", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_number_of_desktops(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_number_of_desktops _cffi_d_xdo_set_number_of_desktops +#endif + +static int _cffi_d_xdo_set_window_class(xdo_t const * x0, unsigned long x1, char const * x2, char const * x3) +{ + return xdo_set_window_class(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_window_class(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + char const * x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_set_window_class", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_window_class(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_window_class _cffi_d_xdo_set_window_class +#endif + +static int _cffi_d_xdo_set_window_override_redirect(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_set_window_override_redirect(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_window_override_redirect(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_set_window_override_redirect", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_window_override_redirect(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_window_override_redirect _cffi_d_xdo_set_window_override_redirect +#endif + +static int _cffi_d_xdo_set_window_property(xdo_t const * x0, unsigned long x1, char const * x2, char const * x3) +{ + return xdo_set_window_property(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_window_property(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + char const * x2; + char const * x3; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "xdo_set_window_property", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg2, (char **)&x2); + if (datasize != 0) { + x2 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg2, (char **)&x2, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(67), arg3, (char **)&x3); + if (datasize != 0) { + x3 = ((size_t)datasize) <= 640 ? (char const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(67), arg3, (char **)&x3, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_window_property(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_window_property _cffi_d_xdo_set_window_property +#endif + +static int _cffi_d_xdo_set_window_size(xdo_t const * x0, unsigned long x1, int x2, int x3, int x4) +{ + return xdo_set_window_size(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_window_size(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + int x3; + int x4; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "xdo_set_window_size", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_window_size(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_window_size _cffi_d_xdo_set_window_size +#endif + +static int _cffi_d_xdo_set_window_urgency(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_set_window_urgency(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_set_window_urgency(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_set_window_urgency", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_set_window_urgency(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_set_window_urgency _cffi_d_xdo_set_window_urgency +#endif + +static int _cffi_d_xdo_translate_window_with_sizehint(xdo_t const * x0, unsigned long x1, unsigned int x2, unsigned int x3, unsigned int * x4, unsigned int * x5) +{ + return xdo_translate_window_with_sizehint(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_translate_window_with_sizehint(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned int x2; + unsigned int x3; + unsigned int * x4; + unsigned int * x5; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "xdo_translate_window_with_sizehint", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, unsigned int); + if (x3 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg4, (char **)&x4); + if (datasize != 0) { + x4 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg4, (char **)&x4, + datasize, &large_args_free) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(10), arg5, (char **)&x5); + if (datasize != 0) { + x5 = ((size_t)datasize) <= 640 ? (unsigned int *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(10), arg5, (char **)&x5, + datasize, &large_args_free) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_translate_window_with_sizehint(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_translate_window_with_sizehint _cffi_d_xdo_translate_window_with_sizehint +#endif + +static int _cffi_d_xdo_unmap_window(xdo_t const * x0, unsigned long x1) +{ + return xdo_unmap_window(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_unmap_window(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "xdo_unmap_window", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_unmap_window(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_unmap_window _cffi_d_xdo_unmap_window +#endif + +static char const * _cffi_d_xdo_version(void) +{ + return xdo_version(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_version(PyObject *self, PyObject *noarg) +{ + char const * result; + PyObject *pyresult; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_version(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + pyresult = _cffi_from_c_pointer((char *)result, _cffi_type(67)); + return pyresult; +} +#else +# define _cffi_f_xdo_version _cffi_d_xdo_version +#endif + +static int _cffi_d_xdo_wait_for_mouse_move_from(xdo_t const * x0, int x1, int x2) +{ + return xdo_wait_for_mouse_move_from(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_wait_for_mouse_move_from(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_wait_for_mouse_move_from", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_wait_for_mouse_move_from(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_wait_for_mouse_move_from _cffi_d_xdo_wait_for_mouse_move_from +#endif + +static int _cffi_d_xdo_wait_for_mouse_move_to(xdo_t const * x0, int x1, int x2) +{ + return xdo_wait_for_mouse_move_to(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_wait_for_mouse_move_to(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + int x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_wait_for_mouse_move_to", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_wait_for_mouse_move_to(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_wait_for_mouse_move_to _cffi_d_xdo_wait_for_mouse_move_to +#endif + +static int _cffi_d_xdo_wait_for_window_active(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_wait_for_window_active(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_wait_for_window_active(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_wait_for_window_active", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_wait_for_window_active(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_wait_for_window_active _cffi_d_xdo_wait_for_window_active +#endif + +static int _cffi_d_xdo_wait_for_window_focus(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_wait_for_window_focus(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_wait_for_window_focus(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_wait_for_window_focus", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_wait_for_window_focus(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_wait_for_window_focus _cffi_d_xdo_wait_for_window_focus +#endif + +static int _cffi_d_xdo_wait_for_window_map_state(xdo_t const * x0, unsigned long x1, int x2) +{ + return xdo_wait_for_window_map_state(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_wait_for_window_map_state(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + int x2; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "xdo_wait_for_window_map_state", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_wait_for_window_map_state(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_wait_for_window_map_state _cffi_d_xdo_wait_for_window_map_state +#endif + +static int _cffi_d_xdo_wait_for_window_size(xdo_t const * x0, unsigned long x1, unsigned int x2, unsigned int x3, int x4, int x5) +{ + return xdo_wait_for_window_size(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_xdo_wait_for_window_size(PyObject *self, PyObject *args) +{ + xdo_t const * x0; + unsigned long x1; + unsigned int x2; + unsigned int x3; + int x4; + int x5; + Py_ssize_t datasize; + struct _cffi_freeme_s *large_args_free = NULL; + int result; + PyObject *pyresult; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "xdo_wait_for_window_size", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(15), arg0, (char **)&x0); + if (datasize != 0) { + x0 = ((size_t)datasize) <= 640 ? (xdo_t const *)alloca((size_t)datasize) : NULL; + if (_cffi_convert_array_argument(_cffi_type(15), arg0, (char **)&x0, + datasize, &large_args_free) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, unsigned int); + if (x3 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = xdo_wait_for_window_size(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + pyresult = _cffi_from_c_int(result, int); + if (large_args_free != NULL) _cffi_free_array_arguments(large_args_free); + return pyresult; +} +#else +# define _cffi_f_xdo_wait_for_window_size _cffi_d_xdo_wait_for_window_size +#endif + +static int _cffi_const_CURRENTWINDOW(unsigned long long *o) +{ + int n = (CURRENTWINDOW) <= 0; + *o = (unsigned long long)((CURRENTWINDOW) | 0); /* check that CURRENTWINDOW is an integer */ + if (!_cffi_check_int(*o, n, 0)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_CLASS(unsigned long long *o) +{ + int n = (SEARCH_CLASS) <= 0; + *o = (unsigned long long)((SEARCH_CLASS) | 0); /* check that SEARCH_CLASS is an integer */ + if (!_cffi_check_int(*o, n, 2U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_CLASSNAME(unsigned long long *o) +{ + int n = (SEARCH_CLASSNAME) <= 0; + *o = (unsigned long long)((SEARCH_CLASSNAME) | 0); /* check that SEARCH_CLASSNAME is an integer */ + if (!_cffi_check_int(*o, n, 64U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_DESKTOP(unsigned long long *o) +{ + int n = (SEARCH_DESKTOP) <= 0; + *o = (unsigned long long)((SEARCH_DESKTOP) | 0); /* check that SEARCH_DESKTOP is an integer */ + if (!_cffi_check_int(*o, n, 128U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_NAME(unsigned long long *o) +{ + int n = (SEARCH_NAME) <= 0; + *o = (unsigned long long)((SEARCH_NAME) | 0); /* check that SEARCH_NAME is an integer */ + if (!_cffi_check_int(*o, n, 4U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_ONLYVISIBLE(unsigned long long *o) +{ + int n = (SEARCH_ONLYVISIBLE) <= 0; + *o = (unsigned long long)((SEARCH_ONLYVISIBLE) | 0); /* check that SEARCH_ONLYVISIBLE is an integer */ + if (!_cffi_check_int(*o, n, 16U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_PID(unsigned long long *o) +{ + int n = (SEARCH_PID) <= 0; + *o = (unsigned long long)((SEARCH_PID) | 0); /* check that SEARCH_PID is an integer */ + if (!_cffi_check_int(*o, n, 8U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_SCREEN(unsigned long long *o) +{ + int n = (SEARCH_SCREEN) <= 0; + *o = (unsigned long long)((SEARCH_SCREEN) | 0); /* check that SEARCH_SCREEN is an integer */ + if (!_cffi_check_int(*o, n, 32U)) + n |= 2; + return n; +} + +static int _cffi_const_SEARCH_TITLE(unsigned long long *o) +{ + int n = (SEARCH_TITLE) <= 0; + *o = (unsigned long long)((SEARCH_TITLE) | 0); /* check that SEARCH_TITLE is an integer */ + if (!_cffi_check_int(*o, n, 1U)) + n |= 2; + return n; +} + +static int _cffi_const_SIZE_FROM(unsigned long long *o) +{ + int n = (SIZE_FROM) <= 0; + *o = (unsigned long long)((SIZE_FROM) | 0); /* check that SIZE_FROM is an integer */ + if (!_cffi_check_int(*o, n, 1U)) + n |= 2; + return n; +} + +static int _cffi_const_SIZE_TO(unsigned long long *o) +{ + int n = (SIZE_TO) <= 0; + *o = (unsigned long long)((SIZE_TO) | 0); /* check that SIZE_TO is an integer */ + if (!_cffi_check_int(*o, n, 0)) + n |= 2; + return n; +} + +static int _cffi_const_SIZE_USEHINTS(unsigned long long *o) +{ + int n = (SIZE_USEHINTS) <= 0; + *o = (unsigned long long)((SIZE_USEHINTS) | 0); /* check that SIZE_USEHINTS is an integer */ + if (!_cffi_check_int(*o, n, 1U)) + n |= 2; + return n; +} + +static int _cffi_const_SIZE_USEHINTS_X(unsigned long long *o) +{ + int n = (SIZE_USEHINTS_X) <= 0; + *o = (unsigned long long)((SIZE_USEHINTS_X) | 0); /* check that SIZE_USEHINTS_X is an integer */ + if (!_cffi_check_int(*o, n, 2U)) + n |= 2; + return n; +} + +static int _cffi_const_SIZE_USEHINTS_Y(unsigned long long *o) +{ + int n = (SIZE_USEHINTS_Y) <= 0; + *o = (unsigned long long)((SIZE_USEHINTS_Y) | 0); /* check that SIZE_USEHINTS_Y is an integer */ + if (!_cffi_check_int(*o, n, 4U)) + n |= 2; + return n; +} + +static int _cffi_const_XDO_ERROR(unsigned long long *o) +{ + int n = (XDO_ERROR) <= 0; + *o = (unsigned long long)((XDO_ERROR) | 0); /* check that XDO_ERROR is an integer */ + if (!_cffi_check_int(*o, n, 1U)) + n |= 2; + return n; +} + +static int _cffi_const_XDO_FIND_CHILDREN(unsigned long long *o) +{ + int n = (XDO_FIND_CHILDREN) <= 0; + *o = (unsigned long long)((XDO_FIND_CHILDREN) | 0); /* check that XDO_FIND_CHILDREN is an integer */ + if (!_cffi_check_int(*o, n, 1U)) + n |= 2; + return n; +} + +static int _cffi_const_XDO_FIND_PARENTS(unsigned long long *o) +{ + int n = (XDO_FIND_PARENTS) <= 0; + *o = (unsigned long long)((XDO_FIND_PARENTS) | 0); /* check that XDO_FIND_PARENTS is an integer */ + if (!_cffi_check_int(*o, n, 0)) + n |= 2; + return n; +} + +static int _cffi_const_XDO_SUCCESS(unsigned long long *o) +{ + int n = (XDO_SUCCESS) <= 0; + *o = (unsigned long long)((XDO_SUCCESS) | 0); /* check that XDO_SUCCESS is an integer */ + if (!_cffi_check_int(*o, n, 0)) + n |= 2; + return n; +} + +_CFFI_UNUSED_FN +static void _cffi_checkfld__charcodemap_t(charcodemap_t *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { wchar_t *tmp = &p->key; (void)tmp; } + (void)((p->code) | 0); /* check that 'charcodemap_t.code' is an integer */ + (void)((p->symbol) | 0); /* check that 'charcodemap_t.symbol' is an integer */ + (void)((p->group) | 0); /* check that 'charcodemap_t.group' is an integer */ + (void)((p->modmask) | 0); /* check that 'charcodemap_t.modmask' is an integer */ + (void)((p->needs_binding) | 0); /* check that 'charcodemap_t.needs_binding' is an integer */ +} +struct _cffi_align__charcodemap_t { char x; charcodemap_t y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld__xdo_t(xdo_t *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { Display * *tmp = &p->xdpy; (void)tmp; } + { char * *tmp = &p->display_name; (void)tmp; } + { charcodemap_t * *tmp = &p->charcodes; (void)tmp; } + (void)((p->charcodes_len) | 0); /* check that 'xdo_t.charcodes_len' is an integer */ + { XModifierKeymap * *tmp = &p->modmap; (void)tmp; } + { unsigned long * *tmp = &p->keymap; (void)tmp; } + (void)((p->keycode_high) | 0); /* check that 'xdo_t.keycode_high' is an integer */ + (void)((p->keycode_low) | 0); /* check that 'xdo_t.keycode_low' is an integer */ + (void)((p->keysyms_per_keycode) | 0); /* check that 'xdo_t.keysyms_per_keycode' is an integer */ + (void)((p->close_display_when_freed) | 0); /* check that 'xdo_t.close_display_when_freed' is an integer */ + (void)((p->quiet) | 0); /* check that 'xdo_t.quiet' is an integer */ + (void)((p->debug) | 0); /* check that 'xdo_t.debug' is an integer */ + (void)((p->features_mask) | 0); /* check that 'xdo_t.features_mask' is an integer */ +} +struct _cffi_align__xdo_t { char x; xdo_t y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld__xdo_search_t(xdo_search_t *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { char const * *tmp = &p->title; (void)tmp; } + { char const * *tmp = &p->winclass; (void)tmp; } + { char const * *tmp = &p->winclassname; (void)tmp; } + { char const * *tmp = &p->winname; (void)tmp; } + (void)((p->pid) | 0); /* check that 'xdo_search_t.pid' is an integer */ + (void)((p->max_depth) | 0); /* check that 'xdo_search_t.max_depth' is an integer */ + (void)((p->only_visible) | 0); /* check that 'xdo_search_t.only_visible' is an integer */ + (void)((p->screen) | 0); /* check that 'xdo_search_t.screen' is an integer */ + /* cannot generate 'enum $1' in field 'require': unknown type name */ + (void)((p->searchmask) | 0); /* check that 'xdo_search_t.searchmask' is an integer */ + (void)((p->desktop) | 0); /* check that 'xdo_search_t.desktop' is an integer */ + (void)((p->limit) | 0); /* check that 'xdo_search_t.limit' is an integer */ +} +struct _cffi_align__xdo_search_t { char x; xdo_search_t y; }; + +static const struct _cffi_global_s _cffi_globals[] = { + { "CURRENTWINDOW", (void *)_cffi_const_CURRENTWINDOW, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_ALL", (void *)_cffi_const_SEARCH_ALL, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SEARCH_ANY", (void *)_cffi_const_SEARCH_ANY, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SEARCH_CLASS", (void *)_cffi_const_SEARCH_CLASS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_CLASSNAME", (void *)_cffi_const_SEARCH_CLASSNAME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_DESKTOP", (void *)_cffi_const_SEARCH_DESKTOP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_NAME", (void *)_cffi_const_SEARCH_NAME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_ONLYVISIBLE", (void *)_cffi_const_SEARCH_ONLYVISIBLE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_PID", (void *)_cffi_const_SEARCH_PID, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_SCREEN", (void *)_cffi_const_SEARCH_SCREEN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SEARCH_TITLE", (void *)_cffi_const_SEARCH_TITLE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SIZE_FROM", (void *)_cffi_const_SIZE_FROM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SIZE_TO", (void *)_cffi_const_SIZE_TO, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SIZE_USEHINTS", (void *)_cffi_const_SIZE_USEHINTS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SIZE_USEHINTS_X", (void *)_cffi_const_SIZE_USEHINTS_X, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SIZE_USEHINTS_Y", (void *)_cffi_const_SIZE_USEHINTS_Y, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "XDO_ERROR", (void *)_cffi_const_XDO_ERROR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "XDO_FEATURE_XTEST", (void *)_cffi_const_XDO_FEATURE_XTEST, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "XDO_FIND_CHILDREN", (void *)_cffi_const_XDO_FIND_CHILDREN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "XDO_FIND_PARENTS", (void *)_cffi_const_XDO_FIND_PARENTS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "XDO_SUCCESS", (void *)_cffi_const_XDO_SUCCESS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "xdo_activate_window", (void *)_cffi_f_xdo_activate_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_activate_window }, + { "xdo_clear_active_modifiers", (void *)_cffi_f_xdo_clear_active_modifiers, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 85), (void *)_cffi_d_xdo_clear_active_modifiers }, + { "xdo_click_window", (void *)_cffi_f_xdo_click_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_click_window }, + { "xdo_click_window_multiple", (void *)_cffi_f_xdo_click_window_multiple, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 125), (void *)_cffi_d_xdo_click_window_multiple }, + { "xdo_close_window", (void *)_cffi_f_xdo_close_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_close_window }, + { "xdo_disable_feature", (void *)_cffi_f_xdo_disable_feature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 202), (void *)_cffi_d_xdo_disable_feature }, + { "xdo_enable_feature", (void *)_cffi_f_xdo_enable_feature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 202), (void *)_cffi_d_xdo_enable_feature }, + { "xdo_enter_text_window", (void *)_cffi_f_xdo_enter_text_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 70), (void *)_cffi_d_xdo_enter_text_window }, + { "xdo_find_window_client", (void *)_cffi_f_xdo_find_window_client, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 171), (void *)_cffi_d_xdo_find_window_client }, + { "xdo_focus_window", (void *)_cffi_f_xdo_focus_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_focus_window }, + { "xdo_free", (void *)_cffi_f_xdo_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 199), (void *)_cffi_d_xdo_free }, + { "xdo_get_active_modifiers", (void *)_cffi_f_xdo_get_active_modifiers, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 14), (void *)_cffi_d_xdo_get_active_modifiers }, + { "xdo_get_active_window", (void *)_cffi_f_xdo_get_active_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 56), (void *)_cffi_d_xdo_get_active_window }, + { "xdo_get_current_desktop", (void *)_cffi_f_xdo_get_current_desktop, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 48), (void *)_cffi_d_xdo_get_current_desktop }, + { "xdo_get_desktop_for_window", (void *)_cffi_f_xdo_get_desktop_for_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 132), (void *)_cffi_d_xdo_get_desktop_for_window }, + { "xdo_get_desktop_viewport", (void *)_cffi_f_xdo_get_desktop_viewport, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 19), (void *)_cffi_d_xdo_get_desktop_viewport }, + { "xdo_get_focused_window", (void *)_cffi_f_xdo_get_focused_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 56), (void *)_cffi_d_xdo_get_focused_window }, + { "xdo_get_focused_window_sane", (void *)_cffi_f_xdo_get_focused_window_sane, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 56), (void *)_cffi_d_xdo_get_focused_window_sane }, + { "xdo_get_input_state", (void *)_cffi_f_xdo_get_input_state, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 196), (void *)_cffi_d_xdo_get_input_state }, + { "xdo_get_mouse_location", (void *)_cffi_f_xdo_get_mouse_location, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 24), (void *)_cffi_d_xdo_get_mouse_location }, + { "xdo_get_mouse_location2", (void *)_cffi_f_xdo_get_mouse_location2, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 30), (void *)_cffi_d_xdo_get_mouse_location2 }, + { "xdo_get_number_of_desktops", (void *)_cffi_f_xdo_get_number_of_desktops, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 48), (void *)_cffi_d_xdo_get_number_of_desktops }, + { "xdo_get_pid_window", (void *)_cffi_f_xdo_get_pid_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_get_pid_window }, + { "xdo_get_symbol_map", (void *)_cffi_f_xdo_get_symbol_map, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 0), (void *)_cffi_d_xdo_get_symbol_map }, + { "xdo_get_viewport_dimensions", (void *)_cffi_f_xdo_get_viewport_dimensions, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 8), (void *)_cffi_d_xdo_get_viewport_dimensions }, + { "xdo_get_window_at_mouse", (void *)_cffi_f_xdo_get_window_at_mouse, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 56), (void *)_cffi_d_xdo_get_window_at_mouse }, + { "xdo_get_window_location", (void *)_cffi_f_xdo_get_window_location, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 100), (void *)_cffi_d_xdo_get_window_location }, + { "xdo_get_window_name", (void *)_cffi_f_xdo_get_window_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 142), (void *)_cffi_d_xdo_get_window_name }, + { "xdo_get_window_property", (void *)_cffi_f_xdo_get_window_property, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 76), (void *)_cffi_d_xdo_get_window_property }, + { "xdo_get_window_property_by_atom", (void *)_cffi_f_xdo_get_window_property_by_atom, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 188), (void *)_cffi_d_xdo_get_window_property_by_atom }, + { "xdo_get_window_size", (void *)_cffi_f_xdo_get_window_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 149), (void *)_cffi_d_xdo_get_window_size }, + { "xdo_has_feature", (void *)_cffi_f_xdo_has_feature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 4), (void *)_cffi_d_xdo_has_feature }, + { "xdo_kill_window", (void *)_cffi_f_xdo_kill_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_kill_window }, + { "xdo_map_window", (void *)_cffi_f_xdo_map_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_map_window }, + { "xdo_minimize_window", (void *)_cffi_f_xdo_minimize_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_minimize_window }, + { "xdo_mouse_down", (void *)_cffi_f_xdo_mouse_down, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_mouse_down }, + { "xdo_mouse_up", (void *)_cffi_f_xdo_mouse_up, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_mouse_up }, + { "xdo_move_mouse", (void *)_cffi_f_xdo_move_mouse, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 42), (void *)_cffi_d_xdo_move_mouse }, + { "xdo_move_mouse_relative", (void *)_cffi_f_xdo_move_mouse_relative, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 37), (void *)_cffi_d_xdo_move_mouse_relative }, + { "xdo_move_mouse_relative_to_window", (void *)_cffi_f_xdo_move_mouse_relative_to_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 112), (void *)_cffi_d_xdo_move_mouse_relative_to_window }, + { "xdo_move_window", (void *)_cffi_f_xdo_move_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 112), (void *)_cffi_d_xdo_move_window }, + { "xdo_new", (void *)_cffi_f_xdo_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 211), (void *)_cffi_d_xdo_new }, + { "xdo_new_with_opened_display", (void *)_cffi_f_xdo_new_with_opened_display, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 206), (void *)_cffi_d_xdo_new_with_opened_display }, + { "xdo_raise_window", (void *)_cffi_f_xdo_raise_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_raise_window }, + { "xdo_reparent_window", (void *)_cffi_f_xdo_reparent_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 177), (void *)_cffi_d_xdo_reparent_window }, + { "xdo_search_windows", (void *)_cffi_f_xdo_search_windows, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 182), (void *)_cffi_d_xdo_search_windows }, + { "xdo_select_window_with_click", (void *)_cffi_f_xdo_select_window_with_click, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 56), (void *)_cffi_d_xdo_select_window_with_click }, + { "xdo_send_keysequence_window", (void *)_cffi_f_xdo_send_keysequence_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 70), (void *)_cffi_d_xdo_send_keysequence_window }, + { "xdo_send_keysequence_window_down", (void *)_cffi_f_xdo_send_keysequence_window_down, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 70), (void *)_cffi_d_xdo_send_keysequence_window_down }, + { "xdo_send_keysequence_window_list_do", (void *)_cffi_f_xdo_send_keysequence_window_list_do, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 91), (void *)_cffi_d_xdo_send_keysequence_window_list_do }, + { "xdo_send_keysequence_window_up", (void *)_cffi_f_xdo_send_keysequence_window_up, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 70), (void *)_cffi_d_xdo_send_keysequence_window_up }, + { "xdo_set_active_modifiers", (void *)_cffi_f_xdo_set_active_modifiers, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 85), (void *)_cffi_d_xdo_set_active_modifiers }, + { "xdo_set_current_desktop", (void *)_cffi_f_xdo_set_current_desktop, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 52), (void *)_cffi_d_xdo_set_current_desktop }, + { "xdo_set_desktop_for_window", (void *)_cffi_f_xdo_set_desktop_for_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 137), (void *)_cffi_d_xdo_set_desktop_for_window }, + { "xdo_set_desktop_viewport", (void *)_cffi_f_xdo_set_desktop_viewport, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 37), (void *)_cffi_d_xdo_set_desktop_viewport }, + { "xdo_set_number_of_desktops", (void *)_cffi_f_xdo_set_number_of_desktops, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 52), (void *)_cffi_d_xdo_set_number_of_desktops }, + { "xdo_set_window_class", (void *)_cffi_f_xdo_set_window_class, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 64), (void *)_cffi_d_xdo_set_window_class }, + { "xdo_set_window_override_redirect", (void *)_cffi_f_xdo_set_window_override_redirect, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_set_window_override_redirect }, + { "xdo_set_window_property", (void *)_cffi_f_xdo_set_window_property, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 64), (void *)_cffi_d_xdo_set_window_property }, + { "xdo_set_window_size", (void *)_cffi_f_xdo_set_window_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 118), (void *)_cffi_d_xdo_set_window_size }, + { "xdo_set_window_urgency", (void *)_cffi_f_xdo_set_window_urgency, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_set_window_urgency }, + { "xdo_translate_window_with_sizehint", (void *)_cffi_f_xdo_translate_window_with_sizehint, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 163), (void *)_cffi_d_xdo_translate_window_with_sizehint }, + { "xdo_unmap_window", (void *)_cffi_f_xdo_unmap_window, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 60), (void *)_cffi_d_xdo_unmap_window }, + { "xdo_version", (void *)_cffi_f_xdo_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2), (void *)_cffi_d_xdo_version }, + { "xdo_wait_for_mouse_move_from", (void *)_cffi_f_xdo_wait_for_mouse_move_from, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 37), (void *)_cffi_d_xdo_wait_for_mouse_move_from }, + { "xdo_wait_for_mouse_move_to", (void *)_cffi_f_xdo_wait_for_mouse_move_to, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 37), (void *)_cffi_d_xdo_wait_for_mouse_move_to }, + { "xdo_wait_for_window_active", (void *)_cffi_f_xdo_wait_for_window_active, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_wait_for_window_active }, + { "xdo_wait_for_window_focus", (void *)_cffi_f_xdo_wait_for_window_focus, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_wait_for_window_focus }, + { "xdo_wait_for_window_map_state", (void *)_cffi_f_xdo_wait_for_window_map_state, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 107), (void *)_cffi_d_xdo_wait_for_window_map_state }, + { "xdo_wait_for_window_size", (void *)_cffi_f_xdo_wait_for_window_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 155), (void *)_cffi_d_xdo_wait_for_window_size }, +}; + +static const struct _cffi_field_s _cffi_fields[] = { + { "max_keypermod", offsetof(XModifierKeymap, max_keypermod), + sizeof(((XModifierKeymap *)0)->max_keypermod), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "modifiermap", offsetof(XModifierKeymap, modifiermap), + sizeof(((XModifierKeymap *)0)->modifiermap), + _CFFI_OP(_CFFI_OP_NOOP, 224) }, + { "key", offsetof(charcodemap_t, key), + sizeof(((charcodemap_t *)0)->key), + _CFFI_OP(_CFFI_OP_NOOP, 227) }, + { "code", offsetof(charcodemap_t, code), + sizeof(((charcodemap_t *)0)->code), + _CFFI_OP(_CFFI_OP_NOOP, 225) }, + { "symbol", offsetof(charcodemap_t, symbol), + sizeof(((charcodemap_t *)0)->symbol), + _CFFI_OP(_CFFI_OP_NOOP, 62) }, + { "group", offsetof(charcodemap_t, group), + sizeof(((charcodemap_t *)0)->group), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "modmask", offsetof(charcodemap_t, modmask), + sizeof(((charcodemap_t *)0)->modmask), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "needs_binding", offsetof(charcodemap_t, needs_binding), + sizeof(((charcodemap_t *)0)->needs_binding), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "xdpy", offsetof(xdo_t, xdpy), + sizeof(((xdo_t *)0)->xdpy), + _CFFI_OP(_CFFI_OP_NOOP, 207) }, + { "display_name", offsetof(xdo_t, display_name), + sizeof(((xdo_t *)0)->display_name), + _CFFI_OP(_CFFI_OP_NOOP, 218) }, + { "charcodes", offsetof(xdo_t, charcodes), + sizeof(((xdo_t *)0)->charcodes), + _CFFI_OP(_CFFI_OP_NOOP, 88) }, + { "charcodes_len", offsetof(xdo_t, charcodes_len), + sizeof(((xdo_t *)0)->charcodes_len), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "modmap", offsetof(xdo_t, modmap), + sizeof(((xdo_t *)0)->modmap), + _CFFI_OP(_CFFI_OP_NOOP, 216) }, + { "keymap", offsetof(xdo_t, keymap), + sizeof(((xdo_t *)0)->keymap), + _CFFI_OP(_CFFI_OP_NOOP, 35) }, + { "keycode_high", offsetof(xdo_t, keycode_high), + sizeof(((xdo_t *)0)->keycode_high), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "keycode_low", offsetof(xdo_t, keycode_low), + sizeof(((xdo_t *)0)->keycode_low), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "keysyms_per_keycode", offsetof(xdo_t, keysyms_per_keycode), + sizeof(((xdo_t *)0)->keysyms_per_keycode), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "close_display_when_freed", offsetof(xdo_t, close_display_when_freed), + sizeof(((xdo_t *)0)->close_display_when_freed), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "quiet", offsetof(xdo_t, quiet), + sizeof(((xdo_t *)0)->quiet), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "debug", offsetof(xdo_t, debug), + sizeof(((xdo_t *)0)->debug), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "features_mask", offsetof(xdo_t, features_mask), + sizeof(((xdo_t *)0)->features_mask), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "title", offsetof(xdo_search_t, title), + sizeof(((xdo_search_t *)0)->title), + _CFFI_OP(_CFFI_OP_NOOP, 67) }, + { "winclass", offsetof(xdo_search_t, winclass), + sizeof(((xdo_search_t *)0)->winclass), + _CFFI_OP(_CFFI_OP_NOOP, 67) }, + { "winclassname", offsetof(xdo_search_t, winclassname), + sizeof(((xdo_search_t *)0)->winclassname), + _CFFI_OP(_CFFI_OP_NOOP, 67) }, + { "winname", offsetof(xdo_search_t, winname), + sizeof(((xdo_search_t *)0)->winname), + _CFFI_OP(_CFFI_OP_NOOP, 67) }, + { "pid", offsetof(xdo_search_t, pid), + sizeof(((xdo_search_t *)0)->pid), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "max_depth", offsetof(xdo_search_t, max_depth), + sizeof(((xdo_search_t *)0)->max_depth), + _CFFI_OP(_CFFI_OP_NOOP, 54) }, + { "only_visible", offsetof(xdo_search_t, only_visible), + sizeof(((xdo_search_t *)0)->only_visible), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "screen", offsetof(xdo_search_t, screen), + sizeof(((xdo_search_t *)0)->screen), + _CFFI_OP(_CFFI_OP_NOOP, 6) }, + { "require", offsetof(xdo_search_t, require), + sizeof(((xdo_search_t *)0)->require), + _CFFI_OP(_CFFI_OP_NOOP, 222) }, + { "searchmask", offsetof(xdo_search_t, searchmask), + sizeof(((xdo_search_t *)0)->searchmask), + _CFFI_OP(_CFFI_OP_NOOP, 158) }, + { "desktop", offsetof(xdo_search_t, desktop), + sizeof(((xdo_search_t *)0)->desktop), + _CFFI_OP(_CFFI_OP_NOOP, 54) }, + { "limit", offsetof(xdo_search_t, limit), + sizeof(((xdo_search_t *)0)->limit), + _CFFI_OP(_CFFI_OP_NOOP, 158) }, +}; + +static const struct _cffi_struct_union_s _cffi_struct_unions[] = { + { "$XModifierKeymap", 217, _CFFI_F_CHECK_FIELDS, + sizeof(XModifierKeymap), offsetof(struct _cffi_align_typedef_XModifierKeymap, y), 0, 2 }, + { "Screen", 223, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "_XDisplay", 214, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "charcodemap", 221, _CFFI_F_CHECK_FIELDS, + sizeof(charcodemap_t), offsetof(struct _cffi_align__charcodemap_t, y), 2, 6 }, + { "xdo", 229, _CFFI_F_CHECK_FIELDS, + sizeof(xdo_t), offsetof(struct _cffi_align__xdo_t, y), 8, 13 }, + { "xdo_search", 228, _CFFI_F_CHECK_FIELDS, + sizeof(xdo_search_t), offsetof(struct _cffi_align__xdo_search_t, y), 21, 12 }, +}; + +static const struct _cffi_enum_s _cffi_enums[] = { + { "$1", 222, _cffi_prim_int(4, 0), + "SEARCH_ANY,SEARCH_ALL" }, + { "$XDO_FEATURES", 215, _cffi_prim_int(sizeof(XDO_FEATURES), ((XDO_FEATURES)-1) <= 0), + "XDO_FEATURE_XTEST" }, +}; + +static const struct _cffi_typename_s _cffi_typenames[] = { + { "Atom", 62 }, + { "Display", 214 }, + { "KeyCode", 225 }, + { "KeySym", 62 }, + { "Window", 62 }, + { "XDO_FEATURES", 215 }, + { "XID", 62 }, + { "XModifierKeymap", 217 }, + { "charcodemap_t", 221 }, + { "useconds_t", 74 }, + { "xdo_search_t", 228 }, + { "xdo_t", 229 }, +}; + +static const struct _cffi_type_context_s _cffi_type_context = { + _cffi_types, + _cffi_globals, + _cffi_fields, + _cffi_struct_unions, + _cffi_enums, + _cffi_typenames, + 91, /* num_globals */ + 6, /* num_struct_unions */ + 2, /* num_enums */ + 12, /* num_typenames */ + NULL, /* no includes */ + 230, /* num_types */ + 0, /* flags */ +}; + +#ifdef __GNUC__ +# pragma GCC visibility push(default) /* for -fvisibility= */ +#endif + +#ifdef PYPY_VERSION +PyMODINIT_FUNC +_cffi_pypyinit__xdo_cffi(const void *p[]) +{ + p[0] = (const void *)0x2601; + p[1] = &_cffi_type_context; +#if PY_MAJOR_VERSION >= 3 + return NULL; +#endif +} +# ifdef _MSC_VER + PyMODINIT_FUNC +# if PY_MAJOR_VERSION >= 3 + PyInit__xdo_cffi(void) { return NULL; } +# else + init_xdo_cffi(void) { } +# endif +# endif +#elif PY_MAJOR_VERSION >= 3 +PyMODINIT_FUNC +PyInit__xdo_cffi(void) +{ + return _cffi_init("_xdo_cffi", 0x2601, &_cffi_type_context); +} +#else +PyMODINIT_FUNC +init_xdo_cffi(void) +{ + _cffi_init("_xdo_cffi", 0x2601, &_cffi_type_context); +} +#endif + +#ifdef __GNUC__ +# pragma GCC visibility pop +#endif diff --git a/xdo_build.py b/xdo_build.py index 6c3a22c..f8e04d3 100644 --- a/xdo_build.py +++ b/xdo_build.py @@ -427,8 +427,11 @@ int xdo_send_keysequence_window_list_do(const xdo_t *xdo, Window window, * by this function. * @param nkeys Pointer to integer where the number of keys will be stored. */ -int xdo_get_active_keys_to_keycode_list(const xdo_t *xdo, charcodemap_t **keys, - int *nkeys); + +// commenting out because for some reason this prevents the python module from being loaded successfully: +// ImportError: /home/user/foo/_xdo_cffi.cpython-38-x86_64-linux-gnu.so: undefined symbol: xdo_get_active_keys_to_keycode_list +//int xdo_get_active_keys_to_keycode_list(const xdo_t *xdo, charcodemap_t **keys, +// int *nkeys); /** * Wait for a window to have a specific map state. diff --git a/xdo_test.py b/xdo_test.py new file mode 100644 index 0000000..87c2cc0 --- /dev/null +++ b/xdo_test.py @@ -0,0 +1,10 @@ +import time + +from _xdo_cffi import ffi, lib + +X = 200 + +xdo = lib.xdo_new(ffi.NULL) +for i in range(20): + lib.xdo_move_mouse(xdo, X * i, 500, 0) + time.sleep(0.1)