com_trolltech_qt_gui8.cpp
10672 lines
| 376.6 KiB
| text/x-c
|
CppLexer
Orochimarufan
|
r205 | #include "com_trolltech_qt_gui8.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QIconEngine> | ||||
#include <QTextBlock> | ||||
#include <QTextCursor> | ||||
#include <QTextEdit> | ||||
#include <QTextFormat> | ||||
#include <QTextFrame> | ||||
#include <QTextLayout> | ||||
#include <QVariant> | ||||
#include <qabstractitemdelegate.h> | ||||
#include <qabstractitemmodel.h> | ||||
#include <qabstracttextdocumentlayout.h> | ||||
#include <qaction.h> | ||||
#include <qbitmap.h> | ||||
#include <qbrush.h> | ||||
#include <qbuttongroup.h> | ||||
#include <qbytearray.h> | ||||
#include <qcalendarwidget.h> | ||||
#include <qcolor.h> | ||||
#include <qcoreevent.h> | ||||
#include <qcursor.h> | ||||
#include <qdatetime.h> | ||||
#include <qdatetimeedit.h> | ||||
#include <qevent.h> | ||||
#include <qfont.h> | ||||
#include <qgraphicseffect.h> | ||||
#include <qgraphicsproxywidget.h> | ||||
#include <qheaderview.h> | ||||
#include <qiodevice.h> | ||||
#include <qitemselectionmodel.h> | ||||
#include <qkeysequence.h> | ||||
#include <qlayout.h> | ||||
#include <qline.h> | ||||
#include <qlineedit.h> | ||||
#include <qlist.h> | ||||
#include <qlocale.h> | ||||
#include <qmargins.h> | ||||
#include <qmatrix.h> | ||||
#include <qmenu.h> | ||||
#include <qmimedata.h> | ||||
#include <qobject.h> | ||||
#include <qpaintdevice.h> | ||||
#include <qpaintengine.h> | ||||
#include <qpainter.h> | ||||
#include <qpainterpath.h> | ||||
#include <qpalette.h> | ||||
#include <qpen.h> | ||||
#include <qpixmap.h> | ||||
#include <qpoint.h> | ||||
#include <qpolygon.h> | ||||
#include <qrect.h> | ||||
#include <qregexp.h> | ||||
#include <qregion.h> | ||||
#include <qscrollbar.h> | ||||
#include <qsize.h> | ||||
#include <qsizepolicy.h> | ||||
#include <qstringlist.h> | ||||
#include <qstyle.h> | ||||
#include <qstyleoption.h> | ||||
#include <qtextcodec.h> | ||||
#include <qtextcursor.h> | ||||
#include <qtextdocument.h> | ||||
#include <qtextdocumentfragment.h> | ||||
#include <qtextdocumentwriter.h> | ||||
#include <qtextedit.h> | ||||
#include <qtextformat.h> | ||||
#include <qtextlist.h> | ||||
#include <qtextobject.h> | ||||
#include <qtexttable.h> | ||||
#include <qtoolbar.h> | ||||
#include <qtoolbox.h> | ||||
#include <qtoolbutton.h> | ||||
#include <qtransform.h> | ||||
#include <qtreeview.h> | ||||
#include <qurl.h> | ||||
#include <qvector.h> | ||||
#include <qvector2d.h> | ||||
#include <qwidget.h> | ||||
PythonQtShell_QTextDocument::~PythonQtShell_QTextDocument() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTextDocument::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextDocument::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextDocument::clear() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||||
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; | ||||
} | ||||
} | ||||
QTextDocument::clear(); | ||||
} | ||||
QTextObject* PythonQtShell_QTextDocument::createObject(const QTextFormat& f) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createObject"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QTextObject*" , "const QTextFormat&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QTextObject* returnValue; | ||||
void* args[2] = {NULL, (void*)&f}; | ||||
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("createObject", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QTextObject**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextDocument::createObject(f); | ||||
} | ||||
void PythonQtShell_QTextDocument::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; | ||||
} | ||||
} | ||||
QTextDocument::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextDocument::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 QTextDocument::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextDocument::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 QTextDocument::eventFilter(arg__1, arg__2); | ||||
} | ||||
QVariant PythonQtShell_QTextDocument::loadResource(int type, const QUrl& name) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "loadResource"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "int" , "const QUrl&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QVariant returnValue; | ||||
void* args[3] = {NULL, (void*)&type, (void*)&name}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("loadResource", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextDocument::loadResource(type, name); | ||||
} | ||||
void PythonQtShell_QTextDocument::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; | ||||
} | ||||
} | ||||
QTextDocument::timerEvent(arg__1); | ||||
} | ||||
QTextDocument* PythonQtWrapper_QTextDocument::new_QTextDocument(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTextDocument(parent); } | ||||
QTextDocument* PythonQtWrapper_QTextDocument::new_QTextDocument(const QString& text, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTextDocument(text, parent); } | ||||
void PythonQtWrapper_QTextDocument::addResource(QTextDocument* theWrappedObject, int type, const QUrl& name, const QVariant& resource) | ||||
{ | ||||
( theWrappedObject->addResource(type, name, resource)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::adjustSize(QTextDocument* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->adjustSize()); | ||||
} | ||||
QVector<QTextFormat > PythonQtWrapper_QTextDocument::allFormats(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->allFormats()); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::availableRedoSteps(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->availableRedoSteps()); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::availableUndoSteps(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->availableUndoSteps()); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::begin(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->begin()); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::blockCount(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->blockCount()); | ||||
} | ||||
QChar PythonQtWrapper_QTextDocument::characterAt(QTextDocument* theWrappedObject, int pos) const | ||||
{ | ||||
return ( theWrappedObject->characterAt(pos)); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::characterCount(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->characterCount()); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::clear(QTextDocument* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextDocument*)theWrappedObject)->promoted_clear()); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::clearUndoRedoStacks(QTextDocument* theWrappedObject, QTextDocument::Stacks historyToClear) | ||||
{ | ||||
( theWrappedObject->clearUndoRedoStacks(historyToClear)); | ||||
} | ||||
QTextDocument* PythonQtWrapper_QTextDocument::clone(QTextDocument* theWrappedObject, QObject* parent) const | ||||
{ | ||||
return ( theWrappedObject->clone(parent)); | ||||
} | ||||
QTextObject* PythonQtWrapper_QTextDocument::createObject(QTextDocument* theWrappedObject, const QTextFormat& f) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextDocument*)theWrappedObject)->promoted_createObject(f)); | ||||
} | ||||
Qt::CursorMoveStyle PythonQtWrapper_QTextDocument::defaultCursorMoveStyle(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->defaultCursorMoveStyle()); | ||||
} | ||||
QFont PythonQtWrapper_QTextDocument::defaultFont(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->defaultFont()); | ||||
} | ||||
QString PythonQtWrapper_QTextDocument::defaultStyleSheet(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->defaultStyleSheet()); | ||||
} | ||||
QTextOption PythonQtWrapper_QTextDocument::defaultTextOption(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->defaultTextOption()); | ||||
} | ||||
QAbstractTextDocumentLayout* PythonQtWrapper_QTextDocument::documentLayout(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->documentLayout()); | ||||
} | ||||
qreal PythonQtWrapper_QTextDocument::documentMargin(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->documentMargin()); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::drawContents(QTextDocument* theWrappedObject, QPainter* painter, const QRectF& rect) | ||||
{ | ||||
( theWrappedObject->drawContents(painter, rect)); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::end(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->end()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QRegExp& expr, const QTextCursor& from, QTextDocument::FindFlags options) const | ||||
{ | ||||
return ( theWrappedObject->find(expr, from, options)); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QRegExp& expr, int from, QTextDocument::FindFlags options) const | ||||
{ | ||||
return ( theWrappedObject->find(expr, from, options)); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QString& subString, const QTextCursor& from, QTextDocument::FindFlags options) const | ||||
{ | ||||
return ( theWrappedObject->find(subString, from, options)); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QString& subString, int from, QTextDocument::FindFlags options) const | ||||
{ | ||||
return ( theWrappedObject->find(subString, from, options)); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::findBlock(QTextDocument* theWrappedObject, int pos) const | ||||
{ | ||||
return ( theWrappedObject->findBlock(pos)); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::findBlockByLineNumber(QTextDocument* theWrappedObject, int blockNumber) const | ||||
{ | ||||
return ( theWrappedObject->findBlockByLineNumber(blockNumber)); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::findBlockByNumber(QTextDocument* theWrappedObject, int blockNumber) const | ||||
{ | ||||
return ( theWrappedObject->findBlockByNumber(blockNumber)); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::firstBlock(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->firstBlock()); | ||||
} | ||||
QTextFrame* PythonQtWrapper_QTextDocument::frameAt(QTextDocument* theWrappedObject, int pos) const | ||||
{ | ||||
return ( theWrappedObject->frameAt(pos)); | ||||
} | ||||
qreal PythonQtWrapper_QTextDocument::idealWidth(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->idealWidth()); | ||||
} | ||||
qreal PythonQtWrapper_QTextDocument::indentWidth(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indentWidth()); | ||||
} | ||||
bool PythonQtWrapper_QTextDocument::isEmpty(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEmpty()); | ||||
} | ||||
bool PythonQtWrapper_QTextDocument::isModified(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isModified()); | ||||
} | ||||
bool PythonQtWrapper_QTextDocument::isRedoAvailable(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isRedoAvailable()); | ||||
} | ||||
bool PythonQtWrapper_QTextDocument::isUndoAvailable(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isUndoAvailable()); | ||||
} | ||||
bool PythonQtWrapper_QTextDocument::isUndoRedoEnabled(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isUndoRedoEnabled()); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextDocument::lastBlock(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastBlock()); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::lineCount(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lineCount()); | ||||
} | ||||
QVariant PythonQtWrapper_QTextDocument::loadResource(QTextDocument* theWrappedObject, int type, const QUrl& name) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextDocument*)theWrappedObject)->promoted_loadResource(type, name)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::markContentsDirty(QTextDocument* theWrappedObject, int from, int length) | ||||
{ | ||||
( theWrappedObject->markContentsDirty(from, length)); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::maximumBlockCount(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maximumBlockCount()); | ||||
} | ||||
QString PythonQtWrapper_QTextDocument::metaInformation(QTextDocument* theWrappedObject, QTextDocument::MetaInformation info) const | ||||
{ | ||||
return ( theWrappedObject->metaInformation(info)); | ||||
} | ||||
QTextObject* PythonQtWrapper_QTextDocument::object(QTextDocument* theWrappedObject, int objectIndex) const | ||||
{ | ||||
return ( theWrappedObject->object(objectIndex)); | ||||
} | ||||
QTextObject* PythonQtWrapper_QTextDocument::objectForFormat(QTextDocument* theWrappedObject, const QTextFormat& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->objectForFormat(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::pageCount(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pageCount()); | ||||
} | ||||
QSizeF PythonQtWrapper_QTextDocument::pageSize(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pageSize()); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::redo(QTextDocument* theWrappedObject, QTextCursor* cursor) | ||||
{ | ||||
( theWrappedObject->redo(cursor)); | ||||
} | ||||
QVariant PythonQtWrapper_QTextDocument::resource(QTextDocument* theWrappedObject, int type, const QUrl& name) const | ||||
{ | ||||
return ( theWrappedObject->resource(type, name)); | ||||
} | ||||
int PythonQtWrapper_QTextDocument::revision(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->revision()); | ||||
} | ||||
QTextFrame* PythonQtWrapper_QTextDocument::rootFrame(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rootFrame()); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setDefaultCursorMoveStyle(QTextDocument* theWrappedObject, Qt::CursorMoveStyle style) | ||||
{ | ||||
( theWrappedObject->setDefaultCursorMoveStyle(style)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setDefaultFont(QTextDocument* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setDefaultFont(font)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setDefaultStyleSheet(QTextDocument* theWrappedObject, const QString& sheet) | ||||
{ | ||||
( theWrappedObject->setDefaultStyleSheet(sheet)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setDefaultTextOption(QTextDocument* theWrappedObject, const QTextOption& option) | ||||
{ | ||||
( theWrappedObject->setDefaultTextOption(option)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setDocumentLayout(QTextDocument* theWrappedObject, QAbstractTextDocumentLayout* layout) | ||||
{ | ||||
( theWrappedObject->setDocumentLayout(layout)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setDocumentMargin(QTextDocument* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setDocumentMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setHtml(QTextDocument* theWrappedObject, const QString& html) | ||||
{ | ||||
( theWrappedObject->setHtml(html)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setIndentWidth(QTextDocument* theWrappedObject, qreal width) | ||||
{ | ||||
( theWrappedObject->setIndentWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setMaximumBlockCount(QTextDocument* theWrappedObject, int maximum) | ||||
{ | ||||
( theWrappedObject->setMaximumBlockCount(maximum)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setMetaInformation(QTextDocument* theWrappedObject, QTextDocument::MetaInformation info, const QString& arg__2) | ||||
{ | ||||
( theWrappedObject->setMetaInformation(info, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setPageSize(QTextDocument* theWrappedObject, const QSizeF& size) | ||||
{ | ||||
( theWrappedObject->setPageSize(size)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setPlainText(QTextDocument* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setPlainText(text)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setTextWidth(QTextDocument* theWrappedObject, qreal width) | ||||
{ | ||||
( theWrappedObject->setTextWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setUndoRedoEnabled(QTextDocument* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setUndoRedoEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::setUseDesignMetrics(QTextDocument* theWrappedObject, bool b) | ||||
{ | ||||
( theWrappedObject->setUseDesignMetrics(b)); | ||||
} | ||||
QSizeF PythonQtWrapper_QTextDocument::size(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
qreal PythonQtWrapper_QTextDocument::textWidth(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textWidth()); | ||||
} | ||||
QString PythonQtWrapper_QTextDocument::toHtml(QTextDocument* theWrappedObject, const QByteArray& encoding) const | ||||
{ | ||||
return ( theWrappedObject->toHtml(encoding)); | ||||
} | ||||
QString PythonQtWrapper_QTextDocument::toPlainText(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPlainText()); | ||||
} | ||||
void PythonQtWrapper_QTextDocument::undo(QTextDocument* theWrappedObject, QTextCursor* cursor) | ||||
{ | ||||
( theWrappedObject->undo(cursor)); | ||||
} | ||||
bool PythonQtWrapper_QTextDocument::useDesignMetrics(QTextDocument* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->useDesignMetrics()); | ||||
} | ||||
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment() | ||||
{ | ||||
return new QTextDocumentFragment(); } | ||||
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment(const QTextCursor& range) | ||||
{ | ||||
return new QTextDocumentFragment(range); } | ||||
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment(const QTextDocument* document) | ||||
{ | ||||
return new QTextDocumentFragment(document); } | ||||
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment(const QTextDocumentFragment& rhs) | ||||
{ | ||||
return new QTextDocumentFragment(rhs); } | ||||
QTextDocumentFragment PythonQtWrapper_QTextDocumentFragment::static_QTextDocumentFragment_fromHtml(const QString& html) | ||||
{ | ||||
return (QTextDocumentFragment::fromHtml(html)); | ||||
} | ||||
QTextDocumentFragment PythonQtWrapper_QTextDocumentFragment::static_QTextDocumentFragment_fromHtml(const QString& html, const QTextDocument* resourceProvider) | ||||
{ | ||||
return (QTextDocumentFragment::fromHtml(html, resourceProvider)); | ||||
} | ||||
QTextDocumentFragment PythonQtWrapper_QTextDocumentFragment::static_QTextDocumentFragment_fromPlainText(const QString& plainText) | ||||
{ | ||||
return (QTextDocumentFragment::fromPlainText(plainText)); | ||||
} | ||||
bool PythonQtWrapper_QTextDocumentFragment::isEmpty(QTextDocumentFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEmpty()); | ||||
} | ||||
QString PythonQtWrapper_QTextDocumentFragment::toHtml(QTextDocumentFragment* theWrappedObject, const QByteArray& encoding) const | ||||
{ | ||||
return ( theWrappedObject->toHtml(encoding)); | ||||
} | ||||
QString PythonQtWrapper_QTextDocumentFragment::toPlainText(QTextDocumentFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPlainText()); | ||||
} | ||||
QTextDocumentWriter* PythonQtWrapper_QTextDocumentWriter::new_QTextDocumentWriter() | ||||
{ | ||||
return new QTextDocumentWriter(); } | ||||
QTextDocumentWriter* PythonQtWrapper_QTextDocumentWriter::new_QTextDocumentWriter(QIODevice* device, const QByteArray& format) | ||||
{ | ||||
return new QTextDocumentWriter(device, format); } | ||||
QTextDocumentWriter* PythonQtWrapper_QTextDocumentWriter::new_QTextDocumentWriter(const QString& fileName, const QByteArray& format) | ||||
{ | ||||
return new QTextDocumentWriter(fileName, format); } | ||||
QTextCodec* PythonQtWrapper_QTextDocumentWriter::codec(QTextDocumentWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->codec()); | ||||
} | ||||
QIODevice* PythonQtWrapper_QTextDocumentWriter::device(QTextDocumentWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
QString PythonQtWrapper_QTextDocumentWriter::fileName(QTextDocumentWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fileName()); | ||||
} | ||||
QByteArray PythonQtWrapper_QTextDocumentWriter::format(QTextDocumentWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
void PythonQtWrapper_QTextDocumentWriter::setCodec(QTextDocumentWriter* theWrappedObject, QTextCodec* codec) | ||||
{ | ||||
( theWrappedObject->setCodec(codec)); | ||||
} | ||||
void PythonQtWrapper_QTextDocumentWriter::setDevice(QTextDocumentWriter* theWrappedObject, QIODevice* device) | ||||
{ | ||||
( theWrappedObject->setDevice(device)); | ||||
} | ||||
void PythonQtWrapper_QTextDocumentWriter::setFileName(QTextDocumentWriter* theWrappedObject, const QString& fileName) | ||||
{ | ||||
( theWrappedObject->setFileName(fileName)); | ||||
} | ||||
void PythonQtWrapper_QTextDocumentWriter::setFormat(QTextDocumentWriter* theWrappedObject, const QByteArray& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
QList<QByteArray > PythonQtWrapper_QTextDocumentWriter::static_QTextDocumentWriter_supportedDocumentFormats() | ||||
{ | ||||
return (QTextDocumentWriter::supportedDocumentFormats()); | ||||
} | ||||
bool PythonQtWrapper_QTextDocumentWriter::write(QTextDocumentWriter* theWrappedObject, const QTextDocument* document) | ||||
{ | ||||
return ( theWrappedObject->write(document)); | ||||
} | ||||
bool PythonQtWrapper_QTextDocumentWriter::write(QTextDocumentWriter* theWrappedObject, const QTextDocumentFragment& fragment) | ||||
{ | ||||
return ( theWrappedObject->write(fragment)); | ||||
} | ||||
PythonQtShell_QTextEdit::~PythonQtShell_QTextEdit() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTextEdit::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::actionEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextEdit::canInsertFromMimeData(const QMimeData* source) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canInsertFromMimeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QMimeData*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&source}; | ||||
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("canInsertFromMimeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::canInsertFromMimeData(source); | ||||
} | ||||
void PythonQtShell_QTextEdit::changeEvent(QEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
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*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::changeEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::contextMenuEvent(QContextMenuEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::contextMenuEvent(e); | ||||
} | ||||
QMimeData* PythonQtShell_QTextEdit::createMimeDataFromSelection() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createMimeDataFromSelection"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QMimeData*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QMimeData* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("createMimeDataFromSelection", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QMimeData**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::createMimeDataFromSelection(); | ||||
} | ||||
void PythonQtShell_QTextEdit::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; | ||||
} | ||||
} | ||||
QTextEdit::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTextEdit::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::devType(); | ||||
} | ||||
void PythonQtShell_QTextEdit::doSetTextCursor(const QTextCursor& cursor) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doSetTextCursor"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QTextCursor&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&cursor}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::doSetTextCursor(cursor); | ||||
} | ||||
void PythonQtShell_QTextEdit::dragEnterEvent(QDragEnterEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::dragEnterEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::dragLeaveEvent(QDragLeaveEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::dragLeaveEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::dragMoveEvent(QDragMoveEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::dragMoveEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::dropEvent(QDropEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::dropEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextEdit::event(QEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
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 QTextEdit::event(e); | ||||
} | ||||
bool PythonQtShell_QTextEdit::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 QTextEdit::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTextEdit::focusInEvent(QFocusEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::focusInEvent(e); | ||||
} | ||||
bool PythonQtShell_QTextEdit::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
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("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTextEdit::focusOutEvent(QFocusEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::focusOutEvent(e); | ||||
} | ||||
bool PythonQtShell_QTextEdit::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QTextEdit::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QTextEdit::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QTextEdit::inputMethodQuery(Qt::InputMethodQuery property) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant returnValue; | ||||
void* args[2] = {NULL, (void*)&property}; | ||||
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("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::inputMethodQuery(property); | ||||
} | ||||
void PythonQtShell_QTextEdit::insertFromMimeData(const QMimeData* source) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertFromMimeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QMimeData*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&source}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::insertFromMimeData(source); | ||||
} | ||||
void PythonQtShell_QTextEdit::keyPressEvent(QKeyEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::keyPressEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::keyReleaseEvent(QKeyEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::keyReleaseEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::leaveEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QTextEdit::loadResource(int type, const QUrl& name) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "loadResource"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "int" , "const QUrl&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QVariant returnValue; | ||||
void* args[3] = {NULL, (void*)&type, (void*)&name}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("loadResource", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::loadResource(type, name); | ||||
} | ||||
int PythonQtShell_QTextEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::mouseDoubleClickEvent(QMouseEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::mouseDoubleClickEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::mouseMoveEvent(QMouseEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::mouseMoveEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::mousePressEvent(QMouseEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::mousePressEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::mouseReleaseEvent(QMouseEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::mouseReleaseEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextEdit::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
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("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::nativeEvent(eventType, message, result); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTextEdit::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTextEdit::paintEvent(QPaintEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::paintEvent(e); | ||||
} | ||||
QPaintDevice* PythonQtShell_QTextEdit::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
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("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::redirected(offset); | ||||
} | ||||
void PythonQtShell_QTextEdit::resizeEvent(QResizeEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::resizeEvent(e); | ||||
} | ||||
void PythonQtShell_QTextEdit::scrollContentsBy(int dx, int dy) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&dx, (void*)&dy}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::scrollContentsBy(dx, dy); | ||||
} | ||||
void PythonQtShell_QTextEdit::setupViewport(QWidget* viewport) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&viewport}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::setupViewport(viewport); | ||||
} | ||||
QPainter* PythonQtShell_QTextEdit::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QTextEdit::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTextEdit::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextEdit::timerEvent(QTimerEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::timerEvent(e); | ||||
} | ||||
bool PythonQtShell_QTextEdit::viewportEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent"); | ||||
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("viewportEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::viewportEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_QTextEdit::viewportSizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextEdit::viewportSizeHint(); | ||||
} | ||||
void PythonQtShell_QTextEdit::wheelEvent(QWheelEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextEdit::wheelEvent(e); | ||||
} | ||||
QTextEdit* PythonQtWrapper_QTextEdit::new_QTextEdit(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTextEdit(parent); } | ||||
QTextEdit* PythonQtWrapper_QTextEdit::new_QTextEdit(const QString& text, QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTextEdit(text, parent); } | ||||
bool PythonQtWrapper_QTextEdit::acceptRichText(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->acceptRichText()); | ||||
} | ||||
Qt::Alignment PythonQtWrapper_QTextEdit::alignment(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->alignment()); | ||||
} | ||||
QString PythonQtWrapper_QTextEdit::anchorAt(QTextEdit* theWrappedObject, const QPoint& pos) const | ||||
{ | ||||
return ( theWrappedObject->anchorAt(pos)); | ||||
} | ||||
QTextEdit::AutoFormatting PythonQtWrapper_QTextEdit::autoFormatting(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoFormatting()); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::canInsertFromMimeData(QTextEdit* theWrappedObject, const QMimeData* source) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_canInsertFromMimeData(source)); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::canPaste(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->canPaste()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::changeEvent(QTextEdit* theWrappedObject, QEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_changeEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::contextMenuEvent(QTextEdit* theWrappedObject, QContextMenuEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_contextMenuEvent(e)); | ||||
} | ||||
QMimeData* PythonQtWrapper_QTextEdit::createMimeDataFromSelection(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_createMimeDataFromSelection()); | ||||
} | ||||
QMenu* PythonQtWrapper_QTextEdit::createStandardContextMenu(QTextEdit* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->createStandardContextMenu()); | ||||
} | ||||
QMenu* PythonQtWrapper_QTextEdit::createStandardContextMenu(QTextEdit* theWrappedObject, const QPoint& position) | ||||
{ | ||||
return ( theWrappedObject->createStandardContextMenu(position)); | ||||
} | ||||
QTextCharFormat PythonQtWrapper_QTextEdit::currentCharFormat(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentCharFormat()); | ||||
} | ||||
QFont PythonQtWrapper_QTextEdit::currentFont(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentFont()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextEdit::cursorForPosition(QTextEdit* theWrappedObject, const QPoint& pos) const | ||||
{ | ||||
return ( theWrappedObject->cursorForPosition(pos)); | ||||
} | ||||
QRect PythonQtWrapper_QTextEdit::cursorRect(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->cursorRect()); | ||||
} | ||||
QRect PythonQtWrapper_QTextEdit::cursorRect(QTextEdit* theWrappedObject, const QTextCursor& cursor) const | ||||
{ | ||||
return ( theWrappedObject->cursorRect(cursor)); | ||||
} | ||||
int PythonQtWrapper_QTextEdit::cursorWidth(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->cursorWidth()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::doSetTextCursor(QTextEdit* theWrappedObject, const QTextCursor& cursor) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_doSetTextCursor(cursor)); | ||||
} | ||||
QTextDocument* PythonQtWrapper_QTextEdit::document(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->document()); | ||||
} | ||||
QString PythonQtWrapper_QTextEdit::documentTitle(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->documentTitle()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::dragEnterEvent(QTextEdit* theWrappedObject, QDragEnterEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dragEnterEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::dragLeaveEvent(QTextEdit* theWrappedObject, QDragLeaveEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dragLeaveEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::dragMoveEvent(QTextEdit* theWrappedObject, QDragMoveEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dragMoveEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::dropEvent(QTextEdit* theWrappedObject, QDropEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dropEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::ensureCursorVisible(QTextEdit* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->ensureCursorVisible()); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::event(QTextEdit* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
QList<QTextEdit::ExtraSelection > PythonQtWrapper_QTextEdit::extraSelections(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->extraSelections()); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::find(QTextEdit* theWrappedObject, const QString& exp, QTextDocument::FindFlags options) | ||||
{ | ||||
return ( theWrappedObject->find(exp, options)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::focusInEvent(QTextEdit* theWrappedObject, QFocusEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_focusInEvent(e)); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::focusNextPrevChild(QTextEdit* theWrappedObject, bool next) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_focusNextPrevChild(next)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::focusOutEvent(QTextEdit* theWrappedObject, QFocusEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_focusOutEvent(e)); | ||||
} | ||||
QString PythonQtWrapper_QTextEdit::fontFamily(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fontFamily()); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::fontItalic(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fontItalic()); | ||||
} | ||||
qreal PythonQtWrapper_QTextEdit::fontPointSize(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fontPointSize()); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::fontUnderline(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fontUnderline()); | ||||
} | ||||
int PythonQtWrapper_QTextEdit::fontWeight(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fontWeight()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::inputMethodEvent(QTextEdit* theWrappedObject, QInputMethodEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_inputMethodEvent(arg__1)); | ||||
} | ||||
QVariant PythonQtWrapper_QTextEdit::inputMethodQuery(QTextEdit* theWrappedObject, Qt::InputMethodQuery property) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_inputMethodQuery(property)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::insertFromMimeData(QTextEdit* theWrappedObject, const QMimeData* source) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_insertFromMimeData(source)); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::isReadOnly(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isReadOnly()); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::isUndoRedoEnabled(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isUndoRedoEnabled()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::keyPressEvent(QTextEdit* theWrappedObject, QKeyEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_keyPressEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::keyReleaseEvent(QTextEdit* theWrappedObject, QKeyEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_keyReleaseEvent(e)); | ||||
} | ||||
int PythonQtWrapper_QTextEdit::lineWrapColumnOrWidth(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lineWrapColumnOrWidth()); | ||||
} | ||||
QTextEdit::LineWrapMode PythonQtWrapper_QTextEdit::lineWrapMode(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lineWrapMode()); | ||||
} | ||||
QVariant PythonQtWrapper_QTextEdit::loadResource(QTextEdit* theWrappedObject, int type, const QUrl& name) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_loadResource(type, name)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::mergeCurrentCharFormat(QTextEdit* theWrappedObject, const QTextCharFormat& modifier) | ||||
{ | ||||
( theWrappedObject->mergeCurrentCharFormat(modifier)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::mouseDoubleClickEvent(QTextEdit* theWrappedObject, QMouseEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mouseDoubleClickEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::mouseMoveEvent(QTextEdit* theWrappedObject, QMouseEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mouseMoveEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::mousePressEvent(QTextEdit* theWrappedObject, QMouseEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mousePressEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::mouseReleaseEvent(QTextEdit* theWrappedObject, QMouseEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mouseReleaseEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::moveCursor(QTextEdit* theWrappedObject, QTextCursor::MoveOperation operation, QTextCursor::MoveMode mode) | ||||
{ | ||||
( theWrappedObject->moveCursor(operation, mode)); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::overwriteMode(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->overwriteMode()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::paintEvent(QTextEdit* theWrappedObject, QPaintEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_paintEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::resizeEvent(QTextEdit* theWrappedObject, QResizeEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_resizeEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::scrollContentsBy(QTextEdit* theWrappedObject, int dx, int dy) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_scrollContentsBy(dx, dy)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setAcceptRichText(QTextEdit* theWrappedObject, bool accept) | ||||
{ | ||||
( theWrappedObject->setAcceptRichText(accept)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setAutoFormatting(QTextEdit* theWrappedObject, QTextEdit::AutoFormatting features) | ||||
{ | ||||
( theWrappedObject->setAutoFormatting(features)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setCurrentCharFormat(QTextEdit* theWrappedObject, const QTextCharFormat& format) | ||||
{ | ||||
( theWrappedObject->setCurrentCharFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setCursorWidth(QTextEdit* theWrappedObject, int width) | ||||
{ | ||||
( theWrappedObject->setCursorWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setDocument(QTextEdit* theWrappedObject, QTextDocument* document) | ||||
{ | ||||
( theWrappedObject->setDocument(document)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setDocumentTitle(QTextEdit* theWrappedObject, const QString& title) | ||||
{ | ||||
( theWrappedObject->setDocumentTitle(title)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setExtraSelections(QTextEdit* theWrappedObject, const QList<QTextEdit::ExtraSelection >& selections) | ||||
{ | ||||
( theWrappedObject->setExtraSelections(selections)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setLineWrapColumnOrWidth(QTextEdit* theWrappedObject, int w) | ||||
{ | ||||
( theWrappedObject->setLineWrapColumnOrWidth(w)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setLineWrapMode(QTextEdit* theWrappedObject, QTextEdit::LineWrapMode mode) | ||||
{ | ||||
( theWrappedObject->setLineWrapMode(mode)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setOverwriteMode(QTextEdit* theWrappedObject, bool overwrite) | ||||
{ | ||||
( theWrappedObject->setOverwriteMode(overwrite)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setReadOnly(QTextEdit* theWrappedObject, bool ro) | ||||
{ | ||||
( theWrappedObject->setReadOnly(ro)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setTabChangesFocus(QTextEdit* theWrappedObject, bool b) | ||||
{ | ||||
( theWrappedObject->setTabChangesFocus(b)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setTabStopWidth(QTextEdit* theWrappedObject, int width) | ||||
{ | ||||
( theWrappedObject->setTabStopWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setTextCursor(QTextEdit* theWrappedObject, const QTextCursor& cursor) | ||||
{ | ||||
( theWrappedObject->setTextCursor(cursor)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setTextInteractionFlags(QTextEdit* theWrappedObject, Qt::TextInteractionFlags flags) | ||||
{ | ||||
( theWrappedObject->setTextInteractionFlags(flags)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setUndoRedoEnabled(QTextEdit* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setUndoRedoEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::setWordWrapMode(QTextEdit* theWrappedObject, QTextOption::WrapMode policy) | ||||
{ | ||||
( theWrappedObject->setWordWrapMode(policy)); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::showEvent(QTextEdit* theWrappedObject, QShowEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_showEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QTextEdit::tabChangesFocus(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabChangesFocus()); | ||||
} | ||||
int PythonQtWrapper_QTextEdit::tabStopWidth(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabStopWidth()); | ||||
} | ||||
QColor PythonQtWrapper_QTextEdit::textBackgroundColor(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textBackgroundColor()); | ||||
} | ||||
QColor PythonQtWrapper_QTextEdit::textColor(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textColor()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextEdit::textCursor(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textCursor()); | ||||
} | ||||
Qt::TextInteractionFlags PythonQtWrapper_QTextEdit::textInteractionFlags(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textInteractionFlags()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::timerEvent(QTextEdit* theWrappedObject, QTimerEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_timerEvent(e)); | ||||
} | ||||
QString PythonQtWrapper_QTextEdit::toHtml(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toHtml()); | ||||
} | ||||
QString PythonQtWrapper_QTextEdit::toPlainText(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPlainText()); | ||||
} | ||||
void PythonQtWrapper_QTextEdit::wheelEvent(QTextEdit* theWrappedObject, QWheelEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_wheelEvent(e)); | ||||
} | ||||
QTextOption::WrapMode PythonQtWrapper_QTextEdit::wordWrapMode(QTextEdit* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->wordWrapMode()); | ||||
} | ||||
PythonQtShell_QTextEdit_ExtraSelection::~PythonQtShell_QTextEdit_ExtraSelection() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextEdit::ExtraSelection* PythonQtWrapper_QTextEdit_ExtraSelection::new_QTextEdit_ExtraSelection() | ||||
{ | ||||
return new PythonQtShell_QTextEdit_ExtraSelection(); } | ||||
QTextFragment* PythonQtWrapper_QTextFragment::new_QTextFragment() | ||||
{ | ||||
return new QTextFragment(); } | ||||
QTextFragment* PythonQtWrapper_QTextFragment::new_QTextFragment(const QTextFragment& o) | ||||
{ | ||||
return new QTextFragment(o); } | ||||
QTextCharFormat PythonQtWrapper_QTextFragment::charFormat(QTextFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->charFormat()); | ||||
} | ||||
int PythonQtWrapper_QTextFragment::charFormatIndex(QTextFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->charFormatIndex()); | ||||
} | ||||
bool PythonQtWrapper_QTextFragment::contains(QTextFragment* theWrappedObject, int position) const | ||||
{ | ||||
return ( theWrappedObject->contains(position)); | ||||
} | ||||
bool PythonQtWrapper_QTextFragment::isValid(QTextFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
int PythonQtWrapper_QTextFragment::length(QTextFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
bool PythonQtWrapper_QTextFragment::__ne__(QTextFragment* theWrappedObject, const QTextFragment& o) const | ||||
{ | ||||
return ( (*theWrappedObject)!= o); | ||||
} | ||||
bool PythonQtWrapper_QTextFragment::__lt__(QTextFragment* theWrappedObject, const QTextFragment& o) const | ||||
{ | ||||
return ( (*theWrappedObject)< o); | ||||
} | ||||
bool PythonQtWrapper_QTextFragment::__eq__(QTextFragment* theWrappedObject, const QTextFragment& o) const | ||||
{ | ||||
return ( (*theWrappedObject)== o); | ||||
} | ||||
int PythonQtWrapper_QTextFragment::position(QTextFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->position()); | ||||
} | ||||
QString PythonQtWrapper_QTextFragment::text(QTextFragment* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
PythonQtShell_QTextFrame::~PythonQtShell_QTextFrame() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTextFrame::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextFrame::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextFrame::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; | ||||
} | ||||
} | ||||
QTextFrame::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextFrame::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 QTextFrame::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextFrame::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 QTextFrame::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTextFrame::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; | ||||
} | ||||
} | ||||
QTextFrame::timerEvent(arg__1); | ||||
} | ||||
QTextFrame* PythonQtWrapper_QTextFrame::new_QTextFrame(QTextDocument* doc) | ||||
{ | ||||
return new PythonQtShell_QTextFrame(doc); } | ||||
QTextFrame::iterator PythonQtWrapper_QTextFrame::begin(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->begin()); | ||||
} | ||||
QList<QTextFrame* > PythonQtWrapper_QTextFrame::childFrames(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->childFrames()); | ||||
} | ||||
QTextFrame::iterator PythonQtWrapper_QTextFrame::end(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->end()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextFrame::firstCursorPosition(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->firstCursorPosition()); | ||||
} | ||||
int PythonQtWrapper_QTextFrame::firstPosition(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->firstPosition()); | ||||
} | ||||
QTextFrameFormat PythonQtWrapper_QTextFrame::frameFormat(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->frameFormat()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextFrame::lastCursorPosition(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastCursorPosition()); | ||||
} | ||||
int PythonQtWrapper_QTextFrame::lastPosition(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastPosition()); | ||||
} | ||||
QTextFrame* PythonQtWrapper_QTextFrame::parentFrame(QTextFrame* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parentFrame()); | ||||
} | ||||
void PythonQtWrapper_QTextFrame::setFrameFormat(QTextFrame* theWrappedObject, const QTextFrameFormat& format) | ||||
{ | ||||
( theWrappedObject->setFrameFormat(format)); | ||||
} | ||||
PythonQtShell_QTextFrameFormat::~PythonQtShell_QTextFrameFormat() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextFrameFormat* PythonQtWrapper_QTextFrameFormat::new_QTextFrameFormat() | ||||
{ | ||||
return new PythonQtShell_QTextFrameFormat(); } | ||||
qreal PythonQtWrapper_QTextFrameFormat::border(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->border()); | ||||
} | ||||
QBrush PythonQtWrapper_QTextFrameFormat::borderBrush(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->borderBrush()); | ||||
} | ||||
QTextFrameFormat::BorderStyle PythonQtWrapper_QTextFrameFormat::borderStyle(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->borderStyle()); | ||||
} | ||||
qreal PythonQtWrapper_QTextFrameFormat::bottomMargin(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomMargin()); | ||||
} | ||||
QTextLength PythonQtWrapper_QTextFrameFormat::height(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
bool PythonQtWrapper_QTextFrameFormat::isValid(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
qreal PythonQtWrapper_QTextFrameFormat::leftMargin(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->leftMargin()); | ||||
} | ||||
qreal PythonQtWrapper_QTextFrameFormat::margin(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->margin()); | ||||
} | ||||
qreal PythonQtWrapper_QTextFrameFormat::padding(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->padding()); | ||||
} | ||||
QTextFormat::PageBreakFlags PythonQtWrapper_QTextFrameFormat::pageBreakPolicy(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pageBreakPolicy()); | ||||
} | ||||
QTextFrameFormat::Position PythonQtWrapper_QTextFrameFormat::position(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->position()); | ||||
} | ||||
qreal PythonQtWrapper_QTextFrameFormat::rightMargin(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rightMargin()); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setBorder(QTextFrameFormat* theWrappedObject, qreal border) | ||||
{ | ||||
( theWrappedObject->setBorder(border)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setBorderBrush(QTextFrameFormat* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setBorderBrush(brush)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setBorderStyle(QTextFrameFormat* theWrappedObject, QTextFrameFormat::BorderStyle style) | ||||
{ | ||||
( theWrappedObject->setBorderStyle(style)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setBottomMargin(QTextFrameFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setBottomMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setHeight(QTextFrameFormat* theWrappedObject, const QTextLength& height) | ||||
{ | ||||
( theWrappedObject->setHeight(height)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setHeight(QTextFrameFormat* theWrappedObject, qreal height) | ||||
{ | ||||
( theWrappedObject->setHeight(height)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setLeftMargin(QTextFrameFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setLeftMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setMargin(QTextFrameFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setPadding(QTextFrameFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setPageBreakPolicy(QTextFrameFormat* theWrappedObject, QTextFormat::PageBreakFlags flags) | ||||
{ | ||||
( theWrappedObject->setPageBreakPolicy(flags)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setPosition(QTextFrameFormat* theWrappedObject, QTextFrameFormat::Position f) | ||||
{ | ||||
( theWrappedObject->setPosition(f)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setRightMargin(QTextFrameFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setRightMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setTopMargin(QTextFrameFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setTopMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setWidth(QTextFrameFormat* theWrappedObject, const QTextLength& length) | ||||
{ | ||||
( theWrappedObject->setWidth(length)); | ||||
} | ||||
void PythonQtWrapper_QTextFrameFormat::setWidth(QTextFrameFormat* theWrappedObject, qreal width) | ||||
{ | ||||
( theWrappedObject->setWidth(width)); | ||||
} | ||||
qreal PythonQtWrapper_QTextFrameFormat::topMargin(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topMargin()); | ||||
} | ||||
QTextLength PythonQtWrapper_QTextFrameFormat::width(QTextFrameFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
PythonQtShell_QTextImageFormat::~PythonQtShell_QTextImageFormat() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextImageFormat* PythonQtWrapper_QTextImageFormat::new_QTextImageFormat() | ||||
{ | ||||
return new PythonQtShell_QTextImageFormat(); } | ||||
qreal PythonQtWrapper_QTextImageFormat::height(QTextImageFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
bool PythonQtWrapper_QTextImageFormat::isValid(QTextImageFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
QString PythonQtWrapper_QTextImageFormat::name(QTextImageFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->name()); | ||||
} | ||||
void PythonQtWrapper_QTextImageFormat::setHeight(QTextImageFormat* theWrappedObject, qreal height) | ||||
{ | ||||
( theWrappedObject->setHeight(height)); | ||||
} | ||||
void PythonQtWrapper_QTextImageFormat::setName(QTextImageFormat* theWrappedObject, const QString& name) | ||||
{ | ||||
( theWrappedObject->setName(name)); | ||||
} | ||||
void PythonQtWrapper_QTextImageFormat::setWidth(QTextImageFormat* theWrappedObject, qreal width) | ||||
{ | ||||
( theWrappedObject->setWidth(width)); | ||||
} | ||||
qreal PythonQtWrapper_QTextImageFormat::width(QTextImageFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
QTextInlineObject* PythonQtWrapper_QTextInlineObject::new_QTextInlineObject() | ||||
{ | ||||
return new QTextInlineObject(); } | ||||
qreal PythonQtWrapper_QTextInlineObject::ascent(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->ascent()); | ||||
} | ||||
qreal PythonQtWrapper_QTextInlineObject::descent(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->descent()); | ||||
} | ||||
QTextFormat PythonQtWrapper_QTextInlineObject::format(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
int PythonQtWrapper_QTextInlineObject::formatIndex(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->formatIndex()); | ||||
} | ||||
qreal PythonQtWrapper_QTextInlineObject::height(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
bool PythonQtWrapper_QTextInlineObject::isValid(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
QRectF PythonQtWrapper_QTextInlineObject::rect(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rect()); | ||||
} | ||||
void PythonQtWrapper_QTextInlineObject::setAscent(QTextInlineObject* theWrappedObject, qreal a) | ||||
{ | ||||
( theWrappedObject->setAscent(a)); | ||||
} | ||||
void PythonQtWrapper_QTextInlineObject::setDescent(QTextInlineObject* theWrappedObject, qreal d) | ||||
{ | ||||
( theWrappedObject->setDescent(d)); | ||||
} | ||||
void PythonQtWrapper_QTextInlineObject::setWidth(QTextInlineObject* theWrappedObject, qreal w) | ||||
{ | ||||
( theWrappedObject->setWidth(w)); | ||||
} | ||||
Qt::LayoutDirection PythonQtWrapper_QTextInlineObject::textDirection(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textDirection()); | ||||
} | ||||
int PythonQtWrapper_QTextInlineObject::textPosition(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textPosition()); | ||||
} | ||||
qreal PythonQtWrapper_QTextInlineObject::width(QTextInlineObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
PythonQtShell_QTextItem::~PythonQtShell_QTextItem() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextItem* PythonQtWrapper_QTextItem::new_QTextItem() | ||||
{ | ||||
return new PythonQtShell_QTextItem(); } | ||||
qreal PythonQtWrapper_QTextItem::ascent(QTextItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->ascent()); | ||||
} | ||||
qreal PythonQtWrapper_QTextItem::descent(QTextItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->descent()); | ||||
} | ||||
QFont PythonQtWrapper_QTextItem::font(QTextItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->font()); | ||||
} | ||||
QTextItem::RenderFlags PythonQtWrapper_QTextItem::renderFlags(QTextItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->renderFlags()); | ||||
} | ||||
QString PythonQtWrapper_QTextItem::text(QTextItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
qreal PythonQtWrapper_QTextItem::width(QTextItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
QTextLine* PythonQtWrapper_QTextLine::new_QTextLine() | ||||
{ | ||||
return new QTextLine(); } | ||||
qreal PythonQtWrapper_QTextLine::ascent(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->ascent()); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::cursorToX(QTextLine* theWrappedObject, int cursorPos, QTextLine::Edge edge) const | ||||
{ | ||||
return ( theWrappedObject->cursorToX(cursorPos, edge)); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::descent(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->descent()); | ||||
} | ||||
void PythonQtWrapper_QTextLine::draw(QTextLine* theWrappedObject, QPainter* p, const QPointF& point, const QTextLayout::FormatRange* selection) const | ||||
{ | ||||
( theWrappedObject->draw(p, point, selection)); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::height(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::horizontalAdvance(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->horizontalAdvance()); | ||||
} | ||||
bool PythonQtWrapper_QTextLine::isValid(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::leading(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->leading()); | ||||
} | ||||
bool PythonQtWrapper_QTextLine::leadingIncluded(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->leadingIncluded()); | ||||
} | ||||
int PythonQtWrapper_QTextLine::lineNumber(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lineNumber()); | ||||
} | ||||
QRectF PythonQtWrapper_QTextLine::naturalTextRect(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->naturalTextRect()); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::naturalTextWidth(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->naturalTextWidth()); | ||||
} | ||||
QPointF PythonQtWrapper_QTextLine::position(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->position()); | ||||
} | ||||
QRectF PythonQtWrapper_QTextLine::rect(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rect()); | ||||
} | ||||
void PythonQtWrapper_QTextLine::setLeadingIncluded(QTextLine* theWrappedObject, bool included) | ||||
{ | ||||
( theWrappedObject->setLeadingIncluded(included)); | ||||
} | ||||
void PythonQtWrapper_QTextLine::setLineWidth(QTextLine* theWrappedObject, qreal width) | ||||
{ | ||||
( theWrappedObject->setLineWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QTextLine::setNumColumns(QTextLine* theWrappedObject, int columns) | ||||
{ | ||||
( theWrappedObject->setNumColumns(columns)); | ||||
} | ||||
void PythonQtWrapper_QTextLine::setNumColumns(QTextLine* theWrappedObject, int columns, qreal alignmentWidth) | ||||
{ | ||||
( theWrappedObject->setNumColumns(columns, alignmentWidth)); | ||||
} | ||||
void PythonQtWrapper_QTextLine::setPosition(QTextLine* theWrappedObject, const QPointF& pos) | ||||
{ | ||||
( theWrappedObject->setPosition(pos)); | ||||
} | ||||
int PythonQtWrapper_QTextLine::textLength(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textLength()); | ||||
} | ||||
int PythonQtWrapper_QTextLine::textStart(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textStart()); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::width(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::x(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
int PythonQtWrapper_QTextLine::xToCursor(QTextLine* theWrappedObject, qreal x, QTextLine::CursorPosition arg__2) const | ||||
{ | ||||
return ( theWrappedObject->xToCursor(x, arg__2)); | ||||
} | ||||
qreal PythonQtWrapper_QTextLine::y(QTextLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
PythonQtShell_QTextList::~PythonQtShell_QTextList() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTextList::blockFormatChanged(const QTextBlock& block) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "blockFormatChanged"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QTextBlock&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&block}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextList::blockFormatChanged(block); | ||||
} | ||||
void PythonQtShell_QTextList::blockInserted(const QTextBlock& block) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "blockInserted"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QTextBlock&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&block}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextList::blockInserted(block); | ||||
} | ||||
void PythonQtShell_QTextList::blockRemoved(const QTextBlock& block) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "blockRemoved"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QTextBlock&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&block}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextList::blockRemoved(block); | ||||
} | ||||
void PythonQtShell_QTextList::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextList::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextList::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; | ||||
} | ||||
} | ||||
QTextList::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextList::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 QTextList::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextList::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 QTextList::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTextList::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; | ||||
} | ||||
} | ||||
QTextList::timerEvent(arg__1); | ||||
} | ||||
QTextList* PythonQtWrapper_QTextList::new_QTextList(QTextDocument* doc) | ||||
{ | ||||
return new PythonQtShell_QTextList(doc); } | ||||
void PythonQtWrapper_QTextList::add(QTextList* theWrappedObject, const QTextBlock& block) | ||||
{ | ||||
( theWrappedObject->add(block)); | ||||
} | ||||
int PythonQtWrapper_QTextList::count(QTextList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
QTextListFormat PythonQtWrapper_QTextList::format(QTextList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextList::item(QTextList* theWrappedObject, int i) const | ||||
{ | ||||
return ( theWrappedObject->item(i)); | ||||
} | ||||
int PythonQtWrapper_QTextList::itemNumber(QTextList* theWrappedObject, const QTextBlock& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->itemNumber(arg__1)); | ||||
} | ||||
QString PythonQtWrapper_QTextList::itemText(QTextList* theWrappedObject, const QTextBlock& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->itemText(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTextList::remove(QTextList* theWrappedObject, const QTextBlock& arg__1) | ||||
{ | ||||
( theWrappedObject->remove(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTextList::removeItem(QTextList* theWrappedObject, int i) | ||||
{ | ||||
( theWrappedObject->removeItem(i)); | ||||
} | ||||
void PythonQtWrapper_QTextList::setFormat(QTextList* theWrappedObject, const QTextListFormat& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
PythonQtShell_QTextListFormat::~PythonQtShell_QTextListFormat() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextListFormat* PythonQtWrapper_QTextListFormat::new_QTextListFormat() | ||||
{ | ||||
return new PythonQtShell_QTextListFormat(); } | ||||
int PythonQtWrapper_QTextListFormat::indent(QTextListFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indent()); | ||||
} | ||||
bool PythonQtWrapper_QTextListFormat::isValid(QTextListFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
QString PythonQtWrapper_QTextListFormat::numberPrefix(QTextListFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->numberPrefix()); | ||||
} | ||||
QString PythonQtWrapper_QTextListFormat::numberSuffix(QTextListFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->numberSuffix()); | ||||
} | ||||
void PythonQtWrapper_QTextListFormat::setIndent(QTextListFormat* theWrappedObject, int indent) | ||||
{ | ||||
( theWrappedObject->setIndent(indent)); | ||||
} | ||||
void PythonQtWrapper_QTextListFormat::setNumberPrefix(QTextListFormat* theWrappedObject, const QString& numberPrefix) | ||||
{ | ||||
( theWrappedObject->setNumberPrefix(numberPrefix)); | ||||
} | ||||
void PythonQtWrapper_QTextListFormat::setNumberSuffix(QTextListFormat* theWrappedObject, const QString& numberSuffix) | ||||
{ | ||||
( theWrappedObject->setNumberSuffix(numberSuffix)); | ||||
} | ||||
void PythonQtWrapper_QTextListFormat::setStyle(QTextListFormat* theWrappedObject, QTextListFormat::Style style) | ||||
{ | ||||
( theWrappedObject->setStyle(style)); | ||||
} | ||||
QTextListFormat::Style PythonQtWrapper_QTextListFormat::style(QTextListFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->style()); | ||||
} | ||||
PythonQtShell_QTextObject::~PythonQtShell_QTextObject() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTextObject::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextObject::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextObject::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; | ||||
} | ||||
} | ||||
QTextObject::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextObject::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 QTextObject::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextObject::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 QTextObject::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTextObject::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; | ||||
} | ||||
} | ||||
QTextObject::timerEvent(arg__1); | ||||
} | ||||
QTextDocument* PythonQtWrapper_QTextObject::document(QTextObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->document()); | ||||
} | ||||
QTextFormat PythonQtWrapper_QTextObject::format(QTextObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
int PythonQtWrapper_QTextObject::formatIndex(QTextObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->formatIndex()); | ||||
} | ||||
int PythonQtWrapper_QTextObject::objectIndex(QTextObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->objectIndex()); | ||||
} | ||||
PythonQtShell_QTextTable::~PythonQtShell_QTextTable() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTextTable::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTextTable::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTextTable::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; | ||||
} | ||||
} | ||||
QTextTable::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextTable::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 QTextTable::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTextTable::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 QTextTable::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTextTable::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; | ||||
} | ||||
} | ||||
QTextTable::timerEvent(arg__1); | ||||
} | ||||
QTextTable* PythonQtWrapper_QTextTable::new_QTextTable(QTextDocument* doc) | ||||
{ | ||||
return new PythonQtShell_QTextTable(doc); } | ||||
void PythonQtWrapper_QTextTable::appendColumns(QTextTable* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->appendColumns(count)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::appendRows(QTextTable* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->appendRows(count)); | ||||
} | ||||
QTextTableCell PythonQtWrapper_QTextTable::cellAt(QTextTable* theWrappedObject, const QTextCursor& c) const | ||||
{ | ||||
return ( theWrappedObject->cellAt(c)); | ||||
} | ||||
QTextTableCell PythonQtWrapper_QTextTable::cellAt(QTextTable* theWrappedObject, int position) const | ||||
{ | ||||
return ( theWrappedObject->cellAt(position)); | ||||
} | ||||
QTextTableCell PythonQtWrapper_QTextTable::cellAt(QTextTable* theWrappedObject, int row, int col) const | ||||
{ | ||||
return ( theWrappedObject->cellAt(row, col)); | ||||
} | ||||
int PythonQtWrapper_QTextTable::columns(QTextTable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->columns()); | ||||
} | ||||
QTextTableFormat PythonQtWrapper_QTextTable::format(QTextTable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
void PythonQtWrapper_QTextTable::insertColumns(QTextTable* theWrappedObject, int pos, int num) | ||||
{ | ||||
( theWrappedObject->insertColumns(pos, num)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::insertRows(QTextTable* theWrappedObject, int pos, int num) | ||||
{ | ||||
( theWrappedObject->insertRows(pos, num)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::mergeCells(QTextTable* theWrappedObject, const QTextCursor& cursor) | ||||
{ | ||||
( theWrappedObject->mergeCells(cursor)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::mergeCells(QTextTable* theWrappedObject, int row, int col, int numRows, int numCols) | ||||
{ | ||||
( theWrappedObject->mergeCells(row, col, numRows, numCols)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::removeColumns(QTextTable* theWrappedObject, int pos, int num) | ||||
{ | ||||
( theWrappedObject->removeColumns(pos, num)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::removeRows(QTextTable* theWrappedObject, int pos, int num) | ||||
{ | ||||
( theWrappedObject->removeRows(pos, num)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::resize(QTextTable* theWrappedObject, int rows, int cols) | ||||
{ | ||||
( theWrappedObject->resize(rows, cols)); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextTable::rowEnd(QTextTable* theWrappedObject, const QTextCursor& c) const | ||||
{ | ||||
return ( theWrappedObject->rowEnd(c)); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextTable::rowStart(QTextTable* theWrappedObject, const QTextCursor& c) const | ||||
{ | ||||
return ( theWrappedObject->rowStart(c)); | ||||
} | ||||
int PythonQtWrapper_QTextTable::rows(QTextTable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rows()); | ||||
} | ||||
void PythonQtWrapper_QTextTable::setFormat(QTextTable* theWrappedObject, const QTextTableFormat& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QTextTable::splitCell(QTextTable* theWrappedObject, int row, int col, int numRows, int numCols) | ||||
{ | ||||
( theWrappedObject->splitCell(row, col, numRows, numCols)); | ||||
} | ||||
QTextTableCell* PythonQtWrapper_QTextTableCell::new_QTextTableCell() | ||||
{ | ||||
return new QTextTableCell(); } | ||||
QTextTableCell* PythonQtWrapper_QTextTableCell::new_QTextTableCell(const QTextTableCell& o) | ||||
{ | ||||
return new QTextTableCell(o); } | ||||
QTextFrame::iterator PythonQtWrapper_QTextTableCell::begin(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->begin()); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::column(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->column()); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::columnSpan(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->columnSpan()); | ||||
} | ||||
QTextFrame::iterator PythonQtWrapper_QTextTableCell::end(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->end()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextTableCell::firstCursorPosition(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->firstCursorPosition()); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::firstPosition(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->firstPosition()); | ||||
} | ||||
QTextCharFormat PythonQtWrapper_QTextTableCell::format(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
bool PythonQtWrapper_QTextTableCell::isValid(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
QTextCursor PythonQtWrapper_QTextTableCell::lastCursorPosition(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastCursorPosition()); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::lastPosition(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastPosition()); | ||||
} | ||||
bool PythonQtWrapper_QTextTableCell::__ne__(QTextTableCell* theWrappedObject, const QTextTableCell& other) const | ||||
{ | ||||
return ( (*theWrappedObject)!= other); | ||||
} | ||||
bool PythonQtWrapper_QTextTableCell::__eq__(QTextTableCell* theWrappedObject, const QTextTableCell& other) const | ||||
{ | ||||
return ( (*theWrappedObject)== other); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::row(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->row()); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::rowSpan(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rowSpan()); | ||||
} | ||||
void PythonQtWrapper_QTextTableCell::setFormat(QTextTableCell* theWrappedObject, const QTextCharFormat& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
int PythonQtWrapper_QTextTableCell::tableCellFormatIndex(QTextTableCell* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tableCellFormatIndex()); | ||||
} | ||||
PythonQtShell_QTextTableCellFormat::~PythonQtShell_QTextTableCellFormat() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextTableCellFormat* PythonQtWrapper_QTextTableCellFormat::new_QTextTableCellFormat() | ||||
{ | ||||
return new PythonQtShell_QTextTableCellFormat(); } | ||||
qreal PythonQtWrapper_QTextTableCellFormat::bottomPadding(QTextTableCellFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomPadding()); | ||||
} | ||||
bool PythonQtWrapper_QTextTableCellFormat::isValid(QTextTableCellFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
qreal PythonQtWrapper_QTextTableCellFormat::leftPadding(QTextTableCellFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->leftPadding()); | ||||
} | ||||
qreal PythonQtWrapper_QTextTableCellFormat::rightPadding(QTextTableCellFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rightPadding()); | ||||
} | ||||
void PythonQtWrapper_QTextTableCellFormat::setBottomPadding(QTextTableCellFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setBottomPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QTextTableCellFormat::setLeftPadding(QTextTableCellFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setLeftPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QTextTableCellFormat::setPadding(QTextTableCellFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QTextTableCellFormat::setRightPadding(QTextTableCellFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setRightPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QTextTableCellFormat::setTopPadding(QTextTableCellFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setTopPadding(padding)); | ||||
} | ||||
qreal PythonQtWrapper_QTextTableCellFormat::topPadding(QTextTableCellFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topPadding()); | ||||
} | ||||
PythonQtShell_QTextTableFormat::~PythonQtShell_QTextTableFormat() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextTableFormat* PythonQtWrapper_QTextTableFormat::new_QTextTableFormat() | ||||
{ | ||||
return new PythonQtShell_QTextTableFormat(); } | ||||
Qt::Alignment PythonQtWrapper_QTextTableFormat::alignment(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->alignment()); | ||||
} | ||||
qreal PythonQtWrapper_QTextTableFormat::cellPadding(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->cellPadding()); | ||||
} | ||||
qreal PythonQtWrapper_QTextTableFormat::cellSpacing(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->cellSpacing()); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::clearColumnWidthConstraints(QTextTableFormat* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clearColumnWidthConstraints()); | ||||
} | ||||
QVector<QTextLength > PythonQtWrapper_QTextTableFormat::columnWidthConstraints(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->columnWidthConstraints()); | ||||
} | ||||
int PythonQtWrapper_QTextTableFormat::columns(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->columns()); | ||||
} | ||||
int PythonQtWrapper_QTextTableFormat::headerRowCount(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->headerRowCount()); | ||||
} | ||||
bool PythonQtWrapper_QTextTableFormat::isValid(QTextTableFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::setAlignment(QTextTableFormat* theWrappedObject, Qt::Alignment alignment) | ||||
{ | ||||
( theWrappedObject->setAlignment(alignment)); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::setCellPadding(QTextTableFormat* theWrappedObject, qreal padding) | ||||
{ | ||||
( theWrappedObject->setCellPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::setCellSpacing(QTextTableFormat* theWrappedObject, qreal spacing) | ||||
{ | ||||
( theWrappedObject->setCellSpacing(spacing)); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::setColumnWidthConstraints(QTextTableFormat* theWrappedObject, const QVector<QTextLength >& constraints) | ||||
{ | ||||
( theWrappedObject->setColumnWidthConstraints(constraints)); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::setColumns(QTextTableFormat* theWrappedObject, int columns) | ||||
{ | ||||
( theWrappedObject->setColumns(columns)); | ||||
} | ||||
void PythonQtWrapper_QTextTableFormat::setHeaderRowCount(QTextTableFormat* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->setHeaderRowCount(count)); | ||||
} | ||||
PythonQtShell_QTileRules::~PythonQtShell_QTileRules() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTileRules* PythonQtWrapper_QTileRules::new_QTileRules(Qt::TileRule horizontalRule, Qt::TileRule verticalRule) | ||||
{ | ||||
return new PythonQtShell_QTileRules(horizontalRule, verticalRule); } | ||||
QTileRules* PythonQtWrapper_QTileRules::new_QTileRules(Qt::TileRule rule) | ||||
{ | ||||
return new PythonQtShell_QTileRules(rule); } | ||||
PythonQtShell_QTimeEdit::~PythonQtShell_QTimeEdit() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTimeEdit::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::changeEvent(QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::changeEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::clear() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::clear(); | ||||
} | ||||
void PythonQtShell_QTimeEdit::closeEvent(QCloseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::closeEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::contextMenuEvent(QContextMenuEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::contextMenuEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::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; | ||||
} | ||||
} | ||||
QTimeEdit::customEvent(arg__1); | ||||
} | ||||
QDateTime PythonQtShell_QTimeEdit::dateTimeFromText(const QString& text) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dateTimeFromText"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QDateTime" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QDateTime returnValue; | ||||
void* args[2] = {NULL, (void*)&text}; | ||||
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("dateTimeFromText", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QDateTime*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::dateTimeFromText(text); | ||||
} | ||||
int PythonQtShell_QTimeEdit::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::devType(); | ||||
} | ||||
void PythonQtShell_QTimeEdit::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTimeEdit::event(QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::event(event); | ||||
} | ||||
bool PythonQtShell_QTimeEdit::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 QTimeEdit::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTimeEdit::fixup(QString& input) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&input}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::fixup(input); | ||||
} | ||||
void PythonQtShell_QTimeEdit::focusInEvent(QFocusEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::focusInEvent(event); | ||||
} | ||||
bool PythonQtShell_QTimeEdit::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
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("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTimeEdit::focusOutEvent(QFocusEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::focusOutEvent(event); | ||||
} | ||||
bool PythonQtShell_QTimeEdit::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QTimeEdit::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::hideEvent(QHideEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::hideEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QTimeEdit::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QTimeEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant 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("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::keyPressEvent(QKeyEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::keyPressEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::keyReleaseEvent(QKeyEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::keyReleaseEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTimeEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeEdit::mouseMoveEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::mouseMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::mousePressEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::mousePressEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::mouseReleaseEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::mouseReleaseEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTimeEdit::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
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("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::nativeEvent(eventType, message, result); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTimeEdit::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTimeEdit::paintEvent(QPaintEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::paintEvent(event); | ||||
} | ||||
QPaintDevice* PythonQtShell_QTimeEdit::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
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("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::redirected(offset); | ||||
} | ||||
void PythonQtShell_QTimeEdit::resizeEvent(QResizeEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::resizeEvent(event); | ||||
} | ||||
QPainter* PythonQtShell_QTimeEdit::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QTimeEdit::showEvent(QShowEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::showEvent(event); | ||||
} | ||||
void PythonQtShell_QTimeEdit::stepBy(int steps) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&steps}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::stepBy(steps); | ||||
} | ||||
QAbstractSpinBox::StepEnabled PythonQtShell_QTimeEdit::stepEnabled() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QAbstractSpinBox::StepEnabled returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::stepEnabled(); | ||||
} | ||||
void PythonQtShell_QTimeEdit::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTimeEdit::tabletEvent(arg__1); | ||||
} | ||||
QString PythonQtShell_QTimeEdit::textFromDateTime(const QDateTime& dt) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromDateTime"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString" , "const QDateTime&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QString returnValue; | ||||
void* args[2] = {NULL, (void*)&dt}; | ||||
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("textFromDateTime", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::textFromDateTime(dt); | ||||
} | ||||
void PythonQtShell_QTimeEdit::timerEvent(QTimerEvent* event) | ||||
{ | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::timerEvent(event); | ||||
} | ||||
QValidator::State PythonQtShell_QTimeEdit::validate(QString& input, int& pos) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QValidator::State returnValue; | ||||
void* args[3] = {NULL, (void*)&input, (void*)&pos}; | ||||
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("validate", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QValidator::State*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeEdit::validate(input, pos); | ||||
} | ||||
void PythonQtShell_QTimeEdit::wheelEvent(QWheelEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeEdit::wheelEvent(event); | ||||
} | ||||
QTimeEdit* PythonQtWrapper_QTimeEdit::new_QTimeEdit(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTimeEdit(parent); } | ||||
QTimeEdit* PythonQtWrapper_QTimeEdit::new_QTimeEdit(const QTime& time, QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTimeEdit(time, parent); } | ||||
PythonQtShell_QToolBar::~PythonQtShell_QToolBar() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QToolBar::actionEvent(QActionEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBar::actionEvent(event); | ||||
} | ||||
void PythonQtShell_QToolBar::changeEvent(QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBar::changeEvent(event); | ||||
} | ||||
void PythonQtShell_QToolBar::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBar::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::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; | ||||
} | ||||
} | ||||
QToolBar::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QToolBar::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::devType(); | ||||
} | ||||
void PythonQtShell_QToolBar::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBar::event(QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::event(event); | ||||
} | ||||
bool PythonQtShell_QToolBar::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 QToolBar::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QToolBar::focusInEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBar::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
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("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QToolBar::focusOutEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::focusOutEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBar::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QToolBar::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBar::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QToolBar::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QToolBar::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant 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("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::keyPressEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QToolBar::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QToolBar::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QToolBar::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::mouseMoveEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::mousePressEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::mouseReleaseEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBar::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
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("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::nativeEvent(eventType, message, result); | ||||
} | ||||
QPaintEngine* PythonQtShell_QToolBar::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::paintEngine(); | ||||
} | ||||
void PythonQtShell_QToolBar::paintEvent(QPaintEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBar::paintEvent(event); | ||||
} | ||||
QPaintDevice* PythonQtShell_QToolBar::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
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("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::redirected(offset); | ||||
} | ||||
void PythonQtShell_QToolBar::resizeEvent(QResizeEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::resizeEvent(arg__1); | ||||
} | ||||
QPainter* PythonQtShell_QToolBar::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QToolBar::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_QToolBar::sizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBar::sizeHint(); | ||||
} | ||||
void PythonQtShell_QToolBar::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::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; | ||||
} | ||||
} | ||||
QToolBar::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBar::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBar::wheelEvent(arg__1); | ||||
} | ||||
QToolBar* PythonQtWrapper_QToolBar::new_QToolBar(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QToolBar(parent); } | ||||
QToolBar* PythonQtWrapper_QToolBar::new_QToolBar(const QString& title, QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QToolBar(title, parent); } | ||||
QAction* PythonQtWrapper_QToolBar::actionAt(QToolBar* theWrappedObject, const QPoint& p) const | ||||
{ | ||||
return ( theWrappedObject->actionAt(p)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::actionAt(QToolBar* theWrappedObject, int x, int y) const | ||||
{ | ||||
return ( theWrappedObject->actionAt(x, y)); | ||||
} | ||||
void PythonQtWrapper_QToolBar::actionEvent(QToolBar* theWrappedObject, QActionEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_actionEvent(event)); | ||||
} | ||||
QRect PythonQtWrapper_QToolBar::actionGeometry(QToolBar* theWrappedObject, QAction* action) const | ||||
{ | ||||
return ( theWrappedObject->actionGeometry(action)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::addAction(QToolBar* theWrappedObject, const QIcon& icon, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->addAction(icon, text)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::addAction(QToolBar* theWrappedObject, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->addAction(text)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::addSeparator(QToolBar* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->addSeparator()); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::addWidget(QToolBar* theWrappedObject, QWidget* widget) | ||||
{ | ||||
return ( theWrappedObject->addWidget(widget)); | ||||
} | ||||
Qt::ToolBarAreas PythonQtWrapper_QToolBar::allowedAreas(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->allowedAreas()); | ||||
} | ||||
void PythonQtWrapper_QToolBar::changeEvent(QToolBar* theWrappedObject, QEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_changeEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QToolBar::clear(QToolBar* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clear()); | ||||
} | ||||
bool PythonQtWrapper_QToolBar::event(QToolBar* theWrappedObject, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_event(event)); | ||||
} | ||||
QSize PythonQtWrapper_QToolBar::iconSize(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->iconSize()); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::insertSeparator(QToolBar* theWrappedObject, QAction* before) | ||||
{ | ||||
return ( theWrappedObject->insertSeparator(before)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::insertWidget(QToolBar* theWrappedObject, QAction* before, QWidget* widget) | ||||
{ | ||||
return ( theWrappedObject->insertWidget(before, widget)); | ||||
} | ||||
bool PythonQtWrapper_QToolBar::isAreaAllowed(QToolBar* theWrappedObject, Qt::ToolBarArea area) const | ||||
{ | ||||
return ( theWrappedObject->isAreaAllowed(area)); | ||||
} | ||||
bool PythonQtWrapper_QToolBar::isFloatable(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isFloatable()); | ||||
} | ||||
bool PythonQtWrapper_QToolBar::isFloating(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isFloating()); | ||||
} | ||||
bool PythonQtWrapper_QToolBar::isMovable(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isMovable()); | ||||
} | ||||
Qt::Orientation PythonQtWrapper_QToolBar::orientation(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->orientation()); | ||||
} | ||||
void PythonQtWrapper_QToolBar::paintEvent(QToolBar* theWrappedObject, QPaintEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_paintEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QToolBar::setAllowedAreas(QToolBar* theWrappedObject, Qt::ToolBarAreas areas) | ||||
{ | ||||
( theWrappedObject->setAllowedAreas(areas)); | ||||
} | ||||
void PythonQtWrapper_QToolBar::setFloatable(QToolBar* theWrappedObject, bool floatable) | ||||
{ | ||||
( theWrappedObject->setFloatable(floatable)); | ||||
} | ||||
void PythonQtWrapper_QToolBar::setMovable(QToolBar* theWrappedObject, bool movable) | ||||
{ | ||||
( theWrappedObject->setMovable(movable)); | ||||
} | ||||
void PythonQtWrapper_QToolBar::setOrientation(QToolBar* theWrappedObject, Qt::Orientation orientation) | ||||
{ | ||||
( theWrappedObject->setOrientation(orientation)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolBar::toggleViewAction(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toggleViewAction()); | ||||
} | ||||
Qt::ToolButtonStyle PythonQtWrapper_QToolBar::toolButtonStyle(QToolBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toolButtonStyle()); | ||||
} | ||||
QWidget* PythonQtWrapper_QToolBar::widgetForAction(QToolBar* theWrappedObject, QAction* action) const | ||||
{ | ||||
return ( theWrappedObject->widgetForAction(action)); | ||||
} | ||||
QToolBarChangeEvent* PythonQtWrapper_QToolBarChangeEvent::new_QToolBarChangeEvent(bool t) | ||||
{ | ||||
return new QToolBarChangeEvent(t); } | ||||
bool PythonQtWrapper_QToolBarChangeEvent::toggle(QToolBarChangeEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toggle()); | ||||
} | ||||
PythonQtShell_QToolBox::~PythonQtShell_QToolBox() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QToolBox::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::changeEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBox::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::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; | ||||
} | ||||
} | ||||
QToolBox::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QToolBox::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::devType(); | ||||
} | ||||
void PythonQtShell_QToolBox::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBox::event(QEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
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 QToolBox::event(e); | ||||
} | ||||
bool PythonQtShell_QToolBox::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 QToolBox::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QToolBox::focusInEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBox::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
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("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QToolBox::focusOutEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::focusOutEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBox::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QToolBox::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBox::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QToolBox::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QToolBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant 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("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::itemInserted(int index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemInserted"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBox::itemInserted(index); | ||||
} | ||||
void PythonQtShell_QToolBox::itemRemoved(int index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemRemoved"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBox::itemRemoved(index); | ||||
} | ||||
void PythonQtShell_QToolBox::keyPressEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QToolBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QToolBox::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QToolBox::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::mouseMoveEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::mousePressEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::mouseReleaseEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolBox::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
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("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::nativeEvent(eventType, message, result); | ||||
} | ||||
QPaintEngine* PythonQtShell_QToolBox::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::paintEngine(); | ||||
} | ||||
void PythonQtShell_QToolBox::paintEvent(QPaintEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::paintEvent(arg__1); | ||||
} | ||||
QPaintDevice* PythonQtShell_QToolBox::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
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("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::redirected(offset); | ||||
} | ||||
void PythonQtShell_QToolBox::resizeEvent(QResizeEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::resizeEvent(arg__1); | ||||
} | ||||
QPainter* PythonQtShell_QToolBox::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolBox::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QToolBox::showEvent(QShowEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolBox::showEvent(e); | ||||
} | ||||
void PythonQtShell_QToolBox::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::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; | ||||
} | ||||
} | ||||
QToolBox::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolBox::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolBox::wheelEvent(arg__1); | ||||
} | ||||
QToolBox* PythonQtWrapper_QToolBox::new_QToolBox(QWidget* parent, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QToolBox(parent, f); } | ||||
int PythonQtWrapper_QToolBox::addItem(QToolBox* theWrappedObject, QWidget* widget, const QIcon& icon, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->addItem(widget, icon, text)); | ||||
} | ||||
int PythonQtWrapper_QToolBox::addItem(QToolBox* theWrappedObject, QWidget* widget, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->addItem(widget, text)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::changeEvent(QToolBox* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QToolBox::count(QToolBox* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
int PythonQtWrapper_QToolBox::currentIndex(QToolBox* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentIndex()); | ||||
} | ||||
QWidget* PythonQtWrapper_QToolBox::currentWidget(QToolBox* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentWidget()); | ||||
} | ||||
bool PythonQtWrapper_QToolBox::event(QToolBox* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
int PythonQtWrapper_QToolBox::indexOf(QToolBox* theWrappedObject, QWidget* widget) const | ||||
{ | ||||
return ( theWrappedObject->indexOf(widget)); | ||||
} | ||||
int PythonQtWrapper_QToolBox::insertItem(QToolBox* theWrappedObject, int index, QWidget* widget, const QIcon& icon, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->insertItem(index, widget, icon, text)); | ||||
} | ||||
int PythonQtWrapper_QToolBox::insertItem(QToolBox* theWrappedObject, int index, QWidget* widget, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->insertItem(index, widget, text)); | ||||
} | ||||
bool PythonQtWrapper_QToolBox::isItemEnabled(QToolBox* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->isItemEnabled(index)); | ||||
} | ||||
QIcon PythonQtWrapper_QToolBox::itemIcon(QToolBox* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->itemIcon(index)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::itemInserted(QToolBox* theWrappedObject, int index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_itemInserted(index)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::itemRemoved(QToolBox* theWrappedObject, int index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_itemRemoved(index)); | ||||
} | ||||
QString PythonQtWrapper_QToolBox::itemText(QToolBox* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->itemText(index)); | ||||
} | ||||
QString PythonQtWrapper_QToolBox::itemToolTip(QToolBox* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->itemToolTip(index)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::removeItem(QToolBox* theWrappedObject, int index) | ||||
{ | ||||
( theWrappedObject->removeItem(index)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::setItemEnabled(QToolBox* theWrappedObject, int index, bool enabled) | ||||
{ | ||||
( theWrappedObject->setItemEnabled(index, enabled)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::setItemIcon(QToolBox* theWrappedObject, int index, const QIcon& icon) | ||||
{ | ||||
( theWrappedObject->setItemIcon(index, icon)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::setItemText(QToolBox* theWrappedObject, int index, const QString& text) | ||||
{ | ||||
( theWrappedObject->setItemText(index, text)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::setItemToolTip(QToolBox* theWrappedObject, int index, const QString& toolTip) | ||||
{ | ||||
( theWrappedObject->setItemToolTip(index, toolTip)); | ||||
} | ||||
void PythonQtWrapper_QToolBox::showEvent(QToolBox* theWrappedObject, QShowEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_showEvent(e)); | ||||
} | ||||
QWidget* PythonQtWrapper_QToolBox::widget(QToolBox* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->widget(index)); | ||||
} | ||||
PythonQtShell_QToolButton::~PythonQtShell_QToolButton() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QToolButton::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::changeEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::checkStateSet() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "checkStateSet"); | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::checkStateSet(); | ||||
} | ||||
void PythonQtShell_QToolButton::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::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; | ||||
} | ||||
} | ||||
QToolButton::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QToolButton::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::devType(); | ||||
} | ||||
void PythonQtShell_QToolButton::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolButton::event(QEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
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 QToolButton::event(e); | ||||
} | ||||
bool PythonQtShell_QToolButton::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 QToolButton::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QToolButton::focusInEvent(QFocusEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::focusInEvent(e); | ||||
} | ||||
bool PythonQtShell_QToolButton::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
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("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QToolButton::focusOutEvent(QFocusEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::focusOutEvent(e); | ||||
} | ||||
bool PythonQtShell_QToolButton::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QToolButton::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::hideEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolButton::hitButton(const QPoint& pos) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hitButton"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QPoint&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&pos}; | ||||
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("hitButton", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::hitButton(pos); | ||||
} | ||||
void PythonQtShell_QToolButton::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QToolButton::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QToolButton::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant 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("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::keyPressEvent(QKeyEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::keyPressEvent(e); | ||||
} | ||||
void PythonQtShell_QToolButton::keyReleaseEvent(QKeyEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::keyReleaseEvent(e); | ||||
} | ||||
void PythonQtShell_QToolButton::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QToolButton::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::mouseMoveEvent(QMouseEvent* e) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QToolButton::mouseMoveEvent(e); | ||||
} | ||||
void PythonQtShell_QToolButton::mousePressEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::mouseReleaseEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QToolButton::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
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("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::nativeEvent(eventType, message, result); | ||||
} | ||||
void PythonQtShell_QToolButton::nextCheckState() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextCheckState"); | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::nextCheckState(); | ||||
} | ||||
QPaintEngine* PythonQtShell_QToolButton::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::paintEngine(); | ||||
} | ||||
void PythonQtShell_QToolButton::paintEvent(QPaintEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::paintEvent(arg__1); | ||||
} | ||||
QPaintDevice* PythonQtShell_QToolButton::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
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("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::redirected(offset); | ||||
} | ||||
void PythonQtShell_QToolButton::resizeEvent(QResizeEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::resizeEvent(arg__1); | ||||
} | ||||
QPainter* PythonQtShell_QToolButton::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QToolButton::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QToolButton::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::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; | ||||
} | ||||
} | ||||
QToolButton::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QToolButton::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QToolButton::wheelEvent(arg__1); | ||||
} | ||||
QToolButton* PythonQtWrapper_QToolButton::new_QToolButton(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QToolButton(parent); } | ||||
void PythonQtWrapper_QToolButton::actionEvent(QToolButton* theWrappedObject, QActionEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_actionEvent(arg__1)); | ||||
} | ||||
Qt::ArrowType PythonQtWrapper_QToolButton::arrowType(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->arrowType()); | ||||
} | ||||
bool PythonQtWrapper_QToolButton::autoRaise(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoRaise()); | ||||
} | ||||
void PythonQtWrapper_QToolButton::changeEvent(QToolButton* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
QAction* PythonQtWrapper_QToolButton::defaultAction(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->defaultAction()); | ||||
} | ||||
void PythonQtWrapper_QToolButton::enterEvent(QToolButton* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_enterEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QToolButton::event(QToolButton* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
bool PythonQtWrapper_QToolButton::hitButton(QToolButton* theWrappedObject, const QPoint& pos) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_hitButton(pos)); | ||||
} | ||||
void PythonQtWrapper_QToolButton::leaveEvent(QToolButton* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_leaveEvent(arg__1)); | ||||
} | ||||
QMenu* PythonQtWrapper_QToolButton::menu(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->menu()); | ||||
} | ||||
QSize PythonQtWrapper_QToolButton::minimumSizeHint(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QToolButton::mousePressEvent(QToolButton* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_mousePressEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QToolButton::mouseReleaseEvent(QToolButton* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QToolButton::nextCheckState(QToolButton* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_nextCheckState()); | ||||
} | ||||
void PythonQtWrapper_QToolButton::paintEvent(QToolButton* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
QToolButton::ToolButtonPopupMode PythonQtWrapper_QToolButton::popupMode(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->popupMode()); | ||||
} | ||||
void PythonQtWrapper_QToolButton::setArrowType(QToolButton* theWrappedObject, Qt::ArrowType type) | ||||
{ | ||||
( theWrappedObject->setArrowType(type)); | ||||
} | ||||
void PythonQtWrapper_QToolButton::setAutoRaise(QToolButton* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setAutoRaise(enable)); | ||||
} | ||||
void PythonQtWrapper_QToolButton::setMenu(QToolButton* theWrappedObject, QMenu* menu) | ||||
{ | ||||
( theWrappedObject->setMenu(menu)); | ||||
} | ||||
void PythonQtWrapper_QToolButton::setPopupMode(QToolButton* theWrappedObject, QToolButton::ToolButtonPopupMode mode) | ||||
{ | ||||
( theWrappedObject->setPopupMode(mode)); | ||||
} | ||||
QSize PythonQtWrapper_QToolButton::sizeHint(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
void PythonQtWrapper_QToolButton::timerEvent(QToolButton* theWrappedObject, QTimerEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_timerEvent(arg__1)); | ||||
} | ||||
Qt::ToolButtonStyle PythonQtWrapper_QToolButton::toolButtonStyle(QToolButton* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toolButtonStyle()); | ||||
} | ||||
QFont PythonQtWrapper_QToolTip::static_QToolTip_font() | ||||
{ | ||||
return (QToolTip::font()); | ||||
} | ||||
void PythonQtWrapper_QToolTip::static_QToolTip_hideText() | ||||
{ | ||||
(QToolTip::hideText()); | ||||
} | ||||
bool PythonQtWrapper_QToolTip::static_QToolTip_isVisible() | ||||
{ | ||||
return (QToolTip::isVisible()); | ||||
} | ||||
QPalette PythonQtWrapper_QToolTip::static_QToolTip_palette() | ||||
{ | ||||
return (QToolTip::palette()); | ||||
} | ||||
void PythonQtWrapper_QToolTip::static_QToolTip_setFont(const QFont& arg__1) | ||||
{ | ||||
(QToolTip::setFont(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QToolTip::static_QToolTip_setPalette(const QPalette& arg__1) | ||||
{ | ||||
(QToolTip::setPalette(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QToolTip::static_QToolTip_showText(const QPoint& pos, const QString& text, QWidget* w) | ||||
{ | ||||
(QToolTip::showText(pos, text, w)); | ||||
} | ||||
void PythonQtWrapper_QToolTip::static_QToolTip_showText(const QPoint& pos, const QString& text, QWidget* w, const QRect& rect) | ||||
{ | ||||
(QToolTip::showText(pos, text, w, rect)); | ||||
} | ||||
QString PythonQtWrapper_QToolTip::static_QToolTip_text() | ||||
{ | ||||
return (QToolTip::text()); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent::setTarget(QTouchEvent* theWrappedObject, QObject* atarget) | ||||
{ | ||||
( theWrappedObject->setTarget(atarget)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent::setTouchPointStates(QTouchEvent* theWrappedObject, Qt::TouchPointStates aTouchPointStates) | ||||
{ | ||||
( theWrappedObject->setTouchPointStates(aTouchPointStates)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent::setTouchPoints(QTouchEvent* theWrappedObject, const QList<QTouchEvent::TouchPoint >& atouchPoints) | ||||
{ | ||||
( theWrappedObject->setTouchPoints(atouchPoints)); | ||||
} | ||||
QObject* PythonQtWrapper_QTouchEvent::target(QTouchEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->target()); | ||||
} | ||||
Qt::TouchPointStates PythonQtWrapper_QTouchEvent::touchPointStates(QTouchEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->touchPointStates()); | ||||
} | ||||
const QList<QTouchEvent::TouchPoint >* PythonQtWrapper_QTouchEvent::touchPoints(QTouchEvent* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->touchPoints()); | ||||
} | ||||
QTouchEvent::TouchPoint* PythonQtWrapper_QTouchEvent_TouchPoint::new_QTouchEvent_TouchPoint(const QTouchEvent::TouchPoint& other) | ||||
{ | ||||
return new QTouchEvent::TouchPoint(other); } | ||||
QTouchEvent::TouchPoint* PythonQtWrapper_QTouchEvent_TouchPoint::new_QTouchEvent_TouchPoint(int id) | ||||
{ | ||||
return new QTouchEvent::TouchPoint(id); } | ||||
int PythonQtWrapper_QTouchEvent_TouchPoint::id(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->id()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastNormalizedPos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastPos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastScenePos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastScenePos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastScreenPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastScreenPos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::normalizedPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->normalizedPos()); | ||||
} | ||||
QTouchEvent::TouchPoint* PythonQtWrapper_QTouchEvent_TouchPoint::operator_assign(QTouchEvent::TouchPoint* theWrappedObject, const QTouchEvent::TouchPoint& other) | ||||
{ | ||||
return &( (*theWrappedObject)= other); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::pos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pos()); | ||||
} | ||||
qreal PythonQtWrapper_QTouchEvent_TouchPoint::pressure(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pressure()); | ||||
} | ||||
QVector<QPointF > PythonQtWrapper_QTouchEvent_TouchPoint::rawScreenPositions(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rawScreenPositions()); | ||||
} | ||||
QRectF PythonQtWrapper_QTouchEvent_TouchPoint::rect(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rect()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::scenePos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->scenePos()); | ||||
} | ||||
QRectF PythonQtWrapper_QTouchEvent_TouchPoint::sceneRect(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sceneRect()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::screenPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->screenPos()); | ||||
} | ||||
QRectF PythonQtWrapper_QTouchEvent_TouchPoint::screenRect(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->screenRect()); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setId(QTouchEvent::TouchPoint* theWrappedObject, int id) | ||||
{ | ||||
( theWrappedObject->setId(id)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastNormalizedPos) | ||||
{ | ||||
( theWrappedObject->setLastNormalizedPos(lastNormalizedPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastPos) | ||||
{ | ||||
( theWrappedObject->setLastPos(lastPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastScenePos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastScenePos) | ||||
{ | ||||
( theWrappedObject->setLastScenePos(lastScenePos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastScreenPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastScreenPos) | ||||
{ | ||||
( theWrappedObject->setLastScreenPos(lastScreenPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& normalizedPos) | ||||
{ | ||||
( theWrappedObject->setNormalizedPos(normalizedPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& pos) | ||||
{ | ||||
( theWrappedObject->setPos(pos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setPressure(QTouchEvent::TouchPoint* theWrappedObject, qreal pressure) | ||||
{ | ||||
( theWrappedObject->setPressure(pressure)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setRawScreenPositions(QTouchEvent::TouchPoint* theWrappedObject, const QVector<QPointF >& positions) | ||||
{ | ||||
( theWrappedObject->setRawScreenPositions(positions)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setRect(QTouchEvent::TouchPoint* theWrappedObject, const QRectF& rect) | ||||
{ | ||||
( theWrappedObject->setRect(rect)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setScenePos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& scenePos) | ||||
{ | ||||
( theWrappedObject->setScenePos(scenePos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setSceneRect(QTouchEvent::TouchPoint* theWrappedObject, const QRectF& sceneRect) | ||||
{ | ||||
( theWrappedObject->setSceneRect(sceneRect)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setScreenPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& screenPos) | ||||
{ | ||||
( theWrappedObject->setScreenPos(screenPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setScreenRect(QTouchEvent::TouchPoint* theWrappedObject, const QRectF& screenRect) | ||||
{ | ||||
( theWrappedObject->setScreenRect(screenRect)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startNormalizedPos) | ||||
{ | ||||
( theWrappedObject->setStartNormalizedPos(startNormalizedPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startPos) | ||||
{ | ||||
( theWrappedObject->setStartPos(startPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartScenePos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startScenePos) | ||||
{ | ||||
( theWrappedObject->setStartScenePos(startScenePos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartScreenPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startScreenPos) | ||||
{ | ||||
( theWrappedObject->setStartScreenPos(startScreenPos)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setState(QTouchEvent::TouchPoint* theWrappedObject, Qt::TouchPointStates state) | ||||
{ | ||||
( theWrappedObject->setState(state)); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::setVelocity(QTouchEvent::TouchPoint* theWrappedObject, const QVector2D& v) | ||||
{ | ||||
( theWrappedObject->setVelocity(v)); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->startNormalizedPos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->startPos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startScenePos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->startScenePos()); | ||||
} | ||||
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startScreenPos(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->startScreenPos()); | ||||
} | ||||
Qt::TouchPointState PythonQtWrapper_QTouchEvent_TouchPoint::state(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->state()); | ||||
} | ||||
void PythonQtWrapper_QTouchEvent_TouchPoint::swap(QTouchEvent::TouchPoint* theWrappedObject, QTouchEvent::TouchPoint& other) | ||||
{ | ||||
( theWrappedObject->swap(other)); | ||||
} | ||||
QVector2D PythonQtWrapper_QTouchEvent_TouchPoint::velocity(QTouchEvent::TouchPoint* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->velocity()); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::new_QTransform() | ||||
{ | ||||
return new QTransform(); } | ||||
QTransform* PythonQtWrapper_QTransform::new_QTransform(const QMatrix& mtx) | ||||
{ | ||||
return new QTransform(mtx); } | ||||
QTransform* PythonQtWrapper_QTransform::new_QTransform(qreal h11, qreal h12, qreal h13, qreal h21, qreal h22, qreal h23, qreal h31, qreal h32, qreal h33) | ||||
{ | ||||
return new QTransform(h11, h12, h13, h21, h22, h23, h31, h32, h33); } | ||||
QTransform* PythonQtWrapper_QTransform::new_QTransform(qreal h11, qreal h12, qreal h21, qreal h22, qreal dx, qreal dy) | ||||
{ | ||||
return new QTransform(h11, h12, h21, h22, dx, dy); } | ||||
QTransform PythonQtWrapper_QTransform::adjoint(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->adjoint()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::det(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->det()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::determinant(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->determinant()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::dx(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->dx()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::dy(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->dy()); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::static_QTransform_fromScale(qreal dx, qreal dy) | ||||
{ | ||||
return (QTransform::fromScale(dx, dy)); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::static_QTransform_fromTranslate(qreal dx, qreal dy) | ||||
{ | ||||
return (QTransform::fromTranslate(dx, dy)); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::inverted(QTransform* theWrappedObject, bool* invertible) const | ||||
{ | ||||
return ( theWrappedObject->inverted(invertible)); | ||||
} | ||||
bool PythonQtWrapper_QTransform::isAffine(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isAffine()); | ||||
} | ||||
bool PythonQtWrapper_QTransform::isIdentity(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isIdentity()); | ||||
} | ||||
bool PythonQtWrapper_QTransform::isInvertible(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isInvertible()); | ||||
} | ||||
bool PythonQtWrapper_QTransform::isRotating(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isRotating()); | ||||
} | ||||
bool PythonQtWrapper_QTransform::isScaling(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isScaling()); | ||||
} | ||||
bool PythonQtWrapper_QTransform::isTranslating(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isTranslating()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m11(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m11()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m12(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m12()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m13(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m13()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m21(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m21()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m22(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m22()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m23(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m23()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m31(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m31()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m32(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m32()); | ||||
} | ||||
qreal PythonQtWrapper_QTransform::m33(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->m33()); | ||||
} | ||||
QLine PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QLine& l) const | ||||
{ | ||||
return ( theWrappedObject->map(l)); | ||||
} | ||||
QLineF PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QLineF& l) const | ||||
{ | ||||
return ( theWrappedObject->map(l)); | ||||
} | ||||
QPainterPath PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPainterPath& p) const | ||||
{ | ||||
return ( theWrappedObject->map(p)); | ||||
} | ||||
QPoint PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPoint& p) const | ||||
{ | ||||
return ( theWrappedObject->map(p)); | ||||
} | ||||
QPointF PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPointF& p) const | ||||
{ | ||||
return ( theWrappedObject->map(p)); | ||||
} | ||||
QPolygon PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPolygon& a) const | ||||
{ | ||||
return ( theWrappedObject->map(a)); | ||||
} | ||||
QPolygonF PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPolygonF& a) const | ||||
{ | ||||
return ( theWrappedObject->map(a)); | ||||
} | ||||
QRegion PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QRegion& r) const | ||||
{ | ||||
return ( theWrappedObject->map(r)); | ||||
} | ||||
QRect PythonQtWrapper_QTransform::mapRect(QTransform* theWrappedObject, const QRect& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->mapRect(arg__1)); | ||||
} | ||||
QRectF PythonQtWrapper_QTransform::mapRect(QTransform* theWrappedObject, const QRectF& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->mapRect(arg__1)); | ||||
} | ||||
QPolygon PythonQtWrapper_QTransform::mapToPolygon(QTransform* theWrappedObject, const QRect& r) const | ||||
{ | ||||
return ( theWrappedObject->mapToPolygon(r)); | ||||
} | ||||
bool PythonQtWrapper_QTransform::__ne__(QTransform* theWrappedObject, const QTransform& arg__1) const | ||||
{ | ||||
return ( (*theWrappedObject)!= arg__1); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::multiplied(QTransform* theWrappedObject, const QTransform& o) const | ||||
{ | ||||
return ( (*theWrappedObject)* o); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::__mul__(QTransform* theWrappedObject, qreal n) | ||||
{ | ||||
return ( (*theWrappedObject)* n); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::__imul__(QTransform* theWrappedObject, const QTransform& arg__1) | ||||
{ | ||||
return &( (*theWrappedObject)*= arg__1); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::__imul__(QTransform* theWrappedObject, qreal div) | ||||
{ | ||||
return &( (*theWrappedObject)*= div); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::__add__(QTransform* theWrappedObject, qreal n) | ||||
{ | ||||
return ( (*theWrappedObject)+ n); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::__iadd__(QTransform* theWrappedObject, qreal div) | ||||
{ | ||||
return &( (*theWrappedObject)+= div); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::__sub__(QTransform* theWrappedObject, qreal n) | ||||
{ | ||||
return ( (*theWrappedObject)- n); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::__isub__(QTransform* theWrappedObject, qreal div) | ||||
{ | ||||
return &( (*theWrappedObject)-= div); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::__div__(QTransform* theWrappedObject, qreal n) | ||||
{ | ||||
return ( (*theWrappedObject)/ n); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::__idiv__(QTransform* theWrappedObject, qreal div) | ||||
{ | ||||
return &( (*theWrappedObject)/= div); | ||||
} | ||||
bool PythonQtWrapper_QTransform::__eq__(QTransform* theWrappedObject, const QTransform& arg__1) const | ||||
{ | ||||
return ( (*theWrappedObject)== arg__1); | ||||
} | ||||
bool PythonQtWrapper_QTransform::static_QTransform_quadToQuad(const QPolygonF& one, const QPolygonF& two, QTransform& result) | ||||
{ | ||||
return (QTransform::quadToQuad(one, two, result)); | ||||
} | ||||
bool PythonQtWrapper_QTransform::static_QTransform_quadToSquare(const QPolygonF& quad, QTransform& result) | ||||
{ | ||||
return (QTransform::quadToSquare(quad, result)); | ||||
} | ||||
void PythonQtWrapper_QTransform::reset(QTransform* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->reset()); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::rotate(QTransform* theWrappedObject, qreal a, Qt::Axis axis) | ||||
{ | ||||
return &( theWrappedObject->rotate(a, axis)); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::rotateRadians(QTransform* theWrappedObject, qreal a, Qt::Axis axis) | ||||
{ | ||||
return &( theWrappedObject->rotateRadians(a, axis)); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::scale(QTransform* theWrappedObject, qreal sx, qreal sy) | ||||
{ | ||||
return &( theWrappedObject->scale(sx, sy)); | ||||
} | ||||
void PythonQtWrapper_QTransform::setMatrix(QTransform* theWrappedObject, qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33) | ||||
{ | ||||
( theWrappedObject->setMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33)); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::shear(QTransform* theWrappedObject, qreal sh, qreal sv) | ||||
{ | ||||
return &( theWrappedObject->shear(sh, sv)); | ||||
} | ||||
bool PythonQtWrapper_QTransform::static_QTransform_squareToQuad(const QPolygonF& square, QTransform& result) | ||||
{ | ||||
return (QTransform::squareToQuad(square, result)); | ||||
} | ||||
const QMatrix* PythonQtWrapper_QTransform::toAffine(QTransform* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->toAffine()); | ||||
} | ||||
QTransform* PythonQtWrapper_QTransform::translate(QTransform* theWrappedObject, qreal dx, qreal dy) | ||||
{ | ||||
return &( theWrappedObject->translate(dx, dy)); | ||||
} | ||||
QTransform PythonQtWrapper_QTransform::transposed(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->transposed()); | ||||
} | ||||
QTransform::TransformationType PythonQtWrapper_QTransform::type(QTransform* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->type()); | ||||
} | ||||
QString PythonQtWrapper_QTransform::py_toString(QTransform* obj) { | ||||
QString result; | ||||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
PythonQtShell_QTreeView::~PythonQtShell_QTreeView() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTreeView::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::changeEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEditor"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "QAbstractItemDelegate::EndEditHint"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&editor, (void*)&hint}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::closeEditor(editor, hint); | ||||
} | ||||
void PythonQtShell_QTreeView::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::commitData(QWidget* editor) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "commitData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&editor}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::commitData(editor); | ||||
} | ||||
void PythonQtShell_QTreeView::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::currentChanged(const QModelIndex& current, const QModelIndex& previous) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "currentChanged"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)¤t, (void*)&previous}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::currentChanged(current, previous); | ||||
} | ||||
void PythonQtShell_QTreeView::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; | ||||
} | ||||
} | ||||
QTreeView::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dataChanged"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&" , "const QVector<int >&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&topLeft, (void*)&bottomRight, (void*)&roles}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::dataChanged(topLeft, bottomRight, roles); | ||||
} | ||||
int PythonQtShell_QTreeView::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::devType(); | ||||
} | ||||
void PythonQtShell_QTreeView::doItemsLayout() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doItemsLayout"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::doItemsLayout(); | ||||
} | ||||
void PythonQtShell_QTreeView::dragEnterEvent(QDragEnterEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::dragEnterEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::dragLeaveEvent(QDragLeaveEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::dragLeaveEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::dragMoveEvent(QDragMoveEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::dragMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::drawBranches(QPainter* painter, const QRect& rect, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawBranches"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QRect&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&painter, (void*)&rect, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::drawBranches(painter, rect, index); | ||||
} | ||||
void PythonQtShell_QTreeView::drawRow(QPainter* painter, const QStyleOptionViewItem& options, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawRow"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&painter, (void*)&options, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::drawRow(painter, options, index); | ||||
} | ||||
void PythonQtShell_QTreeView::dropEvent(QDropEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::dropEvent(event); | ||||
} | ||||
bool PythonQtShell_QTreeView::edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "edit"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "QAbstractItemView::EditTrigger" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&index, (void*)&trigger, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("edit", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::edit(index, trigger, event); | ||||
} | ||||
void PythonQtShell_QTreeView::editorDestroyed(QObject* editor) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "editorDestroyed"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QObject*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&editor}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::editorDestroyed(editor); | ||||
} | ||||
void PythonQtShell_QTreeView::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTreeView::event(QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::event(event); | ||||
} | ||||
bool PythonQtShell_QTreeView::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 QTreeView::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTreeView::focusInEvent(QFocusEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::focusInEvent(event); | ||||
} | ||||
bool PythonQtShell_QTreeView::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
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("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTreeView::focusOutEvent(QFocusEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::focusOutEvent(event); | ||||
} | ||||
bool PythonQtShell_QTreeView::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QTreeView::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::hideEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTreeView::horizontalOffset() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalOffset"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("horizontalOffset", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::horizontalOffset(); | ||||
} | ||||
void PythonQtShell_QTreeView::horizontalScrollbarAction(int action) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarAction"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&action}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::horizontalScrollbarAction(action); | ||||
} | ||||
void PythonQtShell_QTreeView::horizontalScrollbarValueChanged(int value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarValueChanged"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::horizontalScrollbarValueChanged(value); | ||||
} | ||||
QModelIndex PythonQtShell_QTreeView::indexAt(const QPoint& p) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "indexAt"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QModelIndex" , "const QPoint&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QModelIndex returnValue; | ||||
void* args[2] = {NULL, (void*)&p}; | ||||
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("indexAt", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QModelIndex*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::indexAt(p); | ||||
} | ||||
void PythonQtShell_QTreeView::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QTreeView::inputMethodEvent(QInputMethodEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::inputMethodEvent(event); | ||||
} | ||||
QVariant PythonQtShell_QTreeView::inputMethodQuery(Qt::InputMethodQuery query) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant returnValue; | ||||
void* args[2] = {NULL, (void*)&query}; | ||||
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("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::inputMethodQuery(query); | ||||
} | ||||
bool PythonQtShell_QTreeView::isIndexHidden(const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isIndexHidden"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&index}; | ||||
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("isIndexHidden", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::isIndexHidden(index); | ||||
} | ||||
void PythonQtShell_QTreeView::keyPressEvent(QKeyEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::keyPressEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::keyboardSearch(const QString& search) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyboardSearch"); | ||||
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*)&search}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::keyboardSearch(search); | ||||
} | ||||
void PythonQtShell_QTreeView::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTreeView::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int 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("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::mouseDoubleClickEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::mouseDoubleClickEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::mouseMoveEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::mouseMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::mousePressEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::mousePressEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::mouseReleaseEvent(QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::mouseReleaseEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTreeView::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
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("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::nativeEvent(eventType, message, result); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTreeView::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTreeView::paintEvent(QPaintEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::paintEvent(event); | ||||
} | ||||
QPaintDevice* PythonQtShell_QTreeView::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
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("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::redirected(offset); | ||||
} | ||||
void PythonQtShell_QTreeView::reset() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::reset(); | ||||
} | ||||
void PythonQtShell_QTreeView::resizeEvent(QResizeEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::resizeEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsAboutToBeRemoved"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::rowsAboutToBeRemoved(parent, start, end); | ||||
} | ||||
void PythonQtShell_QTreeView::rowsInserted(const QModelIndex& parent, int start, int end) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsInserted"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::rowsInserted(parent, start, end); | ||||
} | ||||
void PythonQtShell_QTreeView::scrollContentsBy(int dx, int dy) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&dx, (void*)&dy}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::scrollContentsBy(dx, dy); | ||||
} | ||||
void PythonQtShell_QTreeView::scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollTo"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&" , "QAbstractItemView::ScrollHint"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&index, (void*)&hint}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::scrollTo(index, hint); | ||||
} | ||||
void PythonQtShell_QTreeView::selectAll() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectAll"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::selectAll(); | ||||
} | ||||
QList<QModelIndex > PythonQtShell_QTreeView::selectedIndexes() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectedIndexes"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QList<QModelIndex >"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QList<QModelIndex > returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectedIndexes", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QModelIndex >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::selectedIndexes(); | ||||
} | ||||
void PythonQtShell_QTreeView::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionChanged"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QItemSelection&" , "const QItemSelection&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&selected, (void*)&deselected}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::selectionChanged(selected, deselected); | ||||
} | ||||
QItemSelectionModel::SelectionFlags PythonQtShell_QTreeView::selectionCommand(const QModelIndex& index, const QEvent* event) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionCommand"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QItemSelectionModel::SelectionFlags" , "const QModelIndex&" , "const QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QItemSelectionModel::SelectionFlags returnValue; | ||||
void* args[3] = {NULL, (void*)&index, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectionCommand", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QItemSelectionModel::SelectionFlags*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::selectionCommand(index, event); | ||||
} | ||||
void PythonQtShell_QTreeView::setModel(QAbstractItemModel* model) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setModel"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QAbstractItemModel*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&model}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::setModel(model); | ||||
} | ||||
void PythonQtShell_QTreeView::setRootIndex(const QModelIndex& index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setRootIndex"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::setRootIndex(index); | ||||
} | ||||
void PythonQtShell_QTreeView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelection"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QRect&" , "QItemSelectionModel::SelectionFlags"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&rect, (void*)&command}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::setSelection(rect, command); | ||||
} | ||||
void PythonQtShell_QTreeView::setSelectionModel(QItemSelectionModel* selectionModel) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelectionModel"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QItemSelectionModel*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionModel}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::setSelectionModel(selectionModel); | ||||
} | ||||
void PythonQtShell_QTreeView::setupViewport(QWidget* viewport) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&viewport}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::setupViewport(viewport); | ||||
} | ||||
QPainter* PythonQtShell_QTreeView::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QTreeView::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::showEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTreeView::sizeHintForColumn(int column) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForColumn"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int returnValue; | ||||
void* args[2] = {NULL, (void*)&column}; | ||||
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("sizeHintForColumn", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::sizeHintForColumn(column); | ||||
} | ||||
int PythonQtShell_QTreeView::sizeHintForRow(int row) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForRow"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int returnValue; | ||||
void* args[2] = {NULL, (void*)&row}; | ||||
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("sizeHintForRow", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::sizeHintForRow(row); | ||||
} | ||||
void PythonQtShell_QTreeView::startDrag(Qt::DropActions supportedActions) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDrag"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "Qt::DropActions"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&supportedActions}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::startDrag(supportedActions); | ||||
} | ||||
void PythonQtShell_QTreeView::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTreeView::timerEvent(QTimerEvent* event) | ||||
{ | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::timerEvent(event); | ||||
} | ||||
void PythonQtShell_QTreeView::updateEditorData() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorData"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::updateEditorData(); | ||||
} | ||||
void PythonQtShell_QTreeView::updateEditorGeometries() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorGeometries"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::updateEditorGeometries(); | ||||
} | ||||
void PythonQtShell_QTreeView::updateGeometries() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateGeometries"); | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::updateGeometries(); | ||||
} | ||||
int PythonQtShell_QTreeView::verticalOffset() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalOffset"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("verticalOffset", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::verticalOffset(); | ||||
} | ||||
void PythonQtShell_QTreeView::verticalScrollbarAction(int action) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarAction"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&action}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::verticalScrollbarAction(action); | ||||
} | ||||
void PythonQtShell_QTreeView::verticalScrollbarValueChanged(int value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarValueChanged"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&value}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTreeView::verticalScrollbarValueChanged(value); | ||||
} | ||||
QStyleOptionViewItem PythonQtShell_QTreeView::viewOptions() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewOptions"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QStyleOptionViewItem"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QStyleOptionViewItem returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("viewOptions", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStyleOptionViewItem*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::viewOptions(); | ||||
} | ||||
bool PythonQtShell_QTreeView::viewportEvent(QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::viewportEvent(event); | ||||
} | ||||
QSize PythonQtShell_QTreeView::viewportSizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::viewportSizeHint(); | ||||
} | ||||
QRect PythonQtShell_QTreeView::visualRect(const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRect"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QRect" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QRect returnValue; | ||||
void* args[2] = {NULL, (void*)&index}; | ||||
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("visualRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::visualRect(index); | ||||
} | ||||
QRegion PythonQtShell_QTreeView::visualRegionForSelection(const QItemSelection& selection) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRegionForSelection"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QRegion" , "const QItemSelection&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QRegion returnValue; | ||||
void* args[2] = {NULL, (void*)&selection}; | ||||
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("visualRegionForSelection", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRegion*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTreeView::visualRegionForSelection(selection); | ||||
} | ||||
void PythonQtShell_QTreeView::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
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; | ||||
} | ||||
} | ||||
QTreeView::wheelEvent(arg__1); | ||||
} | ||||
QTreeView* PythonQtWrapper_QTreeView::new_QTreeView(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTreeView(parent); } | ||||
bool PythonQtWrapper_QTreeView::allColumnsShowFocus(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->allColumnsShowFocus()); | ||||
} | ||||
int PythonQtWrapper_QTreeView::autoExpandDelay(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoExpandDelay()); | ||||
} | ||||
int PythonQtWrapper_QTreeView::columnAt(QTreeView* theWrappedObject, int x) const | ||||
{ | ||||
return ( theWrappedObject->columnAt(x)); | ||||
} | ||||
int PythonQtWrapper_QTreeView::columnViewportPosition(QTreeView* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->columnViewportPosition(column)); | ||||
} | ||||
int PythonQtWrapper_QTreeView::columnWidth(QTreeView* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->columnWidth(column)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::currentChanged(QTreeView* theWrappedObject, const QModelIndex& current, const QModelIndex& previous) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_currentChanged(current, previous)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::dataChanged(QTreeView* theWrappedObject, const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_dataChanged(topLeft, bottomRight, roles)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::doItemsLayout(QTreeView* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_doItemsLayout()); | ||||
} | ||||
void PythonQtWrapper_QTreeView::dragMoveEvent(QTreeView* theWrappedObject, QDragMoveEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_dragMoveEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::drawBranches(QTreeView* theWrappedObject, QPainter* painter, const QRect& rect, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_drawBranches(painter, rect, index)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::drawRow(QTreeView* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& options, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_drawRow(painter, options, index)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::expandsOnDoubleClick(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->expandsOnDoubleClick()); | ||||
} | ||||
QHeaderView* PythonQtWrapper_QTreeView::header(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->header()); | ||||
} | ||||
int PythonQtWrapper_QTreeView::horizontalOffset(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_horizontalOffset()); | ||||
} | ||||
void PythonQtWrapper_QTreeView::horizontalScrollbarAction(QTreeView* theWrappedObject, int action) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_horizontalScrollbarAction(action)); | ||||
} | ||||
int PythonQtWrapper_QTreeView::indentation(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indentation()); | ||||
} | ||||
QModelIndex PythonQtWrapper_QTreeView::indexAbove(QTreeView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( theWrappedObject->indexAbove(index)); | ||||
} | ||||
QModelIndex PythonQtWrapper_QTreeView::indexAt(QTreeView* theWrappedObject, const QPoint& p) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_indexAt(p)); | ||||
} | ||||
QModelIndex PythonQtWrapper_QTreeView::indexBelow(QTreeView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( theWrappedObject->indexBelow(index)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isAnimated(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isAnimated()); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isColumnHidden(QTreeView* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->isColumnHidden(column)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isExpanded(QTreeView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( theWrappedObject->isExpanded(index)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isFirstColumnSpanned(QTreeView* theWrappedObject, int row, const QModelIndex& parent) const | ||||
{ | ||||
return ( theWrappedObject->isFirstColumnSpanned(row, parent)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isHeaderHidden(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isHeaderHidden()); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isIndexHidden(QTreeView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_isIndexHidden(index)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isRowHidden(QTreeView* theWrappedObject, int row, const QModelIndex& parent) const | ||||
{ | ||||
return ( theWrappedObject->isRowHidden(row, parent)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::isSortingEnabled(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSortingEnabled()); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::itemsExpandable(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->itemsExpandable()); | ||||
} | ||||
void PythonQtWrapper_QTreeView::keyPressEvent(QTreeView* theWrappedObject, QKeyEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_keyPressEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::keyboardSearch(QTreeView* theWrappedObject, const QString& search) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_keyboardSearch(search)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::mouseDoubleClickEvent(QTreeView* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mouseDoubleClickEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::mouseMoveEvent(QTreeView* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mouseMoveEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::mousePressEvent(QTreeView* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mousePressEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::mouseReleaseEvent(QTreeView* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mouseReleaseEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::paintEvent(QTreeView* theWrappedObject, QPaintEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_paintEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::reset(QTreeView* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_reset()); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::rootIsDecorated(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rootIsDecorated()); | ||||
} | ||||
void PythonQtWrapper_QTreeView::rowsAboutToBeRemoved(QTreeView* theWrappedObject, const QModelIndex& parent, int start, int end) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_rowsAboutToBeRemoved(parent, start, end)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::rowsInserted(QTreeView* theWrappedObject, const QModelIndex& parent, int start, int end) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_rowsInserted(parent, start, end)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::scrollContentsBy(QTreeView* theWrappedObject, int dx, int dy) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_scrollContentsBy(dx, dy)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::scrollTo(QTreeView* theWrappedObject, const QModelIndex& index, QAbstractItemView::ScrollHint hint) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_scrollTo(index, hint)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::selectAll(QTreeView* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_selectAll()); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QTreeView::selectedIndexes(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_selectedIndexes()); | ||||
} | ||||
void PythonQtWrapper_QTreeView::selectionChanged(QTreeView* theWrappedObject, const QItemSelection& selected, const QItemSelection& deselected) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_selectionChanged(selected, deselected)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setAllColumnsShowFocus(QTreeView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setAllColumnsShowFocus(enable)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setAnimated(QTreeView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setAnimated(enable)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setAutoExpandDelay(QTreeView* theWrappedObject, int delay) | ||||
{ | ||||
( theWrappedObject->setAutoExpandDelay(delay)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setColumnHidden(QTreeView* theWrappedObject, int column, bool hide) | ||||
{ | ||||
( theWrappedObject->setColumnHidden(column, hide)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setColumnWidth(QTreeView* theWrappedObject, int column, int width) | ||||
{ | ||||
( theWrappedObject->setColumnWidth(column, width)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setExpanded(QTreeView* theWrappedObject, const QModelIndex& index, bool expand) | ||||
{ | ||||
( theWrappedObject->setExpanded(index, expand)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setExpandsOnDoubleClick(QTreeView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setExpandsOnDoubleClick(enable)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setFirstColumnSpanned(QTreeView* theWrappedObject, int row, const QModelIndex& parent, bool span) | ||||
{ | ||||
( theWrappedObject->setFirstColumnSpanned(row, parent, span)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setHeader(QTreeView* theWrappedObject, QHeaderView* header) | ||||
{ | ||||
( theWrappedObject->setHeader(header)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setHeaderHidden(QTreeView* theWrappedObject, bool hide) | ||||
{ | ||||
( theWrappedObject->setHeaderHidden(hide)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setIndentation(QTreeView* theWrappedObject, int i) | ||||
{ | ||||
( theWrappedObject->setIndentation(i)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setItemsExpandable(QTreeView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setItemsExpandable(enable)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setModel(QTreeView* theWrappedObject, QAbstractItemModel* model) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setModel(model)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setRootIndex(QTreeView* theWrappedObject, const QModelIndex& index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setRootIndex(index)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setRootIsDecorated(QTreeView* theWrappedObject, bool show) | ||||
{ | ||||
( theWrappedObject->setRootIsDecorated(show)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setRowHidden(QTreeView* theWrappedObject, int row, const QModelIndex& parent, bool hide) | ||||
{ | ||||
( theWrappedObject->setRowHidden(row, parent, hide)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setSelection(QTreeView* theWrappedObject, const QRect& rect, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setSelection(rect, command)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setSelectionModel(QTreeView* theWrappedObject, QItemSelectionModel* selectionModel) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setSelectionModel(selectionModel)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setSortingEnabled(QTreeView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setSortingEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setUniformRowHeights(QTreeView* theWrappedObject, bool uniform) | ||||
{ | ||||
( theWrappedObject->setUniformRowHeights(uniform)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::setWordWrap(QTreeView* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setWordWrap(on)); | ||||
} | ||||
int PythonQtWrapper_QTreeView::sizeHintForColumn(QTreeView* theWrappedObject, int column) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_sizeHintForColumn(column)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::sortByColumn(QTreeView* theWrappedObject, int column, Qt::SortOrder order) | ||||
{ | ||||
( theWrappedObject->sortByColumn(column, order)); | ||||
} | ||||
void PythonQtWrapper_QTreeView::timerEvent(QTreeView* theWrappedObject, QTimerEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_timerEvent(event)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::uniformRowHeights(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->uniformRowHeights()); | ||||
} | ||||
void PythonQtWrapper_QTreeView::updateGeometries(QTreeView* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_updateGeometries()); | ||||
} | ||||
int PythonQtWrapper_QTreeView::verticalOffset(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_verticalOffset()); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::viewportEvent(QTreeView* theWrappedObject, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_viewportEvent(event)); | ||||
} | ||||
QRect PythonQtWrapper_QTreeView::visualRect(QTreeView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_visualRect(index)); | ||||
} | ||||
QRegion PythonQtWrapper_QTreeView::visualRegionForSelection(QTreeView* theWrappedObject, const QItemSelection& selection) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_visualRegionForSelection(selection)); | ||||
} | ||||
bool PythonQtWrapper_QTreeView::wordWrap(QTreeView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->wordWrap()); | ||||
} | ||||