int size = PyString_GET_SIZE(%PYARG_1);
if (size == 1) {
char *str = PyString_AS_STRING(%PYARG_1);
QChar ch(str[0]);
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME(ch));
} else {
PyErr_SetString(PyExc_TypeError, "String must have only one character");
}
Py_INCREF(%PYSELF);
%PYARG_0 = %PYSELF;
if (!%CPPSELF.atEnd())
%PYARG_0 = %CONVERTTOPYTHON[QTextBlock::iterator]((*%CPPSELF)++);
%PYARG_0 = %CONVERTTOPYTHON[QTextBlock::iterator](%CPPSELF.begin());
PyObject* points = PyList_New(%CPPSELF.count());
for (int i = 0, max = %CPPSELF.count(); i < max; ++i){
int x, y;
%CPPSELF.point(i, &x, &y);
PyList_SET_ITEM(points, i, %CONVERTTOPYTHON[QPoint](QPoint(x, y)));
}
%PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItem*](%CPPSELF.operator*());
Shiboken::Object::releaseOwnership(%PYARG_0);
if (%1.type() == QVariant::Pixmap)
%0 = new %TYPE(%1.value<QPixmap>());
else if (%1.type() == QVariant::Image)
%0 = new %TYPE(QPixmap::fromImage(%1.value<QImage>()));
else
PyErr_SetString(PyExc_TypeError, "QVariant must be holding a QPixmap");
const uchar* %out = reinterpret_cast<const uchar*>(PyString_AS_STRING(%PYARG_1));
uint %out = static_cast<uint>(PyString_GET_SIZE(%PYARG_1));
PyTypeObject* pyType = reinterpret_cast<PyTypeObject*>(%PYARG_1->ob_type);
if (pyType->tp_as_buffer
&& pyType->tp_as_buffer->bf_getreadbuffer
&& pyType->tp_as_buffer->bf_getsegcount(%PYARG_1, 0) == 1) {
void* ptr;
pyType->tp_as_buffer->bf_getreadbuffer(%PYARG_1, 0, &ptr);
%0 = new %TYPE((uchar*)ptr, %ARGS);
} else {
PyErr_SetString(PyExc_TypeError, "The object must support buffer protocol with just one segment.");
}
%PYARG_0 = PyBuffer_FromMemory(const_cast<uchar*>(%CPPSELF.%FUNCTION_NAME()), %CPPSELF.byteCount());
// byteCount() is only available on Qt4.7, so we use bytesPerLine * height
%PYARG_0 = PyBuffer_FromReadWriteMemory(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.bytesPerLine() * %CPPSELF.height());
%PYARG_0 = PyBuffer_FromMemory(const_cast<uchar*>(%CPPSELF.%FUNCTION_NAME(%1)), %CPPSELF.bytesPerLine());
%PYARG_0 = PyBuffer_FromReadWriteMemory(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine());
PyObject *createFunction = 0;
switch(%CPPSELF.spec()) {
case QColor::Rgb:
{
qreal r, g, b, a;
createFunction = PyObject_GetAttrString(%PYSELF, "fromRgbF");
%CPPSELF.getRgbF(&r, &g, &b, &a);
%PYARG_0 = Py_BuildValue("(N(ffff))", createFunction, r, g, b, a);
break;
}
case QColor::Hsv:
{
qreal h, s, v, a;
createFunction = PyObject_GetAttrString(%PYSELF, "fromHsvF");
%CPPSELF.getHsvF(&h, &s, &v, &a);
%PYARG_0 = Py_BuildValue("(N(ffff))", createFunction, h, s, v, a);
break;
}
case QColor::Cmyk:
{
qreal c, m, y, k, a;
createFunction = PyObject_GetAttrString(%PYSELF, "fromCmykF");
%CPPSELF.getCmykF(&c, &m, &y, &k, &a);
%PYARG_0 = Py_BuildValue("(N(fffff))", createFunction, c, m, y, k, a);
break;
}
case QColor::Hsl:
{
qreal h, s, l, a;
createFunction = PyObject_GetAttrString(%PYSELF, "fromHslF");
%CPPSELF.getHsvF(&h, &s, &l, &a);
%PYARG_0 = Py_BuildValue("(N(ffff))", createFunction, 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);
}
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);
}
PyObject* userTypeConstant = PyInt_FromLong(QGraphicsItem::UserType);
PyDict_SetItemString(Sbk_QGraphicsItem_Type.super.ht_type.tp_dict, "UserType", userTypeConstant);
QGraphicsItem *item_ = NULL;
%RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&item_);
%PYARG_0 = Shiboken::makeTuple(retval_, item_);
Shiboken::Object::releaseOwnership(%PYARG_2);
//this function is static we need keep ref to default value, to be able to call python virtual functions
static PyObject* _defaultValue = 0;
%CPPSELF.%FUNCTION_NAME(%1);
Py_INCREF(%PYARG_1);
if (_defaultValue)
Py_DECREF(_defaultValue);
_defaultValue = %PYARG_1;
%PYARG_0 = addActionWithPyObject(%CPPSELF, QIcon(), %1, %2, %3);
%PYARG_0 = addActionWithPyObject(%CPPSELF, %1, %2, %3, %4);
%PYARG_0 = addActionWithPyObject(%CPPSELF, %1, %2);
%0 = new %TYPE(%1, %2);
Shiboken::AutoDecRef result(PyObject_CallMethod(%PYSELF, "connect", "OsO", %PYSELF, SIGNAL(activated()), %PYARG_3));
if (!result.isNull())
Shiboken::Object::setParent(%PYARG_2, %PYSELF);
// 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);
}
QWidget *_widget = %CPPSELF.widget(%1);
if (_widget) {
Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](_widget));
Shiboken::Object::setParent(0, pyWidget);
}
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 (Shiboken::Converter<QString>::isConvertible(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 (Shiboken::Converter<int>::isConvertible(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 = 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 (Shiboken::Converter<QValidator::State>::isConvertible(%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",
"PySide.QtGui.QValidator.State, (PySide.QtGui.QValidator.State,), (PySide.QtGui.QValidator.State, unicode) or (PySide.QtGui.QValidator.State, unicode, int)",
pyResult->ob_type->tp_name);
return QValidator::State();
}
%PYARG_0 = %CONVERTTOPYTHON[bool](!(&%CPPSELF == %1));
addLayoutOwnership(%CPPSELF, %0);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %2);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %2);
addLayoutOwnership(%CPPSELF, %2);
addLayoutOwnership(%CPPSELF, %2);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %2);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
addLayoutOwnership(%CPPSELF, %1);
int a, b, c, d;
%CPPSELF.%FUNCTION_NAME(%1, &a, &b, &c, &d);
%PYARG_0 = Shiboken::makeTuple(a, b, c, d);
int %out = PySequence_Size(%PYARG_1);
int numItems = PySequence_Size(%PYARG_1);
PySide::AutoArrayPointer<QGraphicsItem*> %out(numItems);
for (int i=0; i < numItems; i++) {
%out[i] = %CONVERTTOCPP[QGraphicsItem*](PySequence_Fast_GET_ITEM(%PYARG_1, i));
}
Shiboken::AutoDecRef object(PyList_New(0));
for (int i=0, max=numItems; i < max; i++) {
PyList_Append(object, %CONVERTTOPYTHON[QGraphicsItem*](%in[i]));
}
PyObject *%out = object.object();
Shiboken::AutoDecRef option_object(PyList_New(0));
for (int i=0, max=numItems; i < max; i++) {
PyList_Append(option_object, %CONVERTTOPYTHON[QStyleOptionGraphicsItem](%in[i]));
}
PyObject *%out = option_object.object();
int numOptions = PySequence_Size(%PYARG_2);
PySide::AutoArrayPointer<QStyleOptionGraphicsItem> %out(numOptions);
for (int i=0; i < numOptions; i++) {
%out[i] = %CONVERTTOCPP[QStyleOptionGraphicsItem](PySequence_Fast_GET_ITEM(%PYARG_1, i));
}
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME(%1, %2));
Shiboken::Object::keepReference((SbkObject*)%PYARG_0, "setWidget(QWidget*)1", %PYARG_1);
const QList<QGraphicsItem*> items = %CPPSELF.items();
Shiboken::BindingManager& bm = Shiboken::BindingManager::instance();
foreach (QGraphicsItem* item, items) {
SbkObject* obj = bm.retrieveWrapper(item);
if (obj) {
if (obj->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway.
Shiboken::Object::invalidate(obj);
Shiboken::Object::removeParent(obj);
}
}
%CPPSELF.%FUNCTION_NAME();
QTreeWidgetItem *rootItem = %CPPSELF.invisibleRootItem();
Shiboken::BindingManager &bm = Shiboken::BindingManager::instance();
for (int i = 0; i < rootItem->childCount(); ++i) {
QTreeWidgetItem *item = rootItem->child(i);
SbkObject* wrapper = bm.retrieveWrapper(item);
if (wrapper)
Shiboken::Object::setParent(0, reinterpret_cast<PyObject*>(wrapper));
}
// Only call the parent function if this return some value
// the parent can be the TreeWidget
if (%0)
Shiboken::Object::setParent(%PYARG_0, %PYSELF);
// Only call the parent function if this return some value
// the parent can be the TreeWidgetItem
if (%0)
Shiboken::Object::setParent(%PYARG_0, %PYSELF);
Shiboken::Object::keepReference(reinterpret_cast<SbkObject*>(%PYSELF), "__style__", %PYARG_1);
QStyle* myStyle = %CPPSELF->style();
if (myStyle && qApp) {
%PYARG_0 = %CONVERTTOPYTHON[QStyle*](myStyle);
QStyle *appStyle = qApp->style();
if (appStyle == myStyle) {
Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication*](qApp));
Shiboken::Object::setParent(pyApp, %PYARG_0);
Shiboken::Object::releaseOwnership(%PYARG_0);
} else {
Shiboken::Object::keepReference(reinterpret_cast<SbkObject*>(%PYSELF), "__style__", %PYARG_0);
}
}
qwidgetSetLayout(%CPPSELF, %1);
// %FUNCTION_NAME() - disable generation of function call.
Returns the window system identifier of the widget.
Portable in principle, but if you use it you are probably about to do something non-portable. Be careful.
If a widget is non-native (alien) and winId() is invoked on it, that widget will be provided a native handle.
On X11 the type returned is long, on other platforms it's a PyCObject.
This value may change at run-time. An event with type PySide.QtCore.QEvent.WinIdChange will be sent to the widget following a change in window system identifier.
QWidget* tab = %CPPSELF.widget(%1);
if (tab) {
Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](tab));
%CPPSELF.%FUNCTION_NAME(%1);
}
for (int i = 0; i < %CPPSELF.count(); i++) {
Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](%CPPSELF.widget(i)));
Shiboken::Object::setParent(0, pyWidget);
}
%CPPSELF.%FUNCTION_NAME();
// 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);
}
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);
}
%RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2);
%PYARG_0 = Shiboken::makeTuple(retval_, %1);
%PYARG_0 = %CONVERTTOPYTHON[QAction*](%CPPSELF.addAction(%1, %2));
Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, "connect", "OsO", %PYARG_0, SIGNAL(triggered()), %PYARG_3));
%PYARG_0 = %CONVERTTOPYTHON[QAction*](%CPPSELF.addAction(%1));
Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, "connect", "OsO", %PYARG_0, SIGNAL(triggered()), %PYARG_2));
QList<PyObject* > lst;
Shiboken::BindingManager& bm = Shiboken::BindingManager::instance();
foreach(QToolButton* child, %CPPSELF.findChildren<QToolButton*>()) {
if (bm.hasWrapper(child)) {
PyObject* pyChild = %CONVERTTOPYTHON[QToolButton*](child);
Shiboken::Object::setParent(0, pyChild);
lst << pyChild;
}
}
%CPPSELF.clear();
foreach(PyObject* obj, lst) {
Shiboken::Object::invalidate(reinterpret_cast<SbkObject* >(obj));
Py_XDECREF(obj);
}
PyObject* moduleQtGui;
Shiboken::Object::setParent(%CONVERTTOPYTHON[QApplication*](qApp), %PYARG_1);
return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF /= %1);
return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF *= %1);
return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF += %1);
return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF -= %1);
return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF /= %1);
if (PySequence_Size(%PYARG_1) == 16) {
qreal 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]);
}
qreal 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);
}