com_trolltech_qt_gui8.cpp
7900 lines
| 287.1 KiB
| text/x-c
|
CppLexer
florianlink
|
r200 | #include "com_trolltech_qt_gui8.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QIcon> | ||||
#include <QTextBlock> | ||||
#include <QVariant> | ||||
#include <qabstractitemdelegate.h> | ||||
#include <qabstractitemmodel.h> | ||||
#include <qabstractitemview.h> | ||||
#include <qaction.h> | ||||
#include <qbitmap.h> | ||||
#include <qbrush.h> | ||||
#include <qbytearray.h> | ||||
#include <qcolor.h> | ||||
#include <qcoreevent.h> | ||||
#include <qcursor.h> | ||||
#include <qdatastream.h> | ||||
#include <qevent.h> | ||||
#include <qfont.h> | ||||
#include <qgraphicseffect.h> | ||||
#include <qgraphicsproxywidget.h> | ||||
#include <qheaderview.h> | ||||
#include <qicon.h> | ||||
#include <qimage.h> | ||||
#include <qinputcontext.h> | ||||
#include <qitemeditorfactory.h> | ||||
#include <qitemselectionmodel.h> | ||||
#include <qkeysequence.h> | ||||
#include <qlayout.h> | ||||
#include <qline.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 <qpicture.h> | ||||
#include <qpixmap.h> | ||||
#include <qpoint.h> | ||||
#include <qpolygon.h> | ||||
#include <qrect.h> | ||||
#include <qregion.h> | ||||
#include <qscrollbar.h> | ||||
#include <qsize.h> | ||||
#include <qsizepolicy.h> | ||||
#include <qstringlist.h> | ||||
#include <qstyle.h> | ||||
#include <qstyleditemdelegate.h> | ||||
#include <qstyleoption.h> | ||||
#include <qstylepainter.h> | ||||
#include <qsyntaxhighlighter.h> | ||||
#include <qsystemtrayicon.h> | ||||
#include <qtabbar.h> | ||||
#include <qtableview.h> | ||||
#include <qtablewidget.h> | ||||
#include <qtabwidget.h> | ||||
#include <qtextdocument.h> | ||||
#include <qtextedit.h> | ||||
#include <qtextformat.h> | ||||
#include <qtextlayout.h> | ||||
#include <qtextlist.h> | ||||
#include <qtextobject.h> | ||||
#include <qtransform.h> | ||||
#include <qvector.h> | ||||
#include <qwidget.h> | ||||
QStyleOptionTab* PythonQtWrapper_QStyleOptionTab::new_QStyleOptionTab() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTab(); } | ||||
QStyleOptionTab* PythonQtWrapper_QStyleOptionTab::new_QStyleOptionTab(const QStyleOptionTab& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTab(other); } | ||||
QStyleOptionTabBarBase* PythonQtWrapper_QStyleOptionTabBarBase::new_QStyleOptionTabBarBase() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabBarBase(); } | ||||
QStyleOptionTabBarBase* PythonQtWrapper_QStyleOptionTabBarBase::new_QStyleOptionTabBarBase(const QStyleOptionTabBarBase& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabBarBase(other); } | ||||
QStyleOptionTabBarBaseV2* PythonQtWrapper_QStyleOptionTabBarBaseV2::new_QStyleOptionTabBarBaseV2() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabBarBaseV2(); } | ||||
QStyleOptionTabBarBaseV2* PythonQtWrapper_QStyleOptionTabBarBaseV2::new_QStyleOptionTabBarBaseV2(const QStyleOptionTabBarBase& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabBarBaseV2(other); } | ||||
QStyleOptionTabBarBaseV2* PythonQtWrapper_QStyleOptionTabBarBaseV2::new_QStyleOptionTabBarBaseV2(const QStyleOptionTabBarBaseV2& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabBarBaseV2(other); } | ||||
QStyleOptionTabV2* PythonQtWrapper_QStyleOptionTabV2::new_QStyleOptionTabV2() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV2(); } | ||||
QStyleOptionTabV2* PythonQtWrapper_QStyleOptionTabV2::new_QStyleOptionTabV2(const QStyleOptionTab& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV2(other); } | ||||
QStyleOptionTabV2* PythonQtWrapper_QStyleOptionTabV2::new_QStyleOptionTabV2(const QStyleOptionTabV2& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV2(other); } | ||||
QStyleOptionTabV3* PythonQtWrapper_QStyleOptionTabV3::new_QStyleOptionTabV3() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV3(); } | ||||
QStyleOptionTabV3* PythonQtWrapper_QStyleOptionTabV3::new_QStyleOptionTabV3(const QStyleOptionTab& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV3(other); } | ||||
QStyleOptionTabV3* PythonQtWrapper_QStyleOptionTabV3::new_QStyleOptionTabV3(const QStyleOptionTabV2& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV3(other); } | ||||
QStyleOptionTabV3* PythonQtWrapper_QStyleOptionTabV3::new_QStyleOptionTabV3(const QStyleOptionTabV3& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabV3(other); } | ||||
QStyleOptionTabWidgetFrame* PythonQtWrapper_QStyleOptionTabWidgetFrame::new_QStyleOptionTabWidgetFrame() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabWidgetFrame(); } | ||||
QStyleOptionTabWidgetFrame* PythonQtWrapper_QStyleOptionTabWidgetFrame::new_QStyleOptionTabWidgetFrame(const QStyleOptionTabWidgetFrame& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTabWidgetFrame(other); } | ||||
QStyleOptionTitleBar* PythonQtWrapper_QStyleOptionTitleBar::new_QStyleOptionTitleBar() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTitleBar(); } | ||||
QStyleOptionTitleBar* PythonQtWrapper_QStyleOptionTitleBar::new_QStyleOptionTitleBar(const QStyleOptionTitleBar& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionTitleBar(other); } | ||||
QStyleOptionToolBar* PythonQtWrapper_QStyleOptionToolBar::new_QStyleOptionToolBar() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBar(); } | ||||
QStyleOptionToolBar* PythonQtWrapper_QStyleOptionToolBar::new_QStyleOptionToolBar(const QStyleOptionToolBar& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBar(other); } | ||||
QStyleOptionToolBox* PythonQtWrapper_QStyleOptionToolBox::new_QStyleOptionToolBox() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBox(); } | ||||
QStyleOptionToolBox* PythonQtWrapper_QStyleOptionToolBox::new_QStyleOptionToolBox(const QStyleOptionToolBox& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBox(other); } | ||||
QStyleOptionToolBoxV2* PythonQtWrapper_QStyleOptionToolBoxV2::new_QStyleOptionToolBoxV2() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBoxV2(); } | ||||
QStyleOptionToolBoxV2* PythonQtWrapper_QStyleOptionToolBoxV2::new_QStyleOptionToolBoxV2(const QStyleOptionToolBox& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBoxV2(other); } | ||||
QStyleOptionToolBoxV2* PythonQtWrapper_QStyleOptionToolBoxV2::new_QStyleOptionToolBoxV2(const QStyleOptionToolBoxV2& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolBoxV2(other); } | ||||
QStyleOptionToolButton* PythonQtWrapper_QStyleOptionToolButton::new_QStyleOptionToolButton() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolButton(); } | ||||
QStyleOptionToolButton* PythonQtWrapper_QStyleOptionToolButton::new_QStyleOptionToolButton(const QStyleOptionToolButton& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionToolButton(other); } | ||||
QStyleOptionViewItem* PythonQtWrapper_QStyleOptionViewItem::new_QStyleOptionViewItem() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItem(); } | ||||
QStyleOptionViewItem* PythonQtWrapper_QStyleOptionViewItem::new_QStyleOptionViewItem(const QStyleOptionViewItem& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItem(other); } | ||||
QStyleOptionViewItemV2* PythonQtWrapper_QStyleOptionViewItemV2::new_QStyleOptionViewItemV2() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV2(); } | ||||
QStyleOptionViewItemV2* PythonQtWrapper_QStyleOptionViewItemV2::new_QStyleOptionViewItemV2(const QStyleOptionViewItem& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV2(other); } | ||||
QStyleOptionViewItemV2* PythonQtWrapper_QStyleOptionViewItemV2::new_QStyleOptionViewItemV2(const QStyleOptionViewItemV2& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV2(other); } | ||||
QStyleOptionViewItemV3* PythonQtWrapper_QStyleOptionViewItemV3::new_QStyleOptionViewItemV3() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV3(); } | ||||
QStyleOptionViewItemV3* PythonQtWrapper_QStyleOptionViewItemV3::new_QStyleOptionViewItemV3(const QStyleOptionViewItem& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV3(other); } | ||||
QStyleOptionViewItemV3* PythonQtWrapper_QStyleOptionViewItemV3::new_QStyleOptionViewItemV3(const QStyleOptionViewItemV3& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV3(other); } | ||||
QStyleOptionViewItemV4* PythonQtWrapper_QStyleOptionViewItemV4::new_QStyleOptionViewItemV4() | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV4(); } | ||||
QStyleOptionViewItemV4* PythonQtWrapper_QStyleOptionViewItemV4::new_QStyleOptionViewItemV4(const QStyleOptionViewItem& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV4(other); } | ||||
QStyleOptionViewItemV4* PythonQtWrapper_QStyleOptionViewItemV4::new_QStyleOptionViewItemV4(const QStyleOptionViewItemV4& other) | ||||
{ | ||||
return new PythonQtShell_QStyleOptionViewItemV4(other); } | ||||
QStylePainter* PythonQtWrapper_QStylePainter::new_QStylePainter() | ||||
{ | ||||
return new QStylePainter(); } | ||||
QStylePainter* PythonQtWrapper_QStylePainter::new_QStylePainter(QPaintDevice* pd, QWidget* w) | ||||
{ | ||||
return new QStylePainter(pd, w); } | ||||
QStylePainter* PythonQtWrapper_QStylePainter::new_QStylePainter(QWidget* w) | ||||
{ | ||||
return new QStylePainter(w); } | ||||
bool PythonQtWrapper_QStylePainter::begin(QStylePainter* theWrappedObject, QPaintDevice* pd, QWidget* w) | ||||
{ | ||||
return ( theWrappedObject->begin(pd, w)); | ||||
} | ||||
bool PythonQtWrapper_QStylePainter::begin(QStylePainter* theWrappedObject, QWidget* w) | ||||
{ | ||||
return ( theWrappedObject->begin(w)); | ||||
} | ||||
void PythonQtWrapper_QStylePainter::drawComplexControl(QStylePainter* theWrappedObject, QStyle::ComplexControl cc, const QStyleOptionComplex& opt) | ||||
{ | ||||
( theWrappedObject->drawComplexControl(cc, opt)); | ||||
} | ||||
void PythonQtWrapper_QStylePainter::drawControl(QStylePainter* theWrappedObject, QStyle::ControlElement ce, const QStyleOption& opt) | ||||
{ | ||||
( theWrappedObject->drawControl(ce, opt)); | ||||
} | ||||
void PythonQtWrapper_QStylePainter::drawItemPixmap(QStylePainter* theWrappedObject, const QRect& r, int flags, const QPixmap& pixmap) | ||||
{ | ||||
( theWrappedObject->drawItemPixmap(r, flags, pixmap)); | ||||
} | ||||
void PythonQtWrapper_QStylePainter::drawItemText(QStylePainter* theWrappedObject, const QRect& r, int flags, const QPalette& pal, bool enabled, const QString& text, QPalette::ColorRole textRole) | ||||
{ | ||||
( theWrappedObject->drawItemText(r, flags, pal, enabled, text, textRole)); | ||||
} | ||||
void PythonQtWrapper_QStylePainter::drawPrimitive(QStylePainter* theWrappedObject, QStyle::PrimitiveElement pe, const QStyleOption& opt) | ||||
{ | ||||
( theWrappedObject->drawPrimitive(pe, opt)); | ||||
} | ||||
QStyle* PythonQtWrapper_QStylePainter::style(QStylePainter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->style()); | ||||
} | ||||
void PythonQtShell_QStylePlugin::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; | ||||
} | ||||
} | ||||
QStylePlugin::childEvent(arg__1); | ||||
} | ||||
QStyle* PythonQtShell_QStylePlugin::create(const QString& key) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "create"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QStyle*" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QStyle* returnValue; | ||||
void* args[2] = {NULL, (void*)&key}; | ||||
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("create", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStyle**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
void PythonQtShell_QStylePlugin::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; | ||||
} | ||||
} | ||||
QStylePlugin::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QStylePlugin::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 QStylePlugin::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QStylePlugin::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 QStylePlugin::eventFilter(arg__1, arg__2); | ||||
} | ||||
QStringList PythonQtShell_QStylePlugin::keys() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keys"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QStringList"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QStringList 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("keys", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStringList*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStringList(); | ||||
} | ||||
void PythonQtShell_QStylePlugin::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; | ||||
} | ||||
} | ||||
QStylePlugin::timerEvent(arg__1); | ||||
} | ||||
QStylePlugin* PythonQtWrapper_QStylePlugin::new_QStylePlugin(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QStylePlugin(parent); } | ||||
void PythonQtShell_QStyledItemDelegate::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; | ||||
} | ||||
} | ||||
QStyledItemDelegate::childEvent(arg__1); | ||||
} | ||||
QWidget* PythonQtShell_QStyledItemDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createEditor"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QWidget*" , "QWidget*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QWidget* returnValue; | ||||
void* args[4] = {NULL, (void*)&parent, (void*)&option, (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("createEditor", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStyledItemDelegate::createEditor(parent, option, index); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::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; | ||||
} | ||||
} | ||||
QStyledItemDelegate::customEvent(arg__1); | ||||
} | ||||
QString PythonQtShell_QStyledItemDelegate::displayText(const QVariant& value, const QLocale& locale) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "displayText"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString" , "const QVariant&" , "const QLocale&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QString returnValue; | ||||
void* args[3] = {NULL, (void*)&value, (void*)&locale}; | ||||
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("displayText", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStyledItemDelegate::displayText(value, locale); | ||||
} | ||||
bool PythonQtShell_QStyledItemDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "editorEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*" , "QAbstractItemModel*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
bool returnValue; | ||||
void* args[5] = {NULL, (void*)&event, (void*)&model, (void*)&option, (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("editorEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStyledItemDelegate::editorEvent(event, model, option, index); | ||||
} | ||||
bool PythonQtShell_QStyledItemDelegate::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 QStyledItemDelegate::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QStyledItemDelegate::eventFilter(QObject* object, QEvent* event) | ||||
{ | ||||
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*)&object, (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("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStyledItemDelegate::eventFilter(object, event); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::initStyleOption(QStyleOptionViewItem* option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initStyleOption"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QStyleOptionViewItem*" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&option, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QStyledItemDelegate::initStyleOption(option, index); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paint"); | ||||
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*)&option, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QStyledItemDelegate::paint(painter, option, index); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setEditorData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&editor, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QStyledItemDelegate::setEditorData(editor, index); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setModelData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "QAbstractItemModel*" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&editor, (void*)&model, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QStyledItemDelegate::setModelData(editor, model, index); | ||||
} | ||||
QSize PythonQtShell_QStyledItemDelegate::sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QSize returnValue; | ||||
void* args[3] = {NULL, (void*)&option, (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("sizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStyledItemDelegate::sizeHint(option, index); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::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; | ||||
} | ||||
} | ||||
QStyledItemDelegate::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QStyledItemDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorGeometry"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&editor, (void*)&option, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QStyledItemDelegate::updateEditorGeometry(editor, option, index); | ||||
} | ||||
QStyledItemDelegate* PythonQtWrapper_QStyledItemDelegate::new_QStyledItemDelegate(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QStyledItemDelegate(parent); } | ||||
QWidget* PythonQtWrapper_QStyledItemDelegate::createEditor(QStyledItemDelegate* theWrappedObject, QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_createEditor(parent, option, index)); | ||||
} | ||||
QString PythonQtWrapper_QStyledItemDelegate::displayText(QStyledItemDelegate* theWrappedObject, const QVariant& value, const QLocale& locale) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_displayText(value, locale)); | ||||
} | ||||
bool PythonQtWrapper_QStyledItemDelegate::editorEvent(QStyledItemDelegate* theWrappedObject, QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_editorEvent(event, model, option, index)); | ||||
} | ||||
bool PythonQtWrapper_QStyledItemDelegate::eventFilter(QStyledItemDelegate* theWrappedObject, QObject* object, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_eventFilter(object, event)); | ||||
} | ||||
void PythonQtWrapper_QStyledItemDelegate::initStyleOption(QStyledItemDelegate* theWrappedObject, QStyleOptionViewItem* option, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_initStyleOption(option, index)); | ||||
} | ||||
QItemEditorFactory* PythonQtWrapper_QStyledItemDelegate::itemEditorFactory(QStyledItemDelegate* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->itemEditorFactory()); | ||||
} | ||||
void PythonQtWrapper_QStyledItemDelegate::paint(QStyledItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_paint(painter, option, index)); | ||||
} | ||||
void PythonQtWrapper_QStyledItemDelegate::setEditorData(QStyledItemDelegate* theWrappedObject, QWidget* editor, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_setEditorData(editor, index)); | ||||
} | ||||
void PythonQtWrapper_QStyledItemDelegate::setItemEditorFactory(QStyledItemDelegate* theWrappedObject, QItemEditorFactory* factory) | ||||
{ | ||||
( theWrappedObject->setItemEditorFactory(factory)); | ||||
} | ||||
void PythonQtWrapper_QStyledItemDelegate::setModelData(QStyledItemDelegate* theWrappedObject, QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_setModelData(editor, model, index)); | ||||
} | ||||
QSize PythonQtWrapper_QStyledItemDelegate::sizeHint(QStyledItemDelegate* theWrappedObject, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_sizeHint(option, index)); | ||||
} | ||||
void PythonQtWrapper_QStyledItemDelegate::updateEditorGeometry(QStyledItemDelegate* theWrappedObject, QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QStyledItemDelegate*)theWrappedObject)->promoted_updateEditorGeometry(editor, option, index)); | ||||
} | ||||
void PythonQtShell_QSwipeGesture::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; | ||||
} | ||||
} | ||||
QSwipeGesture::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QSwipeGesture::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; | ||||
} | ||||
} | ||||
QSwipeGesture::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QSwipeGesture::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 QSwipeGesture::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QSwipeGesture::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 QSwipeGesture::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QSwipeGesture::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; | ||||
} | ||||
} | ||||
QSwipeGesture::timerEvent(arg__1); | ||||
} | ||||
QSwipeGesture* PythonQtWrapper_QSwipeGesture::new_QSwipeGesture(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QSwipeGesture(parent); } | ||||
QSwipeGesture::SwipeDirection PythonQtWrapper_QSwipeGesture::horizontalDirection(QSwipeGesture* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->horizontalDirection()); | ||||
} | ||||
void PythonQtWrapper_QSwipeGesture::setSwipeAngle(QSwipeGesture* theWrappedObject, qreal value) | ||||
{ | ||||
( theWrappedObject->setSwipeAngle(value)); | ||||
} | ||||
qreal PythonQtWrapper_QSwipeGesture::swipeAngle(QSwipeGesture* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->swipeAngle()); | ||||
} | ||||
QSwipeGesture::SwipeDirection PythonQtWrapper_QSwipeGesture::verticalDirection(QSwipeGesture* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->verticalDirection()); | ||||
} | ||||
void PythonQtShell_QSyntaxHighlighter::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; | ||||
} | ||||
} | ||||
QSyntaxHighlighter::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QSyntaxHighlighter::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; | ||||
} | ||||
} | ||||
QSyntaxHighlighter::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QSyntaxHighlighter::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 QSyntaxHighlighter::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QSyntaxHighlighter::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 QSyntaxHighlighter::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QSyntaxHighlighter::highlightBlock(const QString& text) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "highlightBlock"); | ||||
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*)&text}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
} | ||||
void PythonQtShell_QSyntaxHighlighter::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; | ||||
} | ||||
} | ||||
QSyntaxHighlighter::timerEvent(arg__1); | ||||
} | ||||
QSyntaxHighlighter* PythonQtWrapper_QSyntaxHighlighter::new_QSyntaxHighlighter(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QSyntaxHighlighter(parent); } | ||||
QSyntaxHighlighter* PythonQtWrapper_QSyntaxHighlighter::new_QSyntaxHighlighter(QTextDocument* parent) | ||||
{ | ||||
return new PythonQtShell_QSyntaxHighlighter(parent); } | ||||
QSyntaxHighlighter* PythonQtWrapper_QSyntaxHighlighter::new_QSyntaxHighlighter(QTextEdit* parent) | ||||
{ | ||||
return new PythonQtShell_QSyntaxHighlighter(parent); } | ||||
QTextDocument* PythonQtWrapper_QSyntaxHighlighter::document(QSyntaxHighlighter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->document()); | ||||
} | ||||
void PythonQtWrapper_QSyntaxHighlighter::setDocument(QSyntaxHighlighter* theWrappedObject, QTextDocument* doc) | ||||
{ | ||||
( theWrappedObject->setDocument(doc)); | ||||
} | ||||
void PythonQtShell_QSystemTrayIcon::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; | ||||
} | ||||
} | ||||
QSystemTrayIcon::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QSystemTrayIcon::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; | ||||
} | ||||
} | ||||
QSystemTrayIcon::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QSystemTrayIcon::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 QSystemTrayIcon::event(event); | ||||
} | ||||
bool PythonQtShell_QSystemTrayIcon::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 QSystemTrayIcon::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QSystemTrayIcon::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; | ||||
} | ||||
} | ||||
QSystemTrayIcon::timerEvent(arg__1); | ||||
} | ||||
QSystemTrayIcon* PythonQtWrapper_QSystemTrayIcon::new_QSystemTrayIcon(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QSystemTrayIcon(parent); } | ||||
QSystemTrayIcon* PythonQtWrapper_QSystemTrayIcon::new_QSystemTrayIcon(const QIcon& icon, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QSystemTrayIcon(icon, parent); } | ||||
QMenu* PythonQtWrapper_QSystemTrayIcon::contextMenu(QSystemTrayIcon* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->contextMenu()); | ||||
} | ||||
bool PythonQtWrapper_QSystemTrayIcon::event(QSystemTrayIcon* theWrappedObject, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSystemTrayIcon*)theWrappedObject)->promoted_event(event)); | ||||
} | ||||
QRect PythonQtWrapper_QSystemTrayIcon::geometry(QSystemTrayIcon* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->geometry()); | ||||
} | ||||
QIcon PythonQtWrapper_QSystemTrayIcon::icon(QSystemTrayIcon* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->icon()); | ||||
} | ||||
bool PythonQtWrapper_QSystemTrayIcon::static_QSystemTrayIcon_isSystemTrayAvailable() | ||||
{ | ||||
return (QSystemTrayIcon::isSystemTrayAvailable()); | ||||
} | ||||
bool PythonQtWrapper_QSystemTrayIcon::isVisible(QSystemTrayIcon* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isVisible()); | ||||
} | ||||
void PythonQtWrapper_QSystemTrayIcon::setContextMenu(QSystemTrayIcon* theWrappedObject, QMenu* menu) | ||||
{ | ||||
( theWrappedObject->setContextMenu(menu)); | ||||
} | ||||
void PythonQtWrapper_QSystemTrayIcon::setIcon(QSystemTrayIcon* theWrappedObject, const QIcon& icon) | ||||
{ | ||||
( theWrappedObject->setIcon(icon)); | ||||
} | ||||
void PythonQtWrapper_QSystemTrayIcon::setToolTip(QSystemTrayIcon* theWrappedObject, const QString& tip) | ||||
{ | ||||
( theWrappedObject->setToolTip(tip)); | ||||
} | ||||
void PythonQtWrapper_QSystemTrayIcon::showMessage(QSystemTrayIcon* theWrappedObject, const QString& title, const QString& msg, QSystemTrayIcon::MessageIcon icon, int msecs) | ||||
{ | ||||
( theWrappedObject->showMessage(title, msg, icon, msecs)); | ||||
} | ||||
bool PythonQtWrapper_QSystemTrayIcon::static_QSystemTrayIcon_supportsMessages() | ||||
{ | ||||
return (QSystemTrayIcon::supportsMessages()); | ||||
} | ||||
QString PythonQtWrapper_QSystemTrayIcon::toolTip(QSystemTrayIcon* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toolTip()); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTabBar::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 QTabBar::devType(); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTabBar::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 QTabBar::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTabBar::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 QTabBar::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTabBar::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 QTabBar::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTabBar::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 QTabBar::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QTabBar::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 QTabBar::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QTabBar::languageChange(); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTabBar::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 QTabBar::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTabBar::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 QTabBar::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::tabInserted(int index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabInserted"); | ||||
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; | ||||
} | ||||
} | ||||
QTabBar::tabInserted(index); | ||||
} | ||||
void PythonQtShell_QTabBar::tabLayoutChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabLayoutChange"); | ||||
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; | ||||
} | ||||
} | ||||
QTabBar::tabLayoutChange(); | ||||
} | ||||
void PythonQtShell_QTabBar::tabRemoved(int index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabRemoved"); | ||||
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; | ||||
} | ||||
} | ||||
QTabBar::tabRemoved(index); | ||||
} | ||||
QSize PythonQtShell_QTabBar::tabSizeHint(int index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QSize 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("tabSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTabBar::tabSizeHint(index); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabBar::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; | ||||
} | ||||
} | ||||
QTabBar::wheelEvent(event); | ||||
} | ||||
QTabBar* PythonQtWrapper_QTabBar::new_QTabBar(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTabBar(parent); } | ||||
int PythonQtWrapper_QTabBar::addTab(QTabBar* theWrappedObject, const QIcon& icon, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->addTab(icon, text)); | ||||
} | ||||
int PythonQtWrapper_QTabBar::addTab(QTabBar* theWrappedObject, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->addTab(text)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::changeEvent(QTabBar* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QTabBar::count(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
int PythonQtWrapper_QTabBar::currentIndex(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentIndex()); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::documentMode(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->documentMode()); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::drawBase(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->drawBase()); | ||||
} | ||||
Qt::TextElideMode PythonQtWrapper_QTabBar::elideMode(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->elideMode()); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::event(QTabBar* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_event(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::expanding(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->expanding()); | ||||
} | ||||
void PythonQtWrapper_QTabBar::hideEvent(QTabBar* theWrappedObject, QHideEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_hideEvent(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QTabBar::iconSize(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->iconSize()); | ||||
} | ||||
int PythonQtWrapper_QTabBar::insertTab(QTabBar* theWrappedObject, int index, const QIcon& icon, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->insertTab(index, icon, text)); | ||||
} | ||||
int PythonQtWrapper_QTabBar::insertTab(QTabBar* theWrappedObject, int index, const QString& text) | ||||
{ | ||||
return ( theWrappedObject->insertTab(index, text)); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::isMovable(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isMovable()); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::isTabEnabled(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->isTabEnabled(index)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::keyPressEvent(QTabBar* theWrappedObject, QKeyEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_keyPressEvent(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QTabBar::minimumSizeHint(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QTabBar::mouseMoveEvent(QTabBar* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_mouseMoveEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::mousePressEvent(QTabBar* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_mousePressEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::mouseReleaseEvent(QTabBar* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::moveTab(QTabBar* theWrappedObject, int from, int to) | ||||
{ | ||||
( theWrappedObject->moveTab(from, to)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::paintEvent(QTabBar* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::removeTab(QTabBar* theWrappedObject, int index) | ||||
{ | ||||
( theWrappedObject->removeTab(index)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::resizeEvent(QTabBar* theWrappedObject, QResizeEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_resizeEvent(arg__1)); | ||||
} | ||||
QTabBar::SelectionBehavior PythonQtWrapper_QTabBar::selectionBehaviorOnRemove(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectionBehaviorOnRemove()); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setDocumentMode(QTabBar* theWrappedObject, bool set) | ||||
{ | ||||
( theWrappedObject->setDocumentMode(set)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setDrawBase(QTabBar* theWrappedObject, bool drawTheBase) | ||||
{ | ||||
( theWrappedObject->setDrawBase(drawTheBase)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setElideMode(QTabBar* theWrappedObject, Qt::TextElideMode arg__1) | ||||
{ | ||||
( theWrappedObject->setElideMode(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setExpanding(QTabBar* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setExpanding(enabled)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setIconSize(QTabBar* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setIconSize(size)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setMovable(QTabBar* theWrappedObject, bool movable) | ||||
{ | ||||
( theWrappedObject->setMovable(movable)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setSelectionBehaviorOnRemove(QTabBar* theWrappedObject, QTabBar::SelectionBehavior behavior) | ||||
{ | ||||
( theWrappedObject->setSelectionBehaviorOnRemove(behavior)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setShape(QTabBar* theWrappedObject, QTabBar::Shape shape) | ||||
{ | ||||
( theWrappedObject->setShape(shape)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabButton(QTabBar* theWrappedObject, int index, QTabBar::ButtonPosition position, QWidget* widget) | ||||
{ | ||||
( theWrappedObject->setTabButton(index, position, widget)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabData(QTabBar* theWrappedObject, int index, const QVariant& data) | ||||
{ | ||||
( theWrappedObject->setTabData(index, data)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabEnabled(QTabBar* theWrappedObject, int index, bool arg__2) | ||||
{ | ||||
( theWrappedObject->setTabEnabled(index, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabIcon(QTabBar* theWrappedObject, int index, const QIcon& icon) | ||||
{ | ||||
( theWrappedObject->setTabIcon(index, icon)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabText(QTabBar* theWrappedObject, int index, const QString& text) | ||||
{ | ||||
( theWrappedObject->setTabText(index, text)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabTextColor(QTabBar* theWrappedObject, int index, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setTabTextColor(index, color)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabToolTip(QTabBar* theWrappedObject, int index, const QString& tip) | ||||
{ | ||||
( theWrappedObject->setTabToolTip(index, tip)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabWhatsThis(QTabBar* theWrappedObject, int index, const QString& text) | ||||
{ | ||||
( theWrappedObject->setTabWhatsThis(index, text)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setTabsClosable(QTabBar* theWrappedObject, bool closable) | ||||
{ | ||||
( theWrappedObject->setTabsClosable(closable)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::setUsesScrollButtons(QTabBar* theWrappedObject, bool useButtons) | ||||
{ | ||||
( theWrappedObject->setUsesScrollButtons(useButtons)); | ||||
} | ||||
QTabBar::Shape PythonQtWrapper_QTabBar::shape(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->shape()); | ||||
} | ||||
void PythonQtWrapper_QTabBar::showEvent(QTabBar* theWrappedObject, QShowEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_showEvent(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QTabBar::sizeHint(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
int PythonQtWrapper_QTabBar::tabAt(QTabBar* theWrappedObject, const QPoint& pos) const | ||||
{ | ||||
return ( theWrappedObject->tabAt(pos)); | ||||
} | ||||
QWidget* PythonQtWrapper_QTabBar::tabButton(QTabBar* theWrappedObject, int index, QTabBar::ButtonPosition position) const | ||||
{ | ||||
return ( theWrappedObject->tabButton(index, position)); | ||||
} | ||||
QVariant PythonQtWrapper_QTabBar::tabData(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabData(index)); | ||||
} | ||||
QIcon PythonQtWrapper_QTabBar::tabIcon(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabIcon(index)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::tabInserted(QTabBar* theWrappedObject, int index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_tabInserted(index)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::tabLayoutChange(QTabBar* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_tabLayoutChange()); | ||||
} | ||||
QRect PythonQtWrapper_QTabBar::tabRect(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabRect(index)); | ||||
} | ||||
void PythonQtWrapper_QTabBar::tabRemoved(QTabBar* theWrappedObject, int index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_tabRemoved(index)); | ||||
} | ||||
QSize PythonQtWrapper_QTabBar::tabSizeHint(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_tabSizeHint(index)); | ||||
} | ||||
QString PythonQtWrapper_QTabBar::tabText(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabText(index)); | ||||
} | ||||
QColor PythonQtWrapper_QTabBar::tabTextColor(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabTextColor(index)); | ||||
} | ||||
QString PythonQtWrapper_QTabBar::tabToolTip(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabToolTip(index)); | ||||
} | ||||
QString PythonQtWrapper_QTabBar::tabWhatsThis(QTabBar* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabWhatsThis(index)); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::tabsClosable(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabsClosable()); | ||||
} | ||||
bool PythonQtWrapper_QTabBar::usesScrollButtons(QTabBar* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->usesScrollButtons()); | ||||
} | ||||
void PythonQtWrapper_QTabBar::wheelEvent(QTabBar* theWrappedObject, QWheelEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_wheelEvent(event)); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTabWidget::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 QTabWidget::devType(); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTabWidget::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 QTabWidget::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTabWidget::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 QTabWidget::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTabWidget::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 QTabWidget::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTabWidget::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 QTabWidget::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QTabWidget::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 QTabWidget::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QTabWidget::languageChange(); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTabWidget::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 QTabWidget::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTabWidget::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 QTabWidget::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::tabInserted(int index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabInserted"); | ||||
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; | ||||
} | ||||
} | ||||
QTabWidget::tabInserted(index); | ||||
} | ||||
void PythonQtShell_QTabWidget::tabRemoved(int index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabRemoved"); | ||||
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; | ||||
} | ||||
} | ||||
QTabWidget::tabRemoved(index); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTabWidget::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; | ||||
} | ||||
} | ||||
QTabWidget::wheelEvent(arg__1); | ||||
} | ||||
QTabWidget* PythonQtWrapper_QTabWidget::new_QTabWidget(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTabWidget(parent); } | ||||
int PythonQtWrapper_QTabWidget::addTab(QTabWidget* theWrappedObject, QWidget* widget, const QIcon& icon, const QString& label) | ||||
{ | ||||
return ( theWrappedObject->addTab(widget, icon, label)); | ||||
} | ||||
int PythonQtWrapper_QTabWidget::addTab(QTabWidget* theWrappedObject, QWidget* widget, const QString& arg__2) | ||||
{ | ||||
return ( theWrappedObject->addTab(widget, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::changeEvent(QTabWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::clear(QTabWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clear()); | ||||
} | ||||
QWidget* PythonQtWrapper_QTabWidget::cornerWidget(QTabWidget* theWrappedObject, Qt::Corner corner) const | ||||
{ | ||||
return ( theWrappedObject->cornerWidget(corner)); | ||||
} | ||||
int PythonQtWrapper_QTabWidget::count(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
int PythonQtWrapper_QTabWidget::currentIndex(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentIndex()); | ||||
} | ||||
QWidget* PythonQtWrapper_QTabWidget::currentWidget(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentWidget()); | ||||
} | ||||
bool PythonQtWrapper_QTabWidget::documentMode(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->documentMode()); | ||||
} | ||||
Qt::TextElideMode PythonQtWrapper_QTabWidget::elideMode(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->elideMode()); | ||||
} | ||||
bool PythonQtWrapper_QTabWidget::event(QTabWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_event(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QTabWidget::iconSize(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->iconSize()); | ||||
} | ||||
int PythonQtWrapper_QTabWidget::indexOf(QTabWidget* theWrappedObject, QWidget* widget) const | ||||
{ | ||||
return ( theWrappedObject->indexOf(widget)); | ||||
} | ||||
int PythonQtWrapper_QTabWidget::insertTab(QTabWidget* theWrappedObject, int index, QWidget* widget, const QIcon& icon, const QString& label) | ||||
{ | ||||
return ( theWrappedObject->insertTab(index, widget, icon, label)); | ||||
} | ||||
int PythonQtWrapper_QTabWidget::insertTab(QTabWidget* theWrappedObject, int index, QWidget* widget, const QString& arg__3) | ||||
{ | ||||
return ( theWrappedObject->insertTab(index, widget, arg__3)); | ||||
} | ||||
bool PythonQtWrapper_QTabWidget::isMovable(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isMovable()); | ||||
} | ||||
bool PythonQtWrapper_QTabWidget::isTabEnabled(QTabWidget* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->isTabEnabled(index)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::keyPressEvent(QTabWidget* theWrappedObject, QKeyEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_keyPressEvent(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QTabWidget::minimumSizeHint(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::paintEvent(QTabWidget* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::removeTab(QTabWidget* theWrappedObject, int index) | ||||
{ | ||||
( theWrappedObject->removeTab(index)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::resizeEvent(QTabWidget* theWrappedObject, QResizeEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_resizeEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setCornerWidget(QTabWidget* theWrappedObject, QWidget* w, Qt::Corner corner) | ||||
{ | ||||
( theWrappedObject->setCornerWidget(w, corner)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setDocumentMode(QTabWidget* theWrappedObject, bool set) | ||||
{ | ||||
( theWrappedObject->setDocumentMode(set)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setElideMode(QTabWidget* theWrappedObject, Qt::TextElideMode arg__1) | ||||
{ | ||||
( theWrappedObject->setElideMode(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setIconSize(QTabWidget* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setIconSize(size)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setMovable(QTabWidget* theWrappedObject, bool movable) | ||||
{ | ||||
( theWrappedObject->setMovable(movable)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabEnabled(QTabWidget* theWrappedObject, int index, bool arg__2) | ||||
{ | ||||
( theWrappedObject->setTabEnabled(index, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabIcon(QTabWidget* theWrappedObject, int index, const QIcon& icon) | ||||
{ | ||||
( theWrappedObject->setTabIcon(index, icon)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabPosition(QTabWidget* theWrappedObject, QTabWidget::TabPosition arg__1) | ||||
{ | ||||
( theWrappedObject->setTabPosition(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabShape(QTabWidget* theWrappedObject, QTabWidget::TabShape s) | ||||
{ | ||||
( theWrappedObject->setTabShape(s)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabText(QTabWidget* theWrappedObject, int index, const QString& arg__2) | ||||
{ | ||||
( theWrappedObject->setTabText(index, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabToolTip(QTabWidget* theWrappedObject, int index, const QString& tip) | ||||
{ | ||||
( theWrappedObject->setTabToolTip(index, tip)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabWhatsThis(QTabWidget* theWrappedObject, int index, const QString& text) | ||||
{ | ||||
( theWrappedObject->setTabWhatsThis(index, text)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setTabsClosable(QTabWidget* theWrappedObject, bool closeable) | ||||
{ | ||||
( theWrappedObject->setTabsClosable(closeable)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::setUsesScrollButtons(QTabWidget* theWrappedObject, bool useButtons) | ||||
{ | ||||
( theWrappedObject->setUsesScrollButtons(useButtons)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::showEvent(QTabWidget* theWrappedObject, QShowEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_showEvent(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QTabWidget::sizeHint(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
QIcon PythonQtWrapper_QTabWidget::tabIcon(QTabWidget* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabIcon(index)); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::tabInserted(QTabWidget* theWrappedObject, int index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_tabInserted(index)); | ||||
} | ||||
QTabWidget::TabPosition PythonQtWrapper_QTabWidget::tabPosition(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabPosition()); | ||||
} | ||||
void PythonQtWrapper_QTabWidget::tabRemoved(QTabWidget* theWrappedObject, int index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->promoted_tabRemoved(index)); | ||||
} | ||||
QTabWidget::TabShape PythonQtWrapper_QTabWidget::tabShape(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabShape()); | ||||
} | ||||
QString PythonQtWrapper_QTabWidget::tabText(QTabWidget* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabText(index)); | ||||
} | ||||
QString PythonQtWrapper_QTabWidget::tabToolTip(QTabWidget* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabToolTip(index)); | ||||
} | ||||
QString PythonQtWrapper_QTabWidget::tabWhatsThis(QTabWidget* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->tabWhatsThis(index)); | ||||
} | ||||
bool PythonQtWrapper_QTabWidget::tabsClosable(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabsClosable()); | ||||
} | ||||
bool PythonQtWrapper_QTabWidget::usesScrollButtons(QTabWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->usesScrollButtons()); | ||||
} | ||||
QWidget* PythonQtWrapper_QTabWidget::widget(QTabWidget* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->widget(index)); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::closeEditor(editor, hint); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::commitData(editor); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::currentChanged(current, previous); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dataChanged"); | ||||
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*)&topLeft, (void*)&bottomRight}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTableView::dataChanged(topLeft, bottomRight); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::devType(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::doItemsLayout(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::dragEnterEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::dragLeaveEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::dragMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::dropEvent(event); | ||||
} | ||||
bool PythonQtShell_QTableView::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 QTableView::edit(index, trigger, event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::editorDestroyed(editor); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTableView::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 QTableView::event(event); | ||||
} | ||||
bool PythonQtShell_QTableView::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 QTableView::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::focusInEvent(event); | ||||
} | ||||
bool PythonQtShell_QTableView::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 QTableView::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::focusOutEvent(event); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::hideEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::horizontalOffset(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::horizontalScrollbarAction(action); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::horizontalScrollbarValueChanged(value); | ||||
} | ||||
QModelIndex PythonQtShell_QTableView::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 QTableView::indexAt(p); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::inputMethodEvent(event); | ||||
} | ||||
QVariant PythonQtShell_QTableView::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 QTableView::inputMethodQuery(query); | ||||
} | ||||
bool PythonQtShell_QTableView::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 QTableView::isIndexHidden(index); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::keyPressEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::keyboardSearch(search); | ||||
} | ||||
void PythonQtShell_QTableView::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QTableView::languageChange(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::mouseDoubleClickEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::mouseMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::mousePressEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::mouseReleaseEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTableView::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 QTableView::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::paintEvent(e); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::reset(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::resizeEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::rowsAboutToBeRemoved(parent, start, end); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::rowsInserted(parent, start, end); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::scrollContentsBy(dx, dy); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::scrollTo(index, hint); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::selectAll(); | ||||
} | ||||
QList<QModelIndex > PythonQtShell_QTableView::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 QTableView::selectedIndexes(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::selectionChanged(selected, deselected); | ||||
} | ||||
QItemSelectionModel::SelectionFlags PythonQtShell_QTableView::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 QTableView::selectionCommand(index, event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::setModel(model); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::setRootIndex(index); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::setSelection(rect, command); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::setSelectionModel(selectionModel); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::showEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::sizeHintForColumn(column); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::sizeHintForRow(row); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::startDrag(supportedActions); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::timerEvent(event); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::updateEditorData(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::updateEditorGeometries(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::updateGeometries(); | ||||
} | ||||
int PythonQtShell_QTableView::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 QTableView::verticalOffset(); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::verticalScrollbarAction(action); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::verticalScrollbarValueChanged(value); | ||||
} | ||||
QStyleOptionViewItem PythonQtShell_QTableView::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 QTableView::viewOptions(); | ||||
} | ||||
bool PythonQtShell_QTableView::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 QTableView::viewportEvent(event); | ||||
} | ||||
QRect PythonQtShell_QTableView::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 QTableView::visualRect(index); | ||||
} | ||||
QRegion PythonQtShell_QTableView::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 QTableView::visualRegionForSelection(selection); | ||||
} | ||||
void PythonQtShell_QTableView::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; | ||||
} | ||||
} | ||||
QTableView::wheelEvent(arg__1); | ||||
} | ||||
QTableView* PythonQtWrapper_QTableView::new_QTableView(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTableView(parent); } | ||||
void PythonQtWrapper_QTableView::clearSpans(QTableView* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clearSpans()); | ||||
} | ||||
int PythonQtWrapper_QTableView::columnAt(QTableView* theWrappedObject, int x) const | ||||
{ | ||||
return ( theWrappedObject->columnAt(x)); | ||||
} | ||||
int PythonQtWrapper_QTableView::columnSpan(QTableView* theWrappedObject, int row, int column) const | ||||
{ | ||||
return ( theWrappedObject->columnSpan(row, column)); | ||||
} | ||||
int PythonQtWrapper_QTableView::columnViewportPosition(QTableView* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->columnViewportPosition(column)); | ||||
} | ||||
int PythonQtWrapper_QTableView::columnWidth(QTableView* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->columnWidth(column)); | ||||
} | ||||
void PythonQtWrapper_QTableView::currentChanged(QTableView* theWrappedObject, const QModelIndex& current, const QModelIndex& previous) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_currentChanged(current, previous)); | ||||
} | ||||
Qt::PenStyle PythonQtWrapper_QTableView::gridStyle(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->gridStyle()); | ||||
} | ||||
QHeaderView* PythonQtWrapper_QTableView::horizontalHeader(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->horizontalHeader()); | ||||
} | ||||
int PythonQtWrapper_QTableView::horizontalOffset(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_horizontalOffset()); | ||||
} | ||||
void PythonQtWrapper_QTableView::horizontalScrollbarAction(QTableView* theWrappedObject, int action) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_horizontalScrollbarAction(action)); | ||||
} | ||||
QModelIndex PythonQtWrapper_QTableView::indexAt(QTableView* theWrappedObject, const QPoint& p) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_indexAt(p)); | ||||
} | ||||
bool PythonQtWrapper_QTableView::isColumnHidden(QTableView* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->isColumnHidden(column)); | ||||
} | ||||
bool PythonQtWrapper_QTableView::isCornerButtonEnabled(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isCornerButtonEnabled()); | ||||
} | ||||
bool PythonQtWrapper_QTableView::isIndexHidden(QTableView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_isIndexHidden(index)); | ||||
} | ||||
bool PythonQtWrapper_QTableView::isRowHidden(QTableView* theWrappedObject, int row) const | ||||
{ | ||||
return ( theWrappedObject->isRowHidden(row)); | ||||
} | ||||
bool PythonQtWrapper_QTableView::isSortingEnabled(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSortingEnabled()); | ||||
} | ||||
void PythonQtWrapper_QTableView::paintEvent(QTableView* theWrappedObject, QPaintEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_paintEvent(e)); | ||||
} | ||||
int PythonQtWrapper_QTableView::rowAt(QTableView* theWrappedObject, int y) const | ||||
{ | ||||
return ( theWrappedObject->rowAt(y)); | ||||
} | ||||
int PythonQtWrapper_QTableView::rowHeight(QTableView* theWrappedObject, int row) const | ||||
{ | ||||
return ( theWrappedObject->rowHeight(row)); | ||||
} | ||||
int PythonQtWrapper_QTableView::rowSpan(QTableView* theWrappedObject, int row, int column) const | ||||
{ | ||||
return ( theWrappedObject->rowSpan(row, column)); | ||||
} | ||||
int PythonQtWrapper_QTableView::rowViewportPosition(QTableView* theWrappedObject, int row) const | ||||
{ | ||||
return ( theWrappedObject->rowViewportPosition(row)); | ||||
} | ||||
void PythonQtWrapper_QTableView::scrollContentsBy(QTableView* theWrappedObject, int dx, int dy) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_scrollContentsBy(dx, dy)); | ||||
} | ||||
void PythonQtWrapper_QTableView::scrollTo(QTableView* theWrappedObject, const QModelIndex& index, QAbstractItemView::ScrollHint hint) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_scrollTo(index, hint)); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QTableView::selectedIndexes(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_selectedIndexes()); | ||||
} | ||||
void PythonQtWrapper_QTableView::selectionChanged(QTableView* theWrappedObject, const QItemSelection& selected, const QItemSelection& deselected) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_selectionChanged(selected, deselected)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setColumnHidden(QTableView* theWrappedObject, int column, bool hide) | ||||
{ | ||||
( theWrappedObject->setColumnHidden(column, hide)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setColumnWidth(QTableView* theWrappedObject, int column, int width) | ||||
{ | ||||
( theWrappedObject->setColumnWidth(column, width)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setCornerButtonEnabled(QTableView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setCornerButtonEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setGridStyle(QTableView* theWrappedObject, Qt::PenStyle style) | ||||
{ | ||||
( theWrappedObject->setGridStyle(style)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setHorizontalHeader(QTableView* theWrappedObject, QHeaderView* header) | ||||
{ | ||||
( theWrappedObject->setHorizontalHeader(header)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setModel(QTableView* theWrappedObject, QAbstractItemModel* model) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_setModel(model)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setRootIndex(QTableView* theWrappedObject, const QModelIndex& index) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_setRootIndex(index)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setRowHeight(QTableView* theWrappedObject, int row, int height) | ||||
{ | ||||
( theWrappedObject->setRowHeight(row, height)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setRowHidden(QTableView* theWrappedObject, int row, bool hide) | ||||
{ | ||||
( theWrappedObject->setRowHidden(row, hide)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setSelection(QTableView* theWrappedObject, const QRect& rect, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_setSelection(rect, command)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setSelectionModel(QTableView* theWrappedObject, QItemSelectionModel* selectionModel) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_setSelectionModel(selectionModel)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setSortingEnabled(QTableView* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setSortingEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setSpan(QTableView* theWrappedObject, int row, int column, int rowSpan, int columnSpan) | ||||
{ | ||||
( theWrappedObject->setSpan(row, column, rowSpan, columnSpan)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setVerticalHeader(QTableView* theWrappedObject, QHeaderView* header) | ||||
{ | ||||
( theWrappedObject->setVerticalHeader(header)); | ||||
} | ||||
void PythonQtWrapper_QTableView::setWordWrap(QTableView* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setWordWrap(on)); | ||||
} | ||||
bool PythonQtWrapper_QTableView::showGrid(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->showGrid()); | ||||
} | ||||
int PythonQtWrapper_QTableView::sizeHintForColumn(QTableView* theWrappedObject, int column) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_sizeHintForColumn(column)); | ||||
} | ||||
int PythonQtWrapper_QTableView::sizeHintForRow(QTableView* theWrappedObject, int row) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_sizeHintForRow(row)); | ||||
} | ||||
void PythonQtWrapper_QTableView::sortByColumn(QTableView* theWrappedObject, int column, Qt::SortOrder order) | ||||
{ | ||||
( theWrappedObject->sortByColumn(column, order)); | ||||
} | ||||
void PythonQtWrapper_QTableView::timerEvent(QTableView* theWrappedObject, QTimerEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_timerEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QTableView::updateGeometries(QTableView* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_updateGeometries()); | ||||
} | ||||
QHeaderView* PythonQtWrapper_QTableView::verticalHeader(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->verticalHeader()); | ||||
} | ||||
int PythonQtWrapper_QTableView::verticalOffset(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_verticalOffset()); | ||||
} | ||||
void PythonQtWrapper_QTableView::verticalScrollbarAction(QTableView* theWrappedObject, int action) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_verticalScrollbarAction(action)); | ||||
} | ||||
QStyleOptionViewItem PythonQtWrapper_QTableView::viewOptions(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_viewOptions()); | ||||
} | ||||
QRect PythonQtWrapper_QTableView::visualRect(QTableView* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_visualRect(index)); | ||||
} | ||||
QRegion PythonQtWrapper_QTableView::visualRegionForSelection(QTableView* theWrappedObject, const QItemSelection& selection) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableView*)theWrappedObject)->promoted_visualRegionForSelection(selection)); | ||||
} | ||||
bool PythonQtWrapper_QTableView::wordWrap(QTableView* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->wordWrap()); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::closeEditor(editor, hint); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::commitData(editor); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::currentChanged(current, previous); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dataChanged"); | ||||
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*)&topLeft, (void*)&bottomRight}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTableWidget::dataChanged(topLeft, bottomRight); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::devType(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::doItemsLayout(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::dragEnterEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::dragLeaveEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::dragMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::dropEvent(event); | ||||
} | ||||
bool PythonQtShell_QTableWidget::dropMimeData(int row, int column, const QMimeData* data, Qt::DropAction action) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropMimeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int" , "int" , "const QMimeData*" , "Qt::DropAction"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
bool returnValue; | ||||
void* args[5] = {NULL, (void*)&row, (void*)&column, (void*)&data, (void*)&action}; | ||||
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("dropMimeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidget::dropMimeData(row, column, data, action); | ||||
} | ||||
bool PythonQtShell_QTableWidget::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 QTableWidget::edit(index, trigger, event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::editorDestroyed(editor); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTableWidget::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 QTableWidget::event(e); | ||||
} | ||||
bool PythonQtShell_QTableWidget::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 QTableWidget::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::focusInEvent(event); | ||||
} | ||||
bool PythonQtShell_QTableWidget::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 QTableWidget::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::focusOutEvent(event); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::hideEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::horizontalOffset(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::horizontalScrollbarAction(action); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::horizontalScrollbarValueChanged(value); | ||||
} | ||||
QModelIndex PythonQtShell_QTableWidget::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 QTableWidget::indexAt(p); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::inputMethodEvent(event); | ||||
} | ||||
QVariant PythonQtShell_QTableWidget::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 QTableWidget::inputMethodQuery(query); | ||||
} | ||||
bool PythonQtShell_QTableWidget::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 QTableWidget::isIndexHidden(index); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::keyPressEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::keyboardSearch(search); | ||||
} | ||||
void PythonQtShell_QTableWidget::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QTableWidget::languageChange(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::metric(arg__1); | ||||
} | ||||
QMimeData* PythonQtShell_QTableWidget::mimeData(const QList<QTableWidgetItem* > items) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QMimeData*" , "const QList<QTableWidgetItem* >"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QMimeData* returnValue; | ||||
void* args[2] = {NULL, (void*)&items}; | ||||
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("mimeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QMimeData**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidget::mimeData(items); | ||||
} | ||||
QStringList PythonQtShell_QTableWidget::mimeTypes() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeTypes"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QStringList"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QStringList 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("mimeTypes", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStringList*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidget::mimeTypes(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::mouseDoubleClickEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::mouseMoveEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::mousePressEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::mouseReleaseEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QTableWidget::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 QTableWidget::paintEngine(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::paintEvent(e); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::reset(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::resizeEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::rowsAboutToBeRemoved(parent, start, end); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::rowsInserted(parent, start, end); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::scrollContentsBy(dx, dy); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::scrollTo(index, hint); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::selectAll(); | ||||
} | ||||
QList<QModelIndex > PythonQtShell_QTableWidget::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 QTableWidget::selectedIndexes(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::selectionChanged(selected, deselected); | ||||
} | ||||
QItemSelectionModel::SelectionFlags PythonQtShell_QTableWidget::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 QTableWidget::selectionCommand(index, event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::setRootIndex(index); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::setSelection(rect, command); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::setSelectionModel(selectionModel); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::showEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::sizeHintForColumn(column); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::sizeHintForRow(row); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::startDrag(supportedActions); | ||||
} | ||||
Qt::DropActions PythonQtShell_QTableWidget::supportedDropActions() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "supportedDropActions"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"Qt::DropActions"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
Qt::DropActions 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("supportedDropActions", methodInfo, result); | ||||
} else { | ||||
returnValue = *((Qt::DropActions*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidget::supportedDropActions(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::timerEvent(event); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::updateEditorData(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::updateEditorGeometries(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::updateGeometries(); | ||||
} | ||||
int PythonQtShell_QTableWidget::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 QTableWidget::verticalOffset(); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::verticalScrollbarAction(action); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::verticalScrollbarValueChanged(value); | ||||
} | ||||
QStyleOptionViewItem PythonQtShell_QTableWidget::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 QTableWidget::viewOptions(); | ||||
} | ||||
bool PythonQtShell_QTableWidget::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 QTableWidget::viewportEvent(event); | ||||
} | ||||
QRect PythonQtShell_QTableWidget::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 QTableWidget::visualRect(index); | ||||
} | ||||
QRegion PythonQtShell_QTableWidget::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 QTableWidget::visualRegionForSelection(selection); | ||||
} | ||||
void PythonQtShell_QTableWidget::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; | ||||
} | ||||
} | ||||
QTableWidget::wheelEvent(arg__1); | ||||
} | ||||
QTableWidget* PythonQtWrapper_QTableWidget::new_QTableWidget(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTableWidget(parent); } | ||||
QTableWidget* PythonQtWrapper_QTableWidget::new_QTableWidget(int rows, int columns, QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QTableWidget(rows, columns, parent); } | ||||
QWidget* PythonQtWrapper_QTableWidget::cellWidget(QTableWidget* theWrappedObject, int row, int column) const | ||||
{ | ||||
return ( theWrappedObject->cellWidget(row, column)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::closePersistentEditor(QTableWidget* theWrappedObject, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->closePersistentEditor(item)); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::column(QTableWidget* theWrappedObject, const QTableWidgetItem* item) const | ||||
{ | ||||
return ( theWrappedObject->column(item)); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::columnCount(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->columnCount()); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::currentColumn(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentColumn()); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::currentItem(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentItem()); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::currentRow(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentRow()); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::dropEvent(QTableWidget* theWrappedObject, QDropEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableWidget*)theWrappedObject)->promoted_dropEvent(event)); | ||||
} | ||||
bool PythonQtWrapper_QTableWidget::dropMimeData(QTableWidget* theWrappedObject, int row, int column, const QMimeData* data, Qt::DropAction action) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableWidget*)theWrappedObject)->promoted_dropMimeData(row, column, data, action)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::editItem(QTableWidget* theWrappedObject, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->editItem(item)); | ||||
} | ||||
bool PythonQtWrapper_QTableWidget::event(QTableWidget* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableWidget*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
QList<QTableWidgetItem* > PythonQtWrapper_QTableWidget::findItems(QTableWidget* theWrappedObject, const QString& text, Qt::MatchFlags flags) const | ||||
{ | ||||
return ( theWrappedObject->findItems(text, flags)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::horizontalHeaderItem(QTableWidget* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->horizontalHeaderItem(column)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::item(QTableWidget* theWrappedObject, int row, int column) const | ||||
{ | ||||
return ( theWrappedObject->item(row, column)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::itemAt(QTableWidget* theWrappedObject, const QPoint& p) const | ||||
{ | ||||
return ( theWrappedObject->itemAt(p)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::itemAt(QTableWidget* theWrappedObject, int x, int y) const | ||||
{ | ||||
return ( theWrappedObject->itemAt(x, y)); | ||||
} | ||||
const QTableWidgetItem* PythonQtWrapper_QTableWidget::itemPrototype(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->itemPrototype()); | ||||
} | ||||
QStringList PythonQtWrapper_QTableWidget::mimeTypes(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableWidget*)theWrappedObject)->promoted_mimeTypes()); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::openPersistentEditor(QTableWidget* theWrappedObject, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->openPersistentEditor(item)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::removeCellWidget(QTableWidget* theWrappedObject, int row, int column) | ||||
{ | ||||
( theWrappedObject->removeCellWidget(row, column)); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::row(QTableWidget* theWrappedObject, const QTableWidgetItem* item) const | ||||
{ | ||||
return ( theWrappedObject->row(item)); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::rowCount(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rowCount()); | ||||
} | ||||
QList<QTableWidgetItem* > PythonQtWrapper_QTableWidget::selectedItems(QTableWidget* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->selectedItems()); | ||||
} | ||||
QList<QTableWidgetSelectionRange > PythonQtWrapper_QTableWidget::selectedRanges(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedRanges()); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setCellWidget(QTableWidget* theWrappedObject, int row, int column, QWidget* widget) | ||||
{ | ||||
( theWrappedObject->setCellWidget(row, column, widget)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setColumnCount(QTableWidget* theWrappedObject, int columns) | ||||
{ | ||||
( theWrappedObject->setColumnCount(columns)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setCurrentCell(QTableWidget* theWrappedObject, int row, int column) | ||||
{ | ||||
( theWrappedObject->setCurrentCell(row, column)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setCurrentCell(QTableWidget* theWrappedObject, int row, int column, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
( theWrappedObject->setCurrentCell(row, column, command)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setCurrentItem(QTableWidget* theWrappedObject, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->setCurrentItem(item)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setCurrentItem(QTableWidget* theWrappedObject, QTableWidgetItem* item, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
( theWrappedObject->setCurrentItem(item, command)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setHorizontalHeaderItem(QTableWidget* theWrappedObject, int column, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->setHorizontalHeaderItem(column, item)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setHorizontalHeaderLabels(QTableWidget* theWrappedObject, const QStringList& labels) | ||||
{ | ||||
( theWrappedObject->setHorizontalHeaderLabels(labels)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setItem(QTableWidget* theWrappedObject, int row, int column, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->setItem(row, column, item)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setItemPrototype(QTableWidget* theWrappedObject, const QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->setItemPrototype(item)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setRangeSelected(QTableWidget* theWrappedObject, const QTableWidgetSelectionRange& range, bool select) | ||||
{ | ||||
( theWrappedObject->setRangeSelected(range, select)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setRowCount(QTableWidget* theWrappedObject, int rows) | ||||
{ | ||||
( theWrappedObject->setRowCount(rows)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setVerticalHeaderItem(QTableWidget* theWrappedObject, int row, QTableWidgetItem* item) | ||||
{ | ||||
( theWrappedObject->setVerticalHeaderItem(row, item)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::setVerticalHeaderLabels(QTableWidget* theWrappedObject, const QStringList& labels) | ||||
{ | ||||
( theWrappedObject->setVerticalHeaderLabels(labels)); | ||||
} | ||||
void PythonQtWrapper_QTableWidget::sortItems(QTableWidget* theWrappedObject, int column, Qt::SortOrder order) | ||||
{ | ||||
( theWrappedObject->sortItems(column, order)); | ||||
} | ||||
Qt::DropActions PythonQtWrapper_QTableWidget::supportedDropActions(QTableWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableWidget*)theWrappedObject)->promoted_supportedDropActions()); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::takeHorizontalHeaderItem(QTableWidget* theWrappedObject, int column) | ||||
{ | ||||
return ( theWrappedObject->takeHorizontalHeaderItem(column)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::takeItem(QTableWidget* theWrappedObject, int row, int column) | ||||
{ | ||||
return ( theWrappedObject->takeItem(row, column)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::takeVerticalHeaderItem(QTableWidget* theWrappedObject, int row) | ||||
{ | ||||
return ( theWrappedObject->takeVerticalHeaderItem(row)); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidget::verticalHeaderItem(QTableWidget* theWrappedObject, int row) const | ||||
{ | ||||
return ( theWrappedObject->verticalHeaderItem(row)); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::visualColumn(QTableWidget* theWrappedObject, int logicalColumn) const | ||||
{ | ||||
return ( theWrappedObject->visualColumn(logicalColumn)); | ||||
} | ||||
QRect PythonQtWrapper_QTableWidget::visualItemRect(QTableWidget* theWrappedObject, const QTableWidgetItem* item) const | ||||
{ | ||||
return ( theWrappedObject->visualItemRect(item)); | ||||
} | ||||
int PythonQtWrapper_QTableWidget::visualRow(QTableWidget* theWrappedObject, int logicalRow) const | ||||
{ | ||||
return ( theWrappedObject->visualRow(logicalRow)); | ||||
} | ||||
QTableWidgetItem* PythonQtShell_QTableWidgetItem::clone() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clone"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QTableWidgetItem*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QTableWidgetItem* 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("clone", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QTableWidgetItem**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidgetItem::clone(); | ||||
} | ||||
QVariant PythonQtShell_QTableWidgetItem::data(int role) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant returnValue; | ||||
void* args[2] = {NULL, (void*)&role}; | ||||
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("data", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidgetItem::data(role); | ||||
} | ||||
bool PythonQtShell_QTableWidgetItem::__lt__(const QTableWidgetItem& other) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "__lt__"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QTableWidgetItem&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&other}; | ||||
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("__lt__", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTableWidgetItem::operator<(other); | ||||
} | ||||
void PythonQtShell_QTableWidgetItem::read(QDataStream& in) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "read"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDataStream&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&in}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTableWidgetItem::read(in); | ||||
} | ||||
void PythonQtShell_QTableWidgetItem::setData(int role, const QVariant& value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int" , "const QVariant&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&role, (void*)&value}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTableWidgetItem::setData(role, value); | ||||
} | ||||
void PythonQtShell_QTableWidgetItem::write(QDataStream& out) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "write"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDataStream&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&out}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTableWidgetItem::write(out); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidgetItem::new_QTableWidgetItem(const QIcon& icon, const QString& text, int type) | ||||
{ | ||||
return new PythonQtShell_QTableWidgetItem(icon, text, type); } | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidgetItem::new_QTableWidgetItem(const QString& text, int type) | ||||
{ | ||||
return new PythonQtShell_QTableWidgetItem(text, type); } | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidgetItem::new_QTableWidgetItem(int type) | ||||
{ | ||||
return new PythonQtShell_QTableWidgetItem(type); } | ||||
QBrush PythonQtWrapper_QTableWidgetItem::background(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->background()); | ||||
} | ||||
Qt::CheckState PythonQtWrapper_QTableWidgetItem::checkState(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->checkState()); | ||||
} | ||||
QTableWidgetItem* PythonQtWrapper_QTableWidgetItem::clone(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableWidgetItem*)theWrappedObject)->promoted_clone()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetItem::column(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->column()); | ||||
} | ||||
QVariant PythonQtWrapper_QTableWidgetItem::data(QTableWidgetItem* theWrappedObject, int role) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTableWidgetItem*)theWrappedObject)->promoted_data(role)); | ||||
} | ||||
Qt::ItemFlags PythonQtWrapper_QTableWidgetItem::flags(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->flags()); | ||||
} | ||||
QFont PythonQtWrapper_QTableWidgetItem::font(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->font()); | ||||
} | ||||
QBrush PythonQtWrapper_QTableWidgetItem::foreground(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->foreground()); | ||||
} | ||||
QIcon PythonQtWrapper_QTableWidgetItem::icon(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->icon()); | ||||
} | ||||
bool PythonQtWrapper_QTableWidgetItem::isSelected(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSelected()); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::writeTo(QTableWidgetItem* theWrappedObject, QDataStream& out) | ||||
{ | ||||
out << (*theWrappedObject); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::readFrom(QTableWidgetItem* theWrappedObject, QDataStream& in) | ||||
{ | ||||
in >> (*theWrappedObject); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetItem::row(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->row()); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setBackground(QTableWidgetItem* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setBackground(brush)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setCheckState(QTableWidgetItem* theWrappedObject, Qt::CheckState state) | ||||
{ | ||||
( theWrappedObject->setCheckState(state)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setData(QTableWidgetItem* theWrappedObject, int role, const QVariant& value) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTableWidgetItem*)theWrappedObject)->promoted_setData(role, value)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setFlags(QTableWidgetItem* theWrappedObject, Qt::ItemFlags flags) | ||||
{ | ||||
( theWrappedObject->setFlags(flags)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setFont(QTableWidgetItem* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setFont(font)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setForeground(QTableWidgetItem* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setForeground(brush)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setIcon(QTableWidgetItem* theWrappedObject, const QIcon& icon) | ||||
{ | ||||
( theWrappedObject->setIcon(icon)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setSelected(QTableWidgetItem* theWrappedObject, bool select) | ||||
{ | ||||
( theWrappedObject->setSelected(select)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setSizeHint(QTableWidgetItem* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setSizeHint(size)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setStatusTip(QTableWidgetItem* theWrappedObject, const QString& statusTip) | ||||
{ | ||||
( theWrappedObject->setStatusTip(statusTip)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setText(QTableWidgetItem* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setText(text)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setTextAlignment(QTableWidgetItem* theWrappedObject, int alignment) | ||||
{ | ||||
( theWrappedObject->setTextAlignment(alignment)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setToolTip(QTableWidgetItem* theWrappedObject, const QString& toolTip) | ||||
{ | ||||
( theWrappedObject->setToolTip(toolTip)); | ||||
} | ||||
void PythonQtWrapper_QTableWidgetItem::setWhatsThis(QTableWidgetItem* theWrappedObject, const QString& whatsThis) | ||||
{ | ||||
( theWrappedObject->setWhatsThis(whatsThis)); | ||||
} | ||||
QSize PythonQtWrapper_QTableWidgetItem::sizeHint(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
QString PythonQtWrapper_QTableWidgetItem::statusTip(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->statusTip()); | ||||
} | ||||
QTableWidget* PythonQtWrapper_QTableWidgetItem::tableWidget(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tableWidget()); | ||||
} | ||||
QString PythonQtWrapper_QTableWidgetItem::text(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetItem::textAlignment(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textAlignment()); | ||||
} | ||||
QString PythonQtWrapper_QTableWidgetItem::toolTip(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toolTip()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetItem::type(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->type()); | ||||
} | ||||
QString PythonQtWrapper_QTableWidgetItem::whatsThis(QTableWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->whatsThis()); | ||||
} | ||||
QTableWidgetSelectionRange* PythonQtWrapper_QTableWidgetSelectionRange::new_QTableWidgetSelectionRange() | ||||
{ | ||||
return new QTableWidgetSelectionRange(); } | ||||
QTableWidgetSelectionRange* PythonQtWrapper_QTableWidgetSelectionRange::new_QTableWidgetSelectionRange(const QTableWidgetSelectionRange& other) | ||||
{ | ||||
return new QTableWidgetSelectionRange(other); } | ||||
QTableWidgetSelectionRange* PythonQtWrapper_QTableWidgetSelectionRange::new_QTableWidgetSelectionRange(int top, int left, int bottom, int right) | ||||
{ | ||||
return new QTableWidgetSelectionRange(top, left, bottom, right); } | ||||
int PythonQtWrapper_QTableWidgetSelectionRange::bottomRow(QTableWidgetSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomRow()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetSelectionRange::columnCount(QTableWidgetSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->columnCount()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetSelectionRange::leftColumn(QTableWidgetSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->leftColumn()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetSelectionRange::rightColumn(QTableWidgetSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rightColumn()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetSelectionRange::rowCount(QTableWidgetSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rowCount()); | ||||
} | ||||
int PythonQtWrapper_QTableWidgetSelectionRange::topRow(QTableWidgetSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topRow()); | ||||
} | ||||
QTabletEvent* PythonQtWrapper_QTabletEvent::new_QTabletEvent(QEvent::Type t, const QPoint& pos, const QPoint& globalPos, const QPointF& hiResGlobalPos, int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tangentialPressure, qreal rotation, int z, Qt::KeyboardModifiers keyState, qint64 uniqueID) | ||||
{ | ||||
return new PythonQtShell_QTabletEvent(t, pos, globalPos, hiResGlobalPos, device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, keyState, uniqueID); } | ||||
QTabletEvent::TabletDevice PythonQtWrapper_QTabletEvent::device(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
const QPoint* PythonQtWrapper_QTabletEvent::globalPos(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->globalPos()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::globalX(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->globalX()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::globalY(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->globalY()); | ||||
} | ||||
const QPointF* PythonQtWrapper_QTabletEvent::hiResGlobalPos(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->hiResGlobalPos()); | ||||
} | ||||
qreal PythonQtWrapper_QTabletEvent::hiResGlobalX(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hiResGlobalX()); | ||||
} | ||||
qreal PythonQtWrapper_QTabletEvent::hiResGlobalY(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hiResGlobalY()); | ||||
} | ||||
QTabletEvent::PointerType PythonQtWrapper_QTabletEvent::pointerType(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pointerType()); | ||||
} | ||||
const QPoint* PythonQtWrapper_QTabletEvent::pos(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->pos()); | ||||
} | ||||
qreal PythonQtWrapper_QTabletEvent::pressure(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pressure()); | ||||
} | ||||
qreal PythonQtWrapper_QTabletEvent::rotation(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rotation()); | ||||
} | ||||
qreal PythonQtWrapper_QTabletEvent::tangentialPressure(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tangentialPressure()); | ||||
} | ||||
qint64 PythonQtWrapper_QTabletEvent::uniqueId(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->uniqueId()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::x(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::xTilt(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->xTilt()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::y(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::yTilt(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->yTilt()); | ||||
} | ||||
int PythonQtWrapper_QTabletEvent::z(QTabletEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->z()); | ||||
} | ||||
QTextBlock* PythonQtWrapper_QTextBlock::new_QTextBlock() | ||||
{ | ||||
return new QTextBlock(); } | ||||
QTextBlock* PythonQtWrapper_QTextBlock::new_QTextBlock(const QTextBlock& o) | ||||
{ | ||||
return new QTextBlock(o); } | ||||
QTextBlock::iterator PythonQtWrapper_QTextBlock::begin(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->begin()); | ||||
} | ||||
QTextBlockFormat PythonQtWrapper_QTextBlock::blockFormat(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->blockFormat()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::blockFormatIndex(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->blockFormatIndex()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::blockNumber(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->blockNumber()); | ||||
} | ||||
QTextCharFormat PythonQtWrapper_QTextBlock::charFormat(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->charFormat()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::charFormatIndex(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->charFormatIndex()); | ||||
} | ||||
void PythonQtWrapper_QTextBlock::clearLayout(QTextBlock* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clearLayout()); | ||||
} | ||||
bool PythonQtWrapper_QTextBlock::contains(QTextBlock* theWrappedObject, int position) const | ||||
{ | ||||
return ( theWrappedObject->contains(position)); | ||||
} | ||||
const QTextDocument* PythonQtWrapper_QTextBlock::document(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->document()); | ||||
} | ||||
QTextBlock::iterator PythonQtWrapper_QTextBlock::end(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->end()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::firstLineNumber(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->firstLineNumber()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::fragmentIndex(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fragmentIndex()); | ||||
} | ||||
bool PythonQtWrapper_QTextBlock::isValid(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
bool PythonQtWrapper_QTextBlock::isVisible(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isVisible()); | ||||
} | ||||
QTextLayout* PythonQtWrapper_QTextBlock::layout(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->layout()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::length(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::lineCount(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lineCount()); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextBlock::next(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->next()); | ||||
} | ||||
bool PythonQtWrapper_QTextBlock::__ne__(QTextBlock* theWrappedObject, const QTextBlock& o) const | ||||
{ | ||||
return ( (*theWrappedObject)!= o); | ||||
} | ||||
bool PythonQtWrapper_QTextBlock::__lt__(QTextBlock* theWrappedObject, const QTextBlock& o) const | ||||
{ | ||||
return ( (*theWrappedObject)< o); | ||||
} | ||||
bool PythonQtWrapper_QTextBlock::__eq__(QTextBlock* theWrappedObject, const QTextBlock& o) const | ||||
{ | ||||
return ( (*theWrappedObject)== o); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::position(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->position()); | ||||
} | ||||
QTextBlock PythonQtWrapper_QTextBlock::previous(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->previous()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::revision(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->revision()); | ||||
} | ||||
void PythonQtWrapper_QTextBlock::setLineCount(QTextBlock* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->setLineCount(count)); | ||||
} | ||||
void PythonQtWrapper_QTextBlock::setRevision(QTextBlock* theWrappedObject, int rev) | ||||
{ | ||||
( theWrappedObject->setRevision(rev)); | ||||
} | ||||
void PythonQtWrapper_QTextBlock::setUserData(QTextBlock* theWrappedObject, QTextBlockUserData* data) | ||||
{ | ||||
( theWrappedObject->setUserData(data)); | ||||
} | ||||
void PythonQtWrapper_QTextBlock::setUserState(QTextBlock* theWrappedObject, int state) | ||||
{ | ||||
( theWrappedObject->setUserState(state)); | ||||
} | ||||
void PythonQtWrapper_QTextBlock::setVisible(QTextBlock* theWrappedObject, bool visible) | ||||
{ | ||||
( theWrappedObject->setVisible(visible)); | ||||
} | ||||
QString PythonQtWrapper_QTextBlock::text(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
QTextList* PythonQtWrapper_QTextBlock::textList(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textList()); | ||||
} | ||||
QTextBlockUserData* PythonQtWrapper_QTextBlock::userData(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->userData()); | ||||
} | ||||
int PythonQtWrapper_QTextBlock::userState(QTextBlock* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->userState()); | ||||
} | ||||
QTextBlockFormat* PythonQtWrapper_QTextBlockFormat::new_QTextBlockFormat() | ||||
{ | ||||
return new PythonQtShell_QTextBlockFormat(); } | ||||
Qt::Alignment PythonQtWrapper_QTextBlockFormat::alignment(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->alignment()); | ||||
} | ||||
qreal PythonQtWrapper_QTextBlockFormat::bottomMargin(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomMargin()); | ||||
} | ||||
int PythonQtWrapper_QTextBlockFormat::indent(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indent()); | ||||
} | ||||
bool PythonQtWrapper_QTextBlockFormat::isValid(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
qreal PythonQtWrapper_QTextBlockFormat::leftMargin(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->leftMargin()); | ||||
} | ||||
bool PythonQtWrapper_QTextBlockFormat::nonBreakableLines(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nonBreakableLines()); | ||||
} | ||||
QTextFormat::PageBreakFlags PythonQtWrapper_QTextBlockFormat::pageBreakPolicy(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pageBreakPolicy()); | ||||
} | ||||
qreal PythonQtWrapper_QTextBlockFormat::rightMargin(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rightMargin()); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setAlignment(QTextBlockFormat* theWrappedObject, Qt::Alignment alignment) | ||||
{ | ||||
( theWrappedObject->setAlignment(alignment)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setBottomMargin(QTextBlockFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setBottomMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setIndent(QTextBlockFormat* theWrappedObject, int indent) | ||||
{ | ||||
( theWrappedObject->setIndent(indent)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setLeftMargin(QTextBlockFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setLeftMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setNonBreakableLines(QTextBlockFormat* theWrappedObject, bool b) | ||||
{ | ||||
( theWrappedObject->setNonBreakableLines(b)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setPageBreakPolicy(QTextBlockFormat* theWrappedObject, QTextFormat::PageBreakFlags flags) | ||||
{ | ||||
( theWrappedObject->setPageBreakPolicy(flags)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setRightMargin(QTextBlockFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setRightMargin(margin)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setTabPositions(QTextBlockFormat* theWrappedObject, const QList<QTextOption::Tab >& tabs) | ||||
{ | ||||
( theWrappedObject->setTabPositions(tabs)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setTextIndent(QTextBlockFormat* theWrappedObject, qreal aindent) | ||||
{ | ||||
( theWrappedObject->setTextIndent(aindent)); | ||||
} | ||||
void PythonQtWrapper_QTextBlockFormat::setTopMargin(QTextBlockFormat* theWrappedObject, qreal margin) | ||||
{ | ||||
( theWrappedObject->setTopMargin(margin)); | ||||
} | ||||
QList<QTextOption::Tab > PythonQtWrapper_QTextBlockFormat::tabPositions(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tabPositions()); | ||||
} | ||||
qreal PythonQtWrapper_QTextBlockFormat::textIndent(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textIndent()); | ||||
} | ||||
qreal PythonQtWrapper_QTextBlockFormat::topMargin(QTextBlockFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topMargin()); | ||||
} | ||||