int size = Shiboken::String::len(%PYARG_1);
if (size == 1) {
const char *str = Shiboken::String::toCString(%PYARG_1);
QChar ch(str[0]);
%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ch);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
} else {
PyErr_SetString(PyExc_TypeError, "String must have only one character");
}
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 = reinterpret_cast<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 = reinterpret_cast<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);
// %FUNCTION_NAME()
*%CPPSELF << %1;
%PYARG_0 = %CONVERTTOPYTHON[QPolygon*](%CPPSELF);
Shiboken::AutoDecRef strList(PySequence_Fast(%PYARG_1, "Invalid sequence."));
int lineCount = PySequence_Fast_GET_SIZE(strList.object());
for (int line = 0; line < lineCount; ++line) {
if (!Shiboken::String::check(PySequence_Fast_GET_ITEM(strList.object(), line))) {
PyErr_SetString(PyExc_TypeError, "The argument must be a sequence of strings.");
break;
}
}
const char **xpm = reinterpret_cast<const char**>(malloc(lineCount * sizeof(const char**)));
for (int line = 0; line < lineCount; ++line)
xpm[line] = Shiboken::String::toCString(PySequence_Fast_GET_ITEM(strList.object(), line));
%BEGIN_ALLOW_THREADS
%0 = new %TYPE(xpm);
%END_ALLOW_THREADS
free(xpm);
%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));
%ARG1_TYPE a, b;
%CPPSELF.%FUNCTION_NAME(%1, %2, &a, &b);
%PYARG_0 = PyTuple_New(2);
PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%ARG1_TYPE](a));
PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](b));
uchar *ptr = reinterpret_cast<uchar*>(Shiboken::Buffer::getPointer(%PYARG_1));
%0 = new %TYPE(ptr, %ARGS);
%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);
switch(%CPPSELF.spec()) {
case QColor::Rgb:
{
qreal r, g, b, a;
%CPPSELF.getRgbF(&r, &g, &b, &a);
QString repr = QString().sprintf("PySide2.QtGui.QColor.fromRgbF(%.6f, %.6f, %.6f, %.6f)", r, g, b, a);
%PYARG_0 = Shiboken::String::fromCString(qPrintable(repr));
break;
}
case QColor::Hsv:
{
qreal h, s, v, a;
%CPPSELF.getHsvF(&h, &s, &v, &a);
QString repr = QString().sprintf("PySide2.QtGui.QColor.fromHsvF(%.6f, %.6f, %.6f, %.6f)", h, s, v, a);
%PYARG_0 = Shiboken::String::fromCString(qPrintable(repr));
break;
}
case QColor::Cmyk:
{
qreal c, m, y, k, a;
%CPPSELF.getCmykF(&c, &m, &y, &k, &a);
QString repr = QString().sprintf("PySide2.QtGui.QColor.fromCmykF(%.6f, %.6f, %.6f, %.6f, %.6f)", c, m, y, k, a);
%PYARG_0 = Shiboken::String::fromCString(qPrintable(repr));
break;
}
#if QT_VERSION >= 0x040600
case QColor::Hsl:
{
qreal h, s, l, a;
%CPPSELF.getHslF(&h, &s, &l, &a);
QString repr = QString().sprintf("PySide2.QtGui.QColor.fromHslF(%.6f, %.6f, %.6f, %.6f)", h, s, l, a);
%PYARG_0 = Shiboken::String::fromCString(qPrintable(repr));
break;
}
#endif
default:
{
%PYARG_0 = Shiboken::String::fromCString("PySide2.QtGui.QColor()");
}
}
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 = nullptr;
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 = nullptr;
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 = nullptr;
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);
}
int *array = nullptr;
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 = nullptr;
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);
}
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);
}
QValidator::State %out;
if (PySequence_Check(%PYARG_0)) {
Shiboken::AutoDecRef seq(PySequence_Fast(%PYARG_0, 0));
int size = PySequence_Fast_GET_SIZE(seq.object());
if (size > 1) {
if (%ISCONVERTIBLE[QString](PySequence_Fast_GET_ITEM(seq.object(), 1)))
%1 = %CONVERTTOCPP[QString](PySequence_Fast_GET_ITEM(seq.object(), 1));
else
qWarning("%TYPE::%FUNCTION_NAME: Second tuple element is not convertible to unicode.");
}
if (size > 2) {
if (%ISCONVERTIBLE[int](PySequence_Fast_GET_ITEM(seq.object(), 2)))
%2 = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(seq.object(), 2));
else
qWarning("%TYPE::%FUNCTION_NAME: Second tuple element is not convertible to int.");
}
%PYARG_0.reset(PySequence_Fast_GET_ITEM(seq.object(), 0));
Py_INCREF(%PYARG_0); // we need to incref, because "%PYARG_0 = ..." will decref the tuple and the tuple will be decrefed again at the end of this scope.
}
// check retrun value
if (%ISCONVERTIBLE[QValidator::State](%PYARG_0)) {
%out = %CONVERTTOCPP[QValidator::State](%PYARG_0);
} else {
PyErr_Format(PyExc_TypeError, "Invalid return value in function %s, expected %s, got %s.",
"QValidator.validate",
"PySide2.QtGui.QValidator.State, (PySide2.QtGui.QValidator.State,), (PySide2.QtGui.QValidator.State, unicode) or (PySide2.QtGui.QValidator.State, unicode, int)",
Py_TYPE(pyResult)->tp_name);
return QValidator::State();
}
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());
%END_ALLOW_THREADS
%BEGIN_ALLOW_THREADS
%CPPSELF.%FUNCTION_NAME(%1.data(), %1.size(), %2);
%END_ALLOW_THREADS
%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);
PyObject *empty = PyTuple_New(2);
if (!PyTuple_SetItem(empty, 0, PyList_New(0))) {
QGuiApplicationConstructor(%PYSELF, empty, &%0);
}