return PyLong_FromVoidPtr(reinterpret_cast<void *>(%in));

%out = reinterpret_cast<%OUTTYPE>(PyLong_AsVoidPtr(%in));

QTransform _result; if (QTransform::quadToQuad(%1, %2, _result)) { %PYARG_0 = %CONVERTTOPYTHON[QTransform](_result); } else { Py_INCREF(Py_None); %PYARG_0 = Py_None; }

QTransform _result; if (QTransform::quadToSquare(%1, _result)) { %PYARG_0 = %CONVERTTOPYTHON[QTransform](_result); } else { Py_INCREF(Py_None); %PYARG_0 = Py_None; }

QTransform _result; if (QTransform::squareToQuad(%1, _result)) { %PYARG_0 = %CONVERTTOPYTHON[QTransform](_result); } else { Py_INCREF(Py_None); %PYARG_0 = Py_None; }

uchar* buffer = (uchar*) Shiboken::Buffer::getPointer(%PYARG_2); QBitmap %0 = QBitmap::fromData(%1, buffer, %3); %PYARG_0 = %CONVERTTOPYTHON[QBitmap](%0);

%BEGIN_ALLOW_THREADS %RETURN_TYPE %0 = %CPPSELF->::%TYPE::%FUNCTION_NAME(&%1, %2); %END_ALLOW_THREADS %PYARG_0 = PyTuple_New(2); PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));

if (_i < 0 || _i >= %CPPSELF.count()) { PyErr_SetString(PyExc_IndexError, "index out of bounds"); return 0; } int item = (*%CPPSELF)[_i]; return %CONVERTTOPYTHON[int](item);

%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.data(), %CPPSELF.size());

PyObject* %out = Shiboken::Buffer::newObject(%in, size);

Py_ssize_t bufferLen; char* %out = (char*) Shiboken::Buffer::getPointer(%PYARG_1, &bufferLen);

uint %out = bufferLen;

const QTextDocument* doc = %CPPSELF.document(); if (doc) { Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument*](doc)); Shiboken::Object::setParent(pyDocument, %PYARG_1); }

const QTextDocument* doc = %CPPSELF.document(); if (doc) { Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument*](doc)); Shiboken::Object::setParent(pyDocument, %PYARG_0); }

PyObject* points = PyList_New(%CPPSELF.count()); for (int i = 0, max = %CPPSELF.count(); i < max; ++i){ int x, y; %CPPSELF.point(i, &x, &y); QPoint pt = QPoint(x, y); PyList_SET_ITEM(points, i, %CONVERTTOPYTHON[QPoint](pt)); }

// %FUNCTION_NAME() *%CPPSELF << %1; %PYARG_0 = %CONVERTTOPYTHON[QPolygon*](%CPPSELF);

%0 = new %TYPE(QPixmap::fromImage(%1));

const uchar* %out = reinterpret_cast<const uchar*>(PyBytes_AS_STRING(%PYARG_1));

uint %out = static_cast<uint>(PyBytes_Size(%PYARG_1));

%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.byteCount());

// byteCount() is only available on Qt4.7, so we use bytesPerLine * height %PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.bytesPerLine() * %CPPSELF.height(), Shiboken::Buffer::ReadWrite);

%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine());

%PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine(), Shiboken::Buffer::ReadWrite);

Shiboken::AutoDecRef func(PyObject_GetAttr(%PYSELF, PyTuple_GET_ITEM(%1, 0))); PyObject* args = PyTuple_GET_ITEM(%1, 1); %PYARG_0 = PyObject_Call(func, args, NULL);

switch(%CPPSELF.spec()) { case QColor::Rgb: { qreal r, g, b, a; %CPPSELF.getRgbF(&r, &g, &b, &a); %PYARG_0 = Py_BuildValue("(ON(s(ffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), "setRgbF", (float)r, (float)g, (float)b, (float)a); break; } case QColor::Hsv: { qreal h, s, v, a; %CPPSELF.getHsvF(&h, &s, &v, &a); %PYARG_0 = Py_BuildValue("(ON(s(ffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), "setHsvF", (float)h, (float)s, (float)v, (float)a); break; } case QColor::Cmyk: { qreal c, m, y, k, a; %CPPSELF.getCmykF(&c, &m, &y, &k, &a); %PYARG_0 = Py_BuildValue("(ON(s(fffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), "setCmykF", (float)c, (float)m, (float)y, (float)k, (float)a); break; } #if QT_VERSION >= 0x040600 case QColor::Hsl: { qreal h, s, l, a; %CPPSELF.getHslF(&h, &s, &l, &a); %PYARG_0 = Py_BuildValue("(ON(s(ffff)))", Py_TYPE(%PYSELF), PyTuple_New(0), "setHslF", (float)h, (float)s, (float)l, (float)a); break; } #endif default: { %PYARG_0 = Py_BuildValue("(N(O))", PyObject_Type(%PYSELF), Py_None); } }

switch(%CPPSELF.spec()) { case QColor::Rgb: { int r, g, b, a; %CPPSELF.getRgb(&r, &g, &b, &a); %PYARG_0 = Py_BuildValue("iiii", r, g, b, a); break; } case QColor::Hsv: { int h, s, v, a; %CPPSELF.getHsv(&h, &s, &v, &a); %PYARG_0 = Py_BuildValue("iiii", h, s, v, a); break; } case QColor::Cmyk: { int c, m, y, k, a; %CPPSELF.getCmyk(&c, &m, &y, &k, &a); %PYARG_0 = Py_BuildValue("iiiii", c, m, y, k, a); break; } case QColor::Hsl: { int h, s, l, a; %CPPSELF.getHsl(&h, &s, &l, &a); %PYARG_0 = Py_BuildValue("iiii", h, s, l, a); break; } default: { %PYARG_0 = 0; } }

if (%1.type() == QVariant::Color) %0 = new %TYPE(%1.value<QColor>()); else PyErr_SetString(PyExc_TypeError, "QVariant must be holding a QColor");

int* array = NULL; bool errorOccurred = false; if (numArgs == 5) { array = Shiboken::sequenceToIntArray(%PYARG_5, true); if (PyErr_Occurred()) { if (array) delete []array; errorOccurred = true; } } if (!errorOccurred) { %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, array); if (array) delete []array; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); }

int* array = NULL; bool errorOccurred = false; if (numArgs == 4) { array = Shiboken::sequenceToIntArray(%PYARG_4, true); if (PyErr_Occurred()) { if (array) delete []array; errorOccurred = true; } } if (!errorOccurred) { %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, array); if (array) delete []array; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); }

int* array = NULL; bool errorOccurred = false; if (numArgs == 8) { array = Shiboken::sequenceToIntArray(%PYARG_8, true); if (PyErr_Occurred()) { if (array) delete []array; errorOccurred = true; } } if (!errorOccurred) { %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, %4, %5, %6, %7, array); if (array) delete []array; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval); }

QPixmap p; if (%CPPSELF.%FUNCTION_NAME(%1, &p)) { %PYARG_0 = %CONVERTTOPYTHON[QPixmap](p); } else { %PYARG_0 = Py_None; Py_INCREF(%PYARG_0); }

// Clear parent from the old child QStandardItem* _i = %CPPSELF->child(%1, %2); if (_i) { PyObject* _pyI = %CONVERTTOPYTHON[QStandardItem*](_i); Shiboken::Object::setParent(0, _pyI); }

// Clear parent from the old child QStandardItem* _i = %CPPSELF->child(%1); if (_i) { PyObject* _pyI = %CONVERTTOPYTHON[QStandardItem*](_i); Shiboken::Object::setParent(0, _pyI); }

bool ret = !(&%CPPSELF == %1); %PYARG_0 = %CONVERTTOPYTHON[bool](ret);

// Clear parent from the old child QStandardItem* _i = %CPPSELF->item(%1, %2); if (_i) { PyObject* _pyI = %CONVERTTOPYTHON[QStandardItem*](_i); Shiboken::Object::setParent(0, _pyI); }

// Clear parent from the old child QStandardItem* _i = %CPPSELF->item(%1); if (_i) { PyObject* _pyI = %CONVERTTOPYTHON[QStandardItem*](_i); Shiboken::Object::setParent(0, _pyI); }

// Clear parent from the old child QStandardItem* _i = %CPPSELF->verticalHeaderItem(%1); if (_i) { PyObject* _pyI = %CONVERTTOPYTHON[QStandardItem*](_i); Shiboken::Object::setParent(0, _pyI); }

Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); SbkObject* pyRoot = bm.retrieveWrapper(%CPPSELF.invisibleRootItem()); if (pyRoot) { Shiboken::Object::destroy(pyRoot, %CPPSELF.invisibleRootItem()); } for(int r=0, r_max = %CPPSELF.rowCount(); r < r_max; r++) { QList<QStandardItem *> ri = %CPPSELF.takeRow(0); PyObject *pyResult = %CONVERTTOPYTHON[QList<QStandardItem * >](ri); Shiboken::Object::setParent(Py_None, pyResult); Py_XDECREF(pyResult); }

%BEGIN_ALLOW_THREADS %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2); %END_ALLOW_THREADS %PYARG_0 = PyTuple_New(2); PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_)); PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1));

%BEGIN_ALLOW_THREADS %CPPSELF.%FUNCTION_NAME(%1.data(), %1.size(), %2); %END_ALLOW_THREADS

if (PySequence_Size(%PYARG_1) == 16) { float values[16]; for(int i=0; i < 16; i++) { PyObject *pv = PySequence_Fast_GET_ITEM(%PYARG_1, i); values[i] = PyFloat_AsDouble(pv); } %0 = new %TYPE(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]); }

float values[16]; %CPPSELF.%FUNCTION_NAME(values); %PYARG_0 = PyTuple_New(16); for(int i=0; i < 16; i++) { PyObject *v = PyFloat_FromDouble(values[i]); PyTuple_SET_ITEM(%PYARG_0, i, v); }

if (PySequence_Check(_key)) { Shiboken::AutoDecRef key(PySequence_Fast(_key, "Invalid matrix index.")); if (PySequence_Fast_GET_SIZE(key.object()) == 2) { PyObject* posx = PySequence_Fast_GET_ITEM(key.object(), 0); PyObject* posy = PySequence_Fast_GET_ITEM(key.object(), 1); Py_ssize_t x = PyInt_AsSsize_t(posx); Py_ssize_t y = PyInt_AsSsize_t(posy); float ret = (*%CPPSELF)(x,y); return %CONVERTTOPYTHON[float](ret); } } PyErr_SetString(PyExc_IndexError, "Invalid matrix index."); return 0;

_______ end of matrix block _______ -->

QGuiApplicationConstructor(%PYSELF, args, &%0);