com_trolltech_qt_xmlpatterns0.cpp
2528 lines
| 92.9 KiB
| text/x-c
|
CppLexer
florianlink
|
r99 | #include "com_trolltech_qt_xmlpatterns0.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QVariant> | ||||
#include <qabstractmessagehandler.h> | ||||
#include <qabstracturiresolver.h> | ||||
#include <qabstractxmlnodemodel.h> | ||||
#include <qabstractxmlreceiver.h> | ||||
#include <qbytearray.h> | ||||
#include <qcoreevent.h> | ||||
#include <qiodevice.h> | ||||
#include <qlist.h> | ||||
florianlink
|
r110 | #include <qnetworkaccessmanager.h> | ||
florianlink
|
r99 | #include <qobject.h> | ||
#include <qsourcelocation.h> | ||||
#include <qtextcodec.h> | ||||
#include <qurl.h> | ||||
#include <qvector.h> | ||||
#include <qxmlname.h> | ||||
#include <qxmlnamepool.h> | ||||
#include <qxmlquery.h> | ||||
#include <qxmlresultitems.h> | ||||
florianlink
|
r110 | #include <qxmlschema.h> | ||
#include <qxmlschemavalidator.h> | ||||
florianlink
|
r99 | |||
florianlink
|
r186 | PythonQtShell_QAbstractMessageHandler::~PythonQtShell_QAbstractMessageHandler() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractMessageHandler::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QAbstractMessageHandler::childEvent(arg__1); | ||
} | ||||
void PythonQtShell_QAbstractMessageHandler::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; | ||||
} | ||||
} | ||||
QAbstractMessageHandler::customEvent(arg__1); | ||||
florianlink
|
r110 | } | ||
florianlink
|
r99 | bool PythonQtShell_QAbstractMessageHandler::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 QAbstractMessageHandler::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QAbstractMessageHandler::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 QAbstractMessageHandler::eventFilter(arg__1, arg__2); | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractMessageHandler::handleMessage(QtMsgType type, const QString& description, const QUrl& identifier, const QSourceLocation& sourceLocation) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "handleMessage"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QtMsgType" , "const QString&" , "const QUrl&" , "const QSourceLocation&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&type, (void*)&description, (void*)&identifier, (void*)&sourceLocation}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | |||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractMessageHandler::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r99 | 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; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QAbstractMessageHandler::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | QAbstractMessageHandler* PythonQtWrapper_QAbstractMessageHandler::new_QAbstractMessageHandler(QObject* parent) | ||
{ | ||||
return new PythonQtShell_QAbstractMessageHandler(parent); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QAbstractMessageHandler::message(QAbstractMessageHandler* theWrappedObject, QtMsgType type, const QString& description, const QUrl& identifier, const QSourceLocation& sourceLocation) | ||
{ | ||||
( theWrappedObject->message(type, description, identifier, sourceLocation)); | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QAbstractUriResolver::~PythonQtShell_QAbstractUriResolver() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractUriResolver::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
florianlink
|
r110 | 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; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QAbstractUriResolver::childEvent(arg__1); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractUriResolver::customEvent(QEvent* arg__1) | ||
florianlink
|
r117 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r117 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r117 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r117 | } | ||
} | ||||
florianlink
|
r128 | QAbstractUriResolver::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r99 | bool PythonQtShell_QAbstractUriResolver::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 QAbstractUriResolver::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QAbstractUriResolver::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 QAbstractUriResolver::eventFilter(arg__1, arg__2); | ||||
} | ||||
florianlink
|
r128 | QUrl PythonQtShell_QAbstractUriResolver::resolve(const QUrl& relative, const QUrl& baseURI) const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resolve"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QUrl" , "const QUrl&" , "const QUrl&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QUrl returnValue; | ||||
void* args[3] = {NULL, (void*)&relative, (void*)&baseURI}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | 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("resolve", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QUrl*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QUrl(); | ||
florianlink
|
r120 | } | ||
void PythonQtShell_QAbstractUriResolver::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; | ||||
} | ||||
} | ||||
QAbstractUriResolver::timerEvent(arg__1); | ||||
} | ||||
florianlink
|
r99 | QAbstractUriResolver* PythonQtWrapper_QAbstractUriResolver::new_QAbstractUriResolver(QObject* parent) | ||
{ | ||||
return new PythonQtShell_QAbstractUriResolver(parent); } | ||||
florianlink
|
r186 | PythonQtShell_QAbstractXmlNodeModel::~PythonQtShell_QAbstractXmlNodeModel() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r110 | QVector<QXmlNodeModelIndex > PythonQtShell_QAbstractXmlNodeModel::attributes(const QXmlNodeModelIndex& element) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "attributes"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"QVector<QXmlNodeModelIndex >" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r110 | QVector<QXmlNodeModelIndex > returnValue; | ||
void* args[2] = {NULL, (void*)&element}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r110 | PythonQt::priv()->handleVirtualOverloadReturnError("attributes", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((QVector<QXmlNodeModelIndex >*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QVector<QXmlNodeModelIndex >(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QUrl PythonQtShell_QAbstractXmlNodeModel::baseUri(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "baseUri"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QUrl" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QUrl returnValue; | ||
void* args[2] = {NULL, (void*)&ni}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("baseUri", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QUrl*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QUrl(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex::DocumentOrder PythonQtShell_QAbstractXmlNodeModel::compareOrder(const QXmlNodeModelIndex& ni1, const QXmlNodeModelIndex& ni2) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "compareOrder"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex::DocumentOrder" , "const QXmlNodeModelIndex&" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QXmlNodeModelIndex::DocumentOrder returnValue; | ||||
void* args[3] = {NULL, (void*)&ni1, (void*)&ni2}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("compareOrder", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex::DocumentOrder*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex::DocumentOrder(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QUrl PythonQtShell_QAbstractXmlNodeModel::documentUri(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "documentUri"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QUrl" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QUrl returnValue; | ||
florianlink
|
r110 | void* args[2] = {NULL, (void*)&ni}; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("documentUri", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QUrl*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QUrl(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QXmlNodeModelIndex PythonQtShell_QAbstractXmlNodeModel::elementById(const QXmlName& NCName) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "elementById"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"QXmlNodeModelIndex" , "const QXmlName&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
QXmlNodeModelIndex returnValue; | ||||
florianlink
|
r110 | void* args[2] = {NULL, (void*)&NCName}; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r110 | PythonQt::priv()->handleVirtualOverloadReturnError("elementById", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
returnValue = *((QXmlNodeModelIndex*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QXmlNodeModelIndex(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractXmlNodeModel::isDeepEqual(const QXmlNodeModelIndex& ni1, const QXmlNodeModelIndex& ni2) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isDeepEqual"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "const QXmlNodeModelIndex&" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&ni1, (void*)&ni2}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("isDeepEqual", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractXmlNodeModel::isDeepEqual(ni1, ni2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex::NodeKind PythonQtShell_QAbstractXmlNodeModel::kind(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "kind"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex::NodeKind" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QXmlNodeModelIndex::NodeKind returnValue; | ||
florianlink
|
r99 | void* args[2] = {NULL, (void*)&ni}; | ||
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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("kind", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex::NodeKind*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex::NodeKind(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlName PythonQtShell_QAbstractXmlNodeModel::name(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "name"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlName" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QXmlName returnValue; | ||||
void* args[2] = {NULL, (void*)&ni}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("name", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlName*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlName(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVector<QXmlName > PythonQtShell_QAbstractXmlNodeModel::namespaceBindings(const QXmlNodeModelIndex& n) const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "namespaceBindings"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVector<QXmlName >" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVector<QXmlName > returnValue; | ||||
void* args[2] = {NULL, (void*)&n}; | ||||
florianlink
|
r110 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("namespaceBindings", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((QVector<QXmlName >*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QVector<QXmlName >(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | short PythonQtShell_QAbstractXmlNodeModel::namespaceForPrefix(const QXmlNodeModelIndex& ni, const short prefix) const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "namespaceForPrefix"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"short" , "const QXmlNodeModelIndex&" , "const short"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||
florianlink
|
r128 | short returnValue; | ||
void* args[3] = {NULL, (void*)&ni, (void*)&prefix}; | ||||
florianlink
|
r120 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("namespaceForPrefix", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
florianlink
|
r128 | returnValue = *((short*)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractXmlNodeModel::namespaceForPrefix(ni, prefix); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex PythonQtShell_QAbstractXmlNodeModel::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis axis, const QXmlNodeModelIndex& origin) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextFromSimpleAxis"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex" , "QAbstractXmlNodeModel::SimpleAxis" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QXmlNodeModelIndex returnValue; | ||||
void* args[3] = {NULL, (void*)&axis, (void*)&origin}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("nextFromSimpleAxis", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > PythonQtShell_QAbstractXmlNodeModel::nodesByIdref(const QXmlName& NCName) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nodesByIdref"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVector<QXmlNodeModelIndex >" , "const QXmlName&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > returnValue; | ||
void* args[2] = {NULL, (void*)&NCName}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("nodesByIdref", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QVector<QXmlNodeModelIndex >*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QVector<QXmlNodeModelIndex >(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex PythonQtShell_QAbstractXmlNodeModel::root(const QXmlNodeModelIndex& n) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "root"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QXmlNodeModelIndex returnValue; | ||
florianlink
|
r110 | void* args[2] = {NULL, (void*)&n}; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("root", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtShell_QAbstractXmlNodeModel::stringValue(const QXmlNodeModelIndex& n) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stringValue"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QString returnValue; | ||
void* args[2] = {NULL, (void*)&n}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("stringValue", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QString*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QString(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QVariant PythonQtShell_QAbstractXmlNodeModel::typedValue(const QXmlNodeModelIndex& n) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "typedValue"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVariant" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant returnValue; | ||||
void* args[2] = {NULL, (void*)&n}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("typedValue", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QVariant*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QVariant(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QSourceLocation PythonQtWrapper_QAbstractXmlNodeModel::sourceLocation(QAbstractXmlNodeModel* theWrappedObject, const QXmlNodeModelIndex& index) const | ||
{ | ||||
return ( theWrappedObject->sourceLocation(index)); | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QAbstractXmlReceiver::~PythonQtShell_QAbstractXmlReceiver() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::atomicValue(const QVariant& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atomicValue"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QVariant&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r120 | |||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::attribute(const QXmlName& name, const QStringRef& value) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "attribute"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&" , "const QStringRef&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&name, (void*)&value}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r99 | |||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::characters(const QStringRef& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "characters"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QStringRef&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r117 | void* args[2] = {NULL, (void*)&value}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r120 | |||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::comment(const QString& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "comment"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QString&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&value}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r117 | |||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::endDocument() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endDocument"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::endElement() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endElement"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::endOfSequence() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endOfSequence"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::namespaceBinding(const QXmlName& name) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "namespaceBinding"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&name}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::processingInstruction(const QXmlName& target, const QString& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "processingInstruction"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&" , "const QString&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&target, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::startDocument() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDocument"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | |||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtShell_QAbstractXmlReceiver::startElement(const QXmlName& name) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startElement"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"" , "const QXmlName&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r120 | void* args[2] = {NULL, (void*)&name}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::startOfSequence() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startOfSequence"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QAbstractXmlReceiver::whitespaceOnly(const QStringRef& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "whitespaceOnly"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QStringRef&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QAbstractXmlReceiver::whitespaceOnly(value); | ||
florianlink
|
r99 | } | ||
QAbstractXmlReceiver* PythonQtWrapper_QAbstractXmlReceiver::new_QAbstractXmlReceiver() | ||||
{ | ||||
return new PythonQtShell_QAbstractXmlReceiver(); } | ||||
void PythonQtWrapper_QAbstractXmlReceiver::whitespaceOnly(QAbstractXmlReceiver* theWrappedObject, const QStringRef& value) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QAbstractXmlReceiver*)theWrappedObject)->promoted_whitespaceOnly(value)); | ||||
} | ||||
florianlink
|
r110 | |||
florianlink
|
r186 | PythonQtShell_QSimpleXmlNodeModel::~PythonQtShell_QSimpleXmlNodeModel() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > PythonQtShell_QSimpleXmlNodeModel::attributes(const QXmlNodeModelIndex& element) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "attributes"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVector<QXmlNodeModelIndex >" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > returnValue; | ||
void* args[2] = {NULL, (void*)&element}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("attributes", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QVector<QXmlNodeModelIndex >*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QVector<QXmlNodeModelIndex >(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QUrl PythonQtShell_QSimpleXmlNodeModel::baseUri(const QXmlNodeModelIndex& node) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "baseUri"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QUrl" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QUrl returnValue; | ||
void* args[2] = {NULL, (void*)&node}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("baseUri", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QUrl*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QSimpleXmlNodeModel::baseUri(node); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex::DocumentOrder PythonQtShell_QSimpleXmlNodeModel::compareOrder(const QXmlNodeModelIndex& ni1, const QXmlNodeModelIndex& ni2) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "compareOrder"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex::DocumentOrder" , "const QXmlNodeModelIndex&" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QXmlNodeModelIndex::DocumentOrder returnValue; | ||||
void* args[3] = {NULL, (void*)&ni1, (void*)&ni2}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("compareOrder", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex::DocumentOrder*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex::DocumentOrder(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QUrl PythonQtShell_QSimpleXmlNodeModel::documentUri(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "documentUri"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QUrl" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QUrl returnValue; | ||
void* args[2] = {NULL, (void*)&ni}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("documentUri", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QUrl*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QUrl(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex PythonQtShell_QSimpleXmlNodeModel::elementById(const QXmlName& id) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "elementById"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex" , "const QXmlName&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QXmlNodeModelIndex returnValue; | ||
void* args[2] = {NULL, (void*)&id}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("elementById", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QSimpleXmlNodeModel::elementById(id); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex::NodeKind PythonQtShell_QSimpleXmlNodeModel::kind(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "kind"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex::NodeKind" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QXmlNodeModelIndex::NodeKind returnValue; | ||
void* args[2] = {NULL, (void*)&ni}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("kind", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex::NodeKind*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex::NodeKind(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlName PythonQtShell_QSimpleXmlNodeModel::name(const QXmlNodeModelIndex& ni) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "name"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlName" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QXmlName returnValue; | ||||
void* args[2] = {NULL, (void*)&ni}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("name", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlName*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlName(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QVector<QXmlName > PythonQtShell_QSimpleXmlNodeModel::namespaceBindings(const QXmlNodeModelIndex& arg__1) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "namespaceBindings"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVector<QXmlName >" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QVector<QXmlName > returnValue; | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("namespaceBindings", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QVector<QXmlName >*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QSimpleXmlNodeModel::namespaceBindings(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex PythonQtShell_QSimpleXmlNodeModel::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis axis, const QXmlNodeModelIndex& origin) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextFromSimpleAxis"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex" , "QAbstractXmlNodeModel::SimpleAxis" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r120 | QXmlNodeModelIndex returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&axis, (void*)&origin}; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("nextFromSimpleAxis", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((QXmlNodeModelIndex*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QXmlNodeModelIndex(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > PythonQtShell_QSimpleXmlNodeModel::nodesByIdref(const QXmlName& idref) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nodesByIdref"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVector<QXmlNodeModelIndex >" , "const QXmlName&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > returnValue; | ||
void* args[2] = {NULL, (void*)&idref}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("nodesByIdref", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QVector<QXmlNodeModelIndex >*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QSimpleXmlNodeModel::nodesByIdref(idref); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNodeModelIndex PythonQtShell_QSimpleXmlNodeModel::root(const QXmlNodeModelIndex& n) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "root"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QXmlNodeModelIndex" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QXmlNodeModelIndex returnValue; | ||
florianlink
|
r117 | void* args[2] = {NULL, (void*)&n}; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("root", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QXmlNodeModelIndex*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlNodeModelIndex(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtShell_QSimpleXmlNodeModel::stringValue(const QXmlNodeModelIndex& node) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stringValue"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString" , "const QXmlNodeModelIndex&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QString returnValue; | ||||
void* args[2] = {NULL, (void*)&node}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("stringValue", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QString*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QSimpleXmlNodeModel::stringValue(node); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QVariant PythonQtShell_QSimpleXmlNodeModel::typedValue(const QXmlNodeModelIndex& n) const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "typedValue"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVariant" , "const QXmlNodeModelIndex&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QVariant returnValue; | ||
void* args[2] = {NULL, (void*)&n}; | ||||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("typedValue", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QVariant*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QVariant(); | ||
florianlink
|
r99 | } | ||
QSimpleXmlNodeModel* PythonQtWrapper_QSimpleXmlNodeModel::new_QSimpleXmlNodeModel(const QXmlNamePool& namePool) | ||||
{ | ||||
return new PythonQtShell_QSimpleXmlNodeModel(namePool); } | ||||
florianlink
|
r128 | QUrl PythonQtWrapper_QSimpleXmlNodeModel::baseUri(QSimpleXmlNodeModel* theWrappedObject, const QXmlNodeModelIndex& node) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QSimpleXmlNodeModel*)theWrappedObject)->promoted_baseUri(node)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QXmlNodeModelIndex PythonQtWrapper_QSimpleXmlNodeModel::elementById(QSimpleXmlNodeModel* theWrappedObject, const QXmlName& id) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( ((PythonQtPublicPromoter_QSimpleXmlNodeModel*)theWrappedObject)->promoted_elementById(id)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlNamePool* PythonQtWrapper_QSimpleXmlNodeModel::namePool(QSimpleXmlNodeModel* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return &( theWrappedObject->namePool()); | ||
florianlink
|
r99 | } | ||
QVector<QXmlName > PythonQtWrapper_QSimpleXmlNodeModel::namespaceBindings(QSimpleXmlNodeModel* theWrappedObject, const QXmlNodeModelIndex& arg__1) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSimpleXmlNodeModel*)theWrappedObject)->promoted_namespaceBindings(arg__1)); | ||||
} | ||||
florianlink
|
r128 | QVector<QXmlNodeModelIndex > PythonQtWrapper_QSimpleXmlNodeModel::nodesByIdref(QSimpleXmlNodeModel* theWrappedObject, const QXmlName& idref) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QSimpleXmlNodeModel*)theWrappedObject)->promoted_nodesByIdref(idref)); | ||
} | ||||
QString PythonQtWrapper_QSimpleXmlNodeModel::stringValue(QSimpleXmlNodeModel* theWrappedObject, const QXmlNodeModelIndex& node) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSimpleXmlNodeModel*)theWrappedObject)->promoted_stringValue(node)); | ||||
florianlink
|
r120 | } | ||
florianlink
|
r99 | |||
QSourceLocation* PythonQtWrapper_QSourceLocation::new_QSourceLocation() | ||||
{ | ||||
return new QSourceLocation(); } | ||||
QSourceLocation* PythonQtWrapper_QSourceLocation::new_QSourceLocation(const QSourceLocation& other) | ||||
{ | ||||
return new QSourceLocation(other); } | ||||
QSourceLocation* PythonQtWrapper_QSourceLocation::new_QSourceLocation(const QUrl& uri, int line, int column) | ||||
{ | ||||
return new QSourceLocation(uri, line, column); } | ||||
florianlink
|
r128 | qint64 PythonQtWrapper_QSourceLocation::column(QSourceLocation* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->column()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QSourceLocation::isNull(QSourceLocation* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QSourceLocation::line(QSourceLocation* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->line()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QSourceLocation::__ne__(QSourceLocation* theWrappedObject, const QSourceLocation& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QSourceLocation::__eq__(QSourceLocation* theWrappedObject, const QSourceLocation& other) const | ||
{ | ||||
return ( (*theWrappedObject)== other); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QSourceLocation::setColumn(QSourceLocation* theWrappedObject, qint64 newColumn) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setColumn(newColumn)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QSourceLocation::setLine(QSourceLocation* theWrappedObject, qint64 newLine) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | ( theWrappedObject->setLine(newLine)); | ||
florianlink
|
r99 | } | ||
void PythonQtWrapper_QSourceLocation::setUri(QSourceLocation* theWrappedObject, const QUrl& newUri) | ||||
{ | ||||
( theWrappedObject->setUri(newUri)); | ||||
} | ||||
florianlink
|
r128 | QUrl PythonQtWrapper_QSourceLocation::uri(QSourceLocation* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->uri()); | ||||
} | ||||
florianlink
|
r117 | QString PythonQtWrapper_QSourceLocation::py_toString(QSourceLocation* obj) { | ||
florianlink
|
r99 | QString result; | ||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QXmlFormatter::~PythonQtShell_QXmlFormatter() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::atomicValue(const QVariant& value) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atomicValue"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QVariant&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::atomicValue(value); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::attribute(const QXmlName& name, const QStringRef& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "attribute"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&" , "const QStringRef&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&name, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::attribute(name, value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::characters(const QStringRef& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "characters"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QStringRef&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&value}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::characters(value); | ||
florianlink
|
r99 | } | ||
void PythonQtShell_QXmlFormatter::comment(const QString& value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "comment"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QString&"}; | ||||
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; | ||||
} | ||||
} | ||||
QXmlFormatter::comment(value); | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::endDocument() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endDocument"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::endDocument(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::endElement() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endElement"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::endElement(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::endOfSequence() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endOfSequence"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QXmlFormatter::endOfSequence(); | ||||
} | ||||
void PythonQtShell_QXmlFormatter::namespaceBinding(const QXmlName& nb) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "namespaceBinding"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QXmlName&"}; | ||||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&nb}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::namespaceBinding(nb); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::processingInstruction(const QXmlName& name, const QString& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "processingInstruction"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&" , "const QString&"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||
void* args[3] = {NULL, (void*)&name, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::processingInstruction(name, value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::startDocument() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDocument"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::startDocument(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::startElement(const QXmlName& name) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startElement"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&name}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::startElement(name); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlFormatter::startOfSequence() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startOfSequence"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlFormatter::startOfSequence(); | ||
florianlink
|
r99 | } | ||
void PythonQtShell_QXmlFormatter::whitespaceOnly(const QStringRef& value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "whitespaceOnly"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QStringRef&"}; | ||||
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; | ||||
} | ||||
} | ||||
QXmlFormatter::whitespaceOnly(value); | ||||
} | ||||
QXmlFormatter* PythonQtWrapper_QXmlFormatter::new_QXmlFormatter(const QXmlQuery& query, QIODevice* outputDevice) | ||||
{ | ||||
return new PythonQtShell_QXmlFormatter(query, outputDevice); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::atomicValue(QXmlFormatter* theWrappedObject, const QVariant& value) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_atomicValue(value)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::attribute(QXmlFormatter* theWrappedObject, const QXmlName& name, const QStringRef& value) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_attribute(name, value)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::characters(QXmlFormatter* theWrappedObject, const QStringRef& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_characters(value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::comment(QXmlFormatter* theWrappedObject, const QString& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_comment(value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::endDocument(QXmlFormatter* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_endDocument()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::endElement(QXmlFormatter* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_endElement()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::endOfSequence(QXmlFormatter* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_endOfSequence()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QXmlFormatter::indentationDepth(QXmlFormatter* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->indentationDepth()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::processingInstruction(QXmlFormatter* theWrappedObject, const QXmlName& name, const QString& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_processingInstruction(name, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::setIndentationDepth(QXmlFormatter* theWrappedObject, int depth) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setIndentationDepth(depth)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::startDocument(QXmlFormatter* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_startDocument()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::startElement(QXmlFormatter* theWrappedObject, const QXmlName& name) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_startElement(name)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlFormatter::startOfSequence(QXmlFormatter* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlFormatter*)theWrappedObject)->promoted_startOfSequence()); | ||
florianlink
|
r99 | } | ||
QXmlItem* PythonQtWrapper_QXmlItem::new_QXmlItem() | ||||
{ | ||||
return new QXmlItem(); } | ||||
QXmlItem* PythonQtWrapper_QXmlItem::new_QXmlItem(const QVariant& atomicValue) | ||||
{ | ||||
return new QXmlItem(atomicValue); } | ||||
QXmlItem* PythonQtWrapper_QXmlItem::new_QXmlItem(const QXmlItem& other) | ||||
{ | ||||
return new QXmlItem(other); } | ||||
QXmlItem* PythonQtWrapper_QXmlItem::new_QXmlItem(const QXmlNodeModelIndex& node) | ||||
{ | ||||
return new QXmlItem(node); } | ||||
florianlink
|
r128 | bool PythonQtWrapper_QXmlItem::isAtomicValue(QXmlItem* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isAtomicValue()); | ||
florianlink
|
r99 | } | ||
bool PythonQtWrapper_QXmlItem::isNode(QXmlItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isNode()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QXmlItem::isNull(QXmlItem* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QXmlItem::toAtomicValue(QXmlItem* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->toAtomicValue()); | ||
florianlink
|
r99 | } | ||
QXmlNodeModelIndex PythonQtWrapper_QXmlItem::toNodeModelIndex(QXmlItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toNodeModelIndex()); | ||||
} | ||||
QXmlName* PythonQtWrapper_QXmlName::new_QXmlName() | ||||
{ | ||||
return new QXmlName(); } | ||||
QXmlName* PythonQtWrapper_QXmlName::new_QXmlName(QXmlNamePool& namePool, const QString& localName, const QString& namespaceURI, const QString& prefix) | ||||
{ | ||||
return new QXmlName(namePool, localName, namespaceURI, prefix); } | ||||
florianlink
|
r120 | QXmlName PythonQtWrapper_QXmlName::static_QXmlName_fromClarkName(const QString& clarkName, const QXmlNamePool& namePool) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return (QXmlName::fromClarkName(clarkName, namePool)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlName::static_QXmlName_isNCName(const QString& candidate) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return (QXmlName::isNCName(candidate)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlName::isNull(QXmlName* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QXmlName::localName(QXmlName* theWrappedObject, const QXmlNamePool& query) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->localName(query)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QXmlName::namespaceUri(QXmlName* theWrappedObject, const QXmlNamePool& query) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->namespaceUri(query)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QXmlName::__ne__(QXmlName* theWrappedObject, const QXmlName& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)!= other); | ||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QXmlName::__eq__(QXmlName* theWrappedObject, const QXmlName& other) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QXmlName::prefix(QXmlName* theWrappedObject, const QXmlNamePool& query) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->prefix(query)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QString PythonQtWrapper_QXmlName::toClarkName(QXmlName* theWrappedObject, const QXmlNamePool& query) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->toClarkName(query)); | ||
florianlink
|
r99 | } | ||
QXmlNamePool* PythonQtWrapper_QXmlNamePool::new_QXmlNamePool() | ||||
{ | ||||
return new QXmlNamePool(); } | ||||
QXmlNamePool* PythonQtWrapper_QXmlNamePool::new_QXmlNamePool(const QXmlNamePool& other) | ||||
{ | ||||
return new QXmlNamePool(other); } | ||||
QXmlNodeModelIndex* PythonQtWrapper_QXmlNodeModelIndex::new_QXmlNodeModelIndex() | ||||
{ | ||||
return new QXmlNodeModelIndex(); } | ||||
QXmlNodeModelIndex* PythonQtWrapper_QXmlNodeModelIndex::new_QXmlNodeModelIndex(const QXmlNodeModelIndex& other) | ||||
{ | ||||
return new QXmlNodeModelIndex(other); } | ||||
florianlink
|
r128 | qint64 PythonQtWrapper_QXmlNodeModelIndex::additionalData(QXmlNodeModelIndex* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->additionalData()); | ||||
} | ||||
florianlink
|
r120 | qint64 PythonQtWrapper_QXmlNodeModelIndex::data(QXmlNodeModelIndex* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->data()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QXmlNodeModelIndex::isNull(QXmlNodeModelIndex* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r99 | const QAbstractXmlNodeModel* PythonQtWrapper_QXmlNodeModelIndex::model(QXmlNodeModelIndex* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->model()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QXmlNodeModelIndex::__ne__(QXmlNodeModelIndex* theWrappedObject, const QXmlNodeModelIndex& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QXmlNodeModelIndex::__eq__(QXmlNodeModelIndex* theWrappedObject, const QXmlNodeModelIndex& other) const | ||
florianlink
|
r99 | { | ||
return ( (*theWrappedObject)== other); | ||||
} | ||||
QXmlQuery* PythonQtWrapper_QXmlQuery::new_QXmlQuery() | ||||
{ | ||||
return new QXmlQuery(); } | ||||
florianlink
|
r110 | QXmlQuery* PythonQtWrapper_QXmlQuery::new_QXmlQuery(QXmlQuery::QueryLanguage queryLanguage, const QXmlNamePool& np) | ||
{ | ||||
return new QXmlQuery(queryLanguage, np); } | ||||
florianlink
|
r99 | QXmlQuery* PythonQtWrapper_QXmlQuery::new_QXmlQuery(const QXmlNamePool& np) | ||
{ | ||||
return new QXmlQuery(np); } | ||||
QXmlQuery* PythonQtWrapper_QXmlQuery::new_QXmlQuery(const QXmlQuery& other) | ||||
{ | ||||
return new QXmlQuery(other); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::bindVariable(QXmlQuery* theWrappedObject, const QString& localName, QIODevice* arg__2) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->bindVariable(localName, arg__2)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::bindVariable(QXmlQuery* theWrappedObject, const QString& localName, const QXmlItem& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->bindVariable(localName, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QXmlQuery::bindVariable(QXmlQuery* theWrappedObject, const QString& localName, const QXmlQuery& query) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | ( theWrappedObject->bindVariable(localName, query)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::bindVariable(QXmlQuery* theWrappedObject, const QXmlName& name, QIODevice* arg__2) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->bindVariable(name, arg__2)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::bindVariable(QXmlQuery* theWrappedObject, const QXmlName& name, const QXmlItem& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->bindVariable(name, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::bindVariable(QXmlQuery* theWrappedObject, const QXmlName& name, const QXmlQuery& query) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->bindVariable(name, query)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlQuery::evaluateTo(QXmlQuery* theWrappedObject, QIODevice* target) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->evaluateTo(target)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlQuery::evaluateTo(QXmlQuery* theWrappedObject, QString* output) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->evaluateTo(output)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::evaluateTo(QXmlQuery* theWrappedObject, QXmlResultItems* result) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->evaluateTo(result)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlName PythonQtWrapper_QXmlQuery::initialTemplateName(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->initialTemplateName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlQuery::isValid(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isValid()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QAbstractMessageHandler* PythonQtWrapper_QXmlQuery::messageHandler(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->messageHandler()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QXmlNamePool PythonQtWrapper_QXmlQuery::namePool(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->namePool()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkAccessManager* PythonQtWrapper_QXmlQuery::networkAccessManager(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->networkAccessManager()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlQuery* PythonQtWrapper_QXmlQuery::operator_assign(QXmlQuery* theWrappedObject, const QXmlQuery& other) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return &( (*theWrappedObject)= other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QXmlQuery::QueryLanguage PythonQtWrapper_QXmlQuery::queryLanguage(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->queryLanguage()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlQuery::setFocus(QXmlQuery* theWrappedObject, QIODevice* document) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setFocus(document)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlQuery::setFocus(QXmlQuery* theWrappedObject, const QString& focus) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setFocus(focus)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlQuery::setFocus(QXmlQuery* theWrappedObject, const QUrl& documentURI) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setFocus(documentURI)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setFocus(QXmlQuery* theWrappedObject, const QXmlItem& item) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setFocus(item)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setInitialTemplateName(QXmlQuery* theWrappedObject, const QString& name) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setInitialTemplateName(name)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setInitialTemplateName(QXmlQuery* theWrappedObject, const QXmlName& name) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setInitialTemplateName(name)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setMessageHandler(QXmlQuery* theWrappedObject, QAbstractMessageHandler* messageHandler) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setMessageHandler(messageHandler)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setNetworkAccessManager(QXmlQuery* theWrappedObject, QNetworkAccessManager* newManager) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setNetworkAccessManager(newManager)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setQuery(QXmlQuery* theWrappedObject, QIODevice* sourceCode, const QUrl& documentURI) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setQuery(sourceCode, documentURI)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setQuery(QXmlQuery* theWrappedObject, const QString& sourceCode, const QUrl& documentURI) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setQuery(sourceCode, documentURI)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setQuery(QXmlQuery* theWrappedObject, const QUrl& queryURI, const QUrl& baseURI) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setQuery(queryURI, baseURI)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlQuery::setUriResolver(QXmlQuery* theWrappedObject, const QAbstractUriResolver* resolver) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setUriResolver(resolver)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | const QAbstractUriResolver* PythonQtWrapper_QXmlQuery::uriResolver(QXmlQuery* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->uriResolver()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | PythonQtShell_QXmlResultItems::~PythonQtShell_QXmlResultItems() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r99 | QXmlResultItems* PythonQtWrapper_QXmlResultItems::new_QXmlResultItems() | ||
{ | ||||
return new PythonQtShell_QXmlResultItems(); } | ||||
florianlink
|
r128 | QXmlItem PythonQtWrapper_QXmlResultItems::current(QXmlResultItems* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->current()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QXmlResultItems::hasError(QXmlResultItems* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | return ( theWrappedObject->hasError()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QXmlItem PythonQtWrapper_QXmlResultItems::next(QXmlResultItems* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->next()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
QXmlSchema* PythonQtWrapper_QXmlSchema::new_QXmlSchema() | ||||
{ | ||||
return new QXmlSchema(); } | ||||
QXmlSchema* PythonQtWrapper_QXmlSchema::new_QXmlSchema(const QXmlSchema& other) | ||||
{ | ||||
return new QXmlSchema(other); } | ||||
florianlink
|
r128 | QUrl PythonQtWrapper_QXmlSchema::documentUri(QXmlSchema* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->documentUri()); | ||
} | ||||
bool PythonQtWrapper_QXmlSchema::isValid(QXmlSchema* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QXmlSchema::load(QXmlSchema* theWrappedObject, QIODevice* source, const QUrl& documentUri) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->load(source, documentUri)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QXmlSchema::load(QXmlSchema* theWrappedObject, const QByteArray& data, const QUrl& documentUri) | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | return ( theWrappedObject->load(data, documentUri)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlSchema::load(QXmlSchema* theWrappedObject, const QUrl& source) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->load(source)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QAbstractMessageHandler* PythonQtWrapper_QXmlSchema::messageHandler(QXmlSchema* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->messageHandler()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | QXmlNamePool PythonQtWrapper_QXmlSchema::namePool(QXmlSchema* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | return ( theWrappedObject->namePool()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkAccessManager* PythonQtWrapper_QXmlSchema::networkAccessManager(QXmlSchema* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->networkAccessManager()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSchema::setMessageHandler(QXmlSchema* theWrappedObject, QAbstractMessageHandler* handler) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setMessageHandler(handler)); | ||
florianlink
|
r110 | } | ||
void PythonQtWrapper_QXmlSchema::setNetworkAccessManager(QXmlSchema* theWrappedObject, QNetworkAccessManager* networkmanager) | ||||
{ | ||||
( theWrappedObject->setNetworkAccessManager(networkmanager)); | ||||
} | ||||
florianlink
|
r120 | void PythonQtWrapper_QXmlSchema::setUriResolver(QXmlSchema* theWrappedObject, const QAbstractUriResolver* resolver) | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | ( theWrappedObject->setUriResolver(resolver)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | const QAbstractUriResolver* PythonQtWrapper_QXmlSchema::uriResolver(QXmlSchema* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->uriResolver()); | ||
florianlink
|
r110 | } | ||
QXmlSchemaValidator* PythonQtWrapper_QXmlSchemaValidator::new_QXmlSchemaValidator() | ||||
{ | ||||
return new QXmlSchemaValidator(); } | ||||
QXmlSchemaValidator* PythonQtWrapper_QXmlSchemaValidator::new_QXmlSchemaValidator(const QXmlSchema& schema) | ||||
{ | ||||
return new QXmlSchemaValidator(schema); } | ||||
florianlink
|
r128 | QAbstractMessageHandler* PythonQtWrapper_QXmlSchemaValidator::messageHandler(QXmlSchemaValidator* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->messageHandler()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QXmlNamePool PythonQtWrapper_QXmlSchemaValidator::namePool(QXmlSchemaValidator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->namePool()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkAccessManager* PythonQtWrapper_QXmlSchemaValidator::networkAccessManager(QXmlSchemaValidator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->networkAccessManager()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QXmlSchema PythonQtWrapper_QXmlSchemaValidator::schema(QXmlSchemaValidator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->schema()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSchemaValidator::setMessageHandler(QXmlSchemaValidator* theWrappedObject, QAbstractMessageHandler* handler) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setMessageHandler(handler)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSchemaValidator::setNetworkAccessManager(QXmlSchemaValidator* theWrappedObject, QNetworkAccessManager* networkmanager) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setNetworkAccessManager(networkmanager)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSchemaValidator::setSchema(QXmlSchemaValidator* theWrappedObject, const QXmlSchema& schema) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setSchema(schema)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSchemaValidator::setUriResolver(QXmlSchemaValidator* theWrappedObject, const QAbstractUriResolver* resolver) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setUriResolver(resolver)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | const QAbstractUriResolver* PythonQtWrapper_QXmlSchemaValidator::uriResolver(QXmlSchemaValidator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->uriResolver()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlSchemaValidator::validate(QXmlSchemaValidator* theWrappedObject, QIODevice* source, const QUrl& documentUri) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->validate(source, documentUri)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlSchemaValidator::validate(QXmlSchemaValidator* theWrappedObject, const QByteArray& data, const QUrl& documentUri) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->validate(data, documentUri)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QXmlSchemaValidator::validate(QXmlSchemaValidator* theWrappedObject, const QUrl& source) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->validate(source)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | PythonQtShell_QXmlSerializer::~PythonQtShell_QXmlSerializer() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::atomicValue(const QVariant& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atomicValue"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QVariant&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::atomicValue(value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::attribute(const QXmlName& name, const QStringRef& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "attribute"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&" , "const QStringRef&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&name, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::attribute(name, value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::characters(const QStringRef& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "characters"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QStringRef&"}; | ||
florianlink
|
r99 | 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; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::characters(value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::comment(const QString& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "comment"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QString&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::comment(value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::endDocument() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endDocument"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::endDocument(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::endElement() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endElement"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::endElement(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::endOfSequence() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endOfSequence"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::endOfSequence(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::namespaceBinding(const QXmlName& nb) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "namespaceBinding"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&nb}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::namespaceBinding(nb); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::processingInstruction(const QXmlName& name, const QString& value) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "processingInstruction"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&" , "const QString&"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||
void* args[3] = {NULL, (void*)&name, (void*)&value}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::processingInstruction(name, value); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::startDocument() | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDocument"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::startDocument(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::startElement(const QXmlName& name) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startElement"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QXmlName&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&name}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::startElement(name); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QXmlSerializer::startOfSequence() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startOfSequence"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QXmlSerializer::startOfSequence(); | ||
florianlink
|
r99 | } | ||
void PythonQtShell_QXmlSerializer::whitespaceOnly(const QStringRef& value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "whitespaceOnly"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QStringRef&"}; | ||||
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; | ||||
} | ||||
} | ||||
QXmlSerializer::whitespaceOnly(value); | ||||
} | ||||
QXmlSerializer* PythonQtWrapper_QXmlSerializer::new_QXmlSerializer(const QXmlQuery& query, QIODevice* outputDevice) | ||||
{ | ||||
return new PythonQtShell_QXmlSerializer(query, outputDevice); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::atomicValue(QXmlSerializer* theWrappedObject, const QVariant& value) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_atomicValue(value)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::attribute(QXmlSerializer* theWrappedObject, const QXmlName& name, const QStringRef& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_attribute(name, value)); | ||
} | ||||
void PythonQtWrapper_QXmlSerializer::characters(QXmlSerializer* theWrappedObject, const QStringRef& value) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_characters(value)); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r120 | const QTextCodec* PythonQtWrapper_QXmlSerializer::codec(QXmlSerializer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->codec()); | ||
florianlink
|
r99 | } | ||
void PythonQtWrapper_QXmlSerializer::comment(QXmlSerializer* theWrappedObject, const QString& value) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_comment(value)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::endDocument(QXmlSerializer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_endDocument()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::endElement(QXmlSerializer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_endElement()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::endOfSequence(QXmlSerializer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_endOfSequence()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::namespaceBinding(QXmlSerializer* theWrappedObject, const QXmlName& nb) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_namespaceBinding(nb)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtWrapper_QXmlSerializer::outputDevice(QXmlSerializer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->outputDevice()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::processingInstruction(QXmlSerializer* theWrappedObject, const QXmlName& name, const QString& value) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_processingInstruction(name, value)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::setCodec(QXmlSerializer* theWrappedObject, const QTextCodec* codec) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setCodec(codec)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::startDocument(QXmlSerializer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_startDocument()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::startElement(QXmlSerializer* theWrappedObject, const QXmlName& name) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_startElement(name)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QXmlSerializer::startOfSequence(QXmlSerializer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QXmlSerializer*)theWrappedObject)->promoted_startOfSequence()); | ||
florianlink
|
r99 | } | ||