/*******************************************************************
scanext - Python extension class for SANE

Portions (c) Copyright 2015 HP Development Company, L.P.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

Based on:
"_sane.c", part of the Python Imaging Library (PIL)
http://www.pythonware.com/products/pil/

Modified to work without PIL by Don Welch

(C) Copyright 2003 A.M. Kuchling.  All Rights Reserved
(C) Copyright 2004 A.M. Kuchling, Ralph Heinkel  All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of A.M. Kuchling and
Ralph Heinkel not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.

A.M. KUCHLING, R.H. HEINKEL DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

*******************************************************************/


/* _ScanDevice objects */
#define PY_SSIZE_T_CLEAN

#include "Python.h"
#include "sane.h"
#include <sys/time.h>

#if PY_MAJOR_VERSION >= 3
    #define  PyInt_AsLong  PyLong_AsLong
    #define  PyInt_FromLong PyLong_FromLong
    #define  PyInt_Check PyLong_Check
    #define  PyUNICODE_FromUNICODE PyUnicode_FromString
    #define  PyUNICODE_CHECK PyUnicode_Check
    #define FORMAT_STRING "(iy#)"

    #if (PY_VERSION_HEX < 0x03030000)
        #define PyUNICODE_AsBYTES(x) PyBytes_AsString(PyUnicode_AsUTF8String(x))
    #else
        #define PyUNICODE_AsBYTES PyUnicode_AsUTF8
    #endif 
    
    #define MOD_ERROR_VAL NULL
    #define MOD_SUCCESS_VAL(val) val
    #define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void)
    #define MOD_DEF(ob, name, doc, methods) \
          static struct PyModuleDef moduledef = { \
            PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \
          ob = PyModule_Create(&moduledef);	\

#else
    #define  PyUNICODE_FromUNICODE PyString_FromString
    #define  PyUNICODE_CHECK PyString_Check
    #define  PyUNICODE_AsBYTES PyString_AsString
    #define FORMAT_STRING "(is#)"

    #define MOD_ERROR_VAL
    #define MOD_SUCCESS_VAL(val)
    #define MOD_INIT(name) void init##name(void)
    #define MOD_DEF(ob, name, doc, methods) \
          ob = Py_InitModule3(name, methods, doc);	\

#endif
int multipick;
static char scanext_documentation[] = "Python extension for HP scan sane driver";
static PyObject *ErrorObject;

typedef struct
{
    PyObject_HEAD SANE_Handle h;
} _ScanDevice;

#ifdef WITH_THREAD
PyThreadState *_save;
#endif

/* Raise a SANE exception using a SANE_Status code */
PyObject *raiseSaneError (SANE_Status st)
{
    const char *string;

    if (st == SANE_STATUS_GOOD)
    {
        Py_INCREF (Py_None);
        return (Py_None);
    }

    string = sane_strstatus (st);
    //PyErr_SetString (ErrorObject, string);
    PyErr_SetObject(ErrorObject,  PyInt_FromLong(st));
    return NULL;
}

/* Raise an exception using a character string */
PyObject * raiseError(const char * str)
{
    PyErr_SetString (ErrorObject, str);
    return NULL;
}

/* Raise an exception using a character string */
PyObject * raiseDeviceClosedError(void)
{
    return raiseError ("_ScanDevice object is closed");
}

static PyObject *getErrorMessage(PyObject * self, PyObject * args)
{
    int st;

    if (!PyArg_ParseTuple (args, "i", &st))
        raiseError("Invalid arguments.");

    return Py_BuildValue("s", sane_strstatus (st));
}

static PyTypeObject ScanDevice_type;

#define SaneDevObject_Check(v)  ((v)->ob_type == &ScanDevice_type)

static _ScanDevice *newScanDeviceObject (void)
{
    _ScanDevice *self;

    self = PyObject_NEW (_ScanDevice, &ScanDevice_type);

    if (self == NULL)
        return NULL;

    self->h = NULL;
    return self;
}


/* _ScanDevice methods */

static void deAlloc (_ScanDevice * self)
{
    if (self->h)
        sane_close (self->h);

    self->h = NULL;
    PyObject_DEL (self);
}

static PyObject *closeScan (_ScanDevice * self, PyObject * args)
{
    if (!PyArg_ParseTuple (args, ""))
        return NULL;

    if (self->h)
        sane_close (self->h);

    self->h = NULL;
    Py_INCREF (Py_None);
    return (Py_None);
}

static PyObject *getParameters (_ScanDevice * self, PyObject * args)
{
    SANE_Status st;
    SANE_Parameters p;
    char *format_name = "unknown";

    if (!PyArg_ParseTuple (args, ""))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    Py_BEGIN_ALLOW_THREADS
    st = sane_get_parameters (self->h, &p);
    Py_END_ALLOW_THREADS

    if (st != SANE_STATUS_GOOD)
        return raiseSaneError (st);

    switch (p.format)
    {
        case (SANE_FRAME_GRAY):
            format_name = "gray";
            break;
        case (SANE_FRAME_RGB):
            format_name = "color";
            break;
        case (SANE_FRAME_RED):
            format_name = "red";
            break;
        case (SANE_FRAME_GREEN):
            format_name = "green";
            break;
        case (SANE_FRAME_BLUE):
            format_name = "blue";
            break;
    }

    return Py_BuildValue ("isiiiii", p.format, format_name,
                          p.last_frame, p.pixels_per_line,
                          p.lines, p.depth, p.bytes_per_line);
}

static PyObject *startScan (_ScanDevice * self, PyObject * args)
{
    SANE_Status st;

    if (!PyArg_ParseTuple (args, ""))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    /* sane_start can take several seconds, if the user initiates
       a new scan, while the scan head of a flatbed scanner moves
       back to the start position after finishing a previous scan.
       Hence it is worth to allow threads here.
     */
    Py_BEGIN_ALLOW_THREADS
    st = sane_start (self->h);
    Py_END_ALLOW_THREADS

    if (st != SANE_STATUS_GOOD &&
        st != SANE_STATUS_JAMMED &&
        st != SANE_STATUS_EOF &&
        st != SANE_STATUS_NO_DOCS &&
        st != SANE_STATUS_MULTIPICK)
          return raiseSaneError(st);

    return Py_BuildValue("i", st);
}

static PyObject *cancelScan (_ScanDevice * self, PyObject * args)
{
    if (!PyArg_ParseTuple (args, ""))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    sane_cancel (self->h);
    Py_INCREF (Py_None);
    return Py_None;
}

static PyObject *getOptions (_ScanDevice * self, PyObject * args)
{
    const SANE_Option_Descriptor *d;
    PyObject *list, *value;
    int i = 1;

    if (!PyArg_ParseTuple (args, ""))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    if (!(list = PyList_New (0)))
        raiseError("Unable to allocate list.");

    do
    {
        d = sane_get_option_descriptor (self->h, i);
        if (d != NULL)
        {
            PyObject *constraint = NULL;
            int j;

            switch (d->constraint_type)
            {
            case (SANE_CONSTRAINT_NONE):
                Py_INCREF (Py_None);
                constraint = Py_None;
                break;
            case (SANE_CONSTRAINT_RANGE):
                if (d->type == SANE_TYPE_INT)
                    constraint =
                        Py_BuildValue ("iii", d->constraint.range->min,
                                       d->constraint.range->max,
                                       d->constraint.range->quant);
                else
                    constraint = Py_BuildValue ("ddd",
                                                SANE_UNFIX (d->
                                                            constraint.
                                                            range->min),
                                                SANE_UNFIX (d->
                                                            constraint.
                                                            range->max),
                                                SANE_UNFIX (d->
                                                            constraint.
                                                            range->quant));
                break;
            case (SANE_CONSTRAINT_WORD_LIST):
                constraint = PyList_New (d->constraint.word_list[0]);

                if (d->type == SANE_TYPE_INT)
                    for (j = 1; j <= d->constraint.word_list[0]; j++)
                        PyList_SetItem (constraint, j - 1,
                                        PyInt_FromLong (d->constraint.
                                                        word_list[j]));
                else
                    for (j = 1; j <= d->constraint.word_list[0]; j++)
                        PyList_SetItem (constraint, j - 1,
                                        PyFloat_FromDouble (SANE_UNFIX
                                                            (d->
                                                             constraint.
                                                             word_list[j])));
                break;
            case (SANE_CONSTRAINT_STRING_LIST):
                constraint = PyList_New (0);

                for (j = 0; d->constraint.string_list[j] != NULL; j++)
                    PyList_Append (constraint,
                                   PyUNICODE_FromUNICODE (d->constraint.
                                                        string_list[j]));
                break;
            }
            value = Py_BuildValue ("isssiiiiO", i, d->name, d->title, d->desc,
                                   d->type, d->unit, d->size, d->cap, constraint);

            PyList_Append (list, value);
        }
        i++;
    }

    while (d != NULL);
    return list;
}

static PyObject *getOption (_ScanDevice * self, PyObject * args)
{
    SANE_Status st;
    const SANE_Option_Descriptor *d;
    PyObject *value = NULL;
    int n;
    void *v;

    if (!PyArg_ParseTuple (args, "i", &n))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    d = sane_get_option_descriptor (self->h, n);
    v = malloc (d->size + 1);
    st = sane_control_option (self->h, n, SANE_ACTION_GET_VALUE, v, NULL);

    if (st != SANE_STATUS_GOOD)
    {
        free (v);
        return raiseSaneError(st);
    }

    switch (d->type)
    {
        case (SANE_TYPE_BOOL):
        case (SANE_TYPE_INT):
            value = Py_BuildValue ("i", *((SANE_Int *) v));
            break;

        case (SANE_TYPE_FIXED):
            value = Py_BuildValue ("d", SANE_UNFIX ((*((SANE_Fixed *) v))));
            break;

        case (SANE_TYPE_STRING):
            value = Py_BuildValue ("s", v);
            break;

        case (SANE_TYPE_BUTTON):
        case (SANE_TYPE_GROUP):
            value = Py_BuildValue ("O", Py_None);
            break;
    }

    free (v);
    return value;
}

static PyObject *setOption (_ScanDevice * self, PyObject * args)
{
    SANE_Status st;
    const SANE_Option_Descriptor *d;
    SANE_Int i;
    PyObject *value;
    int n;
    multipick = 1;

if(1)
{
SANE_Bool b = SANE_TRUE;
    sane_control_option (self->h, 9, SANE_ACTION_SET_VALUE, (void *)&b, &i);
}
else
{
SANE_Bool b = SANE_FALSE;
    sane_control_option (self->h, 9, SANE_ACTION_SET_VALUE, (void *)&b, &i);
}
    if (!PyArg_ParseTuple (args, "iO", &n, &value))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    d = sane_get_option_descriptor (self->h, n);
    switch (d->type)
    {
        case (SANE_TYPE_BOOL):
            if (!PyInt_Check (value))
                return raiseError("SANE_Bool requires an integer.");

            SANE_Bool b = PyInt_AsLong(value);

            if (b != SANE_FALSE && b > SANE_TRUE)
                b = SANE_TRUE;

            st = sane_control_option (self->h, n, SANE_ACTION_SET_VALUE, (void *)&b, &i);
            break;

        case (SANE_TYPE_INT):
            if (!PyInt_Check (value))
                return raiseError("SANE_Int requires an integer.");

            SANE_Int j = PyInt_AsLong (value);
            st = sane_control_option (self->h, n, SANE_ACTION_SET_VALUE, (void *)&j, &i);
            break;

        case (SANE_TYPE_FIXED):
            if (!PyFloat_Check (value))
                return raiseError("SANE_Fixed requires an float.");

            SANE_Fixed f = SANE_FIX (PyFloat_AsDouble (value));
            st = sane_control_option (self->h, n, SANE_ACTION_SET_VALUE, (void *)&f, &i);
            break;

        case (SANE_TYPE_STRING):
            if (!PyUNICODE_CHECK (value))
                return raiseError("SANE_String requires a a string.");

            SANE_String s = malloc (d->size + 1);
            strncpy (s, PyUNICODE_AsBYTES (value), d->size - 1);
            ((SANE_String) s)[d->size - 1] = 0;
            st = sane_control_option (self->h, n, SANE_ACTION_SET_VALUE, (void *)s, &i);
            free(s);
            break;

        case (SANE_TYPE_BUTTON):
        case (SANE_TYPE_GROUP):
            break;
    }

    if (st != SANE_STATUS_GOOD)
        return raiseSaneError(st);

    return Py_BuildValue ("i", i);
}

static PyObject *setAutoOption (_ScanDevice * self, PyObject * args)
{
    SANE_Status st;
    const SANE_Option_Descriptor *d;
    SANE_Int i;
    int n;

    if (!PyArg_ParseTuple (args, "i", &n))
        raiseError("Invalid arguments.");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    d = sane_get_option_descriptor (self->h, n);
    st = sane_control_option (self->h, n, SANE_ACTION_SET_AUTO, NULL, &i);

    if (st != SANE_STATUS_GOOD)
        return raiseSaneError (st);

    return Py_BuildValue ("i", i);
}

#define MAX_READSIZE 65536

static PyObject *readScan (_ScanDevice * self, PyObject * args)
{
    SANE_Status st;
    SANE_Int len;
    SANE_Byte buffer[MAX_READSIZE];
    int bytes_to_read;

    if (!PyArg_ParseTuple (args, "i", &bytes_to_read))
        raiseError("Invalid arguments.");

    if (bytes_to_read > MAX_READSIZE)
        return raiseError("bytes_to_read > MAX_READSIZE");

    if (self->h == NULL)
        return raiseDeviceClosedError();

    //Py_BEGIN_ALLOW_THREADS
    Py_UNBLOCK_THREADS
    st = sane_read (self->h, buffer, bytes_to_read, &len);
    //Py_END_ALLOW_THREADS
    Py_BLOCK_THREADS

    if (st != SANE_STATUS_GOOD &&
        st != SANE_STATUS_EOF &&
        st != SANE_STATUS_NO_DOCS &&
        st != SANE_STATUS_MULTIPICK)
    {
        sane_cancel(self->h);
        //Py_BLOCK_THREADS
        return raiseSaneError(st);
    }

    return Py_BuildValue (FORMAT_STRING, st, buffer, len);
}


static PyMethodDef ScanDevice_methods[] = {
    {"getParameters", (PyCFunction) getParameters, METH_VARARGS},

    {"getOptions", (PyCFunction) getOptions, METH_VARARGS},
    {"getOption", (PyCFunction) getOption, METH_VARARGS},
    {"setOption", (PyCFunction) setOption, METH_VARARGS},
    {"setAutoOption", (PyCFunction) setAutoOption, METH_VARARGS},

    {"startScan", (PyCFunction) startScan, METH_VARARGS},
    {"cancelScan", (PyCFunction) cancelScan, METH_VARARGS},
    {"readScan", (PyCFunction) readScan, METH_VARARGS},
    {"closeScan", (PyCFunction) closeScan, METH_VARARGS},
    {NULL, NULL}
};


static PyTypeObject ScanDevice_type =
{
    PyVarObject_HEAD_INIT( &PyType_Type, 0 ) /* ob_size */
    "_ScanDevice",                   /* tp_name */
    sizeof(_ScanDevice ),              /* tp_basicsize */
    0,                                     /* tp_itemsize */
    ( destructor ) deAlloc,           /* tp_dealloc */
    0,                                     /* tp_print */
    0,                      /* tp_getattr */
    0,                                     /* tp_setattr */
    0,                                     /* tp_compare */
    0,                                     /* tp_repr */
    0,                                     /* tp_as_number */
    0,                                     /* tp_as_sequence */
    0,                                     /* tp_as_mapping */
    0,                                     /* tp_hash */
    0,                                     /* tp_call */
    0,                                     /* tp_str */
    PyObject_GenericGetAttr,               /* tp_getattro */
    PyObject_GenericSetAttr,               /* tp_setattro */
    0,                                     /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,         /* tp_flags */
    "Scan Device object",                 /* tp_doc */
    0,                                     /* tp_traverse */
    0,                                     /* tp_clear */
    0,                                     /* tp_richcompare */
    0,                                     /* tp_weaklistoffset */
    0,                                     /* tp_iter */
    0,                                     /* tp_iternext */
    ScanDevice_methods,         /*job_methods, */           /* tp_methods */
    0,                       /* tp_members */
    0,                                     /* tp_getset */
    0,                                     /* tp_base */
    0,                                     /* tp_dict */
    0,                                     /* tp_descr_get */
    0,                                     /* tp_descr_set */
    0,                                     /* tp_dictoffset */
    0,                                     /* tp_init */
    0,                                     /* tp_alloc */
    0,                                     /* tp_new */
};


/* --------------------------------------------------------------------- */

static void auth_callback (SANE_String_Const resource,
                       SANE_Char * username, SANE_Char * password)
{
    printf("auth_callback\n");
}

static PyObject *init (PyObject * self, PyObject * args)
{
    SANE_Status st;
    SANE_Int version;

    if (!PyArg_ParseTuple (args, ""))
        raiseError("Invalid arguments.");

    /* XXX Authorization is not yet supported */
    st = sane_init (&version, auth_callback);

    if (st != SANE_STATUS_GOOD)
        return raiseSaneError (st);

    return Py_BuildValue ("iiii", version, SANE_VERSION_MAJOR (version),
                          SANE_VERSION_MINOR (version),
                          SANE_VERSION_BUILD (version));

}



static PyObject *deInit (PyObject * self, PyObject * args)
{
    if (!PyArg_ParseTuple (args, ""))
        raiseError("Invalid arguments");

    sane_exit ();
    Py_INCREF (Py_None);
    return Py_None;
}

static PyObject *getDevices (PyObject * self, PyObject * args)
{
    const SANE_Device **device_list;
    SANE_Status st;
    PyObject *list;
    int local_only=SANE_FALSE, i;

    if (!PyArg_ParseTuple (args, "|i", &local_only))
        raiseError("Invalid arguments");

    st = sane_get_devices (&device_list, local_only);

    if (st != SANE_STATUS_GOOD)
        return raiseSaneError (st);

    if (!(list = PyList_New (0)))
        return raiseError("Unable to allocate device list.");

    for (i=0; device_list[i]; i++)
    {
        PyList_Append (list, Py_BuildValue ("ssss", device_list[i]->name, device_list[i]->vendor,
                                            device_list[i]->model, device_list[i]->type));
    }

    return list;
}

/* Function returning new _ScanDevice object */

static PyObject *openDevice (PyObject * self, PyObject * args)
{
    _ScanDevice *rv;
    SANE_Status st;
    char *name;

    if (!PyArg_ParseTuple (args, "s", &name))
        raiseError("Invalid arguments");

    rv = newScanDeviceObject ();

    if (rv == NULL)
        return raiseError("Unable to create _ScanDevice object.");

    st = sane_open (name, &(rv->h));

    if (st != SANE_STATUS_GOOD)
    {
        Py_DECREF (rv);
        return raiseSaneError (st);
    }
    return (PyObject *) rv;
}

static PyObject *isOptionActive (PyObject * self, PyObject * args)
{
    SANE_Int cap;
    long lg;

    if (!PyArg_ParseTuple (args, "l", &lg))
        raiseError("Invalid arguments");

    cap = lg;
    return PyInt_FromLong (SANE_OPTION_IS_ACTIVE (cap));
}

static PyObject *setMultipick (PyObject * self, PyObject * args)
{

    if (!PyArg_ParseTuple (args, "i", &multipick))
        raiseError("Invalid arguments");
	Py_INCREF ( Py_None );
    return Py_None;
}
static PyObject *isOptionSettable (PyObject * self, PyObject * args)
{
    SANE_Int cap;
    long lg;

    if (!PyArg_ParseTuple (args, "l", &lg))
        raiseError("Invalid arguments");

    cap = lg;
    return PyInt_FromLong (SANE_OPTION_IS_SETTABLE (cap));
}


/* List of functions defined in the module */

static PyMethodDef ScanExt_methods[] = {
    {"init", init, METH_VARARGS},
    {"deInit", deInit, METH_VARARGS},
    {"getDevices", getDevices, METH_VARARGS},
    {"openDevice", openDevice, METH_VARARGS},
    {"isOptionActive", isOptionActive, METH_VARARGS},
    {"isOptionSettable", isOptionSettable, METH_VARARGS},
    {"getErrorMessage", getErrorMessage, METH_VARARGS},
    {"setMultipick", setMultipick, METH_VARARGS},
    {NULL, NULL}                /* sentinel */
};

static void insint (PyObject * d, char *name, int value)
{
    PyObject *v = PyInt_FromLong ((long) value);

    if (!v || PyDict_SetItemString (d, name, v))
        Py_FatalError ("can't initialize sane module");

    Py_DECREF (v);
}

#if PY_MAJOR_VERSION >= 3
    static struct PyModuleDef moduledef = {
        PyModuleDef_HEAD_INIT,
        "scanext",     /* m_name */
        scanext_documentation,  /* m_doc */
        -1,                  /* m_size */
        ScanExt_methods,    /* m_methods */
        NULL,                /* m_reload */
        NULL,                /* m_traverse */
        NULL,                /* m_clear */
        NULL,                /* m_free */
    };

#endif


MOD_INIT(scanext)  {
    PyObject* mod ;
    MOD_DEF(mod, "scanext", scanext_documentation, ScanExt_methods);
    if (mod == NULL)
    	return MOD_ERROR_VAL;

    /* Add some symbolic constants to the module */
    PyObject* d = PyModule_GetDict(mod);
    ErrorObject = PyErr_NewException("scanext.error", NULL, NULL); 
    if (ErrorObject == NULL) 
    {	
         Py_DECREF(mod);	
         return MOD_ERROR_VAL;
    }
    PyDict_SetItemString (d, "error", ErrorObject);


    insint (d, "INFO_INEXACT", SANE_INFO_INEXACT);
    insint (d, "INFO_RELOAD_OPTIONS", SANE_INFO_RELOAD_OPTIONS);
    insint (d, "RELOAD_PARAMS", SANE_INFO_RELOAD_PARAMS);

    insint (d, "FRAME_GRAY", SANE_FRAME_GRAY);
    insint (d, "FRAME_RGB", SANE_FRAME_RGB);
    insint (d, "FRAME_RED", SANE_FRAME_RED);
    insint (d, "FRAME_GREEN", SANE_FRAME_GREEN);
    insint (d, "FRAME_BLUE", SANE_FRAME_BLUE);

    insint (d, "CONSTRAINT_NONE", SANE_CONSTRAINT_NONE);
    insint (d, "CONSTRAINT_RANGE", SANE_CONSTRAINT_RANGE);
    insint (d, "CONSTRAINT_WORD_LIST", SANE_CONSTRAINT_WORD_LIST);
    insint (d, "CONSTRAINT_STRING_LIST", SANE_CONSTRAINT_STRING_LIST);

    insint (d, "TYPE_BOOL", SANE_TYPE_BOOL);
    insint (d, "TYPE_INT", SANE_TYPE_INT);
    insint (d, "TYPE_FIXED", SANE_TYPE_FIXED);
    insint (d, "TYPE_STRING", SANE_TYPE_STRING);
    insint (d, "TYPE_BUTTON", SANE_TYPE_BUTTON);
    insint (d, "TYPE_GROUP", SANE_TYPE_GROUP);

    insint (d, "UNIT_NONE", SANE_UNIT_NONE);
    insint (d, "UNIT_PIXEL", SANE_UNIT_PIXEL);
    insint (d, "UNIT_BIT", SANE_UNIT_BIT);
    insint (d, "UNIT_MM", SANE_UNIT_MM);
    insint (d, "UNIT_DPI", SANE_UNIT_DPI);
    insint (d, "UNIT_PERCENT", SANE_UNIT_PERCENT);
    insint (d, "UNIT_MICROSECOND", SANE_UNIT_MICROSECOND);

    insint (d, "CAP_SOFT_SELECT", SANE_CAP_SOFT_SELECT);
    insint (d, "CAP_HARD_SELECT", SANE_CAP_HARD_SELECT);
    insint (d, "CAP_SOFT_DETECT", SANE_CAP_SOFT_DETECT);
    insint (d, "CAP_EMULATED", SANE_CAP_EMULATED);
    insint (d, "CAP_AUTOMATIC", SANE_CAP_AUTOMATIC);
    insint (d, "CAP_INACTIVE", SANE_CAP_INACTIVE);
    insint (d, "CAP_ADVANCED", SANE_CAP_ADVANCED);

    /* handy for checking array lengths: */
    insint (d, "SANE_WORD_SIZE", sizeof (SANE_Word));

    /* possible return values of set_option() */
    insint (d, "INFO_INEXACT", SANE_INFO_INEXACT);
    insint (d, "INFO_RELOAD_OPTIONS", SANE_INFO_RELOAD_OPTIONS);
    insint (d, "INFO_RELOAD_PARAMS", SANE_INFO_RELOAD_PARAMS);

    // SANE status codes
    insint (d, "SANE_STATUS_GOOD",  SANE_STATUS_GOOD); //Operation completed succesfully.
    insint (d, "SANE_STATUS_UNSUPPORTED", SANE_STATUS_UNSUPPORTED); // Operation is not supported.
    insint (d, "SANE_STATUS_CANCELLED", SANE_STATUS_CANCELLED); //Operation was cancelled.
    insint (d, "SANE_STATUS_DEVICE_BUSY", SANE_STATUS_DEVICE_BUSY); // Device is busy---retry later.
    insint (d, "SANE_STATUS_INVAL",  SANE_STATUS_INVAL); // Data or argument is invalid.
    insint (d, "SANE_STATUS_EOF", SANE_STATUS_EOF);  // No more data available (end-of-file).
    insint (d, "SANE_STATUS_JAMMED", SANE_STATUS_JAMMED); // Document feeder jammed.
    insint (d, "SANE_STATUS_NO_DOCS", SANE_STATUS_NO_DOCS); // Document feeder out of documents.
    insint (d, "SANE_STATUS_COVER_OPEN", SANE_STATUS_COVER_OPEN); // Scanner cover is open.
    insint (d, "SANE_STATUS_IO_ERROR", SANE_STATUS_IO_ERROR); // Error during device I/O.
    insint (d, "SANE_STATUS_NO_MEM", SANE_STATUS_NO_MEM); // Out of memory.
    insint (d, "SANE_STATUS_ACCESS_DENIED", SANE_STATUS_ACCESS_DENIED);  // Access to resource has been denied.
    insint (d, "SANE_STATUS_MULTIPICK", SANE_STATUS_MULTIPICK);  // multipick error.

    // Maximum buffer size for read()
    insint(d, "MAX_READSIZE", MAX_READSIZE);

    /* Check for errors */
    if (PyErr_Occurred ())
        Py_FatalError ("can't initialize module scanext");

  return MOD_SUCCESS_VAL(mod);
}
