%PYARG_0 = %CONVERTTOPYTHON[double](qAbs(%1));
PySide::runCleanupFunctions();
Shiboken::TypeResolver::createValueTypeResolver<QString>("unicode");
Shiboken::TypeResolver::createValueTypeResolver<QString>("str");
PySide::init(module);
Py_AtExit(QtCoreModuleExit);
#include <pyside.h>
// Define a global variable to handle qInstallMsgHandler callback
static PyObject* qtmsghandler = 0;
void
msghandlercallback(QtMsgType type, const char* msg)
{
Shiboken::AutoDecRef arglist(Shiboken::makeTuple(type, msg));
Shiboken::AutoDecRef ret(PyObject_CallObject(qtmsghandler, arglist));
}
void QtCoreModuleExit()
{
PySide::SignalManager::instance().clear();
}
if (%PYARG_1 == Py_None) {
qInstallMsgHandler(0);
%PYARG_0 = qtmsghandler ? qtmsghandler : Py_None;
qtmsghandler = 0;
} else if (!PyCallable_Check(%PYARG_1)) {
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
} else {
%PYARG_0 = qtmsghandler ? qtmsghandler : Py_None;
Py_INCREF(%PYARG_1);
qtmsghandler = %PYARG_1;
qInstallMsgHandler(msghandlercallback);
}
if (%PYARG_0 == Py_None)
Py_INCREF(%PYARG_0);
namespace PySide {
template<> inline uint hash(const QLine& v) {
return qHash(qMakePair(qMakePair(v.x1(), v.y1()), qMakePair(v.x2(), v.y2())));
}
};
QPointF p;
%RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &p);
%PYARG_0 = Shiboken::makeTuple(retval, p);
int year, month, day;
%CPPSELF.%FUNCTION_NAME(&year, &month, &day);
%PYARG_0 = Shiboken::makeTuple(year, month, day);
int yearNumber;
int week = %CPPSELF.%FUNCTION_NAME(&yearNumber);
%PYARG_0 = Shiboken::makeTuple(week, yearNumber);
QDate date(%1, %2, %3);
QTime time(%4, %5, %6, %7);
%0 = new %TYPE(date, time, Qt::TimeSpec(%8));
namespace PySide {
template<> inline uint hash(const QPoint& v) {
return qHash(qMakePair(v.x(), v.y()));
}
};
namespace PySide {
template<> inline uint hash(const QRect& v) {
return qHash(qMakePair(qMakePair(v.x(), v.y()), qMakePair(v.width(), v.height())));
}
};
namespace PySide {
template<> inline uint hash(const QSize& v) {
return qHash(qMakePair(v.width(), v.height()));
}
};
return %CPPSELF.size();
if (_i < 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
}
return %CONVERTTOPYTHON[bool](%CPPSELF.at(_i));
PyObject* args = Py_BuildValue("(iiO)", _i, 1, _value);
PyObject* result = Sbk_QBitArrayFunc_setBit(self, args);
Py_DECREF(args);
Py_XDECREF(result);
return !result ? -1 : 0;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME(%1, %2, %PYARG_3));
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME());
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnect(%1, %2, %CPPSELF, %3, %4));
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnect(%1, %2, %3, %4, %5));
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnectCallback(%1, %2, %PYARG_3, %4));
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnectCallback(%CPPSELF, %1, %PYARG_2, %3));
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnect(%CPPSELF, %1, %2, %3, %4));
%PYARG_0 = %CONVERTTOPYTHON[bool](PySide::SignalManager::instance().emitSignal(%CPPSELF, %1, %PYARG_2));
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectDisconnectCallback(%CPPSELF, %1, %2));
// %FUNCTION_NAME() - disable generation of function call.
%PYARG_0 = %CONVERTTOPYTHON[bool](qobjectDisconnectCallback(%1, %2, %3));
static bool
qobjectInheritsInternal(PyTypeObject *objType, const char *class_name)
{
if (strcmp(objType->tp_name, class_name) == 0)
return true;
PyTypeObject* base = (objType)->tp_base;
if (base == 0)
return false;
return qobjectInheritsInternal(base, class_name);
}
bool retval = qobjectInheritsInternal(self->ob_type, %1) ? true : %CPPSELF.%FUNCTION_NAME(%1);
%PYARG_0 = %CONVERTTOPYTHON[bool](retval);
%PYARG_0 = %CONVERTTOPYTHON[QObject*](_findChildHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1));
%PYARG_0 = PyList_New(0);
_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0);
QString result;
if (QCoreApplication::instance()) {
PyObject *klass = PyObject_GetAttrString(%PYSELF, "__class__");
PyObject *cname = PyObject_GetAttrString(klass, "__name__");
result = QString(QCoreApplication::instance()->translate(PyString_AsString(cname), %1, %2, QCoreApplication::CodecForTr, %3));
Py_DECREF(klass);
Py_DECREF(cname);
} else {
result = QString(QString::fromLatin1(%1));
}
%PYARG_0 = %CONVERTTOPYTHON[QString](result);
QString result;
if (QCoreApplication::instance()) {
PyObject *klass = PyObject_GetAttrString(%PYSELF, "__class__");
PyObject *cname = PyObject_GetAttrString(klass, "__name__");
result = QString(QCoreApplication::instance()->translate(PyString_AsString(cname), %1, %2, QCoreApplication::UnicodeUTF8, %3));
Py_DECREF(klass);
Py_DECREF(cname);
} else {
result = QString(QString::fromLatin1(%1));
}
%PYARG_0 = %CONVERTTOPYTHON[QString](result);
// Avoid return +1 because SignalManager connect to "destroyed()" signal to control object timelife
int ret = %CPPSELF.%FUNCTION_NAME(%1);
if (ret > 0 && ((strcmp(%1, SIGNAL(destroyed())) == 0) || (strcmp(%1, SIGNAL(destroyed(QObject*))) == 0))) {
if (PySide::SignalManager::instance().hasConnectionWith(%CPPSELF))
ret--;
}
%PYARG_0 = %CONVERTTOPYTHON[int](ret);
<para>URLs can be represented in two forms: encoded or unencoded. The unencoded representation is suitable for showing to users, but the encoded representation is typically what you would send to a web server. For example, the unencoded URL "http://bühler.example.com" would be sent to the server as "http://xn--bhler-kva.example.com/List%20of%20applicants.xml".</para>
int size = PyString_Size(pyargs[0]);
%0 = new QByteArray(%1, size);
#if PY_VERSION_HEX < 0x03000000
Shiboken::SbkType<QByteArray>()->tp_as_buffer = &SbkQByteArrayBufferProc;
Shiboken::SbkType<QByteArray>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER;
#endif
%PYARG_0 = PyString_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());
char c = PyString_AS_STRING(%PYARG_1)[0];
if (c) {
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME(c));
}
%PYARG_0 = PyString_FromString(%CPPSELF.data());
return %CPPSELF.count();
if (_i < 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
} else {
char res[2];
res[0] = %CPPSELF.at(_i);
res[1] = 0;
return PyString_FromString(res);
}
%CPPSELF.remove(_i, 1);
PyObject* args = Py_BuildValue("(nO)", _i, _value);
PyObject* result = Sbk_QByteArrayFunc_insert(self, args);
Py_DECREF(args);
Py_XDECREF(result);
return !result ? -1 : 0;
QByteArray ba;
ba.resize(%2);
%CPPSELF.%FUNCTION_NAME(ba.data(), ba.size());
%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba);
const QByteArray ba(%CONVERTTOCPP[QByteArray](%PYARG_0));
memcpy(%1, ba.data(), ba.size());
long long %out = ba.size();
QByteArray ba;
ba.resize(%2);
%CPPSELF.%FUNCTION_NAME(ba.data(), ba.size());
%PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba);
const QByteArray ba(%CONVERTTOCPP[QByteArray](%PYARG_0));
memcpy(data, ba.data(), ba.size());
long long %out = ba.size();
// %FUNCTION_NAME() - disable generation of c++ function call
(void) %2; // remove warning about unused variable
Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
PyObject* pyTimer = Shiboken::SbkType<QTimer>()->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, 0);
Shiboken::SbkType<QTimer>()->tp_init(pyTimer, emptyTuple, 0);
QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer);
Shiboken::AutoDecRef result(
PyObject_CallMethod(pyTimer,
const_cast<char*>("connect"),
const_cast<char*>("OsOs"),
pyTimer,
SIGNAL(timeout()),
%PYARG_2,
%3)
);
Shiboken::Object::invalidate((SbkObject*)pyTimer);
timer->setSingleShot(true);
timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
timer->start(%1);
// %FUNCTION_NAME() - disable generation of c++ function call
Shiboken::AutoDecRef emptyTuple(PyTuple_New(0));
PyObject *pyTimer = Shiboken::SbkType<QTimer>()->tp_new(Shiboken::SbkType<QTimer>(), emptyTuple, 0);
Shiboken::SbkType<QTimer>()->tp_init(pyTimer, emptyTuple, 0);
QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer);
timer->setSingleShot(true);
timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
if (PyObject_TypeCheck(%2, &PySideSignalInstanceType)) {
PySideSignalInstance* signalInstance = reinterpret_cast<PySideSignalInstance*>(%2);
Shiboken::AutoDecRef signalSignature(PyString_FromFormat("2%s", PySide::Signal::getSignature(signalInstance)));
Shiboken::AutoDecRef result(
PyObject_CallMethod(pyTimer,
const_cast<char*>("connect"),
const_cast<char*>("OsOO"),
pyTimer,
SIGNAL(timeout()),
PySide::Signal::getObject(signalInstance),
signalSignature.object())
);
} else {
Shiboken::AutoDecRef result(
PyObject_CallMethod(pyTimer,
const_cast<char*>("connect"),
const_cast<char*>("OsO"),
pyTimer,
SIGNAL(timeout()),
pyargs[1])
);
}
Shiboken::Object::invalidate((SbkObject*)pyTimer);
timer->start(%1);
qint64 pid;
%RETURN_TYPE retval = %TYPE::%FUNCTION_NAME(%1, %2, %3, &pid);
%PYARG_0 = Shiboken::makeTuple(retval, pid);
.. class:: QCoreApplication(args)
Constructs a Qt kernel application. Kernel applications are applications
without a graphical user interface. These type of applications are used
at the console or as server processes.
The *args* argument is processed by the application, and made available
in a more convenient form by the :meth:`~QCoreApplication.arguments()`
method.
%RETURN_TYPE _cpp_result;
(*%CPPSELF) >> _cpp_result;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](_cpp_result);
(*%CPPSELF) << %1;
*(%CPPSELF) << %1;
%RETURN_TYPE val;
*(%CPPSELF) >> val;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val);
*(%CPPSELF) << %1;
%RETURN_TYPE val;
*(%CPPSELF) >> val;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val);
*(%CPPSELF) << %1;
%RETURN_TYPE val;
*(%CPPSELF) >> val;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val);
*(%CPPSELF) << %1;
%RETURN_TYPE val;
*(%CPPSELF) >> val;
%PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val);
QByteArray data;
data.resize(%2);
%CPPSELF.%FUNCTION_NAME(data.data(), data.size());
%PYARG_0 = PyString_FromStringAndSize(data.constData(), data.size());
int r = %CPPSELF.%FUNCTION_NAME(%1, PyString_Size(%PYARG_1));
%PYARG_0 = %CONVERTTOPYTHON[int](r);
%PYARG_0 = (PyObject*)%CPPSELF.%FUNCTION_NAME();
if (!%PYARG_0)
%PYARG_0 = Py_None;
Py_XINCREF(%PYARG_0);
for(int counter = 0; counter < %CPPSELF.animationCount(); ++counter ) {
PyObject* obj = %CONVERTTOPYTHON[QAbstractAnimation*](%CPPSELF.animationAt(counter));
Shiboken::Object::setParent(NULL, obj);
Py_DECREF(obj);
}
%CPPSELF.clear();
if (PyObject_TypeCheck(%1, &PySideSignalInstanceType)) {
PyObject* dataSource = PySide::Signal::getObject((PySideSignalInstance*) %PYARG_1);
Shiboken::AutoDecRef obType(PyObject_Type(dataSource));
QObject* sender = %CONVERTTOCPP[QObject*](dataSource);
if (sender) {
const char* dataSignature = PySide::Signal::getSignature((PySideSignalInstance*) %PYARG_1);
QByteArray signature(dataSignature); // Append SIGNAL flag (2)
%0 = new QSignalTransitionWrapper(sender, "2" + signature, %2);
}
}
QString signalName(%2);
if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toAscii().data(), QMetaMethod::Signal)) {
%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%CPPSELF->addTransition(%1, %2, %3));
} else {
%PYARG_0 = Py_None;
}
// Obviously the label used by the following goto is a very awkward solution,
// since it refers to a name very tied to the generator implementation.
// Check bug #362 for more information on this
// http://bugs.openbossa.org/show_bug.cgi?id=362
if (!PyObject_TypeCheck(%1, &PySideSignalInstanceType))
goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError;
PySideSignalInstance* signalInstance = reinterpret_cast<PySideSignalInstance*>(%1);
QObject* sender = %CONVERTTOCPP[QObject*](PySide::Signal::getObject(signalInstance));
%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance), %2));
%PYARG_0 = PySet_New(0);
foreach(QAbstractState* abs_state, %CPPSELF.configuration()) {
Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractState*](abs_state));
Shiboken::Object::setParent(self, obj);
PySet_Add(%PYARG_0, obj);
}
%PYARG_0 = PyList_New(0);
foreach(QAbstractAnimation* abs_anim, %CPPSELF.defaultAnimations()) {
Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractAnimation*](abs_anim));
Shiboken::Object::setParent(self, obj);
PyList_Append(%PYARG_0, obj);
}
%PYARG_0 = PyString_FromFormat("2%s", QMetaObject::normalizedSignature(%1).constData());
%PYARG_0 = PyString_FromFormat("1%s", QMetaObject::normalizedSignature(%1).constData());
(void)%1;%PYARG_0 = %PYARG_1;
(void)%1;%PYARG_0 = %PYARG_1;
(void)%1;(void)%2;%PYARG_0 = %PYARG_2;
(void)%1;(void)%2;(void)%3;%PYARG_0 = %PYARG_2;
(void)%1;%PYARG_0 = %PYARG_1;
extern bool
qRegisterResourceData(int,
const unsigned char *,
const unsigned char *,
const unsigned char *);
extern bool
qUnregisterResourceData(int,
const unsigned char *,
const unsigned char *,
const unsigned char *);
%PYARG_0 = %CONVERTTOPYTHON[bool](%FUNCTION_NAME(%1, (uchar*)%2, (uchar*)%3, (uchar*)%4));
%PYARG_0 = %CONVERTTOPYTHON[bool](%FUNCTION_NAME(%1, (uchar*)%2, (uchar*)%3, (uchar*)%4));