|
|
#include "com_trolltech_qt_core2.h"
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <QVariant>
|
|
|
#include <qanimationgroup.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qeasingcurve.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmutex.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpair.h>
|
|
|
#include <qreadwritelock.h>
|
|
|
#include <qtextcodec.h>
|
|
|
#include <qtimer.h>
|
|
|
#include <qtranslator.h>
|
|
|
#include <quuid.h>
|
|
|
#include <qvariantanimation.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qwaitcondition.h>
|
|
|
#include <qxmlstream.h>
|
|
|
|
|
|
PythonQtShell_QTimer::~PythonQtShell_QTimer() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTimer::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimer::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimer::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimer::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTimer::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimer::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTimer::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimer::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTimer::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimer::timerEvent(arg__1);
|
|
|
}
|
|
|
QTimer* PythonQtWrapper_QTimer::new_QTimer(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTimer(parent); }
|
|
|
|
|
|
int PythonQtWrapper_QTimer::interval(QTimer* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->interval());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTimer::isActive(QTimer* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isActive());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTimer::isSingleShot(QTimer* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSingleShot());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimer::remainingTime(QTimer* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->remainingTime());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimer::setInterval(QTimer* theWrappedObject, int msec)
|
|
|
{
|
|
|
( theWrappedObject->setInterval(msec));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimer::setSingleShot(QTimer* theWrappedObject, bool singleShot)
|
|
|
{
|
|
|
( theWrappedObject->setSingleShot(singleShot));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimer::setTimerType(QTimer* theWrappedObject, Qt::TimerType atype)
|
|
|
{
|
|
|
( theWrappedObject->setTimerType(atype));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimer::timerEvent(QTimer* theWrappedObject, QTimerEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTimer*)theWrappedObject)->promoted_timerEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimer::timerId(QTimer* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->timerId());
|
|
|
}
|
|
|
|
|
|
Qt::TimerType PythonQtWrapper_QTimer::timerType(QTimer* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->timerType());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTimerEvent::~PythonQtShell_QTimerEvent() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTimerEvent* PythonQtWrapper_QTimerEvent::new_QTimerEvent(int timerId)
|
|
|
{
|
|
|
return new PythonQtShell_QTimerEvent(timerId); }
|
|
|
|
|
|
int PythonQtWrapper_QTimerEvent::timerId(QTimerEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->timerId());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTranslator::~PythonQtShell_QTranslator() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTranslator::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTranslator::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTranslator::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTranslator::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTranslator::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTranslator::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTranslator::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTranslator::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
bool PythonQtShell_QTranslator::isEmpty() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isEmpty");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("isEmpty", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTranslator::isEmpty();
|
|
|
}
|
|
|
void PythonQtShell_QTranslator::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTranslator::timerEvent(arg__1);
|
|
|
}
|
|
|
QString PythonQtShell_QTranslator::translate(const char* context, const char* sourceText, const char* disambiguation, int n) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "translate");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QString" , "const char*" , "const char*" , "const char*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
QString returnValue;
|
|
|
void* args[5] = {NULL, (void*)&context, (void*)&sourceText, (void*)&disambiguation, (void*)&n};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("translate", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QString*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTranslator::translate(context, sourceText, disambiguation, n);
|
|
|
}
|
|
|
QTranslator* PythonQtWrapper_QTranslator::new_QTranslator(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTranslator(parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QTranslator::isEmpty(QTranslator* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTranslator*)theWrappedObject)->promoted_isEmpty());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTranslator::load(QTranslator* theWrappedObject, const QLocale& locale, const QString& filename, const QString& prefix, const QString& directory, const QString& suffix)
|
|
|
{
|
|
|
return ( theWrappedObject->load(locale, filename, prefix, directory, suffix));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTranslator::load(QTranslator* theWrappedObject, const QString& filename, const QString& directory, const QString& search_delimiters, const QString& suffix)
|
|
|
{
|
|
|
return ( theWrappedObject->load(filename, directory, search_delimiters, suffix));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTranslator::load(QTranslator* theWrappedObject, const uchar* data, int len, const QString& directory)
|
|
|
{
|
|
|
return ( theWrappedObject->load(data, len, directory));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QUuid::~PythonQtShell_QUuid() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QUuid* PythonQtWrapper_QUuid::new_QUuid()
|
|
|
{
|
|
|
return new PythonQtShell_QUuid(); }
|
|
|
|
|
|
QUuid* PythonQtWrapper_QUuid::new_QUuid(const QByteArray& arg__1)
|
|
|
{
|
|
|
return new PythonQtShell_QUuid(arg__1); }
|
|
|
|
|
|
QUuid* PythonQtWrapper_QUuid::new_QUuid(const QString& arg__1)
|
|
|
{
|
|
|
return new PythonQtShell_QUuid(arg__1); }
|
|
|
|
|
|
QUuid* PythonQtWrapper_QUuid::new_QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8)
|
|
|
{
|
|
|
return new PythonQtShell_QUuid(l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8); }
|
|
|
|
|
|
QUuid PythonQtWrapper_QUuid::static_QUuid_createUuid()
|
|
|
{
|
|
|
return (QUuid::createUuid());
|
|
|
}
|
|
|
|
|
|
QUuid PythonQtWrapper_QUuid::static_QUuid_createUuidV3(const QUuid& ns, const QByteArray& baseData)
|
|
|
{
|
|
|
return (QUuid::createUuidV3(ns, baseData));
|
|
|
}
|
|
|
|
|
|
QUuid PythonQtWrapper_QUuid::static_QUuid_createUuidV3(const QUuid& ns, const QString& baseData)
|
|
|
{
|
|
|
return (QUuid::createUuidV3(ns, baseData));
|
|
|
}
|
|
|
|
|
|
QUuid PythonQtWrapper_QUuid::static_QUuid_createUuidV5(const QUuid& ns, const QByteArray& baseData)
|
|
|
{
|
|
|
return (QUuid::createUuidV5(ns, baseData));
|
|
|
}
|
|
|
|
|
|
QUuid PythonQtWrapper_QUuid::static_QUuid_createUuidV5(const QUuid& ns, const QString& baseData)
|
|
|
{
|
|
|
return (QUuid::createUuidV5(ns, baseData));
|
|
|
}
|
|
|
|
|
|
QUuid PythonQtWrapper_QUuid::static_QUuid_fromRfc4122(const QByteArray& arg__1)
|
|
|
{
|
|
|
return (QUuid::fromRfc4122(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QUuid::isNull(QUuid* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isNull());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QUuid::__ne__(QUuid* theWrappedObject, const QUuid& orig) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= orig);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QUuid::__lt__(QUuid* theWrappedObject, const QUuid& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)< other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QUuid::__eq__(QUuid* theWrappedObject, const QUuid& orig) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== orig);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QUuid::__gt__(QUuid* theWrappedObject, const QUuid& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)> other);
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QUuid::toByteArray(QUuid* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toByteArray());
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QUuid::toRfc4122(QUuid* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toRfc4122());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QUuid::toString(QUuid* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toString());
|
|
|
}
|
|
|
|
|
|
QUuid::Variant PythonQtWrapper_QUuid::variant(QUuid* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->variant());
|
|
|
}
|
|
|
|
|
|
QUuid::Version PythonQtWrapper_QUuid::version(QUuid* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->version());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QUuid::py_toString(QUuid* obj) { return obj->toString(); }
|
|
|
|
|
|
|
|
|
PythonQtShell_QVariantAnimation::~PythonQtShell_QVariantAnimation() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QVariantAnimation::duration() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "duration");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("duration", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QVariantAnimation::duration();
|
|
|
}
|
|
|
bool PythonQtShell_QVariantAnimation::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QVariantAnimation::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QVariantAnimation::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QVariantAnimation::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
QVariant PythonQtShell_QVariantAnimation::interpolated(const QVariant& from, const QVariant& to, qreal progress) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "interpolated");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "const QVariant&" , "const QVariant&" , "qreal"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[4] = {NULL, (void*)&from, (void*)&to, (void*)&progress};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("interpolated", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QVariantAnimation::interpolated(from, to, progress);
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::updateCurrentTime(int arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentTime");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::updateCurrentTime(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::updateCurrentValue(const QVariant& value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentValue");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QVariant&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::updateCurrentValue(value);
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::updateDirection(QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateDirection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::Direction"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&direction};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::updateDirection(direction);
|
|
|
}
|
|
|
void PythonQtShell_QVariantAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::State" , "QAbstractAnimation::State"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&newState, (void*)&oldState};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QVariantAnimation::updateState(newState, oldState);
|
|
|
}
|
|
|
QVariantAnimation* PythonQtWrapper_QVariantAnimation::new_QVariantAnimation(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QVariantAnimation(parent); }
|
|
|
|
|
|
QVariant PythonQtWrapper_QVariantAnimation::currentValue(QVariantAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentValue());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QVariantAnimation::duration(QVariantAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_duration());
|
|
|
}
|
|
|
|
|
|
QEasingCurve PythonQtWrapper_QVariantAnimation::easingCurve(QVariantAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->easingCurve());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QVariantAnimation::endValue(QVariantAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->endValue());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QVariantAnimation::event(QVariantAnimation* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QVariantAnimation::interpolated(QVariantAnimation* theWrappedObject, const QVariant& from, const QVariant& to, qreal progress) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_interpolated(from, to, progress));
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QVariantAnimation::keyValueAt(QVariantAnimation* theWrappedObject, qreal step) const
|
|
|
{
|
|
|
return ( theWrappedObject->keyValueAt(step));
|
|
|
}
|
|
|
|
|
|
QVector<QPair<qreal , QVariant > > PythonQtWrapper_QVariantAnimation::keyValues(QVariantAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->keyValues());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::setDuration(QVariantAnimation* theWrappedObject, int msecs)
|
|
|
{
|
|
|
( theWrappedObject->setDuration(msecs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::setEasingCurve(QVariantAnimation* theWrappedObject, const QEasingCurve& easing)
|
|
|
{
|
|
|
( theWrappedObject->setEasingCurve(easing));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::setEndValue(QVariantAnimation* theWrappedObject, const QVariant& value)
|
|
|
{
|
|
|
( theWrappedObject->setEndValue(value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::setKeyValueAt(QVariantAnimation* theWrappedObject, qreal step, const QVariant& value)
|
|
|
{
|
|
|
( theWrappedObject->setKeyValueAt(step, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::setKeyValues(QVariantAnimation* theWrappedObject, const QVector<QPair<qreal , QVariant > >& values)
|
|
|
{
|
|
|
( theWrappedObject->setKeyValues(values));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::setStartValue(QVariantAnimation* theWrappedObject, const QVariant& value)
|
|
|
{
|
|
|
( theWrappedObject->setStartValue(value));
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QVariantAnimation::startValue(QVariantAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->startValue());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::updateCurrentTime(QVariantAnimation* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_updateCurrentTime(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::updateCurrentValue(QVariantAnimation* theWrappedObject, const QVariant& value)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_updateCurrentValue(value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QVariantAnimation::updateState(QVariantAnimation* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_updateState(newState, oldState));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QWaitCondition* PythonQtWrapper_QWaitCondition::new_QWaitCondition()
|
|
|
{
|
|
|
return new QWaitCondition(); }
|
|
|
|
|
|
bool PythonQtWrapper_QWaitCondition::wait(QWaitCondition* theWrappedObject, QMutex* lockedMutex, unsigned long time)
|
|
|
{
|
|
|
return ( theWrappedObject->wait(lockedMutex, time));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QWaitCondition::wait(QWaitCondition* theWrappedObject, QReadWriteLock* lockedReadWriteLock, unsigned long time)
|
|
|
{
|
|
|
return ( theWrappedObject->wait(lockedReadWriteLock, time));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QWaitCondition::wakeAll(QWaitCondition* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->wakeAll());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QWaitCondition::wakeOne(QWaitCondition* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->wakeOne());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttribute::new_QXmlStreamAttribute()
|
|
|
{
|
|
|
return new QXmlStreamAttribute(); }
|
|
|
|
|
|
QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttribute::new_QXmlStreamAttribute(const QString& namespaceUri, const QString& name, const QString& value)
|
|
|
{
|
|
|
return new QXmlStreamAttribute(namespaceUri, name, value); }
|
|
|
|
|
|
QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttribute::new_QXmlStreamAttribute(const QString& qualifiedName, const QString& value)
|
|
|
{
|
|
|
return new QXmlStreamAttribute(qualifiedName, value); }
|
|
|
|
|
|
QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttribute::new_QXmlStreamAttribute(const QXmlStreamAttribute& arg__1)
|
|
|
{
|
|
|
return new QXmlStreamAttribute(arg__1); }
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttribute::isDefault(QXmlStreamAttribute* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isDefault());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttribute::name(QXmlStreamAttribute* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->name());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttribute::namespaceUri(QXmlStreamAttribute* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->namespaceUri());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttribute::__ne__(QXmlStreamAttribute* theWrappedObject, const QXmlStreamAttribute& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttribute::__eq__(QXmlStreamAttribute* theWrappedObject, const QXmlStreamAttribute& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttribute::prefix(QXmlStreamAttribute* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->prefix());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttribute::qualifiedName(QXmlStreamAttribute* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->qualifiedName());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttribute::value(QXmlStreamAttribute* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->value());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamAttributes* PythonQtWrapper_QXmlStreamAttributes::new_QXmlStreamAttributes()
|
|
|
{
|
|
|
return new QXmlStreamAttributes(); }
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::append(QXmlStreamAttributes* theWrappedObject, const QString& namespaceUri, const QString& name, const QString& value)
|
|
|
{
|
|
|
( theWrappedObject->append(namespaceUri, name, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::append(QXmlStreamAttributes* theWrappedObject, const QString& qualifiedName, const QString& value)
|
|
|
{
|
|
|
( theWrappedObject->append(qualifiedName, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::append(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& attribute)
|
|
|
{
|
|
|
( theWrappedObject->append(attribute));
|
|
|
}
|
|
|
|
|
|
const QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttributes::at(QXmlStreamAttributes* theWrappedObject, int i) const
|
|
|
{
|
|
|
return &( theWrappedObject->at(i));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamAttributes::capacity(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->capacity());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::clear(QXmlStreamAttributes* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::contains(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(t));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamAttributes::count(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->count());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamAttributes::count(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t) const
|
|
|
{
|
|
|
return ( theWrappedObject->count(t));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::empty(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->empty());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::endsWith(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t) const
|
|
|
{
|
|
|
return ( theWrappedObject->endsWith(t));
|
|
|
}
|
|
|
|
|
|
QVector<QXmlStreamAttribute >* PythonQtWrapper_QXmlStreamAttributes::fill(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t, int size)
|
|
|
{
|
|
|
return &( theWrappedObject->fill(t, size));
|
|
|
}
|
|
|
|
|
|
const QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttributes::first(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->first());
|
|
|
}
|
|
|
|
|
|
QVector<QXmlStreamAttribute > PythonQtWrapper_QXmlStreamAttributes::static_QXmlStreamAttributes_fromList(const QList<QXmlStreamAttribute >& list)
|
|
|
{
|
|
|
return (QXmlStreamAttributes::fromList(list));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::hasAttribute(QXmlStreamAttributes* theWrappedObject, const QString& namespaceUri, const QString& name) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasAttribute(namespaceUri, name));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::hasAttribute(QXmlStreamAttributes* theWrappedObject, const QString& qualifiedName) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasAttribute(qualifiedName));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamAttributes::indexOf(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t, int from) const
|
|
|
{
|
|
|
return ( theWrappedObject->indexOf(t, from));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::isEmpty(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEmpty());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::isSharedWith(QXmlStreamAttributes* theWrappedObject, const QVector<QXmlStreamAttribute >& other) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSharedWith(other));
|
|
|
}
|
|
|
|
|
|
const QXmlStreamAttribute* PythonQtWrapper_QXmlStreamAttributes::last(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->last());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamAttributes::lastIndexOf(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t, int from) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastIndexOf(t, from));
|
|
|
}
|
|
|
|
|
|
QVector<QXmlStreamAttribute > PythonQtWrapper_QXmlStreamAttributes::mid(QXmlStreamAttributes* theWrappedObject, int pos, int length) const
|
|
|
{
|
|
|
return ( theWrappedObject->mid(pos, length));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::__ne__(QXmlStreamAttributes* theWrappedObject, const QVector<QXmlStreamAttribute >& v) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= v);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::__eq__(QXmlStreamAttributes* theWrappedObject, const QVector<QXmlStreamAttribute >& v) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== v);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::prepend(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t)
|
|
|
{
|
|
|
( theWrappedObject->prepend(t));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::remove(QXmlStreamAttributes* theWrappedObject, int i)
|
|
|
{
|
|
|
( theWrappedObject->remove(i));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::remove(QXmlStreamAttributes* theWrappedObject, int i, int n)
|
|
|
{
|
|
|
( theWrappedObject->remove(i, n));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::replace(QXmlStreamAttributes* theWrappedObject, int i, const QXmlStreamAttribute& t)
|
|
|
{
|
|
|
( theWrappedObject->replace(i, t));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::reserve(QXmlStreamAttributes* theWrappedObject, int size)
|
|
|
{
|
|
|
( theWrappedObject->reserve(size));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::resize(QXmlStreamAttributes* theWrappedObject, int size)
|
|
|
{
|
|
|
( theWrappedObject->resize(size));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::setSharable(QXmlStreamAttributes* theWrappedObject, bool sharable)
|
|
|
{
|
|
|
( theWrappedObject->setSharable(sharable));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamAttributes::size(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->size());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::squeeze(QXmlStreamAttributes* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->squeeze());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamAttributes::startsWith(QXmlStreamAttributes* theWrappedObject, const QXmlStreamAttribute& t) const
|
|
|
{
|
|
|
return ( theWrappedObject->startsWith(t));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamAttributes::swap(QXmlStreamAttributes* theWrappedObject, QVector<QXmlStreamAttribute >& other)
|
|
|
{
|
|
|
( theWrappedObject->swap(other));
|
|
|
}
|
|
|
|
|
|
QList<QXmlStreamAttribute > PythonQtWrapper_QXmlStreamAttributes::toList(QXmlStreamAttributes* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toList());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttributes::value(QXmlStreamAttributes* theWrappedObject, const QString& namespaceUri, const QString& name) const
|
|
|
{
|
|
|
return ( theWrappedObject->value(namespaceUri, name));
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamAttributes::value(QXmlStreamAttributes* theWrappedObject, const QString& qualifiedName) const
|
|
|
{
|
|
|
return ( theWrappedObject->value(qualifiedName));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamEntityDeclaration* PythonQtWrapper_QXmlStreamEntityDeclaration::new_QXmlStreamEntityDeclaration()
|
|
|
{
|
|
|
return new QXmlStreamEntityDeclaration(); }
|
|
|
|
|
|
QXmlStreamEntityDeclaration* PythonQtWrapper_QXmlStreamEntityDeclaration::new_QXmlStreamEntityDeclaration(const QXmlStreamEntityDeclaration& arg__1)
|
|
|
{
|
|
|
return new QXmlStreamEntityDeclaration(arg__1); }
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamEntityDeclaration::name(QXmlStreamEntityDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->name());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamEntityDeclaration::notationName(QXmlStreamEntityDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->notationName());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamEntityDeclaration::__ne__(QXmlStreamEntityDeclaration* theWrappedObject, const QXmlStreamEntityDeclaration& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamEntityDeclaration::__eq__(QXmlStreamEntityDeclaration* theWrappedObject, const QXmlStreamEntityDeclaration& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamEntityDeclaration::publicId(QXmlStreamEntityDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->publicId());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamEntityDeclaration::systemId(QXmlStreamEntityDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->systemId());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamEntityDeclaration::value(QXmlStreamEntityDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->value());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QXmlStreamEntityResolver::~PythonQtShell_QXmlStreamEntityResolver() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QString PythonQtShell_QXmlStreamEntityResolver::resolveEntity(const QString& publicId, const QString& systemId)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resolveEntity");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QString" , "const QString&" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QString returnValue;
|
|
|
void* args[3] = {NULL, (void*)&publicId, (void*)&systemId};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("resolveEntity", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QString*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QXmlStreamEntityResolver::resolveEntity(publicId, systemId);
|
|
|
}
|
|
|
QString PythonQtShell_QXmlStreamEntityResolver::resolveUndeclaredEntity(const QString& name)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resolveUndeclaredEntity");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QString" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QString returnValue;
|
|
|
void* args[2] = {NULL, (void*)&name};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("resolveUndeclaredEntity", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QString*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QXmlStreamEntityResolver::resolveUndeclaredEntity(name);
|
|
|
}
|
|
|
QXmlStreamEntityResolver* PythonQtWrapper_QXmlStreamEntityResolver::new_QXmlStreamEntityResolver()
|
|
|
{
|
|
|
return new PythonQtShell_QXmlStreamEntityResolver(); }
|
|
|
|
|
|
QString PythonQtWrapper_QXmlStreamEntityResolver::resolveEntity(QXmlStreamEntityResolver* theWrappedObject, const QString& publicId, const QString& systemId)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QXmlStreamEntityResolver*)theWrappedObject)->promoted_resolveEntity(publicId, systemId));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QXmlStreamEntityResolver::resolveUndeclaredEntity(QXmlStreamEntityResolver* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QXmlStreamEntityResolver*)theWrappedObject)->promoted_resolveUndeclaredEntity(name));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamNamespaceDeclaration* PythonQtWrapper_QXmlStreamNamespaceDeclaration::new_QXmlStreamNamespaceDeclaration()
|
|
|
{
|
|
|
return new QXmlStreamNamespaceDeclaration(); }
|
|
|
|
|
|
QXmlStreamNamespaceDeclaration* PythonQtWrapper_QXmlStreamNamespaceDeclaration::new_QXmlStreamNamespaceDeclaration(const QString& prefix, const QString& namespaceUri)
|
|
|
{
|
|
|
return new QXmlStreamNamespaceDeclaration(prefix, namespaceUri); }
|
|
|
|
|
|
QXmlStreamNamespaceDeclaration* PythonQtWrapper_QXmlStreamNamespaceDeclaration::new_QXmlStreamNamespaceDeclaration(const QXmlStreamNamespaceDeclaration& arg__1)
|
|
|
{
|
|
|
return new QXmlStreamNamespaceDeclaration(arg__1); }
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamNamespaceDeclaration::namespaceUri(QXmlStreamNamespaceDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->namespaceUri());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamNamespaceDeclaration::__ne__(QXmlStreamNamespaceDeclaration* theWrappedObject, const QXmlStreamNamespaceDeclaration& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamNamespaceDeclaration::__eq__(QXmlStreamNamespaceDeclaration* theWrappedObject, const QXmlStreamNamespaceDeclaration& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamNamespaceDeclaration::prefix(QXmlStreamNamespaceDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->prefix());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamNotationDeclaration* PythonQtWrapper_QXmlStreamNotationDeclaration::new_QXmlStreamNotationDeclaration()
|
|
|
{
|
|
|
return new QXmlStreamNotationDeclaration(); }
|
|
|
|
|
|
QXmlStreamNotationDeclaration* PythonQtWrapper_QXmlStreamNotationDeclaration::new_QXmlStreamNotationDeclaration(const QXmlStreamNotationDeclaration& arg__1)
|
|
|
{
|
|
|
return new QXmlStreamNotationDeclaration(arg__1); }
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamNotationDeclaration::name(QXmlStreamNotationDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->name());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamNotationDeclaration::__ne__(QXmlStreamNotationDeclaration* theWrappedObject, const QXmlStreamNotationDeclaration& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamNotationDeclaration::__eq__(QXmlStreamNotationDeclaration* theWrappedObject, const QXmlStreamNotationDeclaration& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamNotationDeclaration::publicId(QXmlStreamNotationDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->publicId());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamNotationDeclaration::systemId(QXmlStreamNotationDeclaration* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->systemId());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamReader* PythonQtWrapper_QXmlStreamReader::new_QXmlStreamReader()
|
|
|
{
|
|
|
return new QXmlStreamReader(); }
|
|
|
|
|
|
QXmlStreamReader* PythonQtWrapper_QXmlStreamReader::new_QXmlStreamReader(QIODevice* device)
|
|
|
{
|
|
|
return new QXmlStreamReader(device); }
|
|
|
|
|
|
QXmlStreamReader* PythonQtWrapper_QXmlStreamReader::new_QXmlStreamReader(const QByteArray& data)
|
|
|
{
|
|
|
return new QXmlStreamReader(data); }
|
|
|
|
|
|
QXmlStreamReader* PythonQtWrapper_QXmlStreamReader::new_QXmlStreamReader(const QString& data)
|
|
|
{
|
|
|
return new QXmlStreamReader(data); }
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::addData(QXmlStreamReader* theWrappedObject, const QByteArray& data)
|
|
|
{
|
|
|
( theWrappedObject->addData(data));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::addData(QXmlStreamReader* theWrappedObject, const QString& data)
|
|
|
{
|
|
|
( theWrappedObject->addData(data));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::addExtraNamespaceDeclaration(QXmlStreamReader* theWrappedObject, const QXmlStreamNamespaceDeclaration& extraNamespaceDeclaraction)
|
|
|
{
|
|
|
( theWrappedObject->addExtraNamespaceDeclaration(extraNamespaceDeclaraction));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::addExtraNamespaceDeclarations(QXmlStreamReader* theWrappedObject, const QVector<QXmlStreamNamespaceDeclaration >& extraNamespaceDeclaractions)
|
|
|
{
|
|
|
( theWrappedObject->addExtraNamespaceDeclarations(extraNamespaceDeclaractions));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::atEnd(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->atEnd());
|
|
|
}
|
|
|
|
|
|
QXmlStreamAttributes PythonQtWrapper_QXmlStreamReader::attributes(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->attributes());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QXmlStreamReader::characterOffset(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->characterOffset());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::clear(QXmlStreamReader* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QXmlStreamReader::columnNumber(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->columnNumber());
|
|
|
}
|
|
|
|
|
|
QIODevice* PythonQtWrapper_QXmlStreamReader::device(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->device());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::documentEncoding(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentEncoding());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::documentVersion(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentVersion());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::dtdName(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dtdName());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::dtdPublicId(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dtdPublicId());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::dtdSystemId(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dtdSystemId());
|
|
|
}
|
|
|
|
|
|
QVector<QXmlStreamEntityDeclaration > PythonQtWrapper_QXmlStreamReader::entityDeclarations(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->entityDeclarations());
|
|
|
}
|
|
|
|
|
|
QXmlStreamEntityResolver* PythonQtWrapper_QXmlStreamReader::entityResolver(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->entityResolver());
|
|
|
}
|
|
|
|
|
|
QXmlStreamReader::Error PythonQtWrapper_QXmlStreamReader::error(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->error());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QXmlStreamReader::errorString(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->errorString());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::hasError(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasError());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isCDATA(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isCDATA());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isCharacters(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isCharacters());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isComment(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isComment());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isDTD(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isDTD());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isEndDocument(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEndDocument());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isEndElement(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEndElement());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isEntityReference(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEntityReference());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isProcessingInstruction(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isProcessingInstruction());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isStandaloneDocument(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isStandaloneDocument());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isStartDocument(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isStartDocument());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isStartElement(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isStartElement());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::isWhitespace(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isWhitespace());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QXmlStreamReader::lineNumber(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lineNumber());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::name(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->name());
|
|
|
}
|
|
|
|
|
|
QVector<QXmlStreamNamespaceDeclaration > PythonQtWrapper_QXmlStreamReader::namespaceDeclarations(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->namespaceDeclarations());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::namespaceProcessing(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->namespaceProcessing());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::namespaceUri(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->namespaceUri());
|
|
|
}
|
|
|
|
|
|
QVector<QXmlStreamNotationDeclaration > PythonQtWrapper_QXmlStreamReader::notationDeclarations(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->notationDeclarations());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::prefix(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->prefix());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::processingInstructionData(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->processingInstructionData());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::processingInstructionTarget(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->processingInstructionTarget());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::qualifiedName(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->qualifiedName());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::raiseError(QXmlStreamReader* theWrappedObject, const QString& message)
|
|
|
{
|
|
|
( theWrappedObject->raiseError(message));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QXmlStreamReader::readElementText(QXmlStreamReader* theWrappedObject, QXmlStreamReader::ReadElementTextBehaviour behaviour)
|
|
|
{
|
|
|
return ( theWrappedObject->readElementText(behaviour));
|
|
|
}
|
|
|
|
|
|
QXmlStreamReader::TokenType PythonQtWrapper_QXmlStreamReader::readNext(QXmlStreamReader* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->readNext());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamReader::readNextStartElement(QXmlStreamReader* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->readNextStartElement());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::setDevice(QXmlStreamReader* theWrappedObject, QIODevice* device)
|
|
|
{
|
|
|
( theWrappedObject->setDevice(device));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::setEntityResolver(QXmlStreamReader* theWrappedObject, QXmlStreamEntityResolver* resolver)
|
|
|
{
|
|
|
( theWrappedObject->setEntityResolver(resolver));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::setNamespaceProcessing(QXmlStreamReader* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setNamespaceProcessing(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamReader::skipCurrentElement(QXmlStreamReader* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->skipCurrentElement());
|
|
|
}
|
|
|
|
|
|
QStringRef PythonQtWrapper_QXmlStreamReader::text(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->text());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QXmlStreamReader::tokenString(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tokenString());
|
|
|
}
|
|
|
|
|
|
QXmlStreamReader::TokenType PythonQtWrapper_QXmlStreamReader::tokenType(QXmlStreamReader* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tokenType());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QXmlStreamWriter* PythonQtWrapper_QXmlStreamWriter::new_QXmlStreamWriter()
|
|
|
{
|
|
|
return new QXmlStreamWriter(); }
|
|
|
|
|
|
QXmlStreamWriter* PythonQtWrapper_QXmlStreamWriter::new_QXmlStreamWriter(QByteArray* array)
|
|
|
{
|
|
|
return new QXmlStreamWriter(array); }
|
|
|
|
|
|
QXmlStreamWriter* PythonQtWrapper_QXmlStreamWriter::new_QXmlStreamWriter(QIODevice* device)
|
|
|
{
|
|
|
return new QXmlStreamWriter(device); }
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamWriter::autoFormatting(QXmlStreamWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoFormatting());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QXmlStreamWriter::autoFormattingIndent(QXmlStreamWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoFormattingIndent());
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QXmlStreamWriter::codec(QXmlStreamWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->codec());
|
|
|
}
|
|
|
|
|
|
QIODevice* PythonQtWrapper_QXmlStreamWriter::device(QXmlStreamWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->device());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QXmlStreamWriter::hasError(QXmlStreamWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasError());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::setAutoFormatting(QXmlStreamWriter* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setAutoFormatting(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::setAutoFormattingIndent(QXmlStreamWriter* theWrappedObject, int spacesOrTabs)
|
|
|
{
|
|
|
( theWrappedObject->setAutoFormattingIndent(spacesOrTabs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::setCodec(QXmlStreamWriter* theWrappedObject, QTextCodec* codec)
|
|
|
{
|
|
|
( theWrappedObject->setCodec(codec));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::setCodec(QXmlStreamWriter* theWrappedObject, const char* codecName)
|
|
|
{
|
|
|
( theWrappedObject->setCodec(codecName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::setDevice(QXmlStreamWriter* theWrappedObject, QIODevice* device)
|
|
|
{
|
|
|
( theWrappedObject->setDevice(device));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeAttribute(QXmlStreamWriter* theWrappedObject, const QString& namespaceUri, const QString& name, const QString& value)
|
|
|
{
|
|
|
( theWrappedObject->writeAttribute(namespaceUri, name, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeAttribute(QXmlStreamWriter* theWrappedObject, const QString& qualifiedName, const QString& value)
|
|
|
{
|
|
|
( theWrappedObject->writeAttribute(qualifiedName, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeAttribute(QXmlStreamWriter* theWrappedObject, const QXmlStreamAttribute& attribute)
|
|
|
{
|
|
|
( theWrappedObject->writeAttribute(attribute));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeAttributes(QXmlStreamWriter* theWrappedObject, const QXmlStreamAttributes& attributes)
|
|
|
{
|
|
|
( theWrappedObject->writeAttributes(attributes));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeCDATA(QXmlStreamWriter* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->writeCDATA(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeCharacters(QXmlStreamWriter* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->writeCharacters(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeComment(QXmlStreamWriter* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->writeComment(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeCurrentToken(QXmlStreamWriter* theWrappedObject, const QXmlStreamReader& reader)
|
|
|
{
|
|
|
( theWrappedObject->writeCurrentToken(reader));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeDTD(QXmlStreamWriter* theWrappedObject, const QString& dtd)
|
|
|
{
|
|
|
( theWrappedObject->writeDTD(dtd));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeDefaultNamespace(QXmlStreamWriter* theWrappedObject, const QString& namespaceUri)
|
|
|
{
|
|
|
( theWrappedObject->writeDefaultNamespace(namespaceUri));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeEmptyElement(QXmlStreamWriter* theWrappedObject, const QString& namespaceUri, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->writeEmptyElement(namespaceUri, name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeEmptyElement(QXmlStreamWriter* theWrappedObject, const QString& qualifiedName)
|
|
|
{
|
|
|
( theWrappedObject->writeEmptyElement(qualifiedName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeEndDocument(QXmlStreamWriter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->writeEndDocument());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeEndElement(QXmlStreamWriter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->writeEndElement());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeEntityReference(QXmlStreamWriter* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->writeEntityReference(name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeNamespace(QXmlStreamWriter* theWrappedObject, const QString& namespaceUri, const QString& prefix)
|
|
|
{
|
|
|
( theWrappedObject->writeNamespace(namespaceUri, prefix));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeProcessingInstruction(QXmlStreamWriter* theWrappedObject, const QString& target, const QString& data)
|
|
|
{
|
|
|
( theWrappedObject->writeProcessingInstruction(target, data));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeStartDocument(QXmlStreamWriter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->writeStartDocument());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeStartDocument(QXmlStreamWriter* theWrappedObject, const QString& version)
|
|
|
{
|
|
|
( theWrappedObject->writeStartDocument(version));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeStartDocument(QXmlStreamWriter* theWrappedObject, const QString& version, bool standalone)
|
|
|
{
|
|
|
( theWrappedObject->writeStartDocument(version, standalone));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeStartElement(QXmlStreamWriter* theWrappedObject, const QString& namespaceUri, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->writeStartElement(namespaceUri, name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeStartElement(QXmlStreamWriter* theWrappedObject, const QString& qualifiedName)
|
|
|
{
|
|
|
( theWrappedObject->writeStartElement(qualifiedName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeTextElement(QXmlStreamWriter* theWrappedObject, const QString& namespaceUri, const QString& name, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->writeTextElement(namespaceUri, name, text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QXmlStreamWriter::writeTextElement(QXmlStreamWriter* theWrappedObject, const QString& qualifiedName, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->writeTextElement(qualifiedName, text));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
