|
|
#include "com_trolltech_qt_gui8.h"
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <QIconEngine>
|
|
|
#include <QTextBlock>
|
|
|
#include <QTextCursor>
|
|
|
#include <QTextEdit>
|
|
|
#include <QTextFormat>
|
|
|
#include <QTextFrame>
|
|
|
#include <QTextLayout>
|
|
|
#include <QVariant>
|
|
|
#include <qabstractitemdelegate.h>
|
|
|
#include <qabstractitemmodel.h>
|
|
|
#include <qabstracttextdocumentlayout.h>
|
|
|
#include <qaction.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qbrush.h>
|
|
|
#include <qbuttongroup.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcalendarwidget.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qdatetime.h>
|
|
|
#include <qdatetimeedit.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qheaderview.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qitemselectionmodel.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qline.h>
|
|
|
#include <qlineedit.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmatrix.h>
|
|
|
#include <qmenu.h>
|
|
|
#include <qmimedata.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpainterpath.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpen.h>
|
|
|
#include <qpixmap.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qpolygon.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregexp.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qscrollbar.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qtextcodec.h>
|
|
|
#include <qtextcursor.h>
|
|
|
#include <qtextdocument.h>
|
|
|
#include <qtextdocumentfragment.h>
|
|
|
#include <qtextdocumentwriter.h>
|
|
|
#include <qtextedit.h>
|
|
|
#include <qtextformat.h>
|
|
|
#include <qtextlist.h>
|
|
|
#include <qtextobject.h>
|
|
|
#include <qtexttable.h>
|
|
|
#include <qtoolbar.h>
|
|
|
#include <qtoolbox.h>
|
|
|
#include <qtoolbutton.h>
|
|
|
#include <qtransform.h>
|
|
|
#include <qtreeview.h>
|
|
|
#include <qurl.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qvector2d.h>
|
|
|
#include <qwidget.h>
|
|
|
|
|
|
PythonQtShell_QTextDocument::~PythonQtShell_QTextDocument() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTextDocument::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextDocument::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextDocument::clear()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextDocument::clear();
|
|
|
}
|
|
|
QTextObject* PythonQtShell_QTextDocument::createObject(const QTextFormat& f)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createObject");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QTextObject*" , "const QTextFormat&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QTextObject* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&f};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("createObject", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QTextObject**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextDocument::createObject(f);
|
|
|
}
|
|
|
void PythonQtShell_QTextDocument::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextDocument::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextDocument::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextDocument::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextDocument::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextDocument::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
QVariant PythonQtShell_QTextDocument::loadResource(int type, const QUrl& name)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "loadResource");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "int" , "const QUrl&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[3] = {NULL, (void*)&type, (void*)&name};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("loadResource", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextDocument::loadResource(type, name);
|
|
|
}
|
|
|
void PythonQtShell_QTextDocument::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextDocument::timerEvent(arg__1);
|
|
|
}
|
|
|
QTextDocument* PythonQtWrapper_QTextDocument::new_QTextDocument(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTextDocument(parent); }
|
|
|
|
|
|
QTextDocument* PythonQtWrapper_QTextDocument::new_QTextDocument(const QString& text, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTextDocument(text, parent); }
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::addResource(QTextDocument* theWrappedObject, int type, const QUrl& name, const QVariant& resource)
|
|
|
{
|
|
|
( theWrappedObject->addResource(type, name, resource));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::adjustSize(QTextDocument* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->adjustSize());
|
|
|
}
|
|
|
|
|
|
QVector<QTextFormat > PythonQtWrapper_QTextDocument::allFormats(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->allFormats());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::availableRedoSteps(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->availableRedoSteps());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::availableUndoSteps(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->availableUndoSteps());
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::begin(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->begin());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::blockCount(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->blockCount());
|
|
|
}
|
|
|
|
|
|
QChar PythonQtWrapper_QTextDocument::characterAt(QTextDocument* theWrappedObject, int pos) const
|
|
|
{
|
|
|
return ( theWrappedObject->characterAt(pos));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::characterCount(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->characterCount());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::clear(QTextDocument* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextDocument*)theWrappedObject)->promoted_clear());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::clearUndoRedoStacks(QTextDocument* theWrappedObject, QTextDocument::Stacks historyToClear)
|
|
|
{
|
|
|
( theWrappedObject->clearUndoRedoStacks(historyToClear));
|
|
|
}
|
|
|
|
|
|
QTextDocument* PythonQtWrapper_QTextDocument::clone(QTextDocument* theWrappedObject, QObject* parent) const
|
|
|
{
|
|
|
return ( theWrappedObject->clone(parent));
|
|
|
}
|
|
|
|
|
|
QTextObject* PythonQtWrapper_QTextDocument::createObject(QTextDocument* theWrappedObject, const QTextFormat& f)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextDocument*)theWrappedObject)->promoted_createObject(f));
|
|
|
}
|
|
|
|
|
|
Qt::CursorMoveStyle PythonQtWrapper_QTextDocument::defaultCursorMoveStyle(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultCursorMoveStyle());
|
|
|
}
|
|
|
|
|
|
QFont PythonQtWrapper_QTextDocument::defaultFont(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultFont());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocument::defaultStyleSheet(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultStyleSheet());
|
|
|
}
|
|
|
|
|
|
QTextOption PythonQtWrapper_QTextDocument::defaultTextOption(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultTextOption());
|
|
|
}
|
|
|
|
|
|
QAbstractTextDocumentLayout* PythonQtWrapper_QTextDocument::documentLayout(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentLayout());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextDocument::documentMargin(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentMargin());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::drawContents(QTextDocument* theWrappedObject, QPainter* painter, const QRectF& rect)
|
|
|
{
|
|
|
( theWrappedObject->drawContents(painter, rect));
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::end(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->end());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QRegExp& expr, const QTextCursor& from, QTextDocument::FindFlags options) const
|
|
|
{
|
|
|
return ( theWrappedObject->find(expr, from, options));
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QRegExp& expr, int from, QTextDocument::FindFlags options) const
|
|
|
{
|
|
|
return ( theWrappedObject->find(expr, from, options));
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QString& subString, const QTextCursor& from, QTextDocument::FindFlags options) const
|
|
|
{
|
|
|
return ( theWrappedObject->find(subString, from, options));
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextDocument::find(QTextDocument* theWrappedObject, const QString& subString, int from, QTextDocument::FindFlags options) const
|
|
|
{
|
|
|
return ( theWrappedObject->find(subString, from, options));
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::findBlock(QTextDocument* theWrappedObject, int pos) const
|
|
|
{
|
|
|
return ( theWrappedObject->findBlock(pos));
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::findBlockByLineNumber(QTextDocument* theWrappedObject, int blockNumber) const
|
|
|
{
|
|
|
return ( theWrappedObject->findBlockByLineNumber(blockNumber));
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::findBlockByNumber(QTextDocument* theWrappedObject, int blockNumber) const
|
|
|
{
|
|
|
return ( theWrappedObject->findBlockByNumber(blockNumber));
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::firstBlock(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->firstBlock());
|
|
|
}
|
|
|
|
|
|
QTextFrame* PythonQtWrapper_QTextDocument::frameAt(QTextDocument* theWrappedObject, int pos) const
|
|
|
{
|
|
|
return ( theWrappedObject->frameAt(pos));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextDocument::idealWidth(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->idealWidth());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextDocument::indentWidth(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->indentWidth());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocument::isEmpty(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEmpty());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocument::isModified(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isModified());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocument::isRedoAvailable(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isRedoAvailable());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocument::isUndoAvailable(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isUndoAvailable());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocument::isUndoRedoEnabled(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isUndoRedoEnabled());
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextDocument::lastBlock(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastBlock());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::lineCount(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lineCount());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QTextDocument::loadResource(QTextDocument* theWrappedObject, int type, const QUrl& name)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextDocument*)theWrappedObject)->promoted_loadResource(type, name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::markContentsDirty(QTextDocument* theWrappedObject, int from, int length)
|
|
|
{
|
|
|
( theWrappedObject->markContentsDirty(from, length));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::maximumBlockCount(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->maximumBlockCount());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocument::metaInformation(QTextDocument* theWrappedObject, QTextDocument::MetaInformation info) const
|
|
|
{
|
|
|
return ( theWrappedObject->metaInformation(info));
|
|
|
}
|
|
|
|
|
|
QTextObject* PythonQtWrapper_QTextDocument::object(QTextDocument* theWrappedObject, int objectIndex) const
|
|
|
{
|
|
|
return ( theWrappedObject->object(objectIndex));
|
|
|
}
|
|
|
|
|
|
QTextObject* PythonQtWrapper_QTextDocument::objectForFormat(QTextDocument* theWrappedObject, const QTextFormat& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->objectForFormat(arg__1));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::pageCount(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pageCount());
|
|
|
}
|
|
|
|
|
|
QSizeF PythonQtWrapper_QTextDocument::pageSize(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pageSize());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::redo(QTextDocument* theWrappedObject, QTextCursor* cursor)
|
|
|
{
|
|
|
( theWrappedObject->redo(cursor));
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QTextDocument::resource(QTextDocument* theWrappedObject, int type, const QUrl& name) const
|
|
|
{
|
|
|
return ( theWrappedObject->resource(type, name));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextDocument::revision(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->revision());
|
|
|
}
|
|
|
|
|
|
QTextFrame* PythonQtWrapper_QTextDocument::rootFrame(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rootFrame());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setDefaultCursorMoveStyle(QTextDocument* theWrappedObject, Qt::CursorMoveStyle style)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultCursorMoveStyle(style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setDefaultFont(QTextDocument* theWrappedObject, const QFont& font)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultFont(font));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setDefaultStyleSheet(QTextDocument* theWrappedObject, const QString& sheet)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultStyleSheet(sheet));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setDefaultTextOption(QTextDocument* theWrappedObject, const QTextOption& option)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultTextOption(option));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setDocumentLayout(QTextDocument* theWrappedObject, QAbstractTextDocumentLayout* layout)
|
|
|
{
|
|
|
( theWrappedObject->setDocumentLayout(layout));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setDocumentMargin(QTextDocument* theWrappedObject, qreal margin)
|
|
|
{
|
|
|
( theWrappedObject->setDocumentMargin(margin));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setHtml(QTextDocument* theWrappedObject, const QString& html)
|
|
|
{
|
|
|
( theWrappedObject->setHtml(html));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setIndentWidth(QTextDocument* theWrappedObject, qreal width)
|
|
|
{
|
|
|
( theWrappedObject->setIndentWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setMaximumBlockCount(QTextDocument* theWrappedObject, int maximum)
|
|
|
{
|
|
|
( theWrappedObject->setMaximumBlockCount(maximum));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setMetaInformation(QTextDocument* theWrappedObject, QTextDocument::MetaInformation info, const QString& arg__2)
|
|
|
{
|
|
|
( theWrappedObject->setMetaInformation(info, arg__2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setPageSize(QTextDocument* theWrappedObject, const QSizeF& size)
|
|
|
{
|
|
|
( theWrappedObject->setPageSize(size));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setPlainText(QTextDocument* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setPlainText(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setTextWidth(QTextDocument* theWrappedObject, qreal width)
|
|
|
{
|
|
|
( theWrappedObject->setTextWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setUndoRedoEnabled(QTextDocument* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setUndoRedoEnabled(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::setUseDesignMetrics(QTextDocument* theWrappedObject, bool b)
|
|
|
{
|
|
|
( theWrappedObject->setUseDesignMetrics(b));
|
|
|
}
|
|
|
|
|
|
QSizeF PythonQtWrapper_QTextDocument::size(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->size());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextDocument::textWidth(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textWidth());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocument::toHtml(QTextDocument* theWrappedObject, const QByteArray& encoding) const
|
|
|
{
|
|
|
return ( theWrappedObject->toHtml(encoding));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocument::toPlainText(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toPlainText());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocument::undo(QTextDocument* theWrappedObject, QTextCursor* cursor)
|
|
|
{
|
|
|
( theWrappedObject->undo(cursor));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocument::useDesignMetrics(QTextDocument* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->useDesignMetrics());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment()
|
|
|
{
|
|
|
return new QTextDocumentFragment(); }
|
|
|
|
|
|
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment(const QTextCursor& range)
|
|
|
{
|
|
|
return new QTextDocumentFragment(range); }
|
|
|
|
|
|
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment(const QTextDocument* document)
|
|
|
{
|
|
|
return new QTextDocumentFragment(document); }
|
|
|
|
|
|
QTextDocumentFragment* PythonQtWrapper_QTextDocumentFragment::new_QTextDocumentFragment(const QTextDocumentFragment& rhs)
|
|
|
{
|
|
|
return new QTextDocumentFragment(rhs); }
|
|
|
|
|
|
QTextDocumentFragment PythonQtWrapper_QTextDocumentFragment::static_QTextDocumentFragment_fromHtml(const QString& html)
|
|
|
{
|
|
|
return (QTextDocumentFragment::fromHtml(html));
|
|
|
}
|
|
|
|
|
|
QTextDocumentFragment PythonQtWrapper_QTextDocumentFragment::static_QTextDocumentFragment_fromHtml(const QString& html, const QTextDocument* resourceProvider)
|
|
|
{
|
|
|
return (QTextDocumentFragment::fromHtml(html, resourceProvider));
|
|
|
}
|
|
|
|
|
|
QTextDocumentFragment PythonQtWrapper_QTextDocumentFragment::static_QTextDocumentFragment_fromPlainText(const QString& plainText)
|
|
|
{
|
|
|
return (QTextDocumentFragment::fromPlainText(plainText));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocumentFragment::isEmpty(QTextDocumentFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEmpty());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocumentFragment::toHtml(QTextDocumentFragment* theWrappedObject, const QByteArray& encoding) const
|
|
|
{
|
|
|
return ( theWrappedObject->toHtml(encoding));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocumentFragment::toPlainText(QTextDocumentFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toPlainText());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextDocumentWriter* PythonQtWrapper_QTextDocumentWriter::new_QTextDocumentWriter()
|
|
|
{
|
|
|
return new QTextDocumentWriter(); }
|
|
|
|
|
|
QTextDocumentWriter* PythonQtWrapper_QTextDocumentWriter::new_QTextDocumentWriter(QIODevice* device, const QByteArray& format)
|
|
|
{
|
|
|
return new QTextDocumentWriter(device, format); }
|
|
|
|
|
|
QTextDocumentWriter* PythonQtWrapper_QTextDocumentWriter::new_QTextDocumentWriter(const QString& fileName, const QByteArray& format)
|
|
|
{
|
|
|
return new QTextDocumentWriter(fileName, format); }
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextDocumentWriter::codec(QTextDocumentWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->codec());
|
|
|
}
|
|
|
|
|
|
QIODevice* PythonQtWrapper_QTextDocumentWriter::device(QTextDocumentWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->device());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDocumentWriter::fileName(QTextDocumentWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fileName());
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QTextDocumentWriter::format(QTextDocumentWriter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocumentWriter::setCodec(QTextDocumentWriter* theWrappedObject, QTextCodec* codec)
|
|
|
{
|
|
|
( theWrappedObject->setCodec(codec));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocumentWriter::setDevice(QTextDocumentWriter* theWrappedObject, QIODevice* device)
|
|
|
{
|
|
|
( theWrappedObject->setDevice(device));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocumentWriter::setFileName(QTextDocumentWriter* theWrappedObject, const QString& fileName)
|
|
|
{
|
|
|
( theWrappedObject->setFileName(fileName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextDocumentWriter::setFormat(QTextDocumentWriter* theWrappedObject, const QByteArray& format)
|
|
|
{
|
|
|
( theWrappedObject->setFormat(format));
|
|
|
}
|
|
|
|
|
|
QList<QByteArray > PythonQtWrapper_QTextDocumentWriter::static_QTextDocumentWriter_supportedDocumentFormats()
|
|
|
{
|
|
|
return (QTextDocumentWriter::supportedDocumentFormats());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocumentWriter::write(QTextDocumentWriter* theWrappedObject, const QTextDocument* document)
|
|
|
{
|
|
|
return ( theWrappedObject->write(document));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextDocumentWriter::write(QTextDocumentWriter* theWrappedObject, const QTextDocumentFragment& fragment)
|
|
|
{
|
|
|
return ( theWrappedObject->write(fragment));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextEdit::~PythonQtShell_QTextEdit() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::actionEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::canInsertFromMimeData(const QMimeData* source) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canInsertFromMimeData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QMimeData*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&source};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("canInsertFromMimeData", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::canInsertFromMimeData(source);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::changeEvent(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::changeEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::contextMenuEvent(QContextMenuEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::contextMenuEvent(e);
|
|
|
}
|
|
|
QMimeData* PythonQtShell_QTextEdit::createMimeDataFromSelection() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createMimeDataFromSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QMimeData*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QMimeData* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("createMimeDataFromSelection", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QMimeData**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::createMimeDataFromSelection();
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QTextEdit::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::devType();
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::doSetTextCursor(const QTextCursor& cursor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doSetTextCursor");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QTextCursor&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&cursor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::doSetTextCursor(cursor);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::dragEnterEvent(QDragEnterEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::dragEnterEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::dragLeaveEvent(QDragLeaveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::dragLeaveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::dragMoveEvent(QDragMoveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::dragMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::dropEvent(QDropEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::dropEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::focusInEvent(QFocusEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::focusInEvent(e);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::focusOutEvent(QFocusEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::focusOutEvent(e);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QTextEdit::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::initPainter(QPainter* painter) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::initPainter(painter);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QTextEdit::inputMethodQuery(Qt::InputMethodQuery property) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&property};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::inputMethodQuery(property);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::insertFromMimeData(const QMimeData* source)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertFromMimeData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QMimeData*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&source};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::insertFromMimeData(source);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::keyPressEvent(QKeyEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::keyPressEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::keyReleaseEvent(QKeyEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::keyReleaseEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::leaveEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QTextEdit::loadResource(int type, const QUrl& name)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "loadResource");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "int" , "const QUrl&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[3] = {NULL, (void*)&type, (void*)&name};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("loadResource", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::loadResource(type, name);
|
|
|
}
|
|
|
int PythonQtShell_QTextEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::mouseDoubleClickEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::mouseDoubleClickEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::mouseMoveEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::mouseMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::mousePressEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::mousePressEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::mouseReleaseEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::mouseReleaseEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::nativeEvent(eventType, message, result);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QTextEdit::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::paintEvent(QPaintEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::paintEvent(e);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QTextEdit::redirected(QPoint* offset) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::redirected(offset);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::resizeEvent(QResizeEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::resizeEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::scrollContentsBy(int dx, int dy)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&dx, (void*)&dy};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::scrollContentsBy(dx, dy);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::setupViewport(QWidget* viewport)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&viewport};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::setupViewport(viewport);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QTextEdit::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::timerEvent(QTimerEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::timerEvent(e);
|
|
|
}
|
|
|
bool PythonQtShell_QTextEdit::viewportEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::viewportEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QTextEdit::viewportSizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextEdit::viewportSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QTextEdit::wheelEvent(QWheelEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextEdit::wheelEvent(e);
|
|
|
}
|
|
|
QTextEdit* PythonQtWrapper_QTextEdit::new_QTextEdit(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTextEdit(parent); }
|
|
|
|
|
|
QTextEdit* PythonQtWrapper_QTextEdit::new_QTextEdit(const QString& text, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTextEdit(text, parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::acceptRichText(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->acceptRichText());
|
|
|
}
|
|
|
|
|
|
Qt::Alignment PythonQtWrapper_QTextEdit::alignment(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->alignment());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextEdit::anchorAt(QTextEdit* theWrappedObject, const QPoint& pos) const
|
|
|
{
|
|
|
return ( theWrappedObject->anchorAt(pos));
|
|
|
}
|
|
|
|
|
|
QTextEdit::AutoFormatting PythonQtWrapper_QTextEdit::autoFormatting(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoFormatting());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::canInsertFromMimeData(QTextEdit* theWrappedObject, const QMimeData* source) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_canInsertFromMimeData(source));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::canPaste(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->canPaste());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::changeEvent(QTextEdit* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_changeEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::contextMenuEvent(QTextEdit* theWrappedObject, QContextMenuEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_contextMenuEvent(e));
|
|
|
}
|
|
|
|
|
|
QMimeData* PythonQtWrapper_QTextEdit::createMimeDataFromSelection(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_createMimeDataFromSelection());
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QTextEdit::createStandardContextMenu(QTextEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->createStandardContextMenu());
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QTextEdit::createStandardContextMenu(QTextEdit* theWrappedObject, const QPoint& position)
|
|
|
{
|
|
|
return ( theWrappedObject->createStandardContextMenu(position));
|
|
|
}
|
|
|
|
|
|
QTextCharFormat PythonQtWrapper_QTextEdit::currentCharFormat(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentCharFormat());
|
|
|
}
|
|
|
|
|
|
QFont PythonQtWrapper_QTextEdit::currentFont(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentFont());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextEdit::cursorForPosition(QTextEdit* theWrappedObject, const QPoint& pos) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorForPosition(pos));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QTextEdit::cursorRect(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorRect());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QTextEdit::cursorRect(QTextEdit* theWrappedObject, const QTextCursor& cursor) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorRect(cursor));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextEdit::cursorWidth(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorWidth());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::doSetTextCursor(QTextEdit* theWrappedObject, const QTextCursor& cursor)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_doSetTextCursor(cursor));
|
|
|
}
|
|
|
|
|
|
QTextDocument* PythonQtWrapper_QTextEdit::document(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->document());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextEdit::documentTitle(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentTitle());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::dragEnterEvent(QTextEdit* theWrappedObject, QDragEnterEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dragEnterEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::dragLeaveEvent(QTextEdit* theWrappedObject, QDragLeaveEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dragLeaveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::dragMoveEvent(QTextEdit* theWrappedObject, QDragMoveEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dragMoveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::dropEvent(QTextEdit* theWrappedObject, QDropEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_dropEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::ensureCursorVisible(QTextEdit* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->ensureCursorVisible());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::event(QTextEdit* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
QList<QTextEdit::ExtraSelection > PythonQtWrapper_QTextEdit::extraSelections(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->extraSelections());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::find(QTextEdit* theWrappedObject, const QString& exp, QTextDocument::FindFlags options)
|
|
|
{
|
|
|
return ( theWrappedObject->find(exp, options));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::focusInEvent(QTextEdit* theWrappedObject, QFocusEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_focusInEvent(e));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::focusNextPrevChild(QTextEdit* theWrappedObject, bool next)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_focusNextPrevChild(next));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::focusOutEvent(QTextEdit* theWrappedObject, QFocusEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_focusOutEvent(e));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextEdit::fontFamily(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontFamily());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::fontItalic(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontItalic());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextEdit::fontPointSize(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontPointSize());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::fontUnderline(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontUnderline());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextEdit::fontWeight(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontWeight());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::inputMethodEvent(QTextEdit* theWrappedObject, QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_inputMethodEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QTextEdit::inputMethodQuery(QTextEdit* theWrappedObject, Qt::InputMethodQuery property) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_inputMethodQuery(property));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::insertFromMimeData(QTextEdit* theWrappedObject, const QMimeData* source)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_insertFromMimeData(source));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::isReadOnly(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isReadOnly());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::isUndoRedoEnabled(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isUndoRedoEnabled());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::keyPressEvent(QTextEdit* theWrappedObject, QKeyEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_keyPressEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::keyReleaseEvent(QTextEdit* theWrappedObject, QKeyEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_keyReleaseEvent(e));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextEdit::lineWrapColumnOrWidth(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lineWrapColumnOrWidth());
|
|
|
}
|
|
|
|
|
|
QTextEdit::LineWrapMode PythonQtWrapper_QTextEdit::lineWrapMode(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lineWrapMode());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QTextEdit::loadResource(QTextEdit* theWrappedObject, int type, const QUrl& name)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_loadResource(type, name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::mergeCurrentCharFormat(QTextEdit* theWrappedObject, const QTextCharFormat& modifier)
|
|
|
{
|
|
|
( theWrappedObject->mergeCurrentCharFormat(modifier));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::mouseDoubleClickEvent(QTextEdit* theWrappedObject, QMouseEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mouseDoubleClickEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::mouseMoveEvent(QTextEdit* theWrappedObject, QMouseEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mouseMoveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::mousePressEvent(QTextEdit* theWrappedObject, QMouseEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mousePressEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::mouseReleaseEvent(QTextEdit* theWrappedObject, QMouseEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_mouseReleaseEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::moveCursor(QTextEdit* theWrappedObject, QTextCursor::MoveOperation operation, QTextCursor::MoveMode mode)
|
|
|
{
|
|
|
( theWrappedObject->moveCursor(operation, mode));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::overwriteMode(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->overwriteMode());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::paintEvent(QTextEdit* theWrappedObject, QPaintEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_paintEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::resizeEvent(QTextEdit* theWrappedObject, QResizeEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_resizeEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::scrollContentsBy(QTextEdit* theWrappedObject, int dx, int dy)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_scrollContentsBy(dx, dy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setAcceptRichText(QTextEdit* theWrappedObject, bool accept)
|
|
|
{
|
|
|
( theWrappedObject->setAcceptRichText(accept));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setAutoFormatting(QTextEdit* theWrappedObject, QTextEdit::AutoFormatting features)
|
|
|
{
|
|
|
( theWrappedObject->setAutoFormatting(features));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setCurrentCharFormat(QTextEdit* theWrappedObject, const QTextCharFormat& format)
|
|
|
{
|
|
|
( theWrappedObject->setCurrentCharFormat(format));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setCursorWidth(QTextEdit* theWrappedObject, int width)
|
|
|
{
|
|
|
( theWrappedObject->setCursorWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setDocument(QTextEdit* theWrappedObject, QTextDocument* document)
|
|
|
{
|
|
|
( theWrappedObject->setDocument(document));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setDocumentTitle(QTextEdit* theWrappedObject, const QString& title)
|
|
|
{
|
|
|
( theWrappedObject->setDocumentTitle(title));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setExtraSelections(QTextEdit* theWrappedObject, const QList<QTextEdit::ExtraSelection >& selections)
|
|
|
{
|
|
|
( theWrappedObject->setExtraSelections(selections));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setLineWrapColumnOrWidth(QTextEdit* theWrappedObject, int w)
|
|
|
{
|
|
|
( theWrappedObject->setLineWrapColumnOrWidth(w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setLineWrapMode(QTextEdit* theWrappedObject, QTextEdit::LineWrapMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setLineWrapMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setOverwriteMode(QTextEdit* theWrappedObject, bool overwrite)
|
|
|
{
|
|
|
( theWrappedObject->setOverwriteMode(overwrite));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setReadOnly(QTextEdit* theWrappedObject, bool ro)
|
|
|
{
|
|
|
( theWrappedObject->setReadOnly(ro));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setTabChangesFocus(QTextEdit* theWrappedObject, bool b)
|
|
|
{
|
|
|
( theWrappedObject->setTabChangesFocus(b));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setTabStopWidth(QTextEdit* theWrappedObject, int width)
|
|
|
{
|
|
|
( theWrappedObject->setTabStopWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setTextCursor(QTextEdit* theWrappedObject, const QTextCursor& cursor)
|
|
|
{
|
|
|
( theWrappedObject->setTextCursor(cursor));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setTextInteractionFlags(QTextEdit* theWrappedObject, Qt::TextInteractionFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->setTextInteractionFlags(flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setUndoRedoEnabled(QTextEdit* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setUndoRedoEnabled(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::setWordWrapMode(QTextEdit* theWrappedObject, QTextOption::WrapMode policy)
|
|
|
{
|
|
|
( theWrappedObject->setWordWrapMode(policy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::showEvent(QTextEdit* theWrappedObject, QShowEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_showEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEdit::tabChangesFocus(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabChangesFocus());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextEdit::tabStopWidth(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabStopWidth());
|
|
|
}
|
|
|
|
|
|
QColor PythonQtWrapper_QTextEdit::textBackgroundColor(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textBackgroundColor());
|
|
|
}
|
|
|
|
|
|
QColor PythonQtWrapper_QTextEdit::textColor(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textColor());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextEdit::textCursor(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textCursor());
|
|
|
}
|
|
|
|
|
|
Qt::TextInteractionFlags PythonQtWrapper_QTextEdit::textInteractionFlags(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textInteractionFlags());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::timerEvent(QTextEdit* theWrappedObject, QTimerEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_timerEvent(e));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextEdit::toHtml(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toHtml());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextEdit::toPlainText(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toPlainText());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextEdit::wheelEvent(QTextEdit* theWrappedObject, QWheelEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTextEdit*)theWrappedObject)->promoted_wheelEvent(e));
|
|
|
}
|
|
|
|
|
|
QTextOption::WrapMode PythonQtWrapper_QTextEdit::wordWrapMode(QTextEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->wordWrapMode());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextEdit_ExtraSelection::~PythonQtShell_QTextEdit_ExtraSelection() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextEdit::ExtraSelection* PythonQtWrapper_QTextEdit_ExtraSelection::new_QTextEdit_ExtraSelection()
|
|
|
{
|
|
|
return new PythonQtShell_QTextEdit_ExtraSelection(); }
|
|
|
|
|
|
|
|
|
|
|
|
QTextFragment* PythonQtWrapper_QTextFragment::new_QTextFragment()
|
|
|
{
|
|
|
return new QTextFragment(); }
|
|
|
|
|
|
QTextFragment* PythonQtWrapper_QTextFragment::new_QTextFragment(const QTextFragment& o)
|
|
|
{
|
|
|
return new QTextFragment(o); }
|
|
|
|
|
|
QTextCharFormat PythonQtWrapper_QTextFragment::charFormat(QTextFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->charFormat());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextFragment::charFormatIndex(QTextFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->charFormatIndex());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextFragment::contains(QTextFragment* theWrappedObject, int position) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(position));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextFragment::isValid(QTextFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextFragment::length(QTextFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->length());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextFragment::__ne__(QTextFragment* theWrappedObject, const QTextFragment& o) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= o);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextFragment::__lt__(QTextFragment* theWrappedObject, const QTextFragment& o) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)< o);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextFragment::__eq__(QTextFragment* theWrappedObject, const QTextFragment& o) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== o);
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextFragment::position(QTextFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->position());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextFragment::text(QTextFragment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->text());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextFrame::~PythonQtShell_QTextFrame() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTextFrame::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextFrame::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextFrame::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextFrame::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextFrame::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextFrame::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextFrame::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextFrame::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTextFrame::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextFrame::timerEvent(arg__1);
|
|
|
}
|
|
|
QTextFrame* PythonQtWrapper_QTextFrame::new_QTextFrame(QTextDocument* doc)
|
|
|
{
|
|
|
return new PythonQtShell_QTextFrame(doc); }
|
|
|
|
|
|
QTextFrame::iterator PythonQtWrapper_QTextFrame::begin(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->begin());
|
|
|
}
|
|
|
|
|
|
QList<QTextFrame* > PythonQtWrapper_QTextFrame::childFrames(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->childFrames());
|
|
|
}
|
|
|
|
|
|
QTextFrame::iterator PythonQtWrapper_QTextFrame::end(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->end());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextFrame::firstCursorPosition(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->firstCursorPosition());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextFrame::firstPosition(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->firstPosition());
|
|
|
}
|
|
|
|
|
|
QTextFrameFormat PythonQtWrapper_QTextFrame::frameFormat(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->frameFormat());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextFrame::lastCursorPosition(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastCursorPosition());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextFrame::lastPosition(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastPosition());
|
|
|
}
|
|
|
|
|
|
QTextFrame* PythonQtWrapper_QTextFrame::parentFrame(QTextFrame* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->parentFrame());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrame::setFrameFormat(QTextFrame* theWrappedObject, const QTextFrameFormat& format)
|
|
|
{
|
|
|
( theWrappedObject->setFrameFormat(format));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextFrameFormat::~PythonQtShell_QTextFrameFormat() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextFrameFormat* PythonQtWrapper_QTextFrameFormat::new_QTextFrameFormat()
|
|
|
{
|
|
|
return new PythonQtShell_QTextFrameFormat(); }
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::border(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->border());
|
|
|
}
|
|
|
|
|
|
QBrush PythonQtWrapper_QTextFrameFormat::borderBrush(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->borderBrush());
|
|
|
}
|
|
|
|
|
|
QTextFrameFormat::BorderStyle PythonQtWrapper_QTextFrameFormat::borderStyle(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->borderStyle());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::bottomMargin(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->bottomMargin());
|
|
|
}
|
|
|
|
|
|
QTextLength PythonQtWrapper_QTextFrameFormat::height(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->height());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextFrameFormat::isValid(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::leftMargin(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->leftMargin());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::margin(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->margin());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::padding(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->padding());
|
|
|
}
|
|
|
|
|
|
QTextFormat::PageBreakFlags PythonQtWrapper_QTextFrameFormat::pageBreakPolicy(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pageBreakPolicy());
|
|
|
}
|
|
|
|
|
|
QTextFrameFormat::Position PythonQtWrapper_QTextFrameFormat::position(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->position());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::rightMargin(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rightMargin());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setBorder(QTextFrameFormat* theWrappedObject, qreal border)
|
|
|
{
|
|
|
( theWrappedObject->setBorder(border));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setBorderBrush(QTextFrameFormat* theWrappedObject, const QBrush& brush)
|
|
|
{
|
|
|
( theWrappedObject->setBorderBrush(brush));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setBorderStyle(QTextFrameFormat* theWrappedObject, QTextFrameFormat::BorderStyle style)
|
|
|
{
|
|
|
( theWrappedObject->setBorderStyle(style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setBottomMargin(QTextFrameFormat* theWrappedObject, qreal margin)
|
|
|
{
|
|
|
( theWrappedObject->setBottomMargin(margin));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setHeight(QTextFrameFormat* theWrappedObject, const QTextLength& height)
|
|
|
{
|
|
|
( theWrappedObject->setHeight(height));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setHeight(QTextFrameFormat* theWrappedObject, qreal height)
|
|
|
{
|
|
|
( theWrappedObject->setHeight(height));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setLeftMargin(QTextFrameFormat* theWrappedObject, qreal margin)
|
|
|
{
|
|
|
( theWrappedObject->setLeftMargin(margin));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setMargin(QTextFrameFormat* theWrappedObject, qreal margin)
|
|
|
{
|
|
|
( theWrappedObject->setMargin(margin));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setPadding(QTextFrameFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setPadding(padding));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setPageBreakPolicy(QTextFrameFormat* theWrappedObject, QTextFormat::PageBreakFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->setPageBreakPolicy(flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setPosition(QTextFrameFormat* theWrappedObject, QTextFrameFormat::Position f)
|
|
|
{
|
|
|
( theWrappedObject->setPosition(f));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setRightMargin(QTextFrameFormat* theWrappedObject, qreal margin)
|
|
|
{
|
|
|
( theWrappedObject->setRightMargin(margin));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setTopMargin(QTextFrameFormat* theWrappedObject, qreal margin)
|
|
|
{
|
|
|
( theWrappedObject->setTopMargin(margin));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setWidth(QTextFrameFormat* theWrappedObject, const QTextLength& length)
|
|
|
{
|
|
|
( theWrappedObject->setWidth(length));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextFrameFormat::setWidth(QTextFrameFormat* theWrappedObject, qreal width)
|
|
|
{
|
|
|
( theWrappedObject->setWidth(width));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextFrameFormat::topMargin(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->topMargin());
|
|
|
}
|
|
|
|
|
|
QTextLength PythonQtWrapper_QTextFrameFormat::width(QTextFrameFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextImageFormat::~PythonQtShell_QTextImageFormat() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextImageFormat* PythonQtWrapper_QTextImageFormat::new_QTextImageFormat()
|
|
|
{
|
|
|
return new PythonQtShell_QTextImageFormat(); }
|
|
|
|
|
|
qreal PythonQtWrapper_QTextImageFormat::height(QTextImageFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->height());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextImageFormat::isValid(QTextImageFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextImageFormat::name(QTextImageFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->name());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextImageFormat::setHeight(QTextImageFormat* theWrappedObject, qreal height)
|
|
|
{
|
|
|
( theWrappedObject->setHeight(height));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextImageFormat::setName(QTextImageFormat* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->setName(name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextImageFormat::setWidth(QTextImageFormat* theWrappedObject, qreal width)
|
|
|
{
|
|
|
( theWrappedObject->setWidth(width));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextImageFormat::width(QTextImageFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextInlineObject* PythonQtWrapper_QTextInlineObject::new_QTextInlineObject()
|
|
|
{
|
|
|
return new QTextInlineObject(); }
|
|
|
|
|
|
qreal PythonQtWrapper_QTextInlineObject::ascent(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->ascent());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextInlineObject::descent(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->descent());
|
|
|
}
|
|
|
|
|
|
QTextFormat PythonQtWrapper_QTextInlineObject::format(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextInlineObject::formatIndex(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->formatIndex());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextInlineObject::height(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->height());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextInlineObject::isValid(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTextInlineObject::rect(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rect());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextInlineObject::setAscent(QTextInlineObject* theWrappedObject, qreal a)
|
|
|
{
|
|
|
( theWrappedObject->setAscent(a));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextInlineObject::setDescent(QTextInlineObject* theWrappedObject, qreal d)
|
|
|
{
|
|
|
( theWrappedObject->setDescent(d));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextInlineObject::setWidth(QTextInlineObject* theWrappedObject, qreal w)
|
|
|
{
|
|
|
( theWrappedObject->setWidth(w));
|
|
|
}
|
|
|
|
|
|
Qt::LayoutDirection PythonQtWrapper_QTextInlineObject::textDirection(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textDirection());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextInlineObject::textPosition(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textPosition());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextInlineObject::width(QTextInlineObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextItem::~PythonQtShell_QTextItem() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextItem* PythonQtWrapper_QTextItem::new_QTextItem()
|
|
|
{
|
|
|
return new PythonQtShell_QTextItem(); }
|
|
|
|
|
|
qreal PythonQtWrapper_QTextItem::ascent(QTextItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->ascent());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextItem::descent(QTextItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->descent());
|
|
|
}
|
|
|
|
|
|
QFont PythonQtWrapper_QTextItem::font(QTextItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->font());
|
|
|
}
|
|
|
|
|
|
QTextItem::RenderFlags PythonQtWrapper_QTextItem::renderFlags(QTextItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->renderFlags());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextItem::text(QTextItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->text());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextItem::width(QTextItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextLine* PythonQtWrapper_QTextLine::new_QTextLine()
|
|
|
{
|
|
|
return new QTextLine(); }
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::ascent(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->ascent());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::cursorToX(QTextLine* theWrappedObject, int cursorPos, QTextLine::Edge edge) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorToX(cursorPos, edge));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::descent(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->descent());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextLine::draw(QTextLine* theWrappedObject, QPainter* p, const QPointF& point, const QTextLayout::FormatRange* selection) const
|
|
|
{
|
|
|
( theWrappedObject->draw(p, point, selection));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::height(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->height());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::horizontalAdvance(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->horizontalAdvance());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextLine::isValid(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::leading(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->leading());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextLine::leadingIncluded(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->leadingIncluded());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextLine::lineNumber(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lineNumber());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTextLine::naturalTextRect(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->naturalTextRect());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::naturalTextWidth(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->naturalTextWidth());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTextLine::position(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->position());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTextLine::rect(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rect());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextLine::setLeadingIncluded(QTextLine* theWrappedObject, bool included)
|
|
|
{
|
|
|
( theWrappedObject->setLeadingIncluded(included));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextLine::setLineWidth(QTextLine* theWrappedObject, qreal width)
|
|
|
{
|
|
|
( theWrappedObject->setLineWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextLine::setNumColumns(QTextLine* theWrappedObject, int columns)
|
|
|
{
|
|
|
( theWrappedObject->setNumColumns(columns));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextLine::setNumColumns(QTextLine* theWrappedObject, int columns, qreal alignmentWidth)
|
|
|
{
|
|
|
( theWrappedObject->setNumColumns(columns, alignmentWidth));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextLine::setPosition(QTextLine* theWrappedObject, const QPointF& pos)
|
|
|
{
|
|
|
( theWrappedObject->setPosition(pos));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextLine::textLength(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textLength());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextLine::textStart(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textStart());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::width(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::x(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->x());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextLine::xToCursor(QTextLine* theWrappedObject, qreal x, QTextLine::CursorPosition arg__2) const
|
|
|
{
|
|
|
return ( theWrappedObject->xToCursor(x, arg__2));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextLine::y(QTextLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->y());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextList::~PythonQtShell_QTextList() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTextList::blockFormatChanged(const QTextBlock& block)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "blockFormatChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QTextBlock&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&block};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextList::blockFormatChanged(block);
|
|
|
}
|
|
|
void PythonQtShell_QTextList::blockInserted(const QTextBlock& block)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "blockInserted");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QTextBlock&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&block};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextList::blockInserted(block);
|
|
|
}
|
|
|
void PythonQtShell_QTextList::blockRemoved(const QTextBlock& block)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "blockRemoved");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QTextBlock&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&block};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextList::blockRemoved(block);
|
|
|
}
|
|
|
void PythonQtShell_QTextList::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextList::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextList::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextList::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextList::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextList::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextList::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextList::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTextList::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextList::timerEvent(arg__1);
|
|
|
}
|
|
|
QTextList* PythonQtWrapper_QTextList::new_QTextList(QTextDocument* doc)
|
|
|
{
|
|
|
return new PythonQtShell_QTextList(doc); }
|
|
|
|
|
|
void PythonQtWrapper_QTextList::add(QTextList* theWrappedObject, const QTextBlock& block)
|
|
|
{
|
|
|
( theWrappedObject->add(block));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextList::count(QTextList* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->count());
|
|
|
}
|
|
|
|
|
|
QTextListFormat PythonQtWrapper_QTextList::format(QTextList* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
QTextBlock PythonQtWrapper_QTextList::item(QTextList* theWrappedObject, int i) const
|
|
|
{
|
|
|
return ( theWrappedObject->item(i));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextList::itemNumber(QTextList* theWrappedObject, const QTextBlock& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemNumber(arg__1));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextList::itemText(QTextList* theWrappedObject, const QTextBlock& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemText(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextList::remove(QTextList* theWrappedObject, const QTextBlock& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->remove(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextList::removeItem(QTextList* theWrappedObject, int i)
|
|
|
{
|
|
|
( theWrappedObject->removeItem(i));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextList::setFormat(QTextList* theWrappedObject, const QTextListFormat& format)
|
|
|
{
|
|
|
( theWrappedObject->setFormat(format));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextListFormat::~PythonQtShell_QTextListFormat() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextListFormat* PythonQtWrapper_QTextListFormat::new_QTextListFormat()
|
|
|
{
|
|
|
return new PythonQtShell_QTextListFormat(); }
|
|
|
|
|
|
int PythonQtWrapper_QTextListFormat::indent(QTextListFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->indent());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextListFormat::isValid(QTextListFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextListFormat::numberPrefix(QTextListFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->numberPrefix());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextListFormat::numberSuffix(QTextListFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->numberSuffix());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextListFormat::setIndent(QTextListFormat* theWrappedObject, int indent)
|
|
|
{
|
|
|
( theWrappedObject->setIndent(indent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextListFormat::setNumberPrefix(QTextListFormat* theWrappedObject, const QString& numberPrefix)
|
|
|
{
|
|
|
( theWrappedObject->setNumberPrefix(numberPrefix));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextListFormat::setNumberSuffix(QTextListFormat* theWrappedObject, const QString& numberSuffix)
|
|
|
{
|
|
|
( theWrappedObject->setNumberSuffix(numberSuffix));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextListFormat::setStyle(QTextListFormat* theWrappedObject, QTextListFormat::Style style)
|
|
|
{
|
|
|
( theWrappedObject->setStyle(style));
|
|
|
}
|
|
|
|
|
|
QTextListFormat::Style PythonQtWrapper_QTextListFormat::style(QTextListFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->style());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextObject::~PythonQtShell_QTextObject() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTextObject::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextObject::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextObject::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextObject::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextObject::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextObject::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextObject::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextObject::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTextObject::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextObject::timerEvent(arg__1);
|
|
|
}
|
|
|
QTextDocument* PythonQtWrapper_QTextObject::document(QTextObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->document());
|
|
|
}
|
|
|
|
|
|
QTextFormat PythonQtWrapper_QTextObject::format(QTextObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextObject::formatIndex(QTextObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->formatIndex());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextObject::objectIndex(QTextObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->objectIndex());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextTable::~PythonQtShell_QTextTable() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTextTable::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextTable::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTextTable::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextTable::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextTable::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextTable::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTextTable::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextTable::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTextTable::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTextTable::timerEvent(arg__1);
|
|
|
}
|
|
|
QTextTable* PythonQtWrapper_QTextTable::new_QTextTable(QTextDocument* doc)
|
|
|
{
|
|
|
return new PythonQtShell_QTextTable(doc); }
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::appendColumns(QTextTable* theWrappedObject, int count)
|
|
|
{
|
|
|
( theWrappedObject->appendColumns(count));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::appendRows(QTextTable* theWrappedObject, int count)
|
|
|
{
|
|
|
( theWrappedObject->appendRows(count));
|
|
|
}
|
|
|
|
|
|
QTextTableCell PythonQtWrapper_QTextTable::cellAt(QTextTable* theWrappedObject, const QTextCursor& c) const
|
|
|
{
|
|
|
return ( theWrappedObject->cellAt(c));
|
|
|
}
|
|
|
|
|
|
QTextTableCell PythonQtWrapper_QTextTable::cellAt(QTextTable* theWrappedObject, int position) const
|
|
|
{
|
|
|
return ( theWrappedObject->cellAt(position));
|
|
|
}
|
|
|
|
|
|
QTextTableCell PythonQtWrapper_QTextTable::cellAt(QTextTable* theWrappedObject, int row, int col) const
|
|
|
{
|
|
|
return ( theWrappedObject->cellAt(row, col));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTable::columns(QTextTable* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->columns());
|
|
|
}
|
|
|
|
|
|
QTextTableFormat PythonQtWrapper_QTextTable::format(QTextTable* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::insertColumns(QTextTable* theWrappedObject, int pos, int num)
|
|
|
{
|
|
|
( theWrappedObject->insertColumns(pos, num));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::insertRows(QTextTable* theWrappedObject, int pos, int num)
|
|
|
{
|
|
|
( theWrappedObject->insertRows(pos, num));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::mergeCells(QTextTable* theWrappedObject, const QTextCursor& cursor)
|
|
|
{
|
|
|
( theWrappedObject->mergeCells(cursor));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::mergeCells(QTextTable* theWrappedObject, int row, int col, int numRows, int numCols)
|
|
|
{
|
|
|
( theWrappedObject->mergeCells(row, col, numRows, numCols));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::removeColumns(QTextTable* theWrappedObject, int pos, int num)
|
|
|
{
|
|
|
( theWrappedObject->removeColumns(pos, num));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::removeRows(QTextTable* theWrappedObject, int pos, int num)
|
|
|
{
|
|
|
( theWrappedObject->removeRows(pos, num));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::resize(QTextTable* theWrappedObject, int rows, int cols)
|
|
|
{
|
|
|
( theWrappedObject->resize(rows, cols));
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextTable::rowEnd(QTextTable* theWrappedObject, const QTextCursor& c) const
|
|
|
{
|
|
|
return ( theWrappedObject->rowEnd(c));
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextTable::rowStart(QTextTable* theWrappedObject, const QTextCursor& c) const
|
|
|
{
|
|
|
return ( theWrappedObject->rowStart(c));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTable::rows(QTextTable* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rows());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::setFormat(QTextTable* theWrappedObject, const QTextTableFormat& format)
|
|
|
{
|
|
|
( theWrappedObject->setFormat(format));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTable::splitCell(QTextTable* theWrappedObject, int row, int col, int numRows, int numCols)
|
|
|
{
|
|
|
( theWrappedObject->splitCell(row, col, numRows, numCols));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextTableCell* PythonQtWrapper_QTextTableCell::new_QTextTableCell()
|
|
|
{
|
|
|
return new QTextTableCell(); }
|
|
|
|
|
|
QTextTableCell* PythonQtWrapper_QTextTableCell::new_QTextTableCell(const QTextTableCell& o)
|
|
|
{
|
|
|
return new QTextTableCell(o); }
|
|
|
|
|
|
QTextFrame::iterator PythonQtWrapper_QTextTableCell::begin(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->begin());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::column(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->column());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::columnSpan(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->columnSpan());
|
|
|
}
|
|
|
|
|
|
QTextFrame::iterator PythonQtWrapper_QTextTableCell::end(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->end());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextTableCell::firstCursorPosition(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->firstCursorPosition());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::firstPosition(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->firstPosition());
|
|
|
}
|
|
|
|
|
|
QTextCharFormat PythonQtWrapper_QTextTableCell::format(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextTableCell::isValid(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
QTextCursor PythonQtWrapper_QTextTableCell::lastCursorPosition(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastCursorPosition());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::lastPosition(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastPosition());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextTableCell::__ne__(QTextTableCell* theWrappedObject, const QTextTableCell& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextTableCell::__eq__(QTextTableCell* theWrappedObject, const QTextTableCell& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::row(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->row());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::rowSpan(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rowSpan());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableCell::setFormat(QTextTableCell* theWrappedObject, const QTextCharFormat& format)
|
|
|
{
|
|
|
( theWrappedObject->setFormat(format));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableCell::tableCellFormatIndex(QTextTableCell* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tableCellFormatIndex());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextTableCellFormat::~PythonQtShell_QTextTableCellFormat() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextTableCellFormat* PythonQtWrapper_QTextTableCellFormat::new_QTextTableCellFormat()
|
|
|
{
|
|
|
return new PythonQtShell_QTextTableCellFormat(); }
|
|
|
|
|
|
qreal PythonQtWrapper_QTextTableCellFormat::bottomPadding(QTextTableCellFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->bottomPadding());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextTableCellFormat::isValid(QTextTableCellFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextTableCellFormat::leftPadding(QTextTableCellFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->leftPadding());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextTableCellFormat::rightPadding(QTextTableCellFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rightPadding());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableCellFormat::setBottomPadding(QTextTableCellFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setBottomPadding(padding));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableCellFormat::setLeftPadding(QTextTableCellFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setLeftPadding(padding));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableCellFormat::setPadding(QTextTableCellFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setPadding(padding));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableCellFormat::setRightPadding(QTextTableCellFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setRightPadding(padding));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableCellFormat::setTopPadding(QTextTableCellFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setTopPadding(padding));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextTableCellFormat::topPadding(QTextTableCellFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->topPadding());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextTableFormat::~PythonQtShell_QTextTableFormat() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextTableFormat* PythonQtWrapper_QTextTableFormat::new_QTextTableFormat()
|
|
|
{
|
|
|
return new PythonQtShell_QTextTableFormat(); }
|
|
|
|
|
|
Qt::Alignment PythonQtWrapper_QTextTableFormat::alignment(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->alignment());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextTableFormat::cellPadding(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cellPadding());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTextTableFormat::cellSpacing(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cellSpacing());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::clearColumnWidthConstraints(QTextTableFormat* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clearColumnWidthConstraints());
|
|
|
}
|
|
|
|
|
|
QVector<QTextLength > PythonQtWrapper_QTextTableFormat::columnWidthConstraints(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->columnWidthConstraints());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableFormat::columns(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->columns());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextTableFormat::headerRowCount(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->headerRowCount());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextTableFormat::isValid(QTextTableFormat* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::setAlignment(QTextTableFormat* theWrappedObject, Qt::Alignment alignment)
|
|
|
{
|
|
|
( theWrappedObject->setAlignment(alignment));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::setCellPadding(QTextTableFormat* theWrappedObject, qreal padding)
|
|
|
{
|
|
|
( theWrappedObject->setCellPadding(padding));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::setCellSpacing(QTextTableFormat* theWrappedObject, qreal spacing)
|
|
|
{
|
|
|
( theWrappedObject->setCellSpacing(spacing));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::setColumnWidthConstraints(QTextTableFormat* theWrappedObject, const QVector<QTextLength >& constraints)
|
|
|
{
|
|
|
( theWrappedObject->setColumnWidthConstraints(constraints));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::setColumns(QTextTableFormat* theWrappedObject, int columns)
|
|
|
{
|
|
|
( theWrappedObject->setColumns(columns));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextTableFormat::setHeaderRowCount(QTextTableFormat* theWrappedObject, int count)
|
|
|
{
|
|
|
( theWrappedObject->setHeaderRowCount(count));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTileRules::~PythonQtShell_QTileRules() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTileRules* PythonQtWrapper_QTileRules::new_QTileRules(Qt::TileRule horizontalRule, Qt::TileRule verticalRule)
|
|
|
{
|
|
|
return new PythonQtShell_QTileRules(horizontalRule, verticalRule); }
|
|
|
|
|
|
QTileRules* PythonQtWrapper_QTileRules::new_QTileRules(Qt::TileRule rule)
|
|
|
{
|
|
|
return new PythonQtShell_QTileRules(rule); }
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTimeEdit::~PythonQtShell_QTimeEdit() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::changeEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::changeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::clear()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::clear();
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::closeEvent(QCloseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::closeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::contextMenuEvent(QContextMenuEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::contextMenuEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::customEvent(arg__1);
|
|
|
}
|
|
|
QDateTime PythonQtShell_QTimeEdit::dateTimeFromText(const QString& text) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dateTimeFromText");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QDateTime" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QDateTime returnValue;
|
|
|
void* args[2] = {NULL, (void*)&text};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("dateTimeFromText", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QDateTime*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::dateTimeFromText(text);
|
|
|
}
|
|
|
int PythonQtShell_QTimeEdit::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::devType();
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeEdit::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::fixup(QString& input) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&input};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::fixup(input);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::focusInEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::focusInEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeEdit::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::focusOutEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::focusOutEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeEdit::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QTimeEdit::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::hideEvent(QHideEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::hideEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::initPainter(QPainter* painter) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::initPainter(painter);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QTimeEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::keyPressEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::keyPressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::keyReleaseEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::keyReleaseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QTimeEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::mouseMoveEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::mouseMoveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::mousePressEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::mousePressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::mouseReleaseEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::mouseReleaseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::nativeEvent(eventType, message, result);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QTimeEdit::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::paintEvent(QPaintEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::paintEvent(event);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QTimeEdit::redirected(QPoint* offset) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::redirected(offset);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::resizeEvent(QResizeEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::resizeEvent(event);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QTimeEdit::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::showEvent(QShowEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::showEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::stepBy(int steps)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&steps};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::stepBy(steps);
|
|
|
}
|
|
|
QAbstractSpinBox::StepEnabled PythonQtShell_QTimeEdit::stepEnabled() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QAbstractSpinBox::StepEnabled returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::stepEnabled();
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::tabletEvent(arg__1);
|
|
|
}
|
|
|
QString PythonQtShell_QTimeEdit::textFromDateTime(const QDateTime& dt) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromDateTime");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QString" , "const QDateTime&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QString returnValue;
|
|
|
void* args[2] = {NULL, (void*)&dt};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("textFromDateTime", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QString*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::textFromDateTime(dt);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::timerEvent(QTimerEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::timerEvent(event);
|
|
|
}
|
|
|
QValidator::State PythonQtShell_QTimeEdit::validate(QString& input, int& pos) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QValidator::State returnValue;
|
|
|
void* args[3] = {NULL, (void*)&input, (void*)&pos};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QValidator::State*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeEdit::validate(input, pos);
|
|
|
}
|
|
|
void PythonQtShell_QTimeEdit::wheelEvent(QWheelEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTimeEdit::wheelEvent(event);
|
|
|
}
|
|
|
QTimeEdit* PythonQtWrapper_QTimeEdit::new_QTimeEdit(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTimeEdit(parent); }
|
|
|
|
|
|
QTimeEdit* PythonQtWrapper_QTimeEdit::new_QTimeEdit(const QTime& time, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTimeEdit(time, parent); }
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QToolBar::~PythonQtShell_QToolBar() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::actionEvent(QActionEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::actionEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::changeEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::changeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QToolBar::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::devType();
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBar::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBar::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBar::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBar::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QToolBar::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::initPainter(QPainter* painter) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::initPainter(painter);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QToolBar::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QToolBar::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QToolBar::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBar::nativeEvent(const QByteArray& eventType, void* message, long* result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::nativeEvent(eventType, message, result);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QToolBar::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::paintEvent(QPaintEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::paintEvent(event);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QToolBar::redirected(QPoint* offset) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::redirected(offset);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QToolBar::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QToolBar::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBar::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBar::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBar::wheelEvent(arg__1);
|
|
|
}
|
|
|
QToolBar* PythonQtWrapper_QToolBar::new_QToolBar(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QToolBar(parent); }
|
|
|
|
|
|
QToolBar* PythonQtWrapper_QToolBar::new_QToolBar(const QString& title, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QToolBar(title, parent); }
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::actionAt(QToolBar* theWrappedObject, const QPoint& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionAt(p));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::actionAt(QToolBar* theWrappedObject, int x, int y) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionAt(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::actionEvent(QToolBar* theWrappedObject, QActionEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_actionEvent(event));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QToolBar::actionGeometry(QToolBar* theWrappedObject, QAction* action) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionGeometry(action));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::addAction(QToolBar* theWrappedObject, const QIcon& icon, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(icon, text));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::addAction(QToolBar* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(text));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::addSeparator(QToolBar* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addSeparator());
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::addWidget(QToolBar* theWrappedObject, QWidget* widget)
|
|
|
{
|
|
|
return ( theWrappedObject->addWidget(widget));
|
|
|
}
|
|
|
|
|
|
Qt::ToolBarAreas PythonQtWrapper_QToolBar::allowedAreas(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->allowedAreas());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::changeEvent(QToolBar* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_changeEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::clear(QToolBar* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBar::event(QToolBar* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QToolBar::iconSize(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->iconSize());
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::insertSeparator(QToolBar* theWrappedObject, QAction* before)
|
|
|
{
|
|
|
return ( theWrappedObject->insertSeparator(before));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::insertWidget(QToolBar* theWrappedObject, QAction* before, QWidget* widget)
|
|
|
{
|
|
|
return ( theWrappedObject->insertWidget(before, widget));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBar::isAreaAllowed(QToolBar* theWrappedObject, Qt::ToolBarArea area) const
|
|
|
{
|
|
|
return ( theWrappedObject->isAreaAllowed(area));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBar::isFloatable(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isFloatable());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBar::isFloating(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isFloating());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBar::isMovable(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isMovable());
|
|
|
}
|
|
|
|
|
|
Qt::Orientation PythonQtWrapper_QToolBar::orientation(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->orientation());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::paintEvent(QToolBar* theWrappedObject, QPaintEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBar*)theWrappedObject)->promoted_paintEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::setAllowedAreas(QToolBar* theWrappedObject, Qt::ToolBarAreas areas)
|
|
|
{
|
|
|
( theWrappedObject->setAllowedAreas(areas));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::setFloatable(QToolBar* theWrappedObject, bool floatable)
|
|
|
{
|
|
|
( theWrappedObject->setFloatable(floatable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::setMovable(QToolBar* theWrappedObject, bool movable)
|
|
|
{
|
|
|
( theWrappedObject->setMovable(movable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBar::setOrientation(QToolBar* theWrappedObject, Qt::Orientation orientation)
|
|
|
{
|
|
|
( theWrappedObject->setOrientation(orientation));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolBar::toggleViewAction(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toggleViewAction());
|
|
|
}
|
|
|
|
|
|
Qt::ToolButtonStyle PythonQtWrapper_QToolBar::toolButtonStyle(QToolBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toolButtonStyle());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QToolBar::widgetForAction(QToolBar* theWrappedObject, QAction* action) const
|
|
|
{
|
|
|
return ( theWrappedObject->widgetForAction(action));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QToolBarChangeEvent* PythonQtWrapper_QToolBarChangeEvent::new_QToolBarChangeEvent(bool t)
|
|
|
{
|
|
|
return new QToolBarChangeEvent(t); }
|
|
|
|
|
|
bool PythonQtWrapper_QToolBarChangeEvent::toggle(QToolBarChangeEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toggle());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QToolBox::~PythonQtShell_QToolBox() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QToolBox::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::devType();
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBox::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBox::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBox::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBox::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QToolBox::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::initPainter(QPainter* painter) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::initPainter(painter);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QToolBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::itemInserted(int index)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemInserted");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::itemInserted(index);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::itemRemoved(int index)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemRemoved");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::itemRemoved(index);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QToolBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QToolBox::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::nativeEvent(eventType, message, result);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QToolBox::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QToolBox::redirected(QPoint* offset) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::redirected(offset);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QToolBox::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolBox::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::showEvent(QShowEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::showEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolBox::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolBox::wheelEvent(arg__1);
|
|
|
}
|
|
|
QToolBox* PythonQtWrapper_QToolBox::new_QToolBox(QWidget* parent, Qt::WindowFlags f)
|
|
|
{
|
|
|
return new PythonQtShell_QToolBox(parent, f); }
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::addItem(QToolBox* theWrappedObject, QWidget* widget, const QIcon& icon, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addItem(widget, icon, text));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::addItem(QToolBox* theWrappedObject, QWidget* widget, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addItem(widget, text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::changeEvent(QToolBox* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_changeEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::count(QToolBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->count());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::currentIndex(QToolBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentIndex());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QToolBox::currentWidget(QToolBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentWidget());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBox::event(QToolBox* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::indexOf(QToolBox* theWrappedObject, QWidget* widget) const
|
|
|
{
|
|
|
return ( theWrappedObject->indexOf(widget));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::insertItem(QToolBox* theWrappedObject, int index, QWidget* widget, const QIcon& icon, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->insertItem(index, widget, icon, text));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QToolBox::insertItem(QToolBox* theWrappedObject, int index, QWidget* widget, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->insertItem(index, widget, text));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolBox::isItemEnabled(QToolBox* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->isItemEnabled(index));
|
|
|
}
|
|
|
|
|
|
QIcon PythonQtWrapper_QToolBox::itemIcon(QToolBox* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemIcon(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::itemInserted(QToolBox* theWrappedObject, int index)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_itemInserted(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::itemRemoved(QToolBox* theWrappedObject, int index)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_itemRemoved(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QToolBox::itemText(QToolBox* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemText(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QToolBox::itemToolTip(QToolBox* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemToolTip(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::removeItem(QToolBox* theWrappedObject, int index)
|
|
|
{
|
|
|
( theWrappedObject->removeItem(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::setItemEnabled(QToolBox* theWrappedObject, int index, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setItemEnabled(index, enabled));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::setItemIcon(QToolBox* theWrappedObject, int index, const QIcon& icon)
|
|
|
{
|
|
|
( theWrappedObject->setItemIcon(index, icon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::setItemText(QToolBox* theWrappedObject, int index, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setItemText(index, text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::setItemToolTip(QToolBox* theWrappedObject, int index, const QString& toolTip)
|
|
|
{
|
|
|
( theWrappedObject->setItemToolTip(index, toolTip));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolBox::showEvent(QToolBox* theWrappedObject, QShowEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolBox*)theWrappedObject)->promoted_showEvent(e));
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QToolBox::widget(QToolBox* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->widget(index));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QToolButton::~PythonQtShell_QToolButton() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::checkStateSet()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "checkStateSet");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::checkStateSet();
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QToolButton::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::devType();
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolButton::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QToolButton::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::focusInEvent(QFocusEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::focusInEvent(e);
|
|
|
}
|
|
|
bool PythonQtShell_QToolButton::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::focusOutEvent(QFocusEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::focusOutEvent(e);
|
|
|
}
|
|
|
bool PythonQtShell_QToolButton::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QToolButton::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::hideEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolButton::hitButton(const QPoint& pos) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hitButton");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QPoint&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&pos};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hitButton", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::hitButton(pos);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::initPainter(QPainter* painter) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::initPainter(painter);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QToolButton::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::keyPressEvent(QKeyEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::keyPressEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::keyReleaseEvent(QKeyEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::keyReleaseEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QToolButton::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::mouseMoveEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::mouseMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QToolButton::nativeEvent(const QByteArray& eventType, void* message, long* result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::nativeEvent(eventType, message, result);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::nextCheckState()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextCheckState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::nextCheckState();
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QToolButton::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QToolButton::redirected(QPoint* offset) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::redirected(offset);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QToolButton::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QToolButton::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QToolButton::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QToolButton::wheelEvent(arg__1);
|
|
|
}
|
|
|
QToolButton* PythonQtWrapper_QToolButton::new_QToolButton(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QToolButton(parent); }
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::actionEvent(QToolButton* theWrappedObject, QActionEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_actionEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
Qt::ArrowType PythonQtWrapper_QToolButton::arrowType(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->arrowType());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolButton::autoRaise(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoRaise());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::changeEvent(QToolButton* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_changeEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QToolButton::defaultAction(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultAction());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::enterEvent(QToolButton* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_enterEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolButton::event(QToolButton* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolButton::hitButton(QToolButton* theWrappedObject, const QPoint& pos) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_hitButton(pos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::leaveEvent(QToolButton* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_leaveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QToolButton::menu(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->menu());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QToolButton::minimumSizeHint(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->minimumSizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::mousePressEvent(QToolButton* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_mousePressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::mouseReleaseEvent(QToolButton* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::nextCheckState(QToolButton* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_nextCheckState());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::paintEvent(QToolButton* theWrappedObject, QPaintEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_paintEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QToolButton::ToolButtonPopupMode PythonQtWrapper_QToolButton::popupMode(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->popupMode());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::setArrowType(QToolButton* theWrappedObject, Qt::ArrowType type)
|
|
|
{
|
|
|
( theWrappedObject->setArrowType(type));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::setAutoRaise(QToolButton* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setAutoRaise(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::setMenu(QToolButton* theWrappedObject, QMenu* menu)
|
|
|
{
|
|
|
( theWrappedObject->setMenu(menu));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::setPopupMode(QToolButton* theWrappedObject, QToolButton::ToolButtonPopupMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setPopupMode(mode));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QToolButton::sizeHint(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolButton::timerEvent(QToolButton* theWrappedObject, QTimerEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->promoted_timerEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
Qt::ToolButtonStyle PythonQtWrapper_QToolButton::toolButtonStyle(QToolButton* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toolButtonStyle());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QFont PythonQtWrapper_QToolTip::static_QToolTip_font()
|
|
|
{
|
|
|
return (QToolTip::font());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolTip::static_QToolTip_hideText()
|
|
|
{
|
|
|
(QToolTip::hideText());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QToolTip::static_QToolTip_isVisible()
|
|
|
{
|
|
|
return (QToolTip::isVisible());
|
|
|
}
|
|
|
|
|
|
QPalette PythonQtWrapper_QToolTip::static_QToolTip_palette()
|
|
|
{
|
|
|
return (QToolTip::palette());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolTip::static_QToolTip_setFont(const QFont& arg__1)
|
|
|
{
|
|
|
(QToolTip::setFont(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolTip::static_QToolTip_setPalette(const QPalette& arg__1)
|
|
|
{
|
|
|
(QToolTip::setPalette(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolTip::static_QToolTip_showText(const QPoint& pos, const QString& text, QWidget* w)
|
|
|
{
|
|
|
(QToolTip::showText(pos, text, w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QToolTip::static_QToolTip_showText(const QPoint& pos, const QString& text, QWidget* w, const QRect& rect)
|
|
|
{
|
|
|
(QToolTip::showText(pos, text, w, rect));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QToolTip::static_QToolTip_text()
|
|
|
{
|
|
|
return (QToolTip::text());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent::setTarget(QTouchEvent* theWrappedObject, QObject* atarget)
|
|
|
{
|
|
|
( theWrappedObject->setTarget(atarget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent::setTouchPointStates(QTouchEvent* theWrappedObject, Qt::TouchPointStates aTouchPointStates)
|
|
|
{
|
|
|
( theWrappedObject->setTouchPointStates(aTouchPointStates));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent::setTouchPoints(QTouchEvent* theWrappedObject, const QList<QTouchEvent::TouchPoint >& atouchPoints)
|
|
|
{
|
|
|
( theWrappedObject->setTouchPoints(atouchPoints));
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QTouchEvent::target(QTouchEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->target());
|
|
|
}
|
|
|
|
|
|
Qt::TouchPointStates PythonQtWrapper_QTouchEvent::touchPointStates(QTouchEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->touchPointStates());
|
|
|
}
|
|
|
|
|
|
const QList<QTouchEvent::TouchPoint >* PythonQtWrapper_QTouchEvent::touchPoints(QTouchEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->touchPoints());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTouchEvent::TouchPoint* PythonQtWrapper_QTouchEvent_TouchPoint::new_QTouchEvent_TouchPoint(const QTouchEvent::TouchPoint& other)
|
|
|
{
|
|
|
return new QTouchEvent::TouchPoint(other); }
|
|
|
|
|
|
QTouchEvent::TouchPoint* PythonQtWrapper_QTouchEvent_TouchPoint::new_QTouchEvent_TouchPoint(int id)
|
|
|
{
|
|
|
return new QTouchEvent::TouchPoint(id); }
|
|
|
|
|
|
int PythonQtWrapper_QTouchEvent_TouchPoint::id(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->id());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastNormalizedPos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastPos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastScenePos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastScenePos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::lastScreenPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastScreenPos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::normalizedPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->normalizedPos());
|
|
|
}
|
|
|
|
|
|
QTouchEvent::TouchPoint* PythonQtWrapper_QTouchEvent_TouchPoint::operator_assign(QTouchEvent::TouchPoint* theWrappedObject, const QTouchEvent::TouchPoint& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)= other);
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::pos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pos());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTouchEvent_TouchPoint::pressure(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pressure());
|
|
|
}
|
|
|
|
|
|
QVector<QPointF > PythonQtWrapper_QTouchEvent_TouchPoint::rawScreenPositions(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rawScreenPositions());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTouchEvent_TouchPoint::rect(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rect());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::scenePos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->scenePos());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTouchEvent_TouchPoint::sceneRect(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sceneRect());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::screenPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->screenPos());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTouchEvent_TouchPoint::screenRect(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->screenRect());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setId(QTouchEvent::TouchPoint* theWrappedObject, int id)
|
|
|
{
|
|
|
( theWrappedObject->setId(id));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastNormalizedPos)
|
|
|
{
|
|
|
( theWrappedObject->setLastNormalizedPos(lastNormalizedPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastPos)
|
|
|
{
|
|
|
( theWrappedObject->setLastPos(lastPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastScenePos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastScenePos)
|
|
|
{
|
|
|
( theWrappedObject->setLastScenePos(lastScenePos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setLastScreenPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& lastScreenPos)
|
|
|
{
|
|
|
( theWrappedObject->setLastScreenPos(lastScreenPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& normalizedPos)
|
|
|
{
|
|
|
( theWrappedObject->setNormalizedPos(normalizedPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& pos)
|
|
|
{
|
|
|
( theWrappedObject->setPos(pos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setPressure(QTouchEvent::TouchPoint* theWrappedObject, qreal pressure)
|
|
|
{
|
|
|
( theWrappedObject->setPressure(pressure));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setRawScreenPositions(QTouchEvent::TouchPoint* theWrappedObject, const QVector<QPointF >& positions)
|
|
|
{
|
|
|
( theWrappedObject->setRawScreenPositions(positions));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setRect(QTouchEvent::TouchPoint* theWrappedObject, const QRectF& rect)
|
|
|
{
|
|
|
( theWrappedObject->setRect(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setScenePos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& scenePos)
|
|
|
{
|
|
|
( theWrappedObject->setScenePos(scenePos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setSceneRect(QTouchEvent::TouchPoint* theWrappedObject, const QRectF& sceneRect)
|
|
|
{
|
|
|
( theWrappedObject->setSceneRect(sceneRect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setScreenPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& screenPos)
|
|
|
{
|
|
|
( theWrappedObject->setScreenPos(screenPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setScreenRect(QTouchEvent::TouchPoint* theWrappedObject, const QRectF& screenRect)
|
|
|
{
|
|
|
( theWrappedObject->setScreenRect(screenRect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startNormalizedPos)
|
|
|
{
|
|
|
( theWrappedObject->setStartNormalizedPos(startNormalizedPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startPos)
|
|
|
{
|
|
|
( theWrappedObject->setStartPos(startPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartScenePos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startScenePos)
|
|
|
{
|
|
|
( theWrappedObject->setStartScenePos(startScenePos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setStartScreenPos(QTouchEvent::TouchPoint* theWrappedObject, const QPointF& startScreenPos)
|
|
|
{
|
|
|
( theWrappedObject->setStartScreenPos(startScreenPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setState(QTouchEvent::TouchPoint* theWrappedObject, Qt::TouchPointStates state)
|
|
|
{
|
|
|
( theWrappedObject->setState(state));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::setVelocity(QTouchEvent::TouchPoint* theWrappedObject, const QVector2D& v)
|
|
|
{
|
|
|
( theWrappedObject->setVelocity(v));
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startNormalizedPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->startNormalizedPos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->startPos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startScenePos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->startScenePos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTouchEvent_TouchPoint::startScreenPos(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->startScreenPos());
|
|
|
}
|
|
|
|
|
|
Qt::TouchPointState PythonQtWrapper_QTouchEvent_TouchPoint::state(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->state());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTouchEvent_TouchPoint::swap(QTouchEvent::TouchPoint* theWrappedObject, QTouchEvent::TouchPoint& other)
|
|
|
{
|
|
|
( theWrappedObject->swap(other));
|
|
|
}
|
|
|
|
|
|
QVector2D PythonQtWrapper_QTouchEvent_TouchPoint::velocity(QTouchEvent::TouchPoint* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->velocity());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::new_QTransform()
|
|
|
{
|
|
|
return new QTransform(); }
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::new_QTransform(const QMatrix& mtx)
|
|
|
{
|
|
|
return new QTransform(mtx); }
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::new_QTransform(qreal h11, qreal h12, qreal h13, qreal h21, qreal h22, qreal h23, qreal h31, qreal h32, qreal h33)
|
|
|
{
|
|
|
return new QTransform(h11, h12, h13, h21, h22, h23, h31, h32, h33); }
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::new_QTransform(qreal h11, qreal h12, qreal h21, qreal h22, qreal dx, qreal dy)
|
|
|
{
|
|
|
return new QTransform(h11, h12, h21, h22, dx, dy); }
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::adjoint(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->adjoint());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::det(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->det());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::determinant(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->determinant());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::dx(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dx());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::dy(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dy());
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::static_QTransform_fromScale(qreal dx, qreal dy)
|
|
|
{
|
|
|
return (QTransform::fromScale(dx, dy));
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::static_QTransform_fromTranslate(qreal dx, qreal dy)
|
|
|
{
|
|
|
return (QTransform::fromTranslate(dx, dy));
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::inverted(QTransform* theWrappedObject, bool* invertible) const
|
|
|
{
|
|
|
return ( theWrappedObject->inverted(invertible));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::isAffine(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isAffine());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::isIdentity(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isIdentity());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::isInvertible(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isInvertible());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::isRotating(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isRotating());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::isScaling(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isScaling());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::isTranslating(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isTranslating());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m11(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m11());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m12(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m12());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m13(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m13());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m21(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m21());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m22(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m22());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m23(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m23());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m31(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m31());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m32(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m32());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTransform::m33(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->m33());
|
|
|
}
|
|
|
|
|
|
QLine PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QLine& l) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(l));
|
|
|
}
|
|
|
|
|
|
QLineF PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QLineF& l) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(l));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPainterPath& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(p));
|
|
|
}
|
|
|
|
|
|
QPoint PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPoint& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(p));
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPointF& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(p));
|
|
|
}
|
|
|
|
|
|
QPolygon PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPolygon& a) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(a));
|
|
|
}
|
|
|
|
|
|
QPolygonF PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPolygonF& a) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(a));
|
|
|
}
|
|
|
|
|
|
QRegion PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QRegion& r) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(r));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QTransform::mapRect(QTransform* theWrappedObject, const QRect& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapRect(arg__1));
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QTransform::mapRect(QTransform* theWrappedObject, const QRectF& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapRect(arg__1));
|
|
|
}
|
|
|
|
|
|
QPolygon PythonQtWrapper_QTransform::mapToPolygon(QTransform* theWrappedObject, const QRect& r) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapToPolygon(r));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::__ne__(QTransform* theWrappedObject, const QTransform& arg__1) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= arg__1);
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::multiplied(QTransform* theWrappedObject, const QTransform& o) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)* o);
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::__mul__(QTransform* theWrappedObject, qreal n)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* n);
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::__imul__(QTransform* theWrappedObject, const QTransform& arg__1)
|
|
|
{
|
|
|
return &( (*theWrappedObject)*= arg__1);
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::__imul__(QTransform* theWrappedObject, qreal div)
|
|
|
{
|
|
|
return &( (*theWrappedObject)*= div);
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::__add__(QTransform* theWrappedObject, qreal n)
|
|
|
{
|
|
|
return ( (*theWrappedObject)+ n);
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::__iadd__(QTransform* theWrappedObject, qreal div)
|
|
|
{
|
|
|
return &( (*theWrappedObject)+= div);
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::__sub__(QTransform* theWrappedObject, qreal n)
|
|
|
{
|
|
|
return ( (*theWrappedObject)- n);
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::__isub__(QTransform* theWrappedObject, qreal div)
|
|
|
{
|
|
|
return &( (*theWrappedObject)-= div);
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::__div__(QTransform* theWrappedObject, qreal n)
|
|
|
{
|
|
|
return ( (*theWrappedObject)/ n);
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::__idiv__(QTransform* theWrappedObject, qreal div)
|
|
|
{
|
|
|
return &( (*theWrappedObject)/= div);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::__eq__(QTransform* theWrappedObject, const QTransform& arg__1) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== arg__1);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::static_QTransform_quadToQuad(const QPolygonF& one, const QPolygonF& two, QTransform& result)
|
|
|
{
|
|
|
return (QTransform::quadToQuad(one, two, result));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::static_QTransform_quadToSquare(const QPolygonF& quad, QTransform& result)
|
|
|
{
|
|
|
return (QTransform::quadToSquare(quad, result));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTransform::reset(QTransform* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->reset());
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::rotate(QTransform* theWrappedObject, qreal a, Qt::Axis axis)
|
|
|
{
|
|
|
return &( theWrappedObject->rotate(a, axis));
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::rotateRadians(QTransform* theWrappedObject, qreal a, Qt::Axis axis)
|
|
|
{
|
|
|
return &( theWrappedObject->rotateRadians(a, axis));
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::scale(QTransform* theWrappedObject, qreal sx, qreal sy)
|
|
|
{
|
|
|
return &( theWrappedObject->scale(sx, sy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTransform::setMatrix(QTransform* theWrappedObject, qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33)
|
|
|
{
|
|
|
( theWrappedObject->setMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33));
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::shear(QTransform* theWrappedObject, qreal sh, qreal sv)
|
|
|
{
|
|
|
return &( theWrappedObject->shear(sh, sv));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTransform::static_QTransform_squareToQuad(const QPolygonF& square, QTransform& result)
|
|
|
{
|
|
|
return (QTransform::squareToQuad(square, result));
|
|
|
}
|
|
|
|
|
|
const QMatrix* PythonQtWrapper_QTransform::toAffine(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->toAffine());
|
|
|
}
|
|
|
|
|
|
QTransform* PythonQtWrapper_QTransform::translate(QTransform* theWrappedObject, qreal dx, qreal dy)
|
|
|
{
|
|
|
return &( theWrappedObject->translate(dx, dy));
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QTransform::transposed(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->transposed());
|
|
|
}
|
|
|
|
|
|
QTransform::TransformationType PythonQtWrapper_QTransform::type(QTransform* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->type());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTransform::py_toString(QTransform* obj) {
|
|
|
QString result;
|
|
|
QDebug d(&result);
|
|
|
d << *obj;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTreeView::~PythonQtShell_QTreeView() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEditor");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*" , "QAbstractItemDelegate::EndEditHint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&editor, (void*)&hint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::closeEditor(editor, hint);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::commitData(QWidget* editor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "commitData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&editor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::commitData(editor);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::currentChanged(const QModelIndex& current, const QModelIndex& previous)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "currentChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)¤t, (void*)&previous};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::currentChanged(current, previous);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::customEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dataChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&" , "const QVector<int >&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&topLeft, (void*)&bottomRight, (void*)&roles};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::dataChanged(topLeft, bottomRight, roles);
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::devType();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::doItemsLayout()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doItemsLayout");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::doItemsLayout();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::dragEnterEvent(QDragEnterEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::dragEnterEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::dragLeaveEvent(QDragLeaveEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::dragLeaveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::dragMoveEvent(QDragMoveEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::dragMoveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::drawBranches(QPainter* painter, const QRect& rect, const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawBranches");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*" , "const QRect&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&painter, (void*)&rect, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::drawBranches(painter, rect, index);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::drawRow(QPainter* painter, const QStyleOptionViewItem& options, const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawRow");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&painter, (void*)&options, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::drawRow(painter, options, index);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::dropEvent(QDropEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::dropEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "edit");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "QAbstractItemView::EditTrigger" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&index, (void*)&trigger, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("edit", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::edit(index, trigger, event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::editorDestroyed(QObject* editor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "editorDestroyed");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QObject*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&editor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::editorDestroyed(editor);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::focusInEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::focusInEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::focusOutEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::focusOutEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::hideEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::horizontalOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("horizontalOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::horizontalOffset();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::horizontalScrollbarAction(int action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarAction");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&action};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::horizontalScrollbarAction(action);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::horizontalScrollbarValueChanged(int value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarValueChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::horizontalScrollbarValueChanged(value);
|
|
|
}
|
|
|
QModelIndex PythonQtShell_QTreeView::indexAt(const QPoint& p) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "indexAt");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QModelIndex" , "const QPoint&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QModelIndex returnValue;
|
|
|
void* args[2] = {NULL, (void*)&p};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("indexAt", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QModelIndex*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::indexAt(p);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::initPainter(QPainter* painter) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::initPainter(painter);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::inputMethodEvent(QInputMethodEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::inputMethodEvent(event);
|
|
|
}
|
|
|
QVariant PythonQtShell_QTreeView::inputMethodQuery(Qt::InputMethodQuery query) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&query};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::inputMethodQuery(query);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::isIndexHidden(const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isIndexHidden");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("isIndexHidden", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::isIndexHidden(index);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::keyPressEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::keyPressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::keyboardSearch(const QString& search)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyboardSearch");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&search};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::keyboardSearch(search);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::mouseDoubleClickEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::mouseDoubleClickEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::mouseMoveEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::mouseMoveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::mousePressEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::mousePressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::mouseReleaseEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::mouseReleaseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::nativeEvent(const QByteArray& eventType, void* message, long* result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::nativeEvent(eventType, message, result);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QTreeView::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::paintEvent(QPaintEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::paintEvent(event);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QTreeView::redirected(QPoint* offset) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::redirected(offset);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::reset()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::reset();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::resizeEvent(QResizeEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::resizeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsAboutToBeRemoved");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::rowsAboutToBeRemoved(parent, start, end);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::rowsInserted(const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsInserted");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::rowsInserted(parent, start, end);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::scrollContentsBy(int dx, int dy)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&dx, (void*)&dy};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::scrollContentsBy(dx, dy);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollTo");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "QAbstractItemView::ScrollHint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&index, (void*)&hint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::scrollTo(index, hint);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::selectAll()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectAll");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::selectAll();
|
|
|
}
|
|
|
QList<QModelIndex > PythonQtShell_QTreeView::selectedIndexes() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectedIndexes");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QList<QModelIndex >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<QModelIndex > returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("selectedIndexes", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<QModelIndex >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::selectedIndexes();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QItemSelection&" , "const QItemSelection&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&selected, (void*)&deselected};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::selectionChanged(selected, deselected);
|
|
|
}
|
|
|
QItemSelectionModel::SelectionFlags PythonQtShell_QTreeView::selectionCommand(const QModelIndex& index, const QEvent* event) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionCommand");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QItemSelectionModel::SelectionFlags" , "const QModelIndex&" , "const QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QItemSelectionModel::SelectionFlags returnValue;
|
|
|
void* args[3] = {NULL, (void*)&index, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("selectionCommand", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QItemSelectionModel::SelectionFlags*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::selectionCommand(index, event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::setModel(QAbstractItemModel* model)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setModel");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractItemModel*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&model};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::setModel(model);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::setRootIndex(const QModelIndex& index)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setRootIndex");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::setRootIndex(index);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect&" , "QItemSelectionModel::SelectionFlags"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&rect, (void*)&command};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::setSelection(rect, command);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::setSelectionModel(QItemSelectionModel* selectionModel)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelectionModel");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QItemSelectionModel*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&selectionModel};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::setSelectionModel(selectionModel);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::setupViewport(QWidget* viewport)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&viewport};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::setupViewport(viewport);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QTreeView::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::showEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::sizeHintForColumn(int column) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForColumn");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&column};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHintForColumn", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::sizeHintForColumn(column);
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::sizeHintForRow(int row) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForRow");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&row};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHintForRow", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::sizeHintForRow(row);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::startDrag(Qt::DropActions supportedActions)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDrag");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "Qt::DropActions"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&supportedActions};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::startDrag(supportedActions);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::timerEvent(QTimerEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::timerEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::updateEditorData()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::updateEditorData();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::updateEditorGeometries()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorGeometries");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::updateEditorGeometries();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::updateGeometries()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateGeometries");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::updateGeometries();
|
|
|
}
|
|
|
int PythonQtShell_QTreeView::verticalOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("verticalOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::verticalOffset();
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::verticalScrollbarAction(int action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarAction");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&action};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::verticalScrollbarAction(action);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::verticalScrollbarValueChanged(int value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarValueChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::verticalScrollbarValueChanged(value);
|
|
|
}
|
|
|
QStyleOptionViewItem PythonQtShell_QTreeView::viewOptions() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewOptions");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QStyleOptionViewItem"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QStyleOptionViewItem returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewOptions", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QStyleOptionViewItem*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::viewOptions();
|
|
|
}
|
|
|
bool PythonQtShell_QTreeView::viewportEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::viewportEvent(event);
|
|
|
}
|
|
|
QSize PythonQtShell_QTreeView::viewportSizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::viewportSizeHint();
|
|
|
}
|
|
|
QRect PythonQtShell_QTreeView::visualRect(const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QRect returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("visualRect", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::visualRect(index);
|
|
|
}
|
|
|
QRegion PythonQtShell_QTreeView::visualRegionForSelection(const QItemSelection& selection) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRegionForSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRegion" , "const QItemSelection&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QRegion returnValue;
|
|
|
void* args[2] = {NULL, (void*)&selection};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("visualRegionForSelection", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRegion*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTreeView::visualRegionForSelection(selection);
|
|
|
}
|
|
|
void PythonQtShell_QTreeView::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QTreeView::wheelEvent(arg__1);
|
|
|
}
|
|
|
QTreeView* PythonQtWrapper_QTreeView::new_QTreeView(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTreeView(parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::allColumnsShowFocus(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->allColumnsShowFocus());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::autoExpandDelay(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoExpandDelay());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::columnAt(QTreeView* theWrappedObject, int x) const
|
|
|
{
|
|
|
return ( theWrappedObject->columnAt(x));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::columnViewportPosition(QTreeView* theWrappedObject, int column) const
|
|
|
{
|
|
|
return ( theWrappedObject->columnViewportPosition(column));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::columnWidth(QTreeView* theWrappedObject, int column) const
|
|
|
{
|
|
|
return ( theWrappedObject->columnWidth(column));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::currentChanged(QTreeView* theWrappedObject, const QModelIndex& current, const QModelIndex& previous)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_currentChanged(current, previous));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::dataChanged(QTreeView* theWrappedObject, const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_dataChanged(topLeft, bottomRight, roles));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::doItemsLayout(QTreeView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_doItemsLayout());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::dragMoveEvent(QTreeView* theWrappedObject, QDragMoveEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_dragMoveEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::drawBranches(QTreeView* theWrappedObject, QPainter* painter, const QRect& rect, const QModelIndex& index) const
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_drawBranches(painter, rect, index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::drawRow(QTreeView* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& options, const QModelIndex& index) const
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_drawRow(painter, options, index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::expandsOnDoubleClick(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->expandsOnDoubleClick());
|
|
|
}
|
|
|
|
|
|
QHeaderView* PythonQtWrapper_QTreeView::header(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->header());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::horizontalOffset(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_horizontalOffset());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::horizontalScrollbarAction(QTreeView* theWrappedObject, int action)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_horizontalScrollbarAction(action));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::indentation(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->indentation());
|
|
|
}
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QTreeView::indexAbove(QTreeView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( theWrappedObject->indexAbove(index));
|
|
|
}
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QTreeView::indexAt(QTreeView* theWrappedObject, const QPoint& p) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_indexAt(p));
|
|
|
}
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QTreeView::indexBelow(QTreeView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( theWrappedObject->indexBelow(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isAnimated(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isAnimated());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isColumnHidden(QTreeView* theWrappedObject, int column) const
|
|
|
{
|
|
|
return ( theWrappedObject->isColumnHidden(column));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isExpanded(QTreeView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( theWrappedObject->isExpanded(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isFirstColumnSpanned(QTreeView* theWrappedObject, int row, const QModelIndex& parent) const
|
|
|
{
|
|
|
return ( theWrappedObject->isFirstColumnSpanned(row, parent));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isHeaderHidden(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isHeaderHidden());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isIndexHidden(QTreeView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_isIndexHidden(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isRowHidden(QTreeView* theWrappedObject, int row, const QModelIndex& parent) const
|
|
|
{
|
|
|
return ( theWrappedObject->isRowHidden(row, parent));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::isSortingEnabled(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSortingEnabled());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::itemsExpandable(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemsExpandable());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::keyPressEvent(QTreeView* theWrappedObject, QKeyEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_keyPressEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::keyboardSearch(QTreeView* theWrappedObject, const QString& search)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_keyboardSearch(search));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::mouseDoubleClickEvent(QTreeView* theWrappedObject, QMouseEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mouseDoubleClickEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::mouseMoveEvent(QTreeView* theWrappedObject, QMouseEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mouseMoveEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::mousePressEvent(QTreeView* theWrappedObject, QMouseEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mousePressEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::mouseReleaseEvent(QTreeView* theWrappedObject, QMouseEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_mouseReleaseEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::paintEvent(QTreeView* theWrappedObject, QPaintEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_paintEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::reset(QTreeView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_reset());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::rootIsDecorated(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->rootIsDecorated());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::rowsAboutToBeRemoved(QTreeView* theWrappedObject, const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_rowsAboutToBeRemoved(parent, start, end));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::rowsInserted(QTreeView* theWrappedObject, const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_rowsInserted(parent, start, end));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::scrollContentsBy(QTreeView* theWrappedObject, int dx, int dy)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_scrollContentsBy(dx, dy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::scrollTo(QTreeView* theWrappedObject, const QModelIndex& index, QAbstractItemView::ScrollHint hint)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_scrollTo(index, hint));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::selectAll(QTreeView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_selectAll());
|
|
|
}
|
|
|
|
|
|
QList<QModelIndex > PythonQtWrapper_QTreeView::selectedIndexes(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_selectedIndexes());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::selectionChanged(QTreeView* theWrappedObject, const QItemSelection& selected, const QItemSelection& deselected)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_selectionChanged(selected, deselected));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setAllColumnsShowFocus(QTreeView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setAllColumnsShowFocus(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setAnimated(QTreeView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setAnimated(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setAutoExpandDelay(QTreeView* theWrappedObject, int delay)
|
|
|
{
|
|
|
( theWrappedObject->setAutoExpandDelay(delay));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setColumnHidden(QTreeView* theWrappedObject, int column, bool hide)
|
|
|
{
|
|
|
( theWrappedObject->setColumnHidden(column, hide));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setColumnWidth(QTreeView* theWrappedObject, int column, int width)
|
|
|
{
|
|
|
( theWrappedObject->setColumnWidth(column, width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setExpanded(QTreeView* theWrappedObject, const QModelIndex& index, bool expand)
|
|
|
{
|
|
|
( theWrappedObject->setExpanded(index, expand));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setExpandsOnDoubleClick(QTreeView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setExpandsOnDoubleClick(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setFirstColumnSpanned(QTreeView* theWrappedObject, int row, const QModelIndex& parent, bool span)
|
|
|
{
|
|
|
( theWrappedObject->setFirstColumnSpanned(row, parent, span));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setHeader(QTreeView* theWrappedObject, QHeaderView* header)
|
|
|
{
|
|
|
( theWrappedObject->setHeader(header));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setHeaderHidden(QTreeView* theWrappedObject, bool hide)
|
|
|
{
|
|
|
( theWrappedObject->setHeaderHidden(hide));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setIndentation(QTreeView* theWrappedObject, int i)
|
|
|
{
|
|
|
( theWrappedObject->setIndentation(i));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setItemsExpandable(QTreeView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setItemsExpandable(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setModel(QTreeView* theWrappedObject, QAbstractItemModel* model)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setModel(model));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setRootIndex(QTreeView* theWrappedObject, const QModelIndex& index)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setRootIndex(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setRootIsDecorated(QTreeView* theWrappedObject, bool show)
|
|
|
{
|
|
|
( theWrappedObject->setRootIsDecorated(show));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setRowHidden(QTreeView* theWrappedObject, int row, const QModelIndex& parent, bool hide)
|
|
|
{
|
|
|
( theWrappedObject->setRowHidden(row, parent, hide));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setSelection(QTreeView* theWrappedObject, const QRect& rect, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setSelection(rect, command));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setSelectionModel(QTreeView* theWrappedObject, QItemSelectionModel* selectionModel)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_setSelectionModel(selectionModel));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setSortingEnabled(QTreeView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setSortingEnabled(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setUniformRowHeights(QTreeView* theWrappedObject, bool uniform)
|
|
|
{
|
|
|
( theWrappedObject->setUniformRowHeights(uniform));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::setWordWrap(QTreeView* theWrappedObject, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setWordWrap(on));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::sizeHintForColumn(QTreeView* theWrappedObject, int column) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_sizeHintForColumn(column));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::sortByColumn(QTreeView* theWrappedObject, int column, Qt::SortOrder order)
|
|
|
{
|
|
|
( theWrappedObject->sortByColumn(column, order));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::timerEvent(QTreeView* theWrappedObject, QTimerEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_timerEvent(event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::uniformRowHeights(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->uniformRowHeights());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTreeView::updateGeometries(QTreeView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_updateGeometries());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTreeView::verticalOffset(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_verticalOffset());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::viewportEvent(QTreeView* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_viewportEvent(event));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QTreeView::visualRect(QTreeView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_visualRect(index));
|
|
|
}
|
|
|
|
|
|
QRegion PythonQtWrapper_QTreeView::visualRegionForSelection(QTreeView* theWrappedObject, const QItemSelection& selection) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTreeView*)theWrappedObject)->promoted_visualRegionForSelection(selection));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTreeView::wordWrap(QTreeView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->wordWrap());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
