rendered paste body#include "sanepython.h"/* PySANEHandle type */void PySANEHandle_dealloc(PySANEHandle* self){ if (self->handle) sane_close(self->handle); self->ob_type->tp_free((PyObject*)self);}PyObject* PySANEHandle_new(PyTypeObject *type, PyObject *args, PyObject *kwds){ PySANEHandle *self; self = (PySANEHandle *) type->tp_alloc(type, 0); if (self != NULL) { self->handle = NULL; } return (PyObject *)self;}/* Option descriptor methods */PyObject* PySANEOptionDescriptor_new(PyTypeObject *type, PyObject *args, PyObject *kwds){ PySANEOptionDescriptor *self; self = (PySANEOptionDescriptor *) type->tp_alloc(type, 0); if (self != NULL) { self->descriptor = NULL; self->option = 0; self->type = 0; self->unit = 0; self->size = 0; self->name = Py_None; Py_INCREF(Py_None); self->title = Py_None; Py_INCREF(Py_None); self->description = Py_None; Py_INCREF(Py_None); } return (PyObject *)self;}void PySANEOptionDescriptor_dealloc(PySANEOptionDescriptor* self){ Py_DECREF(self->name); Py_DECREF(self->title); Py_DECREF(self->description); self->ob_type->tp_free((PyObject*)self);}PyObject* PySANEOptionDescriptor_FromDescriptor(int option, const SANE_Option_Descriptor *descriptor){ PySANEOptionDescriptor *self; PyObject *constraint; self = (PySANEOptionDescriptor *) PySANEOptionDescriptorType.tp_alloc(&PySANEOptionDescriptorType, 0); if (self != NULL) { self->descriptor = descriptor; self->option = option; self->type = descriptor->type; self->unit = descriptor->unit; self->size = descriptor->size; self->capabilities = descriptor->cap; self->constraintType = descriptor->constraint_type; if (descriptor->name != NULL) self->name = PyString_FromString(descriptor->name); else self->name = PyString_FromString(""); Py_INCREF(self->name); if (descriptor->title != NULL) self->title = PyString_FromString(descriptor->title); else self->title = PyString_FromString(""); Py_INCREF(self->title); if (descriptor->desc != NULL) self->description = PyString_FromString(descriptor->desc); else self->description = PyString_FromString(""); Py_INCREF(self->description); if (self->constraintType == SANE_CONSTRAINT_NONE) constraint = Py_None; else if (self->constraintType == SANE_CONSTRAINT_RANGE) { constraint = PyTuple_New(3); PyTuple_SetItem(constraint, 0, PyInt_FromLong(self->descriptor->constraint.range->min)); PyTuple_SetItem(constraint, 1, PyInt_FromLong(self->descriptor->constraint.range->max)); PyTuple_SetItem(constraint, 2, PyInt_FromLong(self->descriptor->constraint.range->quant)); } else if (self->constraintType == SANE_CONSTRAINT_WORD_LIST) { int i; constraint = PyTuple_New(self->descriptor->constraint.word_list[0]); for (i = 1; i < self->descriptor->constraint.word_list[0]; i++) PyTuple_SetItem(constraint, i, PyInt_FromLong(self->descriptor->constraint.word_list[i])); } else if (self->constraintType == SANE_CONSTRAINT_STRING_LIST) { int i; constraint = PyList_New(0); for (i = 0; self->descriptor->constraint.string_list[i]; i++) PyList_Append(constraint, PyString_FromString(self->descriptor->constraint.string_list[i])); } Py_INCREF(constraint); self->constraint = constraint; } return (PyObject *)self;}PyObject* PySANEOptionDescriptor_get_constraint_word_list(PySANEOptionDescriptor* self){ PyObject *pyret; if (self->descriptor->constraint_type != SANE_CONSTRAINT_WORD_LIST) { pyret = PyList_New(0); } else { pyret = PyList_New(self->descriptor->constraint.word_list[0]); } Py_INCREF(pyret); return pyret;}PyObject* PySANEOptionDescriptor_get_constraint_string_list(PySANEOptionDescriptor* self){ PyObject *pyret; if (self->descriptor->constraint_type != SANE_CONSTRAINT_STRING_LIST) { pyret = PyList_New(0); } else { pyret = PyList_New(0); } Py_INCREF(pyret); return pyret;}PyObject* PySANEOptionDescriptor_get_constraint_range(PySANEOptionDescriptor* self){ PyObject *pyret; if (self->descriptor->constraint_type != SANE_CONSTRAINT_RANGE) { Py_INCREF(Py_None); return Py_None; } pyret = PyTuple_New(3); PyTuple_SetItem(pyret, 0, PyInt_FromLong(self->descriptor->constraint.range->min)); PyTuple_SetItem(pyret, 1, PyInt_FromLong(self->descriptor->constraint.range->max)); PyTuple_SetItem(pyret, 2, PyInt_FromLong(self->descriptor->constraint.range->quant)); Py_INCREF(pyret); return pyret;}PyObject* PySANEOptionDescriptor_str(PySANEOptionDescriptor* self){ PyObject *pyret; char s[1024]; sprintf(s, "<sane.SANEOptionDescriptor option=%d, name=%s, title=%s, desc=%s, type=%d, cap=%d, unit=%d, size=%d, constr=%d>", self->option, self->descriptor->name, self->descriptor->title, self->descriptor->desc, self->descriptor->type, self->descriptor->cap, self->descriptor->unit, self->descriptor->size, self->descriptor->constraint_type); pyret = PyString_FromString(s); Py_INCREF(pyret); return pyret;}/* Parameters */void PySANEParameters_dealloc(PySANEParameters* self){ self->ob_type->tp_free((PyObject*)self);}PyObject* PySANEParameters_new(PyTypeObject *type, PyObject *args, PyObject *kwds){ PySANEParameters *self; fprintf(stderr, "params new\n"); self = (PySANEParameters *) type->tp_alloc(type, 0); fprintf(stderr, "params new 2\n"); return (PyObject *)self;}/* The module content */PyObject* py_sane_init(PyObject *self, PyObject *args){ int status; PyObject *pyret, *authFunc; int version; authFunc = NULL; if (!PyArg_ParseTuple(args, "|iO", &version, &authFunc)) return NULL; if (authFunc) Py_INCREF(authFunc); status = sane_init(&version, NULL); pyret = PyInt_FromLong(status); Py_INCREF(pyret); return pyret;}PyObject* py_sane_strstatus(PyObject *self, PyObject *args){ PyObject *pyret; int statusCode; SANE_String_Const message; if (!PyArg_ParseTuple(args, "i", &statusCode)) return NULL; message = sane_strstatus(statusCode); if (message) pyret = PyString_FromString(message); else pyret = Py_None; Py_INCREF(pyret); return pyret;}PyObject* py_sane_exit(PyObject *self, PyObject *args){ sane_exit(); Py_INCREF(Py_None); return Py_None;}PyObject* py_sane_get_devices(PyObject *self, PyObject *args){ int i; int local; int status; PyObject *deviceList, *pyBool, *deviceTuple, *pyret; const SANE_Device **device_list; if (!PyArg_ParseTuple(args, "|O", &pyBool)) return NULL; local = (pyBool == Py_True); status = sane_get_devices(&device_list, local); pyret = PyTuple_New(2); PyTuple_SetItem(pyret, 0, PyInt_FromLong(status)); if (status == SANE_STATUS_GOOD) { deviceList = PyList_New(0); Py_INCREF(deviceList); for (i = 0; (device_list[i] && device_list[i]->model && device_list[i]->vendor && device_list[i]->name); i++) { deviceTuple = PyTuple_New(3); PyTuple_SetItem(deviceTuple, 0, PyString_FromString(device_list[i]->model)); PyTuple_SetItem(deviceTuple, 1, PyString_FromString(device_list[i]->vendor)); PyTuple_SetItem(deviceTuple, 2, PyString_FromString(device_list[i]->name)); Py_INCREF(deviceTuple); PyList_Append(deviceList, deviceTuple); } PyTuple_SetItem(pyret, 1, deviceList); } else { Py_INCREF(Py_None); PyTuple_SetItem(pyret, 1, Py_None); } return pyret;}PyObject* py_sane_open(PyObject *self, PyObject *args) { int ret; char *name; SANE_Handle sanehandle; PyObject *pyhandle, *pyret, *pyint; if (!PyArg_ParseTuple(args, "s", &name)) return NULL; ret = sane_open(name, &sanehandle); pyret = PyList_New(2); Py_INCREF(pyret); pyint = PyInt_FromLong(ret); Py_INCREF(pyint); PyList_SetItem(pyret, 0, pyint); if (ret == SANE_STATUS_GOOD) { pyhandle = PySANEHandle_new(&PySANEHandleType, NULL, NULL); ((PySANEHandle *) pyhandle)->handle = sanehandle; Py_INCREF(pyhandle); PyList_SetItem(pyret, 1, pyhandle); } else { Py_INCREF(Py_None); PyList_SetItem(pyret, 1, Py_None); } return pyret;}PyObject* py_sane_close(PyObject *self, PyObject *args){ PySANEHandle *pyhandle; if (!PyArg_ParseTuple(args, "O!", &PySANEHandleType, &pyhandle)) return NULL; if (!pyhandle) return NULL; if (pyhandle->handle == NULL) { PyErr_SetObject(PyExc_ValueError, PyString_FromString("handle not open")); return NULL; } sane_close(pyhandle->handle); ((PySANEHandle *) pyhandle)->handle = NULL; Py_INCREF(Py_None); return Py_None;}PyObject* py_sane_get_option_descriptor(PyObject *self, PyObject *args) { int index; const SANE_Option_Descriptor *descriptor; PySANEHandle *pyhandle; PyObject *pyret; if (!PyArg_ParseTuple(args, "O!i", &PySANEHandleType, &pyhandle, &index)) return NULL; if (pyhandle->handle == NULL) { PyErr_SetObject(PyExc_ValueError, PyString_FromString("handle not open")); return NULL; } descriptor = sane_get_option_descriptor(pyhandle->handle, index); if (!descriptor) { char msg[128]; sprintf(msg, "option %d is invalid", index); PyErr_SetObject(PyExc_ValueError, PyString_FromString(msg)); return NULL; } pyret = PySANEOptionDescriptor_FromDescriptor(index, descriptor); Py_INCREF(pyret); return pyret;}PyObject* py_sane_control_option(PyObject *self, PyObject *args){ const SANE_Option_Descriptor *descriptor; int index, action, errors, status, ret; PyObject *pyret, *argValue; PySANEHandle *pyhandle; if (!PyArg_ParseTuple(args, "O!ii|O", &PySANEHandleType, &pyhandle, &index, &action, &argValue)) return NULL; if (pyhandle->handle == NULL) { PyErr_SetObject(PyExc_ValueError, PyString_FromString("handle not open")); return NULL; } descriptor = sane_get_option_descriptor(pyhandle->handle, index); if (descriptor->cap & SANE_CAP_INACTIVE) { char excmsg[128]; sprintf(excmsg, "option %d is inactive", index); PyErr_SetString(PyExc_ValueError, excmsg); return NULL; } pyret = PyTuple_New(3); PyTuple_SetItem(pyret, 0, Py_None); PyTuple_SetItem(pyret, 1, Py_None); PyTuple_SetItem(pyret, 2, Py_None); if (action == SANE_ACTION_GET_VALUE) { if (descriptor->type == SANE_TYPE_INT || descriptor->type == SANE_TYPE_FIXED) { SANE_Int i; ret = sane_control_option(pyhandle->handle, index, action, &i, &status); if (ret == SANE_STATUS_GOOD) PyTuple_SetItem(pyret, 2, PyInt_FromLong(i)); } else if (descriptor->type == SANE_TYPE_BOOL) { SANE_Bool b; ret = sane_control_option(pyhandle->handle, index, action, &b, &status); if (ret == SANE_STATUS_GOOD) if (b == SANE_TRUE) { PyTuple_SetItem(pyret, 2, Py_True); } else { PyTuple_SetItem(pyret, 2, Py_False); } } else if (descriptor->type == SANE_TYPE_STRING) { char s[255]; ret = sane_control_option(pyhandle->handle, index, action, &s, &status); if (ret == SANE_STATUS_GOOD) PyTuple_SetItem(pyret, 2, PyString_FromString(s)); } else if (descriptor->type == SANE_TYPE_GROUP) { PyTuple_SetItem(pyret, 2, Py_None); } } else if (action == SANE_ACTION_SET_VALUE) { if (argValue) { void *pargValue; if (PyNumber_Check(argValue) && descriptor->type == SANE_TYPE_INT) { int i; i = PyInt_AsLong(PyNumber_Int(argValue)); pargValue = (void *) &i; if (descriptor->constraint_type == SANE_CONSTRAINT_RANGE) { if (i < descriptor->constraint.range->min || i > descriptor->constraint.range->max || (descriptor->constraint.range->quant != 0 && i % descriptor->constraint.range->quant) ) { char s[1024]; if (descriptor->constraint.range->quant != 0 && i % descriptor->constraint.range->quant) sprintf(s, "value must be between %d and %d and quantizied with %d", descriptor->constraint.range->min, descriptor->constraint.range->max, descriptor->constraint.range->quant); else sprintf(s, "value must be between %d and %d", descriptor->constraint.range->min, descriptor->constraint.range->max); PyErr_SetObject(PyExc_ValueError, PyString_FromString(s)); return NULL; } } } else if (PyString_Check(argValue) && descriptor->type == SANE_TYPE_STRING) { char *s; s = PyString_AsString(PyObject_Str(argValue)); if (descriptor->constraint_type == SANE_CONSTRAINT_STRING_LIST) { int i; int found; found = 0; for (i = 0; descriptor->constraint.string_list[i]; i++) if (strcmp(descriptor->constraint.string_list[i], s)) found += 1; if (!found) { char msg[1024]; sprintf(msg, "constraint forced"); PyErr_SetObject(PyExc_ValueError, PyString_FromString(msg)); return NULL; } } pargValue = (void *) s; } ret = sane_control_option(pyhandle->handle, index, action, pargValue, &status); } } else if (action == SANE_ACTION_SET_AUTO) { ret = sane_control_option(pyhandle->handle, index, action, NULL, &status); } if (ret >= 0) { PyTuple_SetItem(pyret, 0, PyInt_FromLong(ret)); PyTuple_SetItem(pyret, 1, PyInt_FromLong(status)); } Py_INCREF(pyret); return pyret;}PyObject* py_sane_get_parameters(PyObject *self, PyObject *args){ SANE_Status ret; SANE_Parameters parameters; PyObject *pyret; PySANEHandle *pyhandle; PySANEParameters *pyparams; pyparams = (PySANEParameters *) PySANEParameters_new(&PySANEParametersType, NULL, NULL); if (!PyArg_ParseTuple(args, "O!", &PySANEHandleType, &pyhandle)) return NULL; pyret = PyTuple_New(2); ret = sane_get_parameters(pyhandle->handle, ¶meters); PyTuple_SetItem(pyret, 0, PyInt_FromLong(ret)); if (ret == SANE_STATUS_GOOD) { /* pyparams->format = parameters.format; pyparams->last_frame = parameters.last_frame; pyparams->lines = parameters.lines; pyparams->depth = parameters.depth; pyparams->pixels_per_line = parameters.pixels_per_line; pyparams->bytes_per_line = parameters.bytes_per_line; */ PyTuple_SetItem(pyret, 1, (PyObject *) pyparams); } else PyTuple_SetItem(pyret, 1, Py_None); Py_INCREF(pyret); return pyret;}PyMODINIT_FUNC initsanepython(void) { PyObject* module; if (PyType_Ready(&PySANEHandleType) < 0) return; if (PyType_Ready(&PySANEOptionDescriptorType) < 0) return; module = Py_InitModule3("sanepython", module_methods, "SANE interface for Python."); if (module == NULL) return; PyModule_AddIntConstant(module, "SANE_CURRENT_MAJOR", SANE_CURRENT_MAJOR); PyModule_AddIntConstant(module, "SANE_STATUS_GOOD", SANE_STATUS_GOOD); PyModule_AddIntConstant(module, "SANE_STATUS_NO_MEM", SANE_STATUS_NO_MEM); PyModule_AddIntConstant(module, "SANE_STATUS_DEVICE_BUSY", SANE_STATUS_DEVICE_BUSY); PyModule_AddIntConstant(module, "SANE_STATUS_INVAL", SANE_STATUS_INVAL); PyModule_AddIntConstant(module, "SANE_STATUS_IO_ERROR", SANE_STATUS_IO_ERROR); PyModule_AddIntConstant(module, "SANE_STATUS_ACCESS_DENIED", SANE_STATUS_ACCESS_DENIED); PyModule_AddIntConstant(module, "SANE_ACTION_GET_VALUE", SANE_ACTION_GET_VALUE); PyModule_AddIntConstant(module, "SANE_ACTION_SET_VALUE", SANE_ACTION_SET_VALUE); PyModule_AddIntConstant(module, "SANE_ACTION_SET_AUTO", SANE_ACTION_SET_AUTO); PyModule_AddIntConstant(module, "SANE_TYPE_BOOL", SANE_TYPE_BOOL); PyModule_AddIntConstant(module, "SANE_TYPE_INT", SANE_TYPE_INT); PyModule_AddIntConstant(module, "SANE_TYPE_FIXED", SANE_TYPE_FIXED); PyModule_AddIntConstant(module, "SANE_TYPE_STRING", SANE_TYPE_STRING); PyModule_AddIntConstant(module, "SANE_TYPE_BUTTON", SANE_TYPE_BUTTON); PyModule_AddIntConstant(module, "SANE_TYPE_GROUP", SANE_TYPE_GROUP); PyModule_AddIntConstant(module, "SANE_UNIT_NONE", SANE_UNIT_NONE); PyModule_AddIntConstant(module, "SANE_UNIT_PIXEL", SANE_UNIT_PIXEL); PyModule_AddIntConstant(module, "SANE_UNIT_BIT", SANE_UNIT_BIT); PyModule_AddIntConstant(module, "SANE_UNIT_MM", SANE_UNIT_MM); PyModule_AddIntConstant(module, "SANE_UNIT_DPI", SANE_UNIT_DPI); PyModule_AddIntConstant(module, "SANE_UNIT_PERCENT", SANE_UNIT_PERCENT); PyModule_AddIntConstant(module, "SANE_UNIT_MICROSECOND", SANE_UNIT_MICROSECOND); PyModule_AddIntConstant(module, "SANE_CAP_SOFT_SELECT", SANE_CAP_SOFT_SELECT); PyModule_AddIntConstant(module, "SANE_CAP_HARD_SELECT", SANE_CAP_HARD_SELECT); PyModule_AddIntConstant(module, "SANE_CAP_SOFT_DETECT", SANE_CAP_SOFT_DETECT); PyModule_AddIntConstant(module, "SANE_CAP_EMULATED", SANE_CAP_EMULATED); PyModule_AddIntConstant(module, "SANE_CAP_AUTOMATIC", SANE_CAP_AUTOMATIC); PyModule_AddIntConstant(module, "SANE_CAP_INACTIVE", SANE_CAP_INACTIVE); PyModule_AddIntConstant(module, "SANE_CAP_ADVANCED", SANE_CAP_ADVANCED); PyModule_AddIntConstant(module, "SANE_CONSTRAINT_NONE", SANE_CONSTRAINT_NONE); PyModule_AddIntConstant(module, "SANE_CONSTRAINT_RANGE", SANE_CONSTRAINT_RANGE); PyModule_AddIntConstant(module, "SANE_CONSTRAINT_WORD_LIST", SANE_CONSTRAINT_WORD_LIST); PyModule_AddIntConstant(module, "SANE_CONSTRAINT_STRING_LIST", SANE_CONSTRAINT_STRING_LIST); Py_INCREF(&PySANEHandleType); PyModule_AddObject(module, "SANEHandle", (PyObject *) &PySANEHandleType); PyModule_AddObject(module, "SANEOptionDescriptor", (PyObject *) &PySANEOptionDescriptorType);}